int IDebugPendingBreakpoint2.EnumErrorBreakpoints(
enum_BP_ERROR_TYPE bpErrorType,
out IEnumDebugErrorBreakpoints2 ppEnum)
{
ppEnum = null;
return(VSConstants.S_OK);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public int EnumErrorBreakpoints(enum_BP_ERROR_TYPE bpErrorType, out IEnumDebugErrorBreakpoints2 ppEnum)
{
//
// Enumerates all error breakpoints that resulted from this pending breakpoint.
//
LoggingUtils.PrintFunction();
try
{
ppEnum = new DebuggeeBreakpointError.Enumerator(m_errorBreakpoints.ToArray());
if (m_breakpointDeleted)
{
return(Constants.E_BP_DELETED);
}
return(Constants.S_OK);
}
catch (Exception e)
{
LoggingUtils.HandleException(e);
ppEnum = null;
return(Constants.E_FAIL);
}
}
public DebugBreakpointError(IDebugPendingBreakpoint2 pendingBreakpoint,
enum_BP_ERROR_TYPE errorType, string errorMessage)
{
_pendingBreakpoint = pendingBreakpoint;
_errorType = errorType;
_errorMessage = errorMessage;
}
public int EnumErrorBreakpoints(enum_BP_ERROR_TYPE breakpointErrorType,
out IEnumDebugErrorBreakpoints2 errorBreakpointsEnum)
{
IDebugErrorBreakpoint2[] breakpointErrors = new IDebugErrorBreakpoint2[1];
breakpointErrors[0] = _breakpointError;
errorBreakpointsEnum = _breakpointErrorEnumFactory.Create(breakpointErrors);
return(VSConstants.S_OK);
}
// Enumerates all error breakpoints that resulted from this pending breakpoint.
int IDebugPendingBreakpoint2.EnumErrorBreakpoints(enum_BP_ERROR_TYPE bpErrorType, out IEnumDebugErrorBreakpoints2 ppEnum)
{
// Called when a pending 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 enumeration of IDebugErrorBreakpoint2 from IDebugPendingBreakpoint2::EnumErrorBreakpoints. The debugger will then
// display information about why the breakpoint did not bind to the user.
ppEnum = null;
return(EngineConstants.E_NOTIMPL);
}
// Enumerates all error breakpoints that resulted from this pending breakpoint.
int IDebugPendingBreakpoint2.EnumErrorBreakpoints(enum_BP_ERROR_TYPE bpErrorType, out IEnumDebugErrorBreakpoints2 ppEnum)
{
// Called when a pending breakpoint could not be bound. This may occur for many reasons such as an invalid location, an invalid expression, etc...
// TODO: send an instance of IDebugBreakpointErrorEvent2 to the UI and return a valid enumeration of IDebugErrorBreakpoint2
// from IDebugPendingBreakpoint2::EnumErrorBreakpoints. The debugger will then display information about why the breakpoint
// did not bind to the user.
ppEnum = null;
return(VSConstants.E_NOTIMPL);
}
/// <summary>
/// Enumerates all error breakpoints that resulted from this pending breakpoint.
/// </summary>
public int EnumErrorBreakpoints(enum_BP_ERROR_TYPE bpErrorType, out IEnumDebugErrorBreakpoints2 ppEnum)
{
DLog.Debug(DContext.VSDebuggerComCall, "DebugPendingBreakpoint.EnumErrorBreakpoints");
if (IsDeleted)
{
ppEnum = null;
return(HResults.E_BP_DELETED);
}
throw new NotImplementedException();
}
public int EnumErrorBreakpoints(enum_BP_ERROR_TYPE bpErrorType, out IEnumDebugErrorBreakpoints2 ppEnum)
{
if (_deleted)
{
ppEnum = null;
return(AD7Constants.E_BP_DELETED);
}
ppEnum = new EnumDebugErrorBreakpoints(_errorBreakpoints);
return(VSConstants.S_OK);
}
public int EnumErrorBreakpoints(enum_BP_ERROR_TYPE bpErrorType, out IEnumDebugErrorBreakpoints2 ppEnum)
{
if (_errorBreakpoint != null)
{
ppEnum = new AD7ErrorBreakpointsEnum(new[] { _errorBreakpoint });
}
else
{
ppEnum = null;
}
return(Constants.S_OK);
}
// Enumerates all error breakpoints that resulted from this pending breakpoint.
int IDebugPendingBreakpoint2.EnumErrorBreakpoints(enum_BP_ERROR_TYPE bpErrorType, out IEnumDebugErrorBreakpoints2 ppEnum)
{
// Called when a pending breakpoint could not be bound. This may occur for many reasons such as an invalid location, an invalid expression, etc...
// Return a valid enumeration of IDebugErrorBreakpoint2 from IDebugPendingBreakpoint2::EnumErrorBreakpoints, allowing the debugger to
// display information about why the breakpoint did not bind to the user.
lock (_breakpointErrors) {
IDebugErrorBreakpoint2[] breakpointErrors = _breakpointErrors.Cast <IDebugErrorBreakpoint2>().ToArray();
ppEnum = new AD7ErrorBreakpointsEnum(breakpointErrors);
}
return(VSConstants.S_OK);
}
int IDebugPendingBreakpoint2.EnumErrorBreakpoints(enum_BP_ERROR_TYPE bpErrorType, out IEnumDebugErrorBreakpoints2 ppEnum)
{
Debug.WriteLine("AD7Breakpoint: EnumErrorBreakpoints");
if (((bpErrorType & enum_BP_ERROR_TYPE.BPET_GENERAL_WARNING) != 0) ||
((bpErrorType & enum_BP_ERROR_TYPE.BPET_TYPE_ERROR) != 0))
{
ppEnum = enumError;
}
else
{
ppEnum = null;
}
return(VSConstants.S_OK);
}
// Token: 0x060000D7 RID: 215 RVA: 0x00004566 File Offset: 0x00002766
public int EnumErrorBreakpoints(enum_BP_ERROR_TYPE bpErrorType, out IEnumDebugErrorBreakpoints2 ppEnum)
{
if (this.error_breakpoint != null)
{
ppEnum = new AD7ErrorBreakpointsEnum(new IDebugErrorBreakpoint2[]
{
this.error_breakpoint
});
}
else
{
ppEnum = new AD7ErrorBreakpointsEnum(new IDebugErrorBreakpoint2[0]);
}
return(0);
}
public DebugErrorBreakpointResolution(IDebugProgram2 program, IDebugThread2 thread, enum_BP_TYPE breakpointType, BreakpointResolutionLocation location, enum_BP_ERROR_TYPE errorType, string message)
{
//Contract.Requires<ArgumentNullException>(program != null, "program");
//Contract.Requires<ArgumentNullException>(thread != null, "thread");
Contract.Requires <ArgumentNullException>(message != null, "message");
Contract.Requires <ArgumentNullException>(location != null, "location");
Contract.Requires <ArgumentException>(!string.IsNullOrEmpty(message));
_program = program;
_thread = thread;
_breakpointType = breakpointType;
_errorType = errorType;
_location = location;
_message = message;
}
// Enumerates all error breakpoints that resulted from this pending breakpoint.
int IDebugPendingBreakpoint2.EnumErrorBreakpoints(enum_BP_ERROR_TYPE bpErrorType, out IEnumDebugErrorBreakpoints2 ppEnum)
{
// Called when a pending 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 enumeration of IDebugErrorBreakpoint2 from IDebugPendingBreakpoint2::EnumErrorBreakpoints. The debugger will then
// display information about why the breakpoint did not bind to the user.
if ((_BPError != null) && ((bpErrorType & enum_BP_ERROR_TYPE.BPET_TYPE_ERROR) != 0))
{
IDebugErrorBreakpoint2[] errlist = new IDebugErrorBreakpoint2[1];
errlist[0] = _BPError;
ppEnum = new AD7ErrorBreakpointsEnum(errlist);
return(Constants.S_OK);
}
else
{
ppEnum = null;
return(Constants.S_FALSE);
}
}
public int EnumErrorBreakpoints(enum_BP_ERROR_TYPE breakpointErrorType,
out IEnumDebugErrorBreakpoints2 errorBreakpointsEnum)
{
errorBreakpointsEnum = null;
if (_deleted)
{
return(AD7Constants.E_BP_DELETED);
}
IDebugErrorBreakpoint2[] breakpointErrors;
if (_breakpointError == null)
{
breakpointErrors = new IDebugErrorBreakpoint2[0];
}
else
{
breakpointErrors = new IDebugErrorBreakpoint2[1];
breakpointErrors[0] = _breakpointError;
}
errorBreakpointsEnum = _breakpointErrorEnumFactory.Create(breakpointErrors);
return(VSConstants.S_OK);
}
public int EnumErrorBreakpoints(enum_BP_ERROR_TYPE bpErrorType, out IEnumDebugErrorBreakpoints2 ppEnum)
{
Log.Debug("ScriptBreakpoint: EnumErrorBreakpoints");
ppEnum = null;
return VSConstants.S_OK;
}
public AD7ErrorBreakpointResolution(string msg, enum_BP_ERROR_TYPE errorType = enum_BP_ERROR_TYPE.BPET_GENERAL_WARNING)
{
_message = msg;
_errorType = errorType;
}
public int EnumErrorBreakpoints(enum_BP_ERROR_TYPE bpErrorType, out IEnumDebugErrorBreakpoints2 ppEnum)
{
ppEnum = null;
return(VSConstants.E_NOTIMPL);
}
public AD7ErrorBreakpoint(AD7PendingBreakpoint pending, string errormsg, enum_BP_ERROR_TYPE errorType = enum_BP_ERROR_TYPE.BPET_GENERAL_WARNING)
{
_pending = pending;
_error = errormsg;
_errorType = errorType;
}
public int EnumErrorBreakpoints(enum_BP_ERROR_TYPE bpErrorType, out IEnumDebugErrorBreakpoints2 ppEnum)
{
throw new NotImplementedException();
}
public AD7ErrorBreakpointResolution(string msg, enum_BP_ERROR_TYPE errorType = enum_BP_ERROR_TYPE.BPET_GENERAL_WARNING)
{
_message = msg;
_errorType = errorType;
}
public int EnumErrorBreakpoints(enum_BP_ERROR_TYPE bpErrorType, out IEnumDebugErrorBreakpoints2 ppEnum)
{
if (_deleted)
{
ppEnum = null;
return AD7Constants.E_BP_DELETED;
}
ppEnum = new EnumDebugErrorBreakpoints(_errorBreakpoints);
return VSConstants.S_OK;
}
public int EnumErrorBreakpoints(enum_BP_ERROR_TYPE bpErrorType, out IEnumDebugErrorBreakpoints2 ppEnum)
{
Log.Debug("ScriptBreakpoint: EnumErrorBreakpoints");
ppEnum = null;
return(VSConstants.S_OK);
}
/// <summary>
/// Enumerates all error breakpoints that resulted from this pending breakpoint.
/// </summary>
public int EnumErrorBreakpoints(enum_BP_ERROR_TYPE bpErrorType, out IEnumDebugErrorBreakpoints2 ppEnum)
{
DLog.Debug(DContext.VSDebuggerComCall, "DebugPendingBreakpoint.EnumErrorBreakpoints");
if (IsDeleted)
{
ppEnum = null;
return HResults.E_BP_DELETED;
}
throw new NotImplementedException();
}
int IDebugPendingBreakpoint2.EnumErrorBreakpoints(enum_BP_ERROR_TYPE bpErrorType, out IEnumDebugErrorBreakpoints2 ppEnum) {
ppEnum = null;
return VSConstants.E_NOTIMPL;
}
public AD7ErrorBreakpoint(AD7PendingBreakpoint pending, string errormsg, enum_BP_ERROR_TYPE errorType = enum_BP_ERROR_TYPE.BPET_GENERAL_WARNING)
{
_pending = pending;
_error = errormsg;
_errorType = errorType;
}
public int EnumErrorBreakpoints(enum_BP_ERROR_TYPE bpErrorType, out IEnumDebugErrorBreakpoints2 ppEnum)
{
throw new NotImplementedException();
}
int IDebugPendingBreakpoint2.EnumErrorBreakpoints(enum_BP_ERROR_TYPE bpErrorType, out IEnumDebugErrorBreakpoints2 ppEnum)
{
Debug.WriteLine("AD7Breakpoint: EnumErrorBreakpoints");
if ( ((bpErrorType & enum_BP_ERROR_TYPE.BPET_GENERAL_WARNING) != 0) ||
(( bpErrorType & enum_BP_ERROR_TYPE.BPET_TYPE_ERROR ) != 0 ))
{
ppEnum = enumError;
}
else
{
ppEnum = null;
}
return VSConstants.S_OK;
}
// Enumerates all error breakpoints that resulted from this pending breakpoint.
int IDebugPendingBreakpoint2.EnumErrorBreakpoints(enum_BP_ERROR_TYPE bpErrorType, out IEnumDebugErrorBreakpoints2 ppEnum) {
// Called when a pending breakpoint could not be bound. This may occur for many reasons such as an invalid location, an invalid expression, etc...
// Return a valid enumeration of IDebugErrorBreakpoint2 from IDebugPendingBreakpoint2::EnumErrorBreakpoints, allowing the debugger to
// display information about why the breakpoint did not bind to the user.
lock (_breakpointErrors) {
IDebugErrorBreakpoint2[] breakpointErrors = _breakpointErrors.Cast<IDebugErrorBreakpoint2>().ToArray();
ppEnum = new AD7ErrorBreakpointsEnum(breakpointErrors);
}
return VSConstants.S_OK;
}
// Enumerates all error breakpoints that resulted from this pending breakpoint.
int IDebugPendingBreakpoint2.EnumErrorBreakpoints(enum_BP_ERROR_TYPE bpErrorType, out IEnumDebugErrorBreakpoints2 ppEnum)
{
// Called when a pending 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 enumeration of IDebugErrorBreakpoint2 from IDebugPendingBreakpoint2::EnumErrorBreakpoints. The debugger will then
// display information about why the breakpoint did not bind to the user.
if ((_BPError != null) && ((bpErrorType & enum_BP_ERROR_TYPE.BPET_TYPE_ERROR) != 0))
{
IDebugErrorBreakpoint2[] errlist = new IDebugErrorBreakpoint2[1];
errlist[0] = _BPError;
ppEnum = new AD7ErrorBreakpointsEnum(errlist);
return Constants.S_OK;
}
else
{
ppEnum = null;
return Constants.S_FALSE;
}
}
/// <summary>
/// Gets a list of all error breakpoints that resulted from this pending breakpoint.
/// </summary>
/// <param name="bpErrorType">A combination of values from the BP_ERROR_TYPE enumeration that selects the type of errors to enumerate.</param>
/// <param name="ppEnum">Returns an IEnumDebugErrorBreakpoints2 object that contains a list of IDebugErrorBreakpoint2 objects.</param>
/// <returns>If successful, returns S_OK; otherwise, returns an error code. Returns E_BP_DELETED if the breakpoint has been deleted.</returns>
public virtual int EnumErrorBreakpoints( enum_BP_ERROR_TYPE bpErrorType, out IEnumDebugErrorBreakpoints2 ppEnum )
{
Logger.Debug( string.Empty );
ppEnum = null;
return VSConstants.E_NOTIMPL;
}
// Enumerates all error breakpoints that resulted from this pending breakpoint.
int IDebugPendingBreakpoint2.EnumErrorBreakpoints(enum_BP_ERROR_TYPE bpErrorType, out IEnumDebugErrorBreakpoints2 ppEnum)
{
// Called when a pending 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 enumeration of IDebugErrorBreakpoint2 from IDebugPendingBreakpoint2::EnumErrorBreakpoints. The debugger will then
// display information about why the breakpoint did not bind to the user.
ppEnum = null;
return VSConstants.E_NOTIMPL;
}
public int EnumErrorBreakpoints(enum_BP_ERROR_TYPE errorType, out IEnumDebugErrorBreakpoints2 enumerator)
{
enumerator = null;
return(VSConstants.S_OK);
}
/// <summary>
/// Caches the error, and notifies the DebugEngine that an error occurred with the pending
/// breakpoint. Calling this multiple times will overwrite the previously cached error.
/// </summary>
void SetError(enum_BP_ERROR_TYPE errorType, string errorMessage)
{
_breakpointError = new DebugBreakpointError(Self, errorType, errorMessage);
_breakpointManager.ReportBreakpointError(_breakpointError);
}
/// <summary>
/// Gets a list of all error breakpoints that resulted from this pending breakpoint.
/// </summary>
/// <param name="bpErrorType">A combination of values from the BP_ERROR_TYPE enumeration that selects the type of errors to enumerate.</param>
/// <param name="ppEnum">Returns an IEnumDebugErrorBreakpoints2 object that contains a list of IDebugErrorBreakpoint2 objects.</param>
/// <returns>If successful, returns S_OK; otherwise, returns an error code. Returns E_BP_DELETED if the breakpoint has been deleted.</returns>
public virtual int EnumErrorBreakpoints(enum_BP_ERROR_TYPE bpErrorType, out IEnumDebugErrorBreakpoints2 ppEnum)
{
Logger.Debug(string.Empty);
ppEnum = null;
return(VSConstants.E_NOTIMPL);
}
