public int SetCondition(BP_CONDITION condition)
{
breakpoint.ConditionExpression = condition.bstrCondition;
breakpoint.BreakIfConditionChanges = condition.styleCondition == enum_BP_COND_STYLE.BP_COND_WHEN_CHANGED;
return(VSConstants.S_OK);
}
public int SetCondition(BP_CONDITION bpCondition)
{
Debug.WriteLine("AD7Breakpoint: SetCondition");
EnumBreakpointConditionStyle style = EnumBreakpointConditionStyle.None;
switch (bpCondition.styleCondition)
{
case enum_BP_COND_STYLE.BP_COND_WHEN_CHANGED:
style = EnumBreakpointConditionStyle.WhenChanged;
break;
case enum_BP_COND_STYLE.BP_COND_WHEN_TRUE:
style = EnumBreakpointConditionStyle.WhenTrue;
break;
}
try
{
CoreBreakpoint.SetCondition(bpCondition.bstrCondition, style);
}
catch (DebuggerException e)
{
MessageBox.Show(e.Message, "Error when setting condition breakpoint", MessageBoxButtons.OK);
return(VSConstants.E_FAIL);
}
return(VSConstants.S_OK);
}
int IDebugPendingBreakpoint2.SetCondition(BP_CONDITION bpCondition)
{
PendingBreakpoint bp = null;
lock (_boundBreakpoints)
{
if (!VerifyCondition(bpCondition) || IsDataBreakpoint)
{
this.SetError(new AD7ErrorBreakpoint(this, ResourceStrings.UnsupportedConditionalBreakpoint, enum_BP_ERROR_TYPE.BPET_GENERAL_ERROR), true);
return(Constants.E_FAIL);
}
if ((_bpRequestInfo.dwFields & enum_BPREQI_FIELDS.BPREQI_CONDITION) != 0 &&
_bpRequestInfo.bpCondition.styleCondition == bpCondition.styleCondition &&
_bpRequestInfo.bpCondition.bstrCondition == bpCondition.bstrCondition)
{
return(Constants.S_OK); // this condition was already set
}
_bpRequestInfo.bpCondition = bpCondition;
_bpRequestInfo.dwFields |= enum_BPREQI_FIELDS.BPREQI_CONDITION;
if (_bp != null)
{
bp = _bp;
}
}
if (bp != null)
{
_engine.DebuggedProcess.WorkerThread.RunOperation(() =>
{
_engine.DebuggedProcess.AddInternalBreakAction(
() => bp.SetConditionAsync(bpCondition.bstrCondition, _engine.DebuggedProcess)
);
});
}
return(Constants.S_OK);
}
public int SetCondition(BP_CONDITION bpCondition)
{
_monoBreakpoint.ConditionExpression = bpCondition.bstrCondition;
_monoBreakpoint.BreakIfConditionChanges = (bpCondition.styleCondition == (uint)enum_BP_COND_STYLE.BP_COND_WHEN_CHANGED);
return(S_OK);
}
public int SetCondition(BP_CONDITION bpCondition)
{
if (_deleted)
{
return(AD7Constants.E_BP_DELETED);
}
if (_lldbWatchpoint == null)
{
return(VSConstants.S_FALSE);
}
switch (bpCondition.styleCondition)
{
case enum_BP_COND_STYLE.BP_COND_NONE:
_lldbWatchpoint.SetCondition("");
break;
case enum_BP_COND_STYLE.BP_COND_WHEN_TRUE:
_lldbWatchpoint.SetCondition(bpCondition.bstrCondition);
break;
default:
return(VSConstants.E_NOTIMPL);
}
return(VSConstants.S_OK);
}
public int SetCondition(BP_CONDITION bpCondition)
{
if (_deleted)
{
return(AD7Constants.E_BP_DELETED);
}
throw new NotImplementedException();
}
public int SetCondition(BP_CONDITION bpCondition)
{
DLog.Debug(DContext.VSDebuggerComCall, "DebugBoundBreakpoint.SetCondition");
if (IsDeleted)
{
return(HResults.E_BP_DELETED);
}
return(pendingBreakpoint.SetCondition(bpCondition));
}
/// <summary>
/// Sets or changes the condition associated with this pending breakpoint.
/// </summary>
public int SetCondition(BP_CONDITION bpCondition)
{
DLog.Debug(DContext.VSDebuggerComCall, "DebugPendingBreakpoint.SetCondition");
if (IsDeleted)
{
return(HResults.E_BP_DELETED);
}
throw new NotImplementedException();
}
int IDebugPendingBreakpoint2.SetCondition(BP_CONDITION bpCondition)
{
if (bpCondition.styleCondition == enum_BP_COND_STYLE.BP_COND_WHEN_CHANGED)
{
return(VSConstants.E_NOTIMPL);
}
this._bpRequestInfo.bpCondition = bpCondition;
return(VSConstants.S_OK);
}
public int SetCondition(BP_CONDITION breakpointCondition)
{
if (_deleted)
{
return(AD7Constants.E_BP_DELETED);
}
_breakpointCondition.VariableCondition = breakpointCondition;
return(VSConstants.S_OK);
}
private bool VerifyCondition(BP_CONDITION request)
{
switch (request.styleCondition)
{
case enum_BP_COND_STYLE.BP_COND_NONE:
return true;
case enum_BP_COND_STYLE.BP_COND_WHEN_TRUE:
return request.bstrCondition != null;
default:
return false;
}
}
// Token: 0x06000039 RID: 57 RVA: 0x00002E7B File Offset: 0x0000107B
public virtual int SetCondition(BP_CONDITION bpCondition)
{
if (bpCondition.styleCondition == enum_BP_COND_STYLE.BP_COND_NONE)
{
this.Handle.ConditionExpression = null;
}
else
{
this.Handle.ConditionExpression = bpCondition.bstrCondition;
this.Handle.BreakIfConditionChanges = (bpCondition.styleCondition == enum_BP_COND_STYLE.BP_COND_WHEN_CHANGED);
}
return(0);
}
private bool VerifyCondition(BP_CONDITION request)
{
switch (request.styleCondition)
{
case enum_BP_COND_STYLE.BP_COND_NONE:
return(true);
case enum_BP_COND_STYLE.BP_COND_WHEN_TRUE:
return(request.bstrCondition != null);
default:
return(false);
}
}
int IDebugBoundBreakpoint2.SetCondition(BP_CONDITION bpCondition)
{
if (bpCondition.styleCondition == enum_BP_COND_STYLE.BP_COND_WHEN_CHANGED)
{
return(VSConstants.E_NOTIMPL);
}
if (!this._breakpointBinding.SetConditionAsync(bpCondition.bstrCondition).GetAwaiter().GetResult())
{
return(VSConstants.E_FAIL);
}
return(VSConstants.S_OK);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public virtual int SetCondition(BP_CONDITION bpCondition)
{
//
// Sets or changes the condition associated with this bound breakpoint.
//
LoggingUtils.PrintFunction();
if (m_breakpointDeleted)
{
return(Constants.E_BP_DELETED);
}
return(Constants.S_OK);
}
public int SetCondition(BP_CONDITION breakpointCondition)
{
if (_deleted)
{
return(AD7Constants.E_BP_DELETED);
}
switch (breakpointCondition.styleCondition)
{
case enum_BP_COND_STYLE.BP_COND_NONE:
_breakpointLocation.SetCondition("");
break;
case enum_BP_COND_STYLE.BP_COND_WHEN_TRUE:
_breakpointLocation.SetCondition(breakpointCondition.bstrCondition);
break;
default:
return(VSConstants.E_NOTIMPL);
}
return(VSConstants.S_OK);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public int SetCondition(BP_CONDITION bpCondition)
{
//
// Sets or changes the condition associated with this pending breakpoint.
//
LoggingUtils.PrintFunction();
try
{
foreach (DebuggeeBreakpointBound boundBreakpoint in m_boundBreakpoints.ToArray())
{
LoggingUtils.RequireOk(boundBreakpoint.SetCondition(bpCondition));
}
return(Constants.S_OK);
}
catch (Exception e)
{
LoggingUtils.HandleException(e);
return(Constants.E_FAIL);
}
}
int IDebugBoundBreakpoint2.SetCondition(BP_CONDITION bpCondition)
{
return ((IDebugPendingBreakpoint2)_pendingBreakpoint).SetCondition(bpCondition); // setting on the pending break will set the condition
}
/// <summary>
/// Sets the conditions under which a conditional breakpoint fires. (http://msdn.microsoft.com/en-us/library/bb146215.aspx)
/// </summary>
/// <param name="bpCondition"> Describes the conditions under which a breakpoint fires. </param>
/// <returns> VSConstants.S_OK if successful, VSConstants.S_FALSE if not. </returns>
public int SetCondition(BP_CONDITION bpCondition)
{
bool updatingCondBreak = this.m_engine.m_updatingConditionalBreakpoint.WaitOne(0);
bool isRunning = false;
bool verifyCondition = false;
int result = VSConstants.S_FALSE;
while (!m_engine.eDispatcher.lockedBreakpoint(this, false, true))
{
Thread.Sleep(0);
}
if (m_hitCount != 0)
{
m_engine.eDispatcher.resetHitCount(this, false);
}
while (!m_engine.eDispatcher.enterCriticalRegion())
{
Thread.Sleep(0);
}
if ((m_engine.m_state == AD7Engine.DE_STATE.RUN_MODE) && (EventDispatcher.m_GDBRunMode == true))
{
isRunning = true;
m_engine.eDispatcher.prepareToModifyBreakpoint();
m_engine.m_state = AD7Engine.DE_STATE.BREAK_MODE;
}
m_bpCondition = bpCondition;
if (bpCondition.styleCondition == enum_BP_COND_STYLE.BP_COND_WHEN_TRUE)
{
if (m_breakWhenCondChanged)
{
m_breakWhenCondChanged = false;
verifyCondition = true;
}
else
m_breakWhenCondChanged = false;
m_previousCondEvaluation = "";
if (m_engine.eDispatcher.setBreakpointCondition(GDB_ID, bpCondition.bstrCondition))
result = VSConstants.S_OK;
}
else if (bpCondition.styleCondition == enum_BP_COND_STYLE.BP_COND_WHEN_CHANGED)
{
m_breakWhenCondChanged = true;
m_previousCondEvaluation = bpCondition.bstrCondition; // just to initialize this variable
m_engine.eDispatcher.ignoreHitCount(GDB_ID, 1); // have to break always to evaluate this option because GDB doesn't support it.
m_engine.eDispatcher.setBreakpointCondition(GDB_ID, "");
result = VSConstants.S_OK;
}
else if (bpCondition.styleCondition == enum_BP_COND_STYLE.BP_COND_NONE)
{
if (m_breakWhenCondChanged)
{
m_breakWhenCondChanged = false;
verifyCondition = true;
}
else
m_breakWhenCondChanged = false;
m_previousCondEvaluation = "";
if (m_engine.eDispatcher.setBreakpointCondition(GDB_ID, ""))
result = VSConstants.S_OK;
}
m_engine.eDispatcher.leaveCriticalRegion();
m_engine.eDispatcher.unlockBreakpoint(this, false, true);
if (verifyCondition)
{
SetPassCount(m_bpPassCount);
verifyCondition = false;
}
if (isRunning)
{
isRunning = false;
m_engine.m_state = AD7Engine.DE_STATE.RUN_MODE;
m_engine.eDispatcher.resumeFromInterrupt();
}
this.m_engine.m_updatingConditionalBreakpoint.Set();
return result;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public override int SetCondition (BP_CONDITION bpCondition)
{
//
// Sets or changes the condition associated with this bound breakpoint.
//
LoggingUtils.PrintFunction ();
try
{
int handle = base.SetCondition (bpCondition);
if (handle == Constants.E_BP_DELETED)
{
return handle;
}
LoggingUtils.RequireOk (handle);
string condition = string.Empty;
switch (bpCondition.styleCondition)
{
case enum_BP_COND_STYLE.BP_COND_WHEN_TRUE:
{
condition = bpCondition.bstrCondition;
break;
}
case enum_BP_COND_STYLE.BP_COND_WHEN_CHANGED:
{
throw new NotImplementedException ();
}
}
if (!string.IsNullOrEmpty (condition))
{
m_debugger.RunInterruptOperation (delegate (CLangDebugger debugger)
{
string command = string.Format ("-break-condition {0} \"{1}\"", GdbBreakpoint.ID, condition);
debugger.GdbClient.SendCommand (command, delegate (MiResultRecord resultRecord)
{
MiResultRecord.RequireOk (resultRecord, command);
});
});
}
return Constants.S_OK;
}
catch (NotImplementedException e)
{
LoggingUtils.HandleException (e);
return Constants.E_NOTIMPL;
}
catch (Exception e)
{
LoggingUtils.HandleException (e);
return Constants.E_FAIL;
}
}
public int SetCondition(BP_CONDITION bpCondition)
{
return(VSConstants.E_NOTIMPL);
}
/// <summary>
/// Sets or changes the condition associated with this bound breakpoint. (http://msdn.microsoft.com/en-us/library/bb146215.aspx)
/// </summary>
/// <param name="bpCondition"> Describes the condition. </param>
/// <returns> VSConstants.S_OK if successful, VSConstants.S_FALSE if not. </returns>
int IDebugBoundBreakpoint2.SetCondition(BP_CONDITION bpCondition)
{
return SetCondition(bpCondition);
}
/// <summary>
/// Sets or changes the condition associated with this bound breakpoint.
/// </summary>
/// <param name="bpCondition">The breakpoint condition.</param>
/// <returns>If successful, returns S_OK; otherwise, returns an error code.</returns>
public int SetCondition(BP_CONDITION bpCondition)
{
return(S_OK);
}
int IDebugPendingBreakpoint2.SetCondition(BP_CONDITION bpCondition)
{
PendingBreakpoint bp = null;
lock (_boundBreakpoints)
{
if (!VerifyCondition(bpCondition) || IsDataBreakpoint)
{
this.SetError(new AD7ErrorBreakpoint(this, ResourceStrings.UnsupportedConditionalBreakpoint, enum_BP_ERROR_TYPE.BPET_GENERAL_ERROR), true);
return Constants.E_FAIL;
}
if ((_bpRequestInfo.dwFields & enum_BPREQI_FIELDS.BPREQI_CONDITION) != 0
&& _bpRequestInfo.bpCondition.styleCondition == bpCondition.styleCondition
&& _bpRequestInfo.bpCondition.bstrCondition == bpCondition.bstrCondition)
{
return Constants.S_OK; // this condition was already set
}
_bpRequestInfo.bpCondition = bpCondition;
_bpRequestInfo.dwFields |= enum_BPREQI_FIELDS.BPREQI_CONDITION;
if (_bp != null)
{
bp = _bp;
}
}
if (bp != null)
{
_engine.DebuggedProcess.WorkerThread.RunOperation(() =>
{
_engine.DebuggedProcess.AddInternalBreakAction(
() => bp.SetConditionAsync(bpCondition.bstrCondition, _engine.DebuggedProcess)
);
});
}
return Constants.S_OK;
}
// The sample engine does not support conditions on breakpoints.
// A real-world debugger will use this to specify when a breakpoint will be hit
// and when it should be ignored.
int IDebugBoundBreakpoint2.SetCondition(BP_CONDITION bpCondition)
{
_breakpoint.SetCondition(bpCondition.bstrCondition, bpCondition.styleCondition == enum_BP_COND_STYLE.BP_COND_WHEN_CHANGED ? true : false);
return(VSConstants.S_OK);
}
// The sample engine does not support conditions on breakpoints.
// A real-world debugger will use this to specify when a breakpoint will be hit
// and when it should be ignored.
int IDebugBoundBreakpoint2.SetCondition(BP_CONDITION bpCondition)
{
//throw new NotImplementedException();
return(EngineConstants.E_NOTIMPL);
}
// The sample engine does not support conditions on breakpoints.
// A real-world debugger will use this to specify when a breakpoint will be hit
// and when it should be ignored.
int IDebugBoundBreakpoint2.SetCondition(BP_CONDITION bpCondition)
{
_breakpoint.SetCondition(bpCondition.bstrCondition, bpCondition.styleCondition == enum_BP_COND_STYLE.BP_COND_WHEN_CHANGED ? true : false);
return VSConstants.S_OK;
}
public int SetCondition(BP_CONDITION bpCondition)
{
throw new NotImplementedException();
}
// Token: 0x060000DA RID: 218 RVA: 0x000045F1 File Offset: 0x000027F1
public virtual int SetCondition(BP_CONDITION bpCondition)
{
return(-2147467263);
}
int IDebugBoundBreakpoint2.SetCondition(BP_CONDITION bpCondition)
{
return(VSConstants.E_NOTIMPL);
}
// The sample engine does not support conditions on breakpoints.
// A real-world debugger will use this to specify when a breakpoint will be hit
// and when it should be ignored.
int IDebugBoundBreakpoint2.SetCondition(BP_CONDITION bpCondition)
{
_breakpoint.Condition = bpCondition.bstrCondition;
return(VSConstants.S_OK);
}
// The sample engine does not support conditions on breakpoints.
int IDebugPendingBreakpoint2.SetCondition(BP_CONDITION bpCondition) {
throw new NotImplementedException();
}
int IDebugBoundBreakpoint2.SetCondition(BP_CONDITION bpCondition) {
if (bpCondition.styleCondition == enum_BP_COND_STYLE.BP_COND_WHEN_CHANGED) {
return VSConstants.E_NOTIMPL;
}
if (!_breakpointBinding.SetConditionAsync(bpCondition.bstrCondition).GetAwaiter().GetResult()) {
return VSConstants.E_FAIL;
}
return VSConstants.S_OK;
}
// The sample engine does not support conditions on breakpoints.
int IDebugPendingBreakpoint2.SetCondition(BP_CONDITION bpCondition)
{
_bpRequestInfo.bpCondition = bpCondition;
_breakpoint.Condition = bpCondition.bstrCondition;
return VSConstants.S_OK;
}
/// <summary>
/// Sets or changes the condition associated with this pending breakpoint.
/// </summary>
public int SetCondition(BP_CONDITION bpCondition)
{
DLog.Debug(DContext.VSDebuggerComCall, "DebugPendingBreakpoint.SetCondition");
if (IsDeleted)
return HResults.E_BP_DELETED;
throw new NotImplementedException();
}
// The engine does not support conditions on breakpoints.
int IDebugBoundBreakpoint2.SetCondition(BP_CONDITION bpCondition)
{
throw new NotImplementedException();
}
int IDebugBoundBreakpoint2.SetCondition(BP_CONDITION bpCondition)
{
return(((IDebugPendingBreakpoint2)_pendingBreakpoint).SetCondition(bpCondition)); // setting on the pending break will set the condition
}
// The sample engine does not support conditions on breakpoints.
// A real-world debugger will use this to specify when a breakpoint will be hit
// and when it should be ignored.
int IDebugBoundBreakpoint2.SetCondition(BP_CONDITION bpCondition)
{
_breakpoint.Condition = bpCondition.bstrCondition;
return VSConstants.S_OK;
}
int IDebugBoundBreakpoint2.SetCondition(BP_CONDITION bpCondition)
{
_breakpoint.SetCondition(bpCondition.styleCondition.ToPython(), bpCondition.bstrCondition);
return(VSConstants.S_OK);
}
public int SetCondition(BP_CONDITION bpCondition)
{
Debug.WriteLine("AD7Breakpoint: SetCondition");
EnumBreakpointConditionStyle style = EnumBreakpointConditionStyle.None;
switch (bpCondition.styleCondition)
{
case enum_BP_COND_STYLE.BP_COND_WHEN_CHANGED:
style = EnumBreakpointConditionStyle.WhenChanged;
break;
case enum_BP_COND_STYLE.BP_COND_WHEN_TRUE:
style = EnumBreakpointConditionStyle.WhenTrue;
break;
}
try
{
CoreBreakpoint.SetCondition(bpCondition.bstrCondition, style);
}
catch (DebuggerException e)
{
MessageBox.Show(e.Message, "Error when setting condition breakpoint", MessageBoxButtons.OK);
return VSConstants.E_FAIL;
}
return VSConstants.S_OK;
}
public int SetCondition(BP_CONDITION bpCondition)
{
Log.Debug("ScriptBreakpoint: SetCondition");
return VSConstants.E_NOTIMPL;
}
int IDebugPendingBreakpoint2.SetCondition(BP_CONDITION bpCondition)
{
_bpRequestInfo.bpCondition = bpCondition;
return(VSConstants.S_OK);
}
int IDebugBoundBreakpoint2.SetCondition(BP_CONDITION bpCondition) {
_breakpoint.SetCondition(bpCondition.styleCondition.ToPython(), bpCondition.bstrCondition);
return VSConstants.S_OK;
}
public int SetCondition(BP_CONDITION bpCondition)
{
return(VSConstants.S_OK);
}
int IDebugBoundBreakpoint2.SetCondition(BP_CONDITION bpCondition) {
return VSConstants.E_NOTIMPL;
}
int IDebugBoundBreakpoint2.SetCondition(BP_CONDITION bpCondition)
{
TaskHelpers.RunSynchronouslyOnUIThread(ct => _breakpoint.SetConditionAsync(bpCondition.styleCondition.ToPython(), bpCondition.bstrCondition, ct));
return(VSConstants.S_OK);
}
/// <summary>
/// Sets or changes the condition associated with the pending breakpoint.
/// </summary>
/// <param name="bpCondition"> A BP_CONDITION structure that specifies the condition to set.</param>
/// <returns>If successful, returns S_OK; otherwise, returns an error code.</returns>
/// <remarks>Any condition that was previously associated with the pending breakpoint is lost. All breakpoints bound from this pending breakpoint are called to set their condition to the value specified in the bpCondition parameter.</remarks>
public virtual int SetCondition( BP_CONDITION bpCondition )
{
Logger.Debug( string.Empty );
return VSConstants.E_NOTIMPL;
}
public int SetCondition(BP_CONDITION bpCondition)
{
_condition = bpCondition;
return VSConstants.S_OK;
}
int IDebugPendingBreakpoint2.SetCondition(BP_CONDITION bpCondition) {
if (bpCondition.styleCondition == enum_BP_COND_STYLE.BP_COND_WHEN_CHANGED) {
return VSConstants.E_NOTIMPL;
}
_bpRequestInfo.bpCondition = bpCondition;
return VSConstants.S_OK;
}
public int SetCondition(BP_CONDITION bpCondition)
{
throw new NotImplementedException();
}
public int SetCondition(BP_CONDITION bpCondition)
{
return VSConstants.E_NOTIMPL;
}
