void RemoveCore(DbgCodeBreakpoint[] breakpoints)
{
dbgDispatcherProvider.VerifyAccess();
var removed = new List <DbgCodeBreakpoint>(breakpoints.Length);
lock (lockObj) {
foreach (var bp in breakpoints)
{
var bpImpl = bp as DbgCodeBreakpointImpl;
Debug2.Assert(!(bpImpl is null));
if (bpImpl is null)
{
continue;
}
if (!this.breakpoints.Contains(bpImpl))
{
continue;
}
removed.Add(bpImpl);
this.breakpoints.Remove(bpImpl);
bool b = locationToBreakpoint.Remove(bpImpl.Location);
Debug.Assert(b);
}
}
if (removed.Count > 0)
{
BreakpointsChanged?.Invoke(this, new DbgCollectionChangedEventArgs <DbgCodeBreakpoint>(removed, added: false));
foreach (var bp in removed)
{
bp.Close(dbgDispatcherProvider.Dispatcher);
}
}
}
void AddCore(List <DbgCodeBreakpointImpl> breakpoints, List <DbgObject>?objsToClose)
{
dbgDispatcherProvider.VerifyAccess();
var added = new List <DbgCodeBreakpoint>(breakpoints.Count);
List <DbgCodeBreakpointImpl>?updatedBreakpoints = null;
lock (lockObj) {
foreach (var bp in breakpoints)
{
Debug.Assert(!this.breakpoints.Contains(bp));
if (this.breakpoints.Contains(bp))
{
continue;
}
if (locationToBreakpoint.ContainsKey(bp.Location))
{
if (objsToClose is null)
{
objsToClose = new List <DbgObject>();
}
objsToClose.Add(bp);
}
else
{
added.Add(bp);
this.breakpoints.Add(bp);
locationToBreakpoint.Add(bp.Location, bp);
if (bp.WriteIsDebugging_DbgThread(isDebugging))
{
if (updatedBreakpoints is null)
{
updatedBreakpoints = new List <DbgCodeBreakpointImpl>(breakpoints.Count);
}
updatedBreakpoints.Add(bp);
}
}
}
}
if (!(objsToClose is null))
{
foreach (var obj in objsToClose)
{
obj.Close(dbgDispatcherProvider.Dispatcher);
}
}
if (added.Count > 0)
{
BreakpointsChanged?.Invoke(this, new DbgCollectionChangedEventArgs <DbgCodeBreakpoint>(added, added: true));
}
if (!(updatedBreakpoints is null))
{
foreach (var bp in updatedBreakpoints)
{
bp.RaiseBoundBreakpointsMessageChanged_DbgThread();
}
BoundBreakpointsMessageChanged?.Invoke(this, new DbgBoundBreakpointsMessageChangedEventArgs(new ReadOnlyCollection <DbgCodeBreakpoint>(updatedBreakpoints.ToArray())));
}
}
private async void OnBreakpointsChanged(object sender, EventArgs eventArgs)
{
var newBreakpoints = new Dictionary <Breakpoint, ManagerBreakpoint> ();
var snapshot = textBuffer.CurrentSnapshot;
var needsUpdate = false;
foreach (var breakpoint in DebuggingService.Breakpoints.GetBreakpointsAtFile(textDocument.FilePath))
{
if (breakpoint.Line > snapshot.LineCount)
{
continue;
}
if (eventArgs is BreakpointEventArgs breakpointEventArgs && breakpointEventArgs.Breakpoint == breakpoint)
{
needsUpdate = true;
}
var line = snapshot.GetLineFromLineNumber(breakpoint.Line - 1);
var position = line.Start.Position + breakpoint.Column;
var span = await DebuggingService.GetBreakpointSpanAsync(textDocument, position);
if (breakpoints.TryGetValue(breakpoint, out var existingBreakpoint))
{
newBreakpoints.Add(breakpoint, existingBreakpoint);
if (existingBreakpoint.Span != span)
{
// Update if anything was modified
existingBreakpoint.Span = span;
needsUpdate = true;
}
}
else
{
// Update if anything was added
newBreakpoints.Add(breakpoint, new ManagerBreakpoint {
Breakpoint = breakpoint,
TrackingSpan = snapshot.CreateTrackingSpan(span, SpanTrackingMode.EdgeExclusive),
Span = span
});
needsUpdate = true;
}
}
// Update if anything was removed
if (needsUpdate || breakpoints.Keys.Except(newBreakpoints.Keys).Any())
{
needsUpdate = true;
}
breakpoints = newBreakpoints;
if (needsUpdate)
{
BreakpointsChanged?.Invoke(this, new SnapshotSpanEventArgs(new SnapshotSpan(snapshot, 0, snapshot.Length)));
}
}
public void ClearBreakpoints()
{
Breakpoints = new bool[0x10000];
for (int i = 0; i < Lines.Count; i++)
{
Lines[i].MarkerDelete(BOOKMARK_MARKER);
}
BreakpointsChanged?.Invoke(this, new BreakpointsChangedEventArgs(Breakpoints));
}
private void OnBreakpointsChanged(object sender, EventArgs eventArgs)
{
var snapshot = textBuffer.CurrentSnapshot;
var newBreakpoints = new Dictionary <Breakpoint, ManagerBreakpoint> ();
bool needsUpdate = false;
foreach (var breakpoint in DebuggingService.Breakpoints.GetBreakpointsAtFile(file))
{
if (breakpoint.Line > snapshot.LineCount)
{
continue;
}
if (eventArgs is BreakpointEventArgs breakpointEventArgs && breakpointEventArgs.Breakpoint == breakpoint)
{
needsUpdate = true;
}
var newSpan = snapshot.GetLineFromLineNumber(breakpoint.Line - 1).Extent;
if (breakpoints.TryGetValue(breakpoint, out var existingBreakpoint))
{
newBreakpoints.Add(breakpoint, existingBreakpoint);
if (existingBreakpoint.Span != newSpan.Span)
{
// Update if anything was modifed
needsUpdate = true;
existingBreakpoint.Span = newSpan.Span;
}
}
else
{
// Update if anything was added
needsUpdate = true;
newBreakpoints.Add(breakpoint, new ManagerBreakpoint()
{
Breakpoint = breakpoint,
TrackingSpan = snapshot.CreateTrackingSpan(newSpan, SpanTrackingMode.EdgeExclusive),
Span = newSpan.Span
});
}
}
// Update if anything was removed
if (needsUpdate || breakpoints.Keys.Except(newBreakpoints.Keys).Any())
{
needsUpdate = true;
}
breakpoints = newBreakpoints;
if (needsUpdate)
{
BreakpointsChanged?.Invoke(this, new SnapshotSpanEventArgs(new SnapshotSpan(snapshot, 0, snapshot.Length)));
}
}
void ClearCore()
{
dbgDispatcherProvider.VerifyAccess();
DbgModuleBreakpoint[] removed;
lock (lockObj) {
removed = breakpoints.ToArray();
breakpoints.Clear();
}
if (removed.Length > 0)
{
BreakpointsChanged?.Invoke(this, new DbgCollectionChangedEventArgs <DbgModuleBreakpoint>(removed, added: false));
foreach (var bp in removed)
{
bp.Close(dbgDispatcherProvider.Dispatcher);
}
}
}
void AddCore(DbgModuleBreakpointImpl[] breakpoints)
{
dbgDispatcherProvider.VerifyAccess();
var added = new List <DbgModuleBreakpoint>(breakpoints.Length);
lock (lockObj) {
foreach (var bp in breakpoints)
{
Debug.Assert(!this.breakpoints.Contains(bp));
if (this.breakpoints.Contains(bp))
{
continue;
}
added.Add(bp);
this.breakpoints.Add(bp);
}
}
if (added.Count > 0)
{
BreakpointsChanged?.Invoke(this, new DbgCollectionChangedEventArgs <DbgModuleBreakpoint>(added, added: true));
}
}
void DbgCodeBreakpointsService_BreakpointsChanged(object sender, DbgCollectionChangedEventArgs <DbgCodeBreakpoint> e) => BreakpointsChanged?.Invoke(this, e);
void ToggleBreakpoint(int lineNo)
{
if (!ShowBreakpointsMargin)
{
return;
}
BreakpointsChangedEventArgs e;
Line sline = Lines[lineNo];
const uint mask = (1 << BOOKMARK_MARKER);
while (sline.Text.Length < 4 || sline.Text.Substring(0, 4) == " ")
{
lineNo++;
sline = Lines[lineNo];
if (lineNo > Lines.Count)
{
return;
}
}
string saddress = sline.Text.Substring(0, 4).Trim();
if (saddress.Length > 0)
{
try
{
LastBeakpointAddress = Convert.ToInt32(saddress, 16);
}
catch { return; }
Breakpoints[LastBeakpointAddress] = !Breakpoints[LastBeakpointAddress];
if (!Breakpoints[LastBeakpointAddress])
{
// Remove existing bookmark
sline.MarkerDelete(BOOKMARK_MARKER);
//if (Breakpoint != null) Breakpoint(address, false);
Breakpoints[LastBeakpointAddress] = false;
BreakpointsChanged?.Invoke(this, new BreakpointsChangedEventArgs(Breakpoints));
Refresh();
return;
}
else
{
// Add bookmark
sline.MarkerAdd(BOOKMARK_MARKER);
//if (Breakpoint != null) Breakpoint(address, true);
Breakpoints[LastBeakpointAddress] = true;
}
e = new BreakpointsChangedEventArgs(Breakpoints);
BreakpointsChanged?.Invoke(this, e);
if (!e.SourceChanged)
{
return;
}
lineNo = 0;
while (true)
{
sline = Lines[lineNo];
if (sline.Text.Length < 4 || sline.Text.Substring(0, 4) == " ")
{
lineNo++;
continue;
}
if (sline.Text.Substring(0, 4).Trim() == saddress)
{
if ((sline.MarkerGet() & mask) > 0)
{
// Remove existing bookmark
sline.MarkerDelete(BOOKMARK_MARKER);
//if (Breakpoint != null) Breakpoint(address, false);
Breakpoints[LastBeakpointAddress] = false;
}
else
{
// Add bookmark
sline.MarkerAdd(BOOKMARK_MARKER);
//if (Breakpoint != null) Breakpoint(address, true);
Breakpoints[LastBeakpointAddress] = true;
}
BreakpointsChanged?.Invoke(this, new BreakpointsChangedEventArgs(Breakpoints));
break;
}
lineNo++;
sline = Lines[lineNo];
if (lineNo > Lines.Count)
{
return;
}
}
}
}
/// <summary>
/// Checks if any of the breakpoints has been changed.
/// </summary>
/// <param name="cancellationToken">Cancels running this task</param>
/// <remark>
/// This task always runs on the main thread in idle time.
/// </remark>
private async Task CheckBreakpointChangesAsync(CancellationToken cancellationToken)
{
// --- Store the original breakpoint count
var prevCount = 0;
var loopCount = 0;
var prevBreakpoints = new Dictionary <Breakpoint, BreakpointWithState>();
while (!cancellationToken.IsCancellationRequested)
{
await Task.Delay(WATCH_PERIOD, cancellationToken);
loopCount++;
var currentCount = SpectNetPackage.Default.ApplicationObject.DTE.Debugger.Breakpoints?.Count ?? 0;
// --- We examine new and deleted breakpoints immediately, changed breakpoints only
// --- occasionally
if (currentCount == prevCount && loopCount % 5 != 0)
{
continue;
}
// --- Collect changes
var added = new List <Breakpoint>();
var modified = new List <Breakpoint>();
var deleted = new List <Breakpoint>();
var vsBreakpoints = SpectNetPackage.Default.ApplicationObject.DTE.Debugger.Breakpoints;
if (vsBreakpoints != null)
{
// --- Collect modified breakpoints
var tempBreakpoints = new Dictionary <Breakpoint, BreakpointWithState>();
foreach (Breakpoint currentBreakpoint in vsBreakpoints)
{
tempBreakpoints.Add(currentBreakpoint, new BreakpointWithState
{
Breakpoint = currentBreakpoint,
Enabled = currentBreakpoint.Enabled,
Condition = currentBreakpoint.Condition,
ConditionType = currentBreakpoint.ConditionType,
HitCountType = currentBreakpoint.HitCountType,
HitCountTarget = currentBreakpoint.HitCountTarget
});
if (!prevBreakpoints.TryGetValue(currentBreakpoint, out var oldBreak))
{
added.Add(currentBreakpoint);
}
else
{
if (oldBreak.Enabled != currentBreakpoint.Enabled ||
oldBreak.Condition != currentBreakpoint.Condition ||
oldBreak.ConditionType != currentBreakpoint.ConditionType ||
oldBreak.HitCountType != currentBreakpoint.HitCountType ||
oldBreak.HitCountTarget != currentBreakpoint.HitCountTarget)
{
modified.Add(currentBreakpoint);
}
}
}
// --- Collect deleted breakpoints
foreach (var currentBreakpoint in prevBreakpoints.Values)
{
if (!tempBreakpoints.ContainsKey(currentBreakpoint.Breakpoint))
{
deleted.Add(currentBreakpoint.Breakpoint);
}
}
prevBreakpoints = tempBreakpoints;
}
// --- Check for current breakpoint changes
var debugProvider = SpectNetPackage.Default.DebugInfoProvider;
var currentChanged = debugProvider.CurrentBreakpointFile != _lastCurrentBreakpointFile ||
debugProvider.CurrentBreakpointLine != _lastCurrentBreakpointLine;
if (currentChanged)
{
_lastCurrentBreakpointFile = debugProvider.CurrentBreakpointFile;
_lastCurrentBreakpointLine = debugProvider.CurrentBreakpointLine;
}
if (added.Count == 0 && modified.Count == 0 && deleted.Count == 0 && !currentChanged)
{
continue;
}
if (BreakpointsChanged != null)
{
await BreakpointsChanged.InvokeAsync(this,
new BreakpointsChangedEventArgs(added, modified, deleted, currentChanged));
}
}
}
public void ClearBreakpoints()
{
lock (_locker) { _breakpoints.Clear(); }
BreakpointsChanged?.Invoke();
}
public void AddBreakpoint(int index)
{
lock (_locker) { _breakpoints.Add(index); }
BreakpointsChanged?.Invoke();
}