public BreakpointLocationCodeFileLine(BP_LOCATION location, bool releaseComObjects)
{
Contract.Requires <ArgumentException>((enum_BP_LOCATION_TYPE)location.bpLocationType == enum_BP_LOCATION_TYPE.BPLT_CODE_FILE_LINE);
try
{
if (location.unionmember1 != IntPtr.Zero)
{
_context = Marshal.PtrToStringBSTR(location.unionmember1);
}
if (location.unionmember2 != IntPtr.Zero)
{
_documentPosition = Marshal.GetObjectForIUnknown(location.unionmember2) as IDebugDocumentPosition2;
}
}
finally
{
if (releaseComObjects)
{
if (location.unionmember1 != IntPtr.Zero)
{
Marshal.FreeBSTR(location.unionmember1);
}
if (location.unionmember2 != IntPtr.Zero)
{
Marshal.Release(location.unionmember2);
}
}
}
}
public TextPositionInfo(BP_REQUEST_INFO reqInfo)
{
IDebugDocumentPosition2 docPosition = (IDebugDocumentPosition2)Marshal.GetObjectForIUnknown(reqInfo.bpLocation.unionmember2);
Create(docPosition);
Marshal.ReleaseComObject(docPosition);
}
int IDebugPendingBreakpoint2.Bind()
{
if (!CanBind())
{
// The breakpoint could not be bound. This may occur for many reasons such as an invalid location, an invalid expression, etc...
// We may 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);
}
if (_boundBreakpoint != null)
{
throw new NotImplementedException(); // multiple bound breakpoints are not supported
}
IDebugDocumentPosition2 docPosition = (IDebugDocumentPosition2)
Marshal.GetObjectForIUnknown(_requestInfo.bpLocation.unionmember2);
string documentName;
TEXT_POSITION[] startPosition = new TEXT_POSITION[1];
TEXT_POSITION[] endPosition = new TEXT_POSITION[1];
EngineUtils.RequireOk(docPosition.GetFileName(out documentName));
EngineUtils.RequireOk(docPosition.GetRange(startPosition, endPosition));
var resolution = _manager.ResolveBreakpoint(startPosition[0]);
_boundBreakpoint = new BoundBreakpoint(_backend, this, resolution);
_boundBreakpoint.CompleteBind();
_callbacks.OnBreakpointBound(_boundBreakpoint);
return(VSConstants.S_OK);
}
public int Bind()
{
IDebugDocumentPosition2 docPosition = (IDebugDocumentPosition2)(Marshal.GetObjectForIUnknown(m_bpRequestInfo.bpLocation.unionmember2));
string filename;
docPosition.GetFileName(out filename);
TEXT_POSITION[] startPosition = new TEXT_POSITION[1];
TEXT_POSITION[] endPosition = new TEXT_POSITION[1];
EngineUtils.CheckOk(docPosition.GetRange(startPosition, endPosition));
Command bpCommand = new BreakpointCommand(Path.GetFileName(filename), (int)startPosition[0].dwLine + 1);
m_engine.EnqueueCommand(bpCommand);
AD7DocumentContext docContext = new AD7DocumentContext(filename, startPosition[0], endPosition[0]);
AD7BreakpointResolution breakpointResolution = new AD7BreakpointResolution(this.m_engine, docContext);
AD7BoundBreakpoint boundBreakpoint = new AD7BoundBreakpoint(this.m_engine, this, breakpointResolution);
string fileandline = Path.GetFileName(filename) + ((int)startPosition[0].dwLine + 1).ToString();
m_bpManager.StoreBoundBreakpoint(fileandline, boundBreakpoint);
return(VSConstants.S_OK);
}
public int EnumCodeContexts(
IDebugDocumentPosition2 docPos, out IEnumDebugCodeContexts2 contextsEnum)
{
contextsEnum = null;
var startPositions = new TEXT_POSITION[1];
var result = docPos.GetRange(startPositions, null);
if (result != VSConstants.S_OK)
{
Trace.WriteLine("Error: Unable to retrieve starting position.");
return(result);
}
string fileName;
docPos.GetFileName(out fileName);
var codeContexts = new List <IDebugCodeContext2>();
// TODO: Find a less hacky way of doing this
var tempBreakpoint = _lldbTarget.BreakpointCreateByLocation(fileName,
startPositions[0].dwLine + 1);
if (tempBreakpoint == null)
{
Trace.WriteLine("Error: Failed to set temporary breakpoint used to map document " +
"position to code contexts.");
return(VSConstants.E_FAIL);
}
try
{
var numLocations = tempBreakpoint.GetNumLocations();
for (uint i = 0; i < numLocations; ++i)
{
var location = tempBreakpoint.GetLocationAtIndex(i);
var address = location.GetAddress();
if (address != null)
{
var codeContext = _codeContextFactory.Create(
address.GetLoadAddress(_lldbTarget),
address.GetFunction().GetName(),
_documentContextFactory.Create(address.GetLineEntry()),
Guid.Empty);
codeContexts.Add(codeContext);
}
else
{
Trace.WriteLine("Warning: Failed to obtain address for code context " +
"from temporary breakpoint location. Code context skipped.");
}
}
}
finally
{
_lldbTarget.BreakpointDelete(tempBreakpoint.GetId());
tempBreakpoint = null;
}
contextsEnum = _codeContextEnumFactory.Create(codeContexts);
return(VSConstants.S_OK);
}
public Breakpoint(Program program, IDebugBreakpointRequest2 request, IDebugDocumentPosition2 documentInfo)
{
_program = program;
_request = request;
_documentInfo = documentInfo;
ErrorHandler.ThrowOnFailure(_documentInfo.GetFileName(out _sourcePath));
}
public static IDebugDocument2 GetDocument(this IDebugDocumentPosition2 documentPosition)
{
Contract.Requires <ArgumentNullException>(documentPosition != null, "documentPosition");
IDebugDocument2 document;
ErrorHandler.ThrowOnFailure(documentPosition.GetDocument(out document));
return(document);
}
public static string GetFileName(this IDebugDocumentPosition2 documentPosition)
{
Contract.Requires <ArgumentNullException>(documentPosition != null, "documentPosition");
string fileName;
ErrorHandler.ThrowOnFailure(documentPosition.GetFileName(out fileName));
return(fileName);
}
// Binds this pending breakpoint to one or more code locations.
int IDebugPendingBreakpoint2.Bind()
{
try
{
if (CanBind())
{
IDebugDocumentPosition2 docPosition = (IDebugDocumentPosition2)(Marshal.GetObjectForIUnknown(m_bpRequestInfo.bpLocation.unionmember2));
// Get the name of the document that the breakpoint was put in
string documentName;
EngineUtils.CheckOk(docPosition.GetFileName(out documentName));
// Get the location in the document that the breakpoint is in.
TEXT_POSITION[] startPosition = new TEXT_POSITION[1];
TEXT_POSITION[] endPosition = new TEXT_POSITION[1];
EngineUtils.CheckOk(docPosition.GetRange(startPosition, endPosition));
// Ask the symbol engine to find all addresses in all modules with symbols that match this source and line number.
uint[] addresses = m_engine.DebuggedProcess.GetAddressesForSourceLocation(null,
documentName,
startPosition[0].dwLine + 1,
startPosition[0].dwColumn);
lock (m_boundBreakpoints)
{
foreach (uint addr in addresses)
{
AD7BreakpointResolution breakpointResolution = new AD7BreakpointResolution(m_engine, addr, GetDocumentContext(addr));
AD7BoundBreakpoint boundBreakpoint = new AD7BoundBreakpoint(m_engine, addr, this, breakpointResolution);
m_boundBreakpoints.Add(boundBreakpoint);
m_engine.DebuggedProcess.SetBreakpoint(addr, boundBreakpoint);
((IDebugBoundBreakpoint2)boundBreakpoint).Enable(m_enabled ? 1 : 0);
}
}
return(EngineConstants.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(EngineConstants.S_FALSE);
}
}
catch (ComponentException e)
{
return(e.HRESULT);
}
catch (Exception e)
{
return(EngineUtils.UnexpectedException(e));
}
}
internal async Task BindAsync()
{
if (CanBind())
{
string documentName = null;
TEXT_POSITION[] startPosition = new TEXT_POSITION[1];
TEXT_POSITION[] endPosition = new TEXT_POSITION[1];
string condition = null;
lock (_boundBreakpoints)
{
if (_bp != null) // already bound
{
Debug.Fail("Breakpoint already bound");
return;
}
IDebugDocumentPosition2 docPosition = HostMarshal.GetDocumentPositionForIntPtr(_bpRequestInfo.bpLocation.unionmember2);
// Get the name of the document that the breakpoint was put in
EngineUtils.CheckOk(docPosition.GetFileName(out documentName));
// Get the location in the document that the breakpoint is in.
EngineUtils.CheckOk(docPosition.GetRange(startPosition, endPosition));
if ((_bpRequestInfo.dwFields & enum_BPREQI_FIELDS.BPREQI_CONDITION) != 0 &&
_bpRequestInfo.bpCondition.styleCondition == enum_BP_COND_STYLE.BP_COND_WHEN_TRUE)
{
condition = _bpRequestInfo.bpCondition.bstrCondition;
}
}
// Bind all breakpoints that match this source and line number.
PendingBreakpoint.BindResult bindResult = await PendingBreakpoint.Bind(documentName, startPosition[0].dwLine + 1, startPosition[0].dwColumn, _engine.DebuggedProcess, condition, this);
lock (_boundBreakpoints)
{
if (bindResult.PendingBreakpoint != null)
{
_bp = bindResult.PendingBreakpoint; // an MI breakpoint object exists: TODO: lock?
}
if (bindResult.BoundBreakpoints == null || bindResult.BoundBreakpoints.Count == 0)
{
_BPError = new AD7ErrorBreakpoint(this, bindResult.ErrorMessage);
_engine.Callback.OnBreakpointError(_BPError);
}
else
{
Debug.Assert(_bp != null);
foreach (BoundBreakpoint bp in bindResult.BoundBreakpoints)
{
AddBoundBreakpoint(bp);
}
}
}
}
}
public int EnumCodeContexts(IDebugDocumentPosition2 pDocPos, out IEnumDebugCodeContexts2 ppEnum)
{
TextPositionInfo posInfo = new TextPositionInfo(pDocPos);
MonoDocumentContext docCtx = new MonoDocumentContext(posInfo, null);
MonoMemoryContext memoryCtx = new MonoMemoryContext(docCtx, 0);
ppEnum = new MonoCodeContextEnumerator(new IDebugCodeContext2[] { memoryCtx });
return(S_OK);
}
public static IntPtr RegisterDocumentPosition(IDebugDocumentPosition2 documentPosition)
{
if (documentPosition == null)
{
throw new ArgumentNullException("documentPosition");
}
lock (s_documentPositions)
{
return((IntPtr)s_documentPositions.Create(documentPosition));
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public int EnumCodeContexts(IDebugDocumentPosition2 pDocPos, out IEnumDebugCodeContexts2 ppEnum)
{
//
// Enumerates the code contexts for a given position in a source file.
//
LoggingUtils.PrintFunction();
ppEnum = null;
try
{
List <IDebugCodeContext2> codeContexts = new List <IDebugCodeContext2> ();
uint count;
{
LoggingUtils.RequireOk(AttachedEngine.NativeDebugger.NativeProgram.EnumCodeContexts(pDocPos, out ppEnum));
LoggingUtils.RequireOk(ppEnum.GetCount(out count));
IDebugCodeContext2 [] codeContextArray = new IDebugCodeContext2 [count];
LoggingUtils.RequireOk(ppEnum.Next(count, codeContextArray, ref count));
codeContexts.AddRange(codeContextArray);
}
#if false
{
LoggingUtils.RequireOk(AttachedEngine.JavaDebugger.JavaProgram.EnumCodeContexts(pDocPos, out ppEnum));
LoggingUtils.RequireOk(ppEnum.GetCount(out count));
IDebugCodeContext2 [] codeContextArray = new IDebugCodeContext2 [count];
LoggingUtils.RequireOk(ppEnum.Next(count, codeContextArray, ref count));
codeContexts.AddRange(codeContextArray);
}
#endif
ppEnum = new DebuggeeCodeContext.Enumerator(codeContexts);
return(Constants.S_OK);
}
catch (Exception e)
{
LoggingUtils.HandleException(e);
return(Constants.E_FAIL);
}
}
public string GetLocationInfo(IDebugDocumentPosition2 docPosition, out TEXT_POSITION[] startPosition, out TEXT_POSITION[] endPosition)
{
string documentName;
EngineUtils.CheckOk(docPosition.GetFileName(out documentName));
startPosition = new TEXT_POSITION[1];
endPosition = new TEXT_POSITION[1];
EngineUtils.CheckOk(docPosition.GetRange(startPosition, endPosition));
return(documentName);
}
// Enumerates the code contexts for a given position in a source file.
public int EnumCodeContexts(IDebugDocumentPosition2 pDocPos, out IEnumDebugCodeContexts2 ppEnum)
{
string filename;
pDocPos.GetFileName(out filename);
TEXT_POSITION[] beginning = new TEXT_POSITION[1], end = new TEXT_POSITION[1];
pDocPos.GetRange(beginning, end);
ppEnum = new AD7CodeContextEnum(new[] { new AD7MemoryAddress(this, filename, (uint)beginning[0].dwLine) });
return(VSConstants.S_OK);
}
public static TextSpan GetRange(this IDebugDocumentPosition2 documentPosition)
{
Contract.Requires <ArgumentNullException>(documentPosition != null, "documentPosition");
TEXT_POSITION[] startPosition = new TEXT_POSITION[1];
TEXT_POSITION[] endPosition = new TEXT_POSITION[1];
ErrorHandler.ThrowOnFailure(documentPosition.GetRange(startPosition, endPosition));
return(new TextSpan()
{
iStartLine = (int)startPosition[0].dwLine,
iStartIndex = (int)startPosition[0].dwColumn,
iEndLine = (int)endPosition[0].dwLine,
iEndIndex = (int)endPosition[0].dwColumn
});
}
public int EnumCodeContexts(IDebugDocumentPosition2 pDocPos, out IEnumDebugCodeContexts2 ppEnum)
{
TEXT_POSITION[] startPosition;
TEXT_POSITION[] endPosition;
var documentName = breakpointManager.Engine.GetLocationInfo(pDocPos, out startPosition, out endPosition);
var textPosition = new TEXT_POSITION {
dwLine = startPosition[0].dwLine + 1
};
var documentContext = new MonoDocumentContext(documentName, textPosition, textPosition, null);
ppEnum = new MonoCodeContextEnum(new[] { new MonoMemoryAddress(this, 0, documentContext) });
return(VSConstants.S_OK);
}
// Get the document context for this pending breakpoint. A document context is a abstract representation of a source file
// location.
public AD7DocumentContext GetDocumentContext(PythonBreakpoint address)
{
IDebugDocumentPosition2 docPosition = (IDebugDocumentPosition2)(Marshal.GetObjectForIUnknown(_bpRequestInfo.bpLocation.unionmember2));
EngineUtils.CheckOk(docPosition.GetFileName(out global::System.String documentName));
// Get the location in the document that the breakpoint is in.
TEXT_POSITION[] startPosition = new TEXT_POSITION[1];
TEXT_POSITION[] endPosition = new TEXT_POSITION[1];
EngineUtils.CheckOk(docPosition.GetRange(startPosition, endPosition));
AD7MemoryAddress codeContext = new AD7MemoryAddress(_engine, documentName, startPosition[0].dwLine);
return(new AD7DocumentContext(documentName, startPosition[0], startPosition[0], codeContext, FrameKind.Python));
}
private void Create(IDebugDocumentPosition2 docPosition)
{
string path;
TEXT_POSITION[] tstart = new TEXT_POSITION[1];
TEXT_POSITION[] tend = new TEXT_POSITION[1];
docPosition.GetFileName(out path);
docPosition.GetRange(tstart, tend);
FilePath = path;
StartLine = (int)tstart[0].dwLine;
StartColumn = (int)tstart[0].dwColumn;
EndLine = (int)tend[0].dwLine;
EndColumn = (int)tend[0].dwColumn;
}
// Get the document context for this pending breakpoint. A document context is a abstract representation of a source file
// location.
public AD7DocumentContext GetDocumentContext(uint address)
{
IDebugDocumentPosition2 docPosition = (IDebugDocumentPosition2)(Marshal.GetObjectForIUnknown(mBpRequestInfo.bpLocation.unionmember2));
string documentName;
EngineUtils.CheckOk(docPosition.GetFileName(out documentName));
// Get the location in the document that the breakpoint is in.
TEXT_POSITION[] startPosition = new TEXT_POSITION[1];
TEXT_POSITION[] endPosition = new TEXT_POSITION[1];
EngineUtils.CheckOk(docPosition.GetRange(startPosition, endPosition));
AD7MemoryAddress codeContext = new AD7MemoryAddress(mEngine, address);
return(new AD7DocumentContext(documentName, startPosition[0], startPosition[0], codeContext));
}
// Get the document context for this pending breakpoint. A document context is a abstract representation of a source file
// location.
public AD7DocumentContext GetDocumentContext(ulong address, string functionName)
{
IDebugDocumentPosition2 docPosition = HostMarshal.GetDocumentPositionForIntPtr(_bpRequestInfo.bpLocation.unionmember2);
string documentName;
EngineUtils.CheckOk(docPosition.GetFileName(out documentName));
// Get the location in the document that the breakpoint is in.
TEXT_POSITION[] startPosition = new TEXT_POSITION[1];
TEXT_POSITION[] endPosition = new TEXT_POSITION[1];
EngineUtils.CheckOk(docPosition.GetRange(startPosition, endPosition));
AD7MemoryAddress codeContext = new AD7MemoryAddress(_engine, address, functionName);
return(new AD7DocumentContext(new MITextPosition(documentName, startPosition[0], startPosition[0]), codeContext));
}
/// <summary>
/// Retrieves a list of the code contexts for a given position in a source file.
/// </summary>
/// <param name="pDocPos">An IDebugDocumentPosition2 object representing an abstract position in a source file known to the IDE.</param>
/// <param name="ppEnum">Returns an IEnumDebugCodeContexts2 object that contains a list of the code contexts.</param>
/// <returns>If successful, returns S_OK; otherwise, returns an error code.</returns>
/// <remarks>
/// This method allows the session debug manager (SDM) or IDE to map a source file position into a code
/// position. More than one code context is returned if the source generates multiple blocks of code (for
/// example, C++ templates).
/// </remarks>
public int EnumCodeContexts(IDebugDocumentPosition2 pDocPos, out IEnumDebugCodeContexts2 ppEnum)
{
if (pDocPos == null)
{
throw new ArgumentNullException("pDocPos");
}
string fileName = pDocPos.GetFileName();
int lineNumber = pDocPos.GetRange().iStartLine + 1;
List <IDebugCodeContext2> codeContexts = new List <IDebugCodeContext2>();
IEnumerable <JavaDebugProgram> programs = DebugEngine.Programs.ToArray();
foreach (var program in programs)
{
if (!program.IsLoaded)
{
continue;
}
IVirtualMachine virtualMachine = program.VirtualMachine;
ReadOnlyCollection <IReferenceType> classes = virtualMachine.GetAllClasses();
foreach (var @class in classes)
{
if ([email protected]())
{
continue;
}
ReadOnlyCollection <ILocation> locations = @class.GetLocationsOfLine(@class.GetDefaultStratum(), Path.GetFileName(fileName), lineNumber);
ILocation bindLocation = locations.OrderBy(i => i.GetCodeIndex()).FirstOrDefault();
if (bindLocation != null)
{
codeContexts.Add(new JavaDebugCodeContext(this, bindLocation));
}
}
}
if (codeContexts.Count == 0)
{
ppEnum = null;
return(VSConstants.E_FAIL);
}
ppEnum = new EnumDebugCodeContexts(codeContexts);
return(VSConstants.S_OK);
}
int IDebugProgram2.EnumCodeContexts(IDebugDocumentPosition2 pDocPos, out IEnumDebugCodeContexts2 ppEnum)
{
ThrowIfDisposed();
string fileName;
Marshal.ThrowExceptionForHR(pDocPos.GetFileName(out fileName));
var start = new TEXT_POSITION[1];
var end = new TEXT_POSITION[1];
Marshal.ThrowExceptionForHR(pDocPos.GetRange(start, end));
var addr = new AD7MemoryAddress(this, fileName, (int)start[0].dwLine);
ppEnum = new AD7CodeContextEnum(new[] { addr });
return(VSConstants.S_OK);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public int EnumCodeContexts(IDebugDocumentPosition2 pDocPos, out IEnumDebugCodeContexts2 ppEnum)
{
//
// Enumerates the code contexts for a given position in a source file.
//
LoggingUtils.PrintFunction();
try
{
string fileName;
TEXT_POSITION [] startPos = new TEXT_POSITION [1];
TEXT_POSITION [] endPos = new TEXT_POSITION [1];
LoggingUtils.RequireOk(pDocPos.GetFileName(out fileName));
LoggingUtils.RequireOk(pDocPos.GetRange(startPos, endPos));
string location = string.Format("\"{0}:{1}\"", fileName, startPos [0].dwLine + 1);
DebuggeeCodeContext codeContext = m_debugger.GetCodeContextForLocation(location);
if (codeContext == null)
{
throw new InvalidOperationException("Failed evaluating code-context for location.");
}
DebuggeeCodeContext [] codeContexts = new DebuggeeCodeContext [] { codeContext };
ppEnum = new DebuggeeCodeContext.Enumerator(codeContexts);
return(Constants.S_OK);
}
catch (Exception e)
{
LoggingUtils.HandleException(e);
ppEnum = null;
return(Constants.E_FAIL);
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public int EnumCodeContexts (IDebugDocumentPosition2 pDocPos, out IEnumDebugCodeContexts2 ppEnum)
{
//
// Enumerates the code contexts for a given position in a source file.
//
LoggingUtils.PrintFunction ();
try
{
string fileName;
TEXT_POSITION [] startPos = new TEXT_POSITION [1];
TEXT_POSITION [] endPos = new TEXT_POSITION [1];
LoggingUtils.RequireOk (pDocPos.GetFileName (out fileName));
LoggingUtils.RequireOk (pDocPos.GetRange (startPos, endPos));
DebuggeeDocumentContext documentContext = new DebuggeeDocumentContext (m_debugger.Engine, fileName, startPos [0], endPos [0]);
CLangDebuggeeCodeContext codeContext = CLangDebuggeeCodeContext.GetCodeContextForDocumentContext (m_debugger, documentContext);
if (codeContext == null)
{
throw new InvalidOperationException ("Failed evaluating code-context for location.");
}
CLangDebuggeeCodeContext [] codeContexts = new CLangDebuggeeCodeContext [] { codeContext };
ppEnum = new DebuggeeCodeContext.Enumerator (codeContexts);
return Constants.S_OK;
}
catch (Exception e)
{
LoggingUtils.HandleException (e);
ppEnum = null;
return Constants.E_FAIL;
}
}
// Enumerates the code contexts for a given position in a source file.
public int EnumCodeContexts(IDebugDocumentPosition2 docPosition, out IEnumDebugCodeContexts2 ppEnum)
{
string documentName;
EngineUtils.CheckOk(docPosition.GetFileName(out documentName));
// Get the location in the document
TEXT_POSITION[] startPosition = new TEXT_POSITION[1];
TEXT_POSITION[] endPosition = new TEXT_POSITION[1];
EngineUtils.CheckOk(docPosition.GetRange(startPosition, endPosition));
List <IDebugCodeContext2> codeContexts = new List <IDebugCodeContext2>();
List <ulong> addresses = null;
uint line = startPosition[0].dwLine + 1;
_debuggedProcess.WorkerThread.RunOperation(async() =>
{
addresses = await DebuggedProcess.StartAddressesForLine(documentName, line);
});
if (addresses != null && addresses.Count > 0)
{
foreach (var a in addresses)
{
var codeCxt = new AD7MemoryAddress(this, a, null);
TEXT_POSITION pos;
pos.dwLine = line;
pos.dwColumn = 0;
MITextPosition textPosition = new MITextPosition(documentName, pos, pos);
codeCxt.SetDocumentContext(new AD7DocumentContext(textPosition, codeCxt, this.DebuggedProcess));
codeContexts.Add(codeCxt);
}
if (codeContexts.Count > 0)
{
ppEnum = new AD7CodeContextEnum(codeContexts.ToArray());
return(Constants.S_OK);
}
}
ppEnum = null;
return(Constants.E_FAIL);
}
// Get the document context for this pending breakpoint. A document context is a abstract representation of a source file
// location.
public AD7DocumentContext GetDocumentContext(ulong address, string functionName)
{
if ((enum_BP_LOCATION_TYPE)_bpRequestInfo.bpLocation.bpLocationType == enum_BP_LOCATION_TYPE.BPLT_CODE_FILE_LINE)
{
IDebugDocumentPosition2 docPosition = HostMarshal.GetDocumentPositionForIntPtr(_bpRequestInfo.bpLocation.unionmember2);
string documentName;
EngineUtils.CheckOk(docPosition.GetFileName(out documentName));
// Get the location in the document that the breakpoint is in.
TEXT_POSITION[] startPosition = new TEXT_POSITION[1];
TEXT_POSITION[] endPosition = new TEXT_POSITION[1];
EngineUtils.CheckOk(docPosition.GetRange(startPosition, endPosition));
AD7MemoryAddress codeContext = new AD7MemoryAddress(_engine, address, functionName);
return(new AD7DocumentContext(new MITextPosition(documentName, startPosition[0], startPosition[0]), codeContext, _engine.DebuggedProcess));
}
else
{
return(null);
}
}
private int FindBreakpointLine()
{
IDebugDocumentPosition2 docPosition = (IDebugDocumentPosition2)(Marshal.GetObjectForIUnknown(_bpRequestInfo.bpLocation.unionmember2));
TEXT_POSITION[] startPosition = new TEXT_POSITION[1];
TEXT_POSITION[] endPosition = new TEXT_POSITION[1];
docPosition.GetRange(startPosition, endPosition);
_lineNumber = startPosition[0].dwLine + 1;
_beginPosition = startPosition[0];
_endPosition = endPosition[0];
string fileName;
docPosition.GetFileName(out fileName);
if (fileName != _node.FileName)
{
return(VSConstants.E_FAIL);
}
else
{
return(VSConstants.S_OK);
}
}
// Binds this pending breakpoint to one or more code locations.
int IDebugPendingBreakpoint2.Bind()
{
if (CanBind())
{
IDebugDocumentPosition2 docPosition = (IDebugDocumentPosition2)(Marshal.GetObjectForIUnknown(_bpRequestInfo.bpLocation.unionmember2));
// Get the name of the document that the breakpoint was put in
string documentName;
EngineUtils.CheckOk(docPosition.GetFileName(out documentName));
// Get the location in the document that the breakpoint is in.
TEXT_POSITION[] startPosition = new TEXT_POSITION[1];
TEXT_POSITION[] endPosition = new TEXT_POSITION[1];
EngineUtils.CheckOk(docPosition.GetRange(startPosition, endPosition));
lock (_boundBreakpoints) {
var bp = _engine.Process.AddBreakPoint(documentName, (int)(startPosition[0].dwLine + 1), _bpRequestInfo.bpCondition.bstrCondition, _bpRequestInfo.bpCondition.styleCondition == enum_BP_COND_STYLE.BP_COND_WHEN_TRUE ? false : true);
AD7BreakpointResolution breakpointResolution = new AD7BreakpointResolution(_engine, bp, GetDocumentContext(bp));
AD7BoundBreakpoint boundBreakpoint = new AD7BoundBreakpoint(_engine, bp, this, breakpointResolution);
_boundBreakpoints.Add(boundBreakpoint);
_bpManager.AddBoundBreakpoint(bp, boundBreakpoint);
if (_enabled)
{
bp.Add();
}
}
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);
}
}
public BreakpointLocationCodeFileLine(BP_LOCATION location, bool releaseComObjects)
{
Contract.Requires<ArgumentException>((enum_BP_LOCATION_TYPE)location.bpLocationType == enum_BP_LOCATION_TYPE.BPLT_CODE_FILE_LINE);
try
{
if (location.unionmember1 != IntPtr.Zero)
_context = Marshal.PtrToStringBSTR(location.unionmember1);
if (location.unionmember2 != IntPtr.Zero)
_documentPosition = Marshal.GetObjectForIUnknown(location.unionmember2) as IDebugDocumentPosition2;
}
finally
{
if (releaseComObjects)
{
if (location.unionmember1 != IntPtr.Zero)
Marshal.FreeBSTR(location.unionmember1);
if (location.unionmember2 != IntPtr.Zero)
Marshal.Release(location.unionmember2);
}
}
}
/// <summary>
/// Retrieves a list of the code contexts for a given position in a source file.
/// </summary>
/// <param name="pDocPos">An IDebugDocumentPosition2 object representing an abstract position in a source file known to the IDE.</param>
/// <param name="ppEnum">Returns an IEnumDebugCodeContexts2 object that contains a list of the code contexts.</param>
/// <returns>If successful, returns S_OK; otherwise, returns an error code.</returns>
/// <remarks>
/// This method allows the session debug manager (SDM) or IDE to map a source file position into a code
/// position. More than one code context is returned if the source generates multiple blocks of code (for
/// example, C++ templates).
/// </remarks>
public int EnumCodeContexts(IDebugDocumentPosition2 pDocPos, out IEnumDebugCodeContexts2 ppEnum)
{
if (pDocPos == null)
throw new ArgumentNullException("pDocPos");
string fileName = pDocPos.GetFileName();
int lineNumber = pDocPos.GetRange().iStartLine + 1;
List<IDebugCodeContext2> codeContexts = new List<IDebugCodeContext2>();
IEnumerable<JavaDebugProgram> programs = DebugEngine.Programs.ToArray();
foreach (var program in programs)
{
if (!program.IsLoaded)
continue;
IVirtualMachine virtualMachine = program.VirtualMachine;
ReadOnlyCollection<IReferenceType> classes = virtualMachine.GetAllClasses();
foreach (var @class in classes)
{
if ([email protected]())
continue;
ReadOnlyCollection<ILocation> locations = @class.GetLocationsOfLine(@class.GetDefaultStratum(), Path.GetFileName(fileName), lineNumber);
ILocation bindLocation = locations.OrderBy(i => i.GetCodeIndex()).FirstOrDefault();
if (bindLocation != null)
codeContexts.Add(new JavaDebugCodeContext(this, bindLocation));
}
}
if (codeContexts.Count == 0)
{
ppEnum = null;
return VSConstants.E_FAIL;
}
ppEnum = new EnumDebugCodeContexts(codeContexts);
return VSConstants.S_OK;
}
public int EnumCodeContexts(IDebugDocumentPosition2 pDocPos, out IEnumDebugCodeContexts2 ppEnum)
{
ppEnum = null;
return(VSConstants.E_NOTIMPL);
}
/// <summary>
/// Retrieves a list of the code contexts for a given position in a source file. Not implemented.
/// (http://msdn.microsoft.com/en-us/library/bb145902.aspx)
/// </summary>
/// <param name="pDocPos"> An object representing an abstract position in a source file known to the IDE. </param>
/// <param name="ppEnum"> Returns an IEnumDebugCodeContexts2 object that contains a list of the code contexts. </param>
/// <returns> Not implemented. </returns>
public int EnumCodeContexts(IDebugDocumentPosition2 pDocPos, out IEnumDebugCodeContexts2 ppEnum)
{
throw new Exception("The method or operation is not implemented.");
}
public int EnumCodeContexts(IDebugDocumentPosition2 pDocPos, out IEnumDebugCodeContexts2 ppEnum)
{
DLog.Debug(DContext.VSDebuggerComCall, "IDebugProgram2.EnumCodeContexts");
ppEnum = null;
string fileName;
if (ErrorHandler.Failed(pDocPos.GetFileName(out fileName)))
return VSConstants.E_INVALIDARG;
var beginPosition = new TEXT_POSITION[1];
var endPosition = new TEXT_POSITION[1];
if (ErrorHandler.Failed(pDocPos.GetRange(beginPosition, endPosition)))
return VSConstants.E_INVALIDARG;
// Search matching document
var doc = MapFile.FindDocument(fileName);
if (doc == null)
throw new ArgumentException("Unknown document " + fileName);
DLog.Debug(DContext.VSDebuggerComCall, "document {0} positions {1}/{2} - {3}/{4}", fileName, (int)beginPosition[0].dwLine, (int)beginPosition[0].dwColumn, (int)endPosition[0].dwLine, (int)endPosition[0].dwColumn);
// Search positions
var documentPositions = doc.FindAll((int)beginPosition[0].dwLine + 1, (int)beginPosition[0].dwColumn + 1, (int)endPosition[0].dwLine + 1, (int)endPosition[0].dwColumn + 1)
.ToList();
if (documentPositions.Count == 0)
{
DLog.Debug(DContext.VSDebuggerComCall, "found nothing.");
return VSConstants.E_FAIL;
}
List<DebugCodeContext> list = new List<DebugCodeContext>();
foreach (var pos in documentPositions)
{
var loc = GetLocationFromPositionAsync(pos).Await(VmTimeout);
if (loc == null)
continue;
// only find one location per method.
if(list.Any(c=>c.Location.IsSameMethod(loc.Location)))
continue;
var ctx = new DebugCodeContext(loc.Location);
ctx.DocumentContext = new DebugDocumentContext(loc, ctx);
DLog.Debug(DContext.VSDebuggerComCall, "found {0}: {1}", loc.Description, loc.Location);
list.Add(ctx);
}
DLog.Debug(DContext.VSDebuggerComCall, "done.");
if (list.Count == 0)
return VSConstants.E_FAIL;
ppEnum = new CodeContextEnum(list);
return VSConstants.S_OK;
}
// Enumerates the code contexts for a given position in a source file.
public int EnumCodeContexts(IDebugDocumentPosition2 pDocPos, out IEnumDebugCodeContexts2 ppEnum)
{
if (_mixedMode) {
ppEnum = null;
return VSConstants.E_NOTIMPL;
}
string filename;
pDocPos.GetFileName(out filename);
TEXT_POSITION[] beginning = new TEXT_POSITION[1], end = new TEXT_POSITION[1];
pDocPos.GetRange(beginning, end);
ppEnum = new AD7CodeContextEnum(new[] { new AD7MemoryAddress(this, filename, (uint)beginning[0].dwLine) });
return VSConstants.S_OK;
}
int IDebugProgram2.EnumCodeContexts(IDebugDocumentPosition2 pDocPos, out IEnumDebugCodeContexts2 ppEnum)
{
Debug.WriteLine("AD7ProgramNode: Entering EnumCodeContexts");
throw new NotImplementedException();
}
// Enumerates the code contexts for a given position in a source file.
public int EnumCodeContexts(IDebugDocumentPosition2 pDocPos, out IEnumDebugCodeContexts2 ppEnum) {
DebugWriteCommand("EnumCodeContexts");
string filename;
pDocPos.GetFileName(out filename);
TEXT_POSITION[] beginning = new TEXT_POSITION[1], end = new TEXT_POSITION[1];
pDocPos.GetRange(beginning, end);
ppEnum = new AD7CodeContextEnum(new[] { new AD7MemoryAddress(this, filename, (int)beginning[0].dwLine, (int)beginning[0].dwColumn) });
return VSConstants.S_OK;
}
public DebugDocumentCodeContext(IDebugDocumentPosition2 documentPosition)
{
Contract.Requires<ArgumentNullException>(documentPosition != null, "documentPosition");
_documentPosition = documentPosition;
}
// Enumerates the code contexts for a given position in a source file.
public int EnumCodeContexts(IDebugDocumentPosition2 pDocPos, out IEnumDebugCodeContexts2 ppEnum)
{
ppEnum = null;
return VSConstants.E_NOTIMPL;
}
int IDebugProgram2.EnumCodeContexts(IDebugDocumentPosition2 pDocPos, out IEnumDebugCodeContexts2 ppEnum) {
ThrowIfDisposed();
string fileName;
Marshal.ThrowExceptionForHR(pDocPos.GetFileName(out fileName));
var start = new TEXT_POSITION[1];
var end = new TEXT_POSITION[1];
Marshal.ThrowExceptionForHR(pDocPos.GetRange(start, end));
var addr = new AD7MemoryAddress(this, fileName, (int)start[0].dwLine);
ppEnum = new AD7CodeContextEnum(new[] { addr });
return VSConstants.S_OK;
}
int IDebugProgram3.EnumCodeContexts(IDebugDocumentPosition2 pDocPos, out IEnumDebugCodeContexts2 ppEnum) {
return IDebugProgram2.EnumCodeContexts(pDocPos, out ppEnum);
}
public int EnumCodeContexts(IDebugDocumentPosition2 pDocPos, out IEnumDebugCodeContexts2 ppEnum)
{
DLog.Debug(DContext.VSDebuggerComCall, "IDebugProgram2.EnumCodeContexts");
throw new NotImplementedException();
}
// Enumerates the code contexts for a given position in a source file.
public int EnumCodeContexts(IDebugDocumentPosition2 docPosition, out IEnumDebugCodeContexts2 ppEnum)
{
string documentName;
EngineUtils.CheckOk(docPosition.GetFileName(out documentName));
// Get the location in the document
TEXT_POSITION[] startPosition = new TEXT_POSITION[1];
TEXT_POSITION[] endPosition = new TEXT_POSITION[1];
EngineUtils.CheckOk(docPosition.GetRange(startPosition, endPosition));
List<IDebugCodeContext2> codeContexts = new List<IDebugCodeContext2>();
List<ulong> addresses = null;
uint line = startPosition[0].dwLine + 1;
_debuggedProcess.WorkerThread.RunOperation(async () =>
{
addresses = await DebuggedProcess.StartAddressesForLine(documentName, line);
});
if (addresses != null && addresses.Count > 0)
{
foreach (var a in addresses)
{
var codeCxt = new AD7MemoryAddress(this, a, null);
TEXT_POSITION pos;
pos.dwLine = line;
pos.dwColumn = 0;
MITextPosition textPosition = new MITextPosition(documentName, pos, pos);
codeCxt.SetDocumentContext(new AD7DocumentContext(textPosition, codeCxt, this.DebuggedProcess));
codeContexts.Add(codeCxt);
}
if (codeContexts.Count > 0)
{
ppEnum = new AD7CodeContextEnum(codeContexts.ToArray());
return Constants.S_OK;
}
}
ppEnum = null;
return Constants.E_FAIL;
}
public int EnumCodeContexts(IDebugDocumentPosition2 pDocPos, out IEnumDebugCodeContexts2 ppEnum) {
throw new NotImplementedException();
}
int Microsoft.VisualStudio.Debugger.Interop.IDebugProgram2.EnumCodeContexts(IDebugDocumentPosition2 pDocPos, out IEnumDebugCodeContexts2 ppEnum)
{
ppEnum = null;
return Utility.COM_HResults.S_OK;
}
/// <summary>
/// Retrieves a list of the code contexts for a given position in a source file.
/// </summary>
/// <param name="pDocPos">An IDebugDocumentPosition2 object representing an abstract position in a source file known to the IDE.</param>
/// <param name="ppEnum">Returns an IEnumDebugCodeContexts2 object that contains a list of the code contexts.</param>
/// <returns>If successful, returns S_OK; otherwise, returns an error code.</returns>
/// <remarks>This method allows the session debug manager (SDM) or IDE to map a source file position into a code position. More than one code context is returned if the source generates multiple blocks of code (for example, C++ templates).</remarks>
public virtual int EnumCodeContexts( IDebugDocumentPosition2 pDocPos, out IEnumDebugCodeContexts2 ppEnum )
{
Logger.Debug( string.Empty );
ppEnum = null;
return VSConstants.E_NOTIMPL;
}
