/// <summary>
/// Executes "watch" command.
/// </summary>
/// <param name="parameters">Address of Symbol to watch.</param>
protected void Watch(string[] parameters)
{
if (parameters.Length != 1)
{
Console.WriteLine("Invalid parameters for Watch command.");
return;
}
string s = parameters[0];
long address;
try
{ address = long.Parse(s); }
catch
{
DebugSymbol sym;
if (Debugger.DebugInformation.ByName.TryGetValue(s, out sym))
{
address = sym.Value;
}
else
{
Console.WriteLine("Symbol \"" + s + "\" not found.");
return;
}
}
MemoryBreakpoint bp = new MemoryBreakpoint(address);
bp.OnExecute = false;
bp.OnWrite = true;
Debugger.Breakpoints.Add(bp);
Console.WriteLine("Breakpoint " + Debugger.Breakpoints.IndexOf(bp) + " at " + address + " on Write.");
}
public void MemoryBreakpointsCanCopyToArray()
{
MemoryDebugger.AddBreakpoint(new MemoryChangedBreakpoint(0x1234, 1));
MemoryDebugger.AddBreakpoint(new MemoryValueEqualsBreakpoint(0x2345, 1, 0x55));
var array = new MemoryBreakpoint[2];
MemoryDebugger.Breakpoints.CopyTo(array, 0);
Assert.IsTrue(array[0] is MemoryChangedBreakpoint);
Assert.IsTrue(array[1] is MemoryValueEqualsBreakpoint);
}
public bool DeleteBreakpoint(MemoryBreakpoint breakpoint)
{
Breakpoints.Remove(breakpoint);
return(true);
}
public bool AddBreakpoint(MemoryBreakpoint breakpoint)
{
Breakpoints.Add(breakpoint);
return(true);
}
/// <summary>
/// Executes "info" command.
/// </summary>
/// <param name="parameters">Either "reg", "r", "break", "breakpoints" or "b".</param>
protected void Info(string[] parameters)
{
bool ok = true;
if (parameters.Length != 1)
{
ok = false;
}
string command = parameters[0].ToLower();
if (command != "reg" && command != "r" &&
command != "break" && command != "breakpoints" && command != "b")
{
ok = false;
}
if (!ok)
{
Console.WriteLine("Invalid parameters for Info command.");
return;
}
if (command == "reg" || command == "r")
{
Console.WriteLine("+----------+----------+");
Console.WriteLine("|Register |Value |");
Console.WriteLine("+----------+----------+");
foreach (string reg in Debugger.Target.Registers.Names)
{
Console.Write("|");
Console.Write(reg.PadRight(10));
Console.Write("|");
Console.Write(Debugger.Target.Registers[reg].ToString().PadLeft(10));
Console.WriteLine("|");
}
Console.WriteLine("+----------+----------+");
}
else // breakpoints
{
Console.WriteLine("+--------+----------------+------------+----------+");
Console.WriteLine("|N |Address |On Execute |On Write |");
Console.WriteLine("+--------+----------------+------------+----------+");
for (int i = 0; i < Debugger.Breakpoints.Count; i++)
{
MemoryBreakpoint bp = Debugger.Breakpoints[i] as MemoryBreakpoint;
if (bp == null)
{
continue;
}
Console.Write("|");
Console.Write(i.ToString().PadRight(8));
Console.Write("|");
Console.Write(bp.Address.ToString().PadRight(16));
Console.Write("|");
Console.Write(bp.OnExecute ? "YES " : "NO ");
Console.Write("|");
Console.Write(bp.OnWrite ? "YES " : "NO ");
Console.WriteLine("|");
}
Console.WriteLine("+--------+----------------+------------+----------+");
}
}
/// <summary>
/// Executes "break" command.
/// </summary>
/// <param name="parameters">Source code location; or Address or Symbol starting with '*'</param>
protected void Break(string[] parameters)
{
if (parameters.Length != 1 || parameters[0].Length == 0)
{
Console.WriteLine("Invalid parameters for Break command.");
return;
}
if (parameters[0][0] == '*') // Address or label
{
string s = parameters[0].Remove(0, 1);
long address;
try
{ address = long.Parse(s); }
catch
{
DebugSymbol sym;
if (Debugger.DebugInformation.ByName.TryGetValue(s, out sym))
{
address = sym.Value;
if (!sym.IsExecutable)
{
Console.WriteLine("Symbol \"" + s + "\" is not a label.");
return;
}
}
else
{
Console.WriteLine("Symbol \"" + s + "\" not found.");
return;
}
}
MemoryBreakpoint bp = new MemoryBreakpoint(address);
Debugger.Breakpoints.Add(bp);
Console.WriteLine("Breakpoint " + Debugger.Breakpoints.IndexOf(bp) + " at " + address + " on Execute.");
}
else // Source line
{
string s = parameters[0];
int line;
string file = null;
try
{ line = int.Parse(s); }
catch
{
string[] parts = s.Split(':');
if (parts.Length != 2)
{
Console.WriteLine("Invalid parameters for Break command.");
return;
}
try
{ line = int.Parse(parts[0]); }
catch
{
Console.WriteLine("Invalid parameters for Break command.");
return;
}
file = parts[1];
}
MemoryBreakpoint bp;
try
{
if (file == null)
{
bp = new MemoryBreakpoint(Debugger, line);
}
else
{
bp = new MemoryBreakpoint(Debugger, file, line);
}
}
catch (DebugSymbolNotFoundException)
{
Console.WriteLine("Debug Symbol not found for specified location.");
return;
}
Debugger.Breakpoints.Add(bp);
Console.WriteLine("Breakpoint " + Debugger.Breakpoints.IndexOf(bp) + " at " + bp.Address +
(bp.OnExecute ? " on Execute." : " on Write."));
}
}
/// <summary>
/// Executes "watch" command.
/// </summary>
/// <param name="parameters">Address of Symbol to watch.</param>
protected void Watch(string[] parameters)
{
if (parameters.Length != 1)
{
Console.WriteLine("Invalid parameters for Watch command.");
return;
}
string s = parameters[0];
long address;
try
{ address = long.Parse(s); }
catch
{
DebugSymbol sym;
if (Debugger.DebugInformation.ByName.TryGetValue(s, out sym))
{ address = sym.Value; }
else
{
Console.WriteLine("Symbol \"" + s + "\" not found.");
return;
}
}
MemoryBreakpoint bp = new MemoryBreakpoint(address);
bp.OnExecute = false;
bp.OnWrite = true;
Debugger.Breakpoints.Add(bp);
Console.WriteLine("Breakpoint " + Debugger.Breakpoints.IndexOf(bp) + " at " + address + " on Write.");
}
/// <summary>
/// Executes "break" command.
/// </summary>
/// <param name="parameters">Source code location; or Address or Symbol starting with '*'</param>
protected void Break(string[] parameters)
{
if (parameters.Length != 1 || parameters[0].Length == 0)
{
Console.WriteLine("Invalid parameters for Break command.");
return;
}
if (parameters[0][0] == '*') // Address or label
{
string s = parameters[0].Remove(0, 1);
long address;
try
{ address = long.Parse(s); }
catch
{
DebugSymbol sym;
if (Debugger.DebugInformation.ByName.TryGetValue(s, out sym))
{
address = sym.Value;
if (!sym.IsExecutable)
{
Console.WriteLine("Symbol \"" + s + "\" is not a label.");
return;
}
}
else
{
Console.WriteLine("Symbol \"" + s + "\" not found.");
return;
}
}
MemoryBreakpoint bp = new MemoryBreakpoint(address);
Debugger.Breakpoints.Add(bp);
Console.WriteLine("Breakpoint " + Debugger.Breakpoints.IndexOf(bp) + " at " + address + " on Execute.");
}
else // Source line
{
string s = parameters[0];
int line;
string file = null;
try
{ line = int.Parse(s); }
catch
{
string[] parts = s.Split(':');
if (parts.Length != 2)
{
Console.WriteLine("Invalid parameters for Break command.");
return;
}
try
{ line = int.Parse(parts[0]); }
catch
{
Console.WriteLine("Invalid parameters for Break command.");
return;
}
file = parts[1];
}
MemoryBreakpoint bp;
try
{
if (file == null)
{ bp = new MemoryBreakpoint(Debugger, line); }
else
{ bp = new MemoryBreakpoint(Debugger, file, line); }
}
catch (DebugSymbolNotFoundException)
{
Console.WriteLine("Debug Symbol not found for specified location.");
return;
}
Debugger.Breakpoints.Add(bp);
Console.WriteLine("Breakpoint " + Debugger.Breakpoints.IndexOf(bp) + " at " + bp.Address +
(bp.OnExecute ? " on Execute." : " on Write."));
}
}
public void exportBreakpoints(File f)
{
System.IO.StreamWriter @out = null;
try
{
@out = new System.IO.StreamWriter(f);
IEnumerator <MemoryBreakpoint> it = memoryBreakpoints.GetEnumerator();
while (it.MoveNext())
{
MemoryBreakpoint mbp = it.Current;
string line = "";
switch (mbp.Access)
{
case READ:
line += "R ";
break;
case WRITE:
line += "W ";
break;
case READWRITE:
line += "RW ";
break;
default:
// ignore - but should never happen
continue;
}
line += string.Format("0x{0:X8}", mbp.StartAddress);
if (mbp.StartAddress != mbp.EndAddress)
{
line += string.Format(" - 0x{0:X8}", mbp.EndAddress);
}
line += System.getProperty("line.separator");
@out.Write(line);
}
if (traceMemoryRead)
{
@out.Write("read|");
}
if (traceMemoryWrite)
{
@out.Write("write|");
}
if (traceMemoryRead8)
{
@out.Write("read8|");
}
if (traceMemoryWrite8)
{
@out.Write("write8|");
}
if (traceMemoryRead16)
{
@out.Write("read16|");
}
if (traceMemoryWrite16)
{
@out.Write("write16|");
}
if (traceMemoryRead32)
{
@out.Write("read32|");
}
if (traceMemoryWrite32)
{
@out.Write("write32|");
}
if (pauseEmulatorOnMemoryBreakpoint)
{
@out.Write("pause");
}
@out.BaseStream.WriteByte(System.getProperty("line.separator"));
}
catch (IOException)
{
// ignore
}
finally
{
Utilities.close(@out);
}
}
public MemoryBreakpointEventArgs(MemoryBreakpoint breakpoint, ushort address, byte value)
{
Breakpoint = breakpoint;
Address = address;
Value = value;
}
