// Parses a text-based expression for evaluation.
// The engine sample only supports locals and parameters so the only task here is to check the names in those collections.
int IDebugExpressionContext2.ParseText(string pszCode, enum_PARSEFLAGS dwFlags, uint nRadix, out IDebugExpression2 ppExpr,
out string pbstrError,
out uint pichError)
{
//System.Windows.Forms.MessageBox.Show("pszCode: " + pszCode);
pbstrError = "";
pichError = 0;
ppExpr = null;
try {
if (mParams != null)
{
foreach (DebugLocalInfo currVariable in mParams)
{
if (String.CompareOrdinal(currVariable.Name, pszCode) == 0)
{
ppExpr = new AD7Expression(currVariable, mProcess, this);
return(VSConstants.S_OK);
}
}
}
if (mLocals != null)
{
foreach (DebugLocalInfo currVariable in mLocals)
{
if (String.CompareOrdinal(currVariable.Name, pszCode) == 0)
{
ppExpr = new AD7Expression(currVariable, mProcess, this);
return(VSConstants.S_OK);
}
}
}
pbstrError = "Invalid Expression";
pichError = (uint)pbstrError.Length;
return(VSConstants.S_FALSE);
} catch (Exception e) {
return(EngineUtils.UnexpectedException(e));
}
}
// Gets the file statement range of the document context.
// A statement range is the range of the lines that contributed the code to which this document context refers.
int IDebugDocumentContext2.GetStatementRange(TEXT_POSITION[] pBegPosition, TEXT_POSITION[] pEndPosition)
{
try
{
pBegPosition[0].dwColumn = m_begPos.dwColumn;
pBegPosition[0].dwLine = m_begPos.dwLine;
pEndPosition[0].dwColumn = m_endPos.dwColumn;
pEndPosition[0].dwLine = m_endPos.dwLine;
}
//catch (ComponentException e)
//{
// return e.HResult;
//}
catch (Exception e)
{
return(EngineUtils.UnexpectedException(e));
}
return(VSConstants.S_OK);
}
// Creates an enumerator for properties associated with the stack frame, such as local variables.
// The sample engine only supports returning locals and parameters. Other possible values include
// class fields (this pointer), registers, exceptions...
int IDebugStackFrame2.EnumProperties(enum_DEBUGPROP_INFO_FLAGS dwFields, uint nRadix, ref Guid guidFilter, uint dwTimeout, out uint elementsReturned, out IEnumDebugPropertyInfo2 enumObject)
{
int hr;
elementsReturned = 0;
enumObject = null;
try {
if (guidFilter == AD7Guids.guidFilterLocalsPlusArgs ||
guidFilter == AD7Guids.guidFilterAllLocalsPlusArgs)
{
CreateLocalsPlusArgsProperties(out elementsReturned, out enumObject);
hr = VSConstants.S_OK;
}
else if (guidFilter == AD7Guids.guidFilterLocals)
{
CreateLocalProperties(out elementsReturned, out enumObject);
hr = VSConstants.S_OK;
}
else if (guidFilter == AD7Guids.guidFilterArgs)
{
CreateParameterProperties(out elementsReturned, out enumObject);
hr = VSConstants.S_OK;
}
else
{
hr = VSConstants.E_NOTIMPL;
}
}
//catch (ComponentException e)
//{
// return e.HResult;
//}
catch (Exception e) {
return(EngineUtils.UnexpectedException(e));
}
return(hr);
}
// During startup these methods are called in this order:
// -LaunchSuspended
// -ResumeProcess
// -Attach - Triggered by Attach
int IDebugEngineLaunch2.LaunchSuspended(string aPszServer, IDebugPort2 aPort, string aDebugInfo
, string aArgs, string aDir, string aEnv, string aOptions, enum_LAUNCH_FLAGS aLaunchFlags
, uint aStdInputHandle, uint aStdOutputHandle, uint hStdError, IDebugEventCallback2 aAD7Callback
, out IDebugProcess2 oProcess)
{
// Launches a process by means of the debug engine.
// Normally, Visual Studio launches a program using the IDebugPortEx2::LaunchSuspended method and then attaches the debugger
// to the suspended program. However, there are circumstances in which the debug engine may need to launch a program
// (for example, if the debug engine is part of an interpreter and the program being debugged is an interpreted language),
// in which case Visual Studio uses the IDebugEngineLaunch2::LaunchSuspended method
// The IDebugEngineLaunch2::ResumeProcess method is called to start the process after the process has been successfully launched in a suspended state.
oProcess = null;
try {
mEngineCallback = new EngineCallback(this, aAD7Callback);
var xDebugInfo = new NameValueCollection();
NameValueCollectionHelper.LoadFromString(xDebugInfo, aDebugInfo);
//TODO: In the future we might support command line args for kernel etc
//string xCmdLine = EngineUtils.BuildCommandLine(exe, args);
//var processLaunchInfo = new ProcessLaunchInfo(exe, xCmdLine, dir, env, options, launchFlags, hStdInput, hStdOutput, hStdError);
AD7EngineCreateEvent.Send(this);
oProcess = mProcess = new AD7Process(xDebugInfo, mEngineCallback, this, aPort);
// We only support one process, so just use its ID for the program ID
mProgramID = mProcess.ID;
//AD7ThreadCreateEvent.Send(this, xProcess.Thread);
mModule = new AD7Module();
mProgNode = new AD7ProgramNode(mProcess.PhysID);
} catch (NotSupportedException) {
return(VSConstants.S_FALSE);
} catch (Exception e) {
return(EngineUtils.UnexpectedException(e));
}
return(VSConstants.S_OK);
}
// Binds this pending breakpoint to one or more code locations.
int IDebugPendingBreakpoint2.Bind()
{
try {
if (CanBind())
{
var xDocPos = (IDebugDocumentPosition2)(Marshal.GetObjectForIUnknown(mBpRequestInfo.bpLocation.unionmember2));
// Get the name of the document that the breakpoint was put in
string xDocName;
EngineUtils.CheckOk(xDocPos.GetFileName(out xDocName));
xDocName = xDocName.ToLower(); //Bug: Some filenames were returned with the drive letter as lower case but in DocumentGUIDs it was captialised so file-not-found!
// Get the location in the document that the breakpoint is in.
var xStartPos = new TEXT_POSITION[1];
var xEndPos = new TEXT_POSITION[1];
EngineUtils.CheckOk(xDocPos.GetRange(xStartPos, xEndPos));
UInt32 xAddress = 0;
var xDebugInfo = mEngine.mProcess.mDebugInfoDb;
// We must check for DocID. This is important because in a solution that contains many projects,
// VS will send us BPs from other Cosmos projects (and possibly non Cosmos ones, didnt look that deep)
// but we wont have them in our doc list because it contains only ones from the currently project
// to run.
Guid xDocID;
if (xDebugInfo.DocumentGUIDs.TryGetValue(xDocName, out xDocID))
{
// Find which Method the Doc, Line, Col are in.
// Must add +1 for both Line and Col. They are 0 based, while SP ones are 1 based.
// () around << are VERY important.. + has precedence over <<
Int64 xPos = (((Int64)xStartPos[0].dwLine + 1) << 32) + xStartPos[0].dwColumn + 1;
try
{
var potXMethods = xDebugInfo.Connection.Query(new SQLinq <Method>().Where(x => x.DocumentID == xDocID &&
x.LineColStart <= xPos &&
x.LineColEnd >= xPos));
var xMethod = potXMethods.Single();
var asm = xDebugInfo.Connection.Get <AssemblyFile>(xMethod.AssemblyFileID);
// We have the method. Now find out what Sequence Point it belongs to.
var xSPs = xDebugInfo.GetSequencePoints(asm.Pathname, xMethod.MethodToken);
var xSP = xSPs.Single(q => q.LineColStart <= xPos && q.LineColEnd >= xPos);
// We have the Sequence Point, find the MethodILOp
var xOp = xDebugInfo.Connection.Query(new SQLinq <MethodIlOp>().Where(q => q.MethodID == xMethod.ID && q.IlOffset == xSP.Offset)).First();
// Get the address of the Label
xAddress = xDebugInfo.AddressOfLabel(xOp.LabelName);
if (xAddress > 0)
{
var xBPR = new AD7BreakpointResolution(mEngine, xAddress, GetDocumentContext(xAddress));
var xBBP = new AD7BoundBreakpoint(mEngine, xAddress, this, xBPR);
mBoundBPs.Add(xBBP);
}
// Ask the symbol engine to find all addresses in all modules with symbols that match this source and line number.
//uint[] addresses = mEngine.DebuggedProcess.GetAddressesForSourceLocation(null, documentName, startPosition[0].dwLine + 1, startPosition[0].dwColumn);
lock (mBoundBPs)
{
//foreach (uint addr in addresses) {
// AD7BreakpointResolution breakpointResolution = new AD7BreakpointResolution(mEngine, addr, GetDocumentContext(addr));
// AD7BoundBreakpoint boundBreakpoint = new AD7BoundBreakpoint(mEngine, addr, this, breakpointResolution);
// m_boundBreakpoints.Add(boundBreakpoint);
// mEngine.DebuggedProcess.SetBreakpoint(addr, boundBreakpoint);
//}
}
}
catch (InvalidOperationException)
{
//No elements in potXMethods sequence!
return(VSConstants.S_FALSE);
}
}
return(VSConstants.S_OK);
}
else
{
// The breakpoint could not be bound. This may occur for many reasons such as an invalid location, an invalid expression, etc...
// The sample engine does not support this, but a real world engine will want to send an instance of IDebugBreakpointErrorEvent2 to the
// UI and return a valid instance of IDebugErrorBreakpoint2 from IDebugPendingBreakpoint2::EnumErrorBreakpoints. The debugger will then
// display information about why the breakpoint did not bind to the user.
return(VSConstants.S_FALSE);
}
}
//catch (ComponentException e)
//{
// return e.HResult;
//}
catch (Exception e) {
return(EngineUtils.UnexpectedException(e));
}
}
// Compares the memory context to each context in the given array in the manner indicated by compare flags,
// returning an index of the first context that matches.
public int Compare(enum_CONTEXT_COMPARE uContextCompare, IDebugMemoryContext2[] compareToItems, uint compareToLength, out uint foundIndex)
{
foundIndex = uint.MaxValue;
try
{
enum_CONTEXT_COMPARE contextCompare = (enum_CONTEXT_COMPARE)uContextCompare;
for (uint c = 0; c < compareToLength; c++)
{
AD7MemoryAddress compareTo = compareToItems[c] as AD7MemoryAddress;
if (compareTo == null)
{
continue;
}
if (!AD7Engine.ReferenceEquals(this.m_engine, compareTo.m_engine))
{
continue;
}
bool result;
switch (contextCompare)
{
case enum_CONTEXT_COMPARE.CONTEXT_EQUAL:
result = (this.m_address == compareTo.m_address);
break;
case enum_CONTEXT_COMPARE.CONTEXT_LESS_THAN:
result = (this.m_address < compareTo.m_address);
break;
case enum_CONTEXT_COMPARE.CONTEXT_GREATER_THAN:
result = (this.m_address > compareTo.m_address);
break;
case enum_CONTEXT_COMPARE.CONTEXT_LESS_THAN_OR_EQUAL:
result = (this.m_address <= compareTo.m_address);
break;
case enum_CONTEXT_COMPARE.CONTEXT_GREATER_THAN_OR_EQUAL:
result = (this.m_address >= compareTo.m_address);
break;
// The sample debug engine doesn't understand scopes or functions
case enum_CONTEXT_COMPARE.CONTEXT_SAME_SCOPE:
case enum_CONTEXT_COMPARE.CONTEXT_SAME_FUNCTION:
result = (this.m_address == compareTo.m_address);
break;
case enum_CONTEXT_COMPARE.CONTEXT_SAME_MODULE:
result = (this.m_address == compareTo.m_address);
if (result == false)
{
//DebuggedModule module = m_engine.DebuggedProcess.ResolveAddress(m_address);
//if (module != null)
//{
// result = (compareTo.m_address >= module.BaseAddress) &&
// (compareTo.m_address < module.BaseAddress + module.Size);
//}
}
break;
case enum_CONTEXT_COMPARE.CONTEXT_SAME_PROCESS:
result = true;
break;
default:
// A new comparison was invented that we don't support
return(VSConstants.E_NOTIMPL);
}
if (result)
{
foundIndex = c;
return(VSConstants.S_OK);
}
}
return(VSConstants.S_FALSE);
}
//catch (ComponentException e)
//{
// return e.HResult;
//}
catch (Exception e)
{
return(EngineUtils.UnexpectedException(e));
}
}
public string GetAddressDescription(uint ip)
{
// DebuggedModule module = m_debuggedProcess.ResolveAddress(ip);
return(EngineUtils.GetAddressDescription(/*module,*/ this, ip));
}
// Gets the MODULE_INFO that describes this module.
// This is how the debugger obtains most of the information about the module.
int IDebugModule2.GetInfo(enum_MODULE_INFO_FIELDS dwFields, MODULE_INFO[] infoArray)
{
try
{
MODULE_INFO info = new MODULE_INFO();
if (dwFields.HasFlag(enum_MODULE_INFO_FIELDS.MIF_NAME))
{
//info.m_bstrName = System.IO.Path.GetFileName(this.DebuggedModule.Name);
info.m_bstrName = "DEADBEEF";
info.dwValidFields |= enum_MODULE_INFO_FIELDS.MIF_NAME;
}
if (dwFields.HasFlag(enum_MODULE_INFO_FIELDS.MIF_URL))
{
//info.m_bstrUrl = this.DebuggedModule.Name;
info.m_bstrUrl = "DEADBEEF";
info.dwValidFields |= enum_MODULE_INFO_FIELDS.MIF_URL;
}
if (dwFields.HasFlag(enum_MODULE_INFO_FIELDS.MIF_LOADADDRESS))
{
//info.m_addrLoadAddress = (ulong)this.DebuggedModule.BaseAddress;
info.dwValidFields |= enum_MODULE_INFO_FIELDS.MIF_LOADADDRESS;
}
if (dwFields.HasFlag(enum_MODULE_INFO_FIELDS.MIF_PREFFEREDADDRESS))
{
// A debugger that actually supports showing the preferred base should crack the PE header and get
// that field. This debugger does not do that, so assume the module loaded where it was suppose to.
//info.m_addrPreferredLoadAddress = (ulong)this.DebuggedModule.BaseAddress;
info.dwValidFields |= enum_MODULE_INFO_FIELDS.MIF_PREFFEREDADDRESS;
}
if (dwFields.HasFlag(enum_MODULE_INFO_FIELDS.MIF_SIZE))
{
//info.m_dwSize = this.DebuggedModule.Size;
info.dwValidFields |= enum_MODULE_INFO_FIELDS.MIF_SIZE;
}
if (dwFields.HasFlag(enum_MODULE_INFO_FIELDS.MIF_LOADORDER))
{
//info.m_dwLoadOrder = this.DebuggedModule.GetLoadOrder();
info.dwValidFields |= enum_MODULE_INFO_FIELDS.MIF_LOADORDER;
}
if (dwFields.HasFlag(enum_MODULE_INFO_FIELDS.MIF_URLSYMBOLLOCATION))
{
//if (this.DebuggedModule.SymbolsLoaded)
{
//info.m_bstrUrlSymbolLocation = this.DebuggedModule.SymbolPath;
info.dwValidFields |= enum_MODULE_INFO_FIELDS.MIF_URLSYMBOLLOCATION;
}
}
if (dwFields.HasFlag(enum_MODULE_INFO_FIELDS.MIF_FLAGS))
{
info.m_dwModuleFlags = 0;
//if (this.DebuggedModule.SymbolsLoaded)
{
info.m_dwModuleFlags |= (enum_MODULE_FLAGS.MODULE_FLAG_SYMBOLS);
}
info.dwValidFields |= enum_MODULE_INFO_FIELDS.MIF_FLAGS;
}
infoArray[0] = info;
return(VSConstants.S_OK);
}
//catch (ComponentException e)
//{
// return e.HResult;
//}
catch (Exception e)
{
return(EngineUtils.UnexpectedException(e));
}
}
