private void AddBreakpoint(int address, bool isInternal)
{
if (Breakpoints.All(b => b.Address != address))
{
Breakpoints.Add(new Breakpoint(address, isInternal));
}
}
private void UpdateBreakpoints()
{
if (Repository == null)
{
return;
}
var bps = Repository.All <Breakpoint>();
Breakpoints = bps.ToList();
if (BreakpointsList == null)
{
BreakpointsList = new TreeViewModel();
}
BreakpointsList.SingleItemIcon = "BreakpointIcon";
BreakpointsList.Data = Breakpoints.OfType <IItem>().ToList();
BreakpointsList.Submit = i =>
{
var bp = i as Breakpoint;
if (bp != null)
{
Execute(new NavigateToNodeCommand()
{
Node = bp.Action,
Select = true
});
}
};
}
private void LoadBreakpoints()
{
_loadingBreakpoints = true;
var solution = _shell.CurrentSolution;
if (solution != null)
{
var file = System.IO.Path.Combine(Platform.GetUserDataDirectory(solution), "Breakpoints.xml");
if (System.IO.File.Exists(file))
{
using (var reader = XmlReader.Create(file))
{
var doc = new XmlDocument();
doc.Load(reader);
Breakpoints.Load(doc.DocumentElement);
}
}
}
else
{
Breakpoints.Clear();
}
_loadingBreakpoints = false;
}
void AddBreakEvent(BreakEvent be)
{
object handle = null;
try {
handle = OnInsertBreakEvent(be, be.Enabled);
} catch (Exception ex) {
Breakpoint bp = be as Breakpoint;
if (bp != null)
{
OnDebuggerOutput(false, "Could not set breakpoint at location '" + bp.FileName + ":" + bp.Line + "' (" + ex.Message + ")\n");
}
else
{
OnDebuggerOutput(false, "Could not set catchpoint for exception '" + ((Catchpoint)be).ExceptionName + "' (" + ex.Message + ")\n");
}
HandleException(ex);
return;
}
lock (breakpoints) {
SetBreakEventHandle(be, handle);
Breakpoints.NotifyStatusChanged(be);
}
}
internal protected void NotifySourceFileUnloaded(string fullFilePath)
{
List <BreakEvent> toUpdate = new List <BreakEvent> ();
lock (breakpoints) {
// Make a copy of the breakpoints table since it can be modified while iterating
Dictionary <BreakEvent, BreakEventInfo> breakpointsCopy = new Dictionary <BreakEvent, BreakEventInfo> (breakpoints);
foreach (KeyValuePair <BreakEvent, BreakEventInfo> bps in breakpointsCopy)
{
Breakpoint bp = bps.Key as Breakpoint;
if (bp != null && bps.Value.Handle != null)
{
if (System.IO.Path.GetFullPath(bp.FileName) == fullFilePath)
{
toUpdate.Add(bp);
}
}
}
foreach (BreakEvent be in toUpdate)
{
SetBreakEventHandle(be, null);
Breakpoints.NotifyStatusChanged(be);
}
}
}
public static void Write(FileInfo file)
{
var state = new DebuggerState
{
WorkingDirectory = WorkingDirectory,
Arguments = Arguments,
EnvironmentVariables = EnvironmentVariables,
Watches = Watches,
NextWatchId = _nextWatchId,
Breakpoints = Breakpoints.ToDictionary(x => x.Key,
x => Tuple.Create(x.Value, BreakEvents.Contains(x.Value))),
NextBreakpointId = _nextBreakpointId,
Catchpoints = BreakEvents.GetCatchpoints(),
Aliases = Aliases,
};
try
{
using (var stream = file.Open(FileMode.Create, FileAccess.Write))
new BinaryFormatter().Serialize(stream, state);
}
catch (Exception ex)
{
Log.Error("Could not write database file '{0}':", file);
Log.Error(ex.ToString());
}
}
static void OnTargetEvent(object sender, TargetEventArgs args)
{
if (args.BreakEvent != null && args.BreakEvent.NonUserBreakpoint)
{
return;
}
nextStatementLocations.Clear();
try {
switch (args.Type)
{
case TargetEventType.TargetExited:
Breakpoints.RemoveRunToCursorBreakpoints();
Cleanup();
break;
case TargetEventType.TargetSignaled:
case TargetEventType.TargetStopped:
case TargetEventType.TargetHitBreakpoint:
case TargetEventType.TargetInterrupted:
case TargetEventType.UnhandledException:
case TargetEventType.ExceptionThrown:
Breakpoints.RemoveRunToCursorBreakpoints();
SetCurrentBacktrace(args.Backtrace);
NotifyPaused();
NotifyException(args);
break;
}
} catch (Exception ex) {
LoggingService.LogError("Error handling debugger target event", ex);
}
}
public void SetKernel(FoenixSystem kernel)
{
this.kernel = kernel;
MemoryLimit = kernel.MemMgr.RAM.Length;
registerDisplay1.CPU = kernel.CPU;
knl_breakpoints = kernel.Breakpoints;
if (knl_breakpoints.Count > 0)
{
BPLabel.Text = knl_breakpoints.Count.ToString() + " BP";
// Update the combo
foreach (KeyValuePair <int, string> kvp in knl_breakpoints)
{
BPCombo.Items.Add(kvp.Value);
UpdateDebugLines(kvp.Key, true);
}
}
else
{
BPLabel.Text = "Breakpoint";
}
UpdateQueue();
int pc = kernel.CPU.PC;
DebugLine line = GetExecutionInstruction(pc);
if (line == null)
{
GenerateNextInstruction(pc);
}
DebugPanel.Refresh();
}
public bool OpenFiles(ListView source, ListView disassembly, ListView variables, TextBox comms)
{
this.source = source;
this.disassembly = disassembly;
this.varView = variables;
this.comms = comms;
Breakpoints.Clear();
if (OpenSourceFile())
{
if (parseSourceFile())
{
if (OpenDisassembly())
{
source.Click -= Source_Click;
source.Click += Source_Click;
varView.FullRowSelect = true;
varView.Click -= Variable_Click;
varView.Click += Variable_Click;
//varView.ItemMouseHover -= VarView_ItemMouseHover;
//varView.ItemMouseHover += VarView_ItemMouseHover;
varView.Enabled = false;
return(true);
}
}
}
MessageBox.Show("Problem opening files");
return(false);
}
private void OnEndSession()
{
Dispatcher.UIThread.InvokeAsync(() =>
{
DebugSessionEnded?.Invoke(this, EventArgs.Empty);
_shell.CurrentPerspective = Perspective.Editor;
_lastDocument?.ClearDebugHighlight();
_lastDocument = null;
});
lock (_sessionLock)
{
if (_session != null)
{
_session.Exit();
_session.TargetUnhandledException -= _session_TargetStopped;
_session.TargetStopped -= _session_TargetStopped;
_session.TargetHitBreakpoint -= _session_TargetStopped;
_session.TargetSignaled -= _session_TargetStopped;
_session.TargetInterrupted -= _session_TargetStopped;
_session.TargetExited -= _session_TargetExited;
_session.TargetStarted -= _session_TargetStarted;
_session.TargetReady -= _session_TargetReady;
_session.Dispose();
_session = null;
}
}
// This will save breakpoints that were moved to be closer to actual sequence points.
Breakpoints.Save();
}
public override bool SetBreakpoints(Breakpoints breakpoints)
{
// remove those no longer set
foreach (var current in _enabledBreakpoints)
{
var remove = true;
foreach (var wanted in breakpoints)
{
if (wanted.Index == current)
{
remove = false;
break;
}
}
if (remove)
{
SendAndReceiveSingle("disable-breakpoint " + (current + 1));
}
}
foreach (var b in breakpoints)
{
_enabledBreakpoints.Add(b.Index);
SetSingleBreakpoint(b);
}
ReadBreakpoints();
return(true);
}
private bool IsBreakPointTriggered()
{
//This prevents the Run Command from getting stuck after reaching a breakpoint
if (_breakpointTriggered)
{
_breakpointTriggered = false;
return(false);
}
foreach (var breakpoint in Breakpoints.Where(x => x.IsEnabled))
{
int value;
if (!int.TryParse(breakpoint.Value, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out value))
{
continue;
}
if (breakpoint.Type == BreakpointType.NumberOfCycleType && value == NumberOfCycles)
{
_breakpointTriggered = true;
RunPause();
return(true);
}
if (breakpoint.Type == BreakpointType.ProgramCounterType && value == Proc.ProgramCounter)
{
_breakpointTriggered = true;
RunPause();
return(true);
}
}
return(false);
}
public static Breakpoint GetMatchingBreakpoint(UInt32 startAddress, UInt32 endAddress, SnesMemoryType memoryType)
{
bool isAddressRange = startAddress != endAddress;
return Breakpoints.Where((bp) =>
bp.MemoryType == memoryType &&
((!isAddressRange && bp.Address == startAddress) || (isAddressRange && bp.StartAddress == startAddress && bp.EndAddress == endAddress))
).FirstOrDefault();
}
private void RemoveBreakpoint()
{
if (_breakpoint != null && SelectedBreakpointIndex >= 0)
{
Breakpoints.RemoveAt(SelectedBreakpointIndex);
_console.UnsetBreakpoint(_breakpoint.Value);
}
}
private void AddBreakpoint()
{
if (_breakpoint != null && !Breakpoints.Contains(_breakpoint.Value))
{
Breakpoints.Add(_breakpoint.Value);
_console.SetBreakpoint(_breakpoint.Value);
}
}
public void Reset()
{
cpu.Resume();
cpu.Reset();
MaxCycle = 0;
CurrentCycle = 0;
Breakpoints.Clear();
}
public int[] GetBreakpoints()
{
if (string.IsNullOrWhiteSpace(Breakpoints))
{
return(new int[] { });
}
return(Breakpoints.Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries).Select(x => int.Parse(x)).OrderBy(x => x).ToArray());
}
/// <summary>
/// Performs a single step (generally, executes a single instruction).
/// </summary>
public void StepInto()
{
if (Engine == null)
{
throw new NoProgramLoadedException();
}
Breakpoints.Add(new StepBreakpoint(Target.ProgramLocation, StepKind.Into));
Engine.Continue();
}
private static IMonitor MonitorFromBreakpoint(IControlContainer container, Breakpoints p)
{
return(p.Name switch
{
Name.Cpu => Cpu.Instance(container),
Name.Memory => Memory.Instance(container),
Name.Disk => Disk.Instance(container),
_ => throw new Exception($"Unable to location monitor for {p.Name}")
});
public void ToggleBreakPointEnabled(int address)
{
var breakpoint = Breakpoints[address];
if (breakpoint != null)
{
Breakpoints.Toggle(breakpoint.Address);
}
}
public void RemoveBreakpoint(BreakpointBookmark breakpoint)
{
Breakpoint debuggerBreakpoint = Breakpoints.GetBreakpointByBookmark(breakpoint);
if (debuggerBreakpoint != null)
{
debuggerBreakpoint.Enabled = false;
}
}
public bool DeleteBreakpoint(ProgramBreakpoint breakpoint)
{
if (Breakpoints.Contains(breakpoint))
{
Breakpoints.Remove(breakpoint);
return(true);
}
return(false);
}
private bool ClearBreakpoint(int no)
{
var index = no - 1;
if (index >= 0 && index < Breakpoints.Count())
{
Breakpoints.RemoveAt(index);
return(true);
}
return(false);
}
private void RemoveBreakPoint()
{
if (SelectedBreakpoint == null)
{
return;
}
Breakpoints.Remove(SelectedBreakpoint);
SelectedBreakpoint = null;
RaisePropertyChanged("SelectedBreakpoint");
}
/// <summary>
/// Insers a new breakpoint at a specified index.
/// </summary>
/// <param name="index">The zero-based index at which the breakpoint should be inserted.</param>
/// <param name="item">The breakpoint to insert. Cannot be null.</param>
public void Insert(int index, Breakpoint item)
{
lock (this)
{
if (item == null)
{
throw new ArgumentNullException();
}
Debugger.Target.SetBreakpointChecker(item);
Breakpoints.Insert(index, item);
}
}
/// <summary>
/// Adds a breakpoint to the collection and sets its Checker.
/// </summary>
/// <param name="breakpoint">The breakpoint to add. Cannot be null.</param>
public void Add(Breakpoint breakpoint)
{
lock (this)
{
if (breakpoint == null)
{
throw new ArgumentNullException();
}
Debugger.Target.SetBreakpointChecker(breakpoint);
Breakpoints.Add(breakpoint);
}
}
/// <summary>
/// Removes all Step breakpoints.
/// </summary>
/// <remarks>
/// This is typically used when the execution is stopped.
/// </remarks>
public void RemoveStepBreakpoints()
{
lock (this)
{
for (int i = Breakpoints.Count - 1; i >= 0; i--)
{
if (Breakpoints[i] is StepBreakpoint)
{
Breakpoints.RemoveAt(i);
}
}
}
}
public IEnumerable <TrackBreakpointType> GetCrossedBreakpoints(int oldPosition, int newPosition)
{
var crossedBreakpoints = new List <TrackBreakpointType>();
for (var i = oldPosition - 1; i >= newPosition; i--)
{
if (Breakpoints.ContainsKey(i))
{
crossedBreakpoints.Add(Breakpoints[i]);
}
}
return(crossedBreakpoints);
}
void BreakpointHit(string path, int line)
{
foreach (var bp in Breakpoints.GetBreakpoints())
{
if (bp.FileName == path && bp.Line == line)
{
var args = new TargetEventArgs(TargetEventType.TargetHitBreakpoint);
args.BreakEvent = bp;
OnTargetEvent(args);
break;
}
}
}
public static void ShowAddTracepointDialog(string file, int line)
{
AddTracePointDialog dlg = new AddTracePointDialog();
if (MessageService.RunCustomDialog(dlg) == (int)Gtk.ResponseType.Ok && dlg.Text.Length > 0)
{
Breakpoint bp = new Breakpoint(file, line);
bp.HitAction = HitAction.PrintExpression;
bp.TraceExpression = dlg.Text;
bp.ConditionExpression = dlg.Condition;
Breakpoints.Add(bp);
}
dlg.Destroy();
}
public BreakpointCollectionNodeFactory(Breakpoints breakpoints)
{
_breakpoints = breakpoints;
}
