public void e(DebuggerCore debugger, Expression expr)
{
try
{
debugger.WriteLine(debugger.ExpressionContext.EvalAndFormat(expr));
}
catch (Exception x)
{
debugger.WriteLine("Error: {0}", x.Message);
}
}
public void bp_list(DebuggerCore debugger)
{
foreach (var bp in debugger.BreakPoints)
{
debugger.WriteLine(bp.ToString());
}
}
public void close_log(DebuggerCore debugger)
{
if (_logger != null)
{
debugger.Redirect(null);
_logger.Dispose();
}
debugger.WriteLine("Logger closed");
}
public void log(DebuggerCore debugger, string filename)
{
if (_logger != null)
{
_logger.Dispose();
_logger = null;
}
_logger = new StreamWriter(filename, false, Encoding.UTF8);
debugger.WriteLine("Logging to file {0}", filename);
debugger.Redirect(_logger);
}
public void trace_set(DebuggerCore debugger, int size = -1)
{
if (size > 0)
{
debugger.TraceBufferSize = size;
}
debugger.WriteLine("Trace buffer size = {0}, tracing {1}", debugger.TraceBufferSize, debugger.EnableTrace ? "on" : "off");
return;
}
public void disasm(DebuggerCore debugger, FarPointer addr, ushort length = 16)
{
var dis = new Disassembler(debugger.CPU);
dis.cs = addr.Segment;
dis.ip = addr.Offset;
while (dis.ip < addr.Offset + length)
{
debugger.WriteLine("{0:X4}:{1:X4} {2}", dis.cs, dis.ip, dis.Read());
}
}
public void r_time(DebuggerCore debugger, ulong counter)
{
if (counter > debugger.CPU.CpuTime)
{
debugger.BreakAtTemp(new CpuTimeBreakPoint(counter));
debugger.Continue();
}
else
{
debugger.WriteLine("{0} is in the past!", counter);
}
}
public void w_del(DebuggerCore debugger, int number)
{
var bp = debugger.WatchExpressions.FirstOrDefault(x => x.Number == number);
if (bp != null)
{
debugger.RemoveWatchExpression(bp);
}
else
{
debugger.WriteLine("Watch expression #{0} doesn't exist", number);
}
}
public void help(DebuggerCore debugger)
{
foreach (var mi in debugger.CommandDispatcher._commandHandlers
.SelectMany(x => x.GetType().GetMethods())
.OrderBy(x => x.Name))
{
var help = mi.GetCustomAttributes(true).OfType <DebuggerHelpAttribute>().FirstOrDefault();
if (help == null)
{
continue;
}
debugger.WriteLine("{0,20} - {1}", mi.Name.Replace("_", " "), help.Help);
}
}
public void bp_reset(DebuggerCore debugger, BreakPoint bp = null)
{
if (bp != null)
{
bp.TripCount = 0;
debugger.WriteLine(bp.ToString());
}
else
{
foreach (var x in debugger.BreakPoints)
{
x.TripCount = 0;
}
bp_list(debugger);
}
}
public void w_edit(DebuggerCore debugger, int number, Expression expression = null)
{
var w = debugger.WatchExpressions.FirstOrDefault(x => x.Number == number);
if (w == null)
{
debugger.WriteLine("Watch expression #{0} doesn't exist", number);
return;
}
if (expression == null)
{
debugger.PromptConsole(string.Format("w edit {0} {1}", w.Number, w.ExpressionText));
}
else
{
debugger.EditWatchExpression(w, expression);
}
}
public object TryExecuteCommand(object handler, System.Reflection.MethodInfo mi, string cmdline, string args)
{
var tokenizer = new Expression.Tokenizer(new StringReader(args));
// Setup parameters
var pis = mi.GetParameters();
object[] paramValues = new object[pis.Length];
for (int i = 0; i < pis.Length; i++)
{
// Get parameter info
var pi = pis[i];
// Debugger reference?
if (pi.ParameterType.IsAssignableFrom(typeof(DebuggerCore)))
{
paramValues[i] = _debugger;
continue;
}
// Redirect is essential eof
// Check we have enough parameters
if (tokenizer.CurrentToken == Expression.Token.EOF || IsRedirect(tokenizer.CurrentToken))
{
if (pi.HasDefaultValue)
{
paramValues[i] = pi.DefaultValue;
continue;
}
throw new ArgumentException(string.Format("Missing parameter: {0}", pis[i].Name));
}
if (tokenizer.CurrentToken == Expression.Token.Comma)
{
if (pi.HasDefaultValue)
{
paramValues[i] = pi.DefaultValue;
tokenizer.NextToken();
continue;
}
throw new ArgumentException(string.Format("Missing parameter: {0}", pis[i].Name));
}
if (pi.ParameterType == typeof(string))
{
if (pi.GetCustomAttributes <ArgTailAttribute>().Any())
{
// Capture rest of the command string
paramValues[i] = args.Substring(tokenizer.CurrentTokenPosition);
// Skip everything
tokenizer.SkipToEnd();
continue;
}
if (tokenizer.CurrentToken == Expression.Token.Identifier)
{
paramValues[i] = tokenizer.String;
tokenizer.NextToken();
tokenizer.SkipIf(Expression.Token.Comma);
continue;
}
}
// Parse the expression
var expr = new Expression(null);
expr.Parse(tokenizer, args);
// Does command want unevaluated expression?
if (pi.ParameterType == typeof(Expression))
{
expr.ResolveImmediateNodes(_debugger.ExpressionContext);
paramValues[i] = expr;
tokenizer.SkipIf(Expression.Token.Comma);
continue;
}
// Does it want far pointer?
if (pi.ParameterType == typeof(FarPointer))
{
var fp = _debugger.ExpressionContext.ResolveFarPointer(expr);
paramValues[i] = fp;
tokenizer.SkipIf(Expression.Token.Comma);
continue;
}
// Eval the expression
var exprValue = expr.Eval(_debugger.ExpressionContext);
if (pi.ParameterType == typeof(BreakPoint))
{
var bpNumber = (int)Convert.ChangeType(exprValue, typeof(int));
var bp = _debugger.BreakPoints.FirstOrDefault(x => x.Number == bpNumber);
if (bp == null)
{
throw new InvalidDataException(string.Format("Breakpoint #{0} doesn't exist", bpNumber));
}
paramValues[i] = bp;
}
else
{
// Store it
paramValues[i] = Convert.ChangeType(exprValue, pi.ParameterType);
}
// Skip commas
tokenizer.SkipIf(Expression.Token.Comma);
}
// All command line parameters used?
if (tokenizer.CurrentToken != Expression.Token.EOF && !IsRedirect(tokenizer.CurrentToken))
{
throw new ArgumentException("Too many parameters on command line");
}
// Redirect?
Action FinishRedirect = null;
if (IsRedirect(tokenizer.CurrentToken))
{
bool append = tokenizer.CurrentToken == Expression.Token.RedirectAppend;
tokenizer.NextToken();
var target = args.Substring(tokenizer.CurrentTokenPosition).Trim();
if (target == "clipboard")
{
var tw = new StringWriter();
_debugger.Redirect(tw);
FinishRedirect = () =>
{
tw.WriteLine();
tw.Close();
Clipboard.SetText(tw.ToString());
_debugger.Redirect(null);
};
}
else if (target == "editor")
{
var filename = System.IO.Path.Combine(System.IO.Path.GetTempPath(), "debug.txt");
var tw = new StreamWriter(filename, append, Encoding.UTF8);
_debugger.Redirect(tw);
FinishRedirect = () =>
{
tw.WriteLine();
tw.Close();
System.Diagnostics.Process.Start(filename);
_debugger.Redirect(null);
};
}
else
{
var tw = new StreamWriter(target, append, Encoding.UTF8);
_debugger.Redirect(tw);
FinishRedirect = () =>
{
tw.WriteLine();
tw.Close();
_debugger.Redirect(null);
};
}
_debugger.WriteLine(">" + cmdline);
}
try
{
// Execute
var retv = mi.Invoke(handler, paramValues);
// Write return value
if (retv is string)
{
_debugger.WriteLine(retv.ToString());
}
return(retv);
}
finally
{
if (FinishRedirect != null)
{
FinishRedirect();
}
}
}
public void dump_mem(DebuggerCore debugger, FarPointer addr, ushort length = 16, string format = "b")
{
try
{
ushort seg = addr.Segment;
ushort ofs = addr.Offset;
switch (format)
{
case "b":
{
char[] chBuf = new char[16];
for (int i = 0; i < length; i++)
{
if ((i % 16 == 0))
{
if (i > 0)
{
debugger.Write("|");
debugger.Write(new string(chBuf));
debugger.WriteLine("|");
}
debugger.Write(string.Format("{0:X4}:{1:X4} ", seg, ofs + i));
}
byte b = debugger.CPU.MemoryBus.ReadByte(seg, (ushort)(ofs + i));
chBuf[i % 16] = (b >= 32 && b < 128) ? (char)b : ' ';
debugger.Write(string.Format("{0:X2} ", b));
}
if ((length % 16) != 0)
{
debugger.Write(new string(' ', (16 - length % 16) * 3));
}
debugger.Write("|");
debugger.Write(new string(chBuf, 0, (length % 16) == 0 ? 16 : length % 16));
debugger.WriteLine("|");
break;
}
case "w":
for (int i = 0; i < length; i++)
{
if ((i % 8 == 0))
{
if (i > 0)
{
debugger.WriteLine();
}
debugger.Write(string.Format("{0:X4}:{1:X4} ", seg, ofs + i * 2));
}
var val = debugger.CPU.MemoryBus.ReadWord(seg, (ushort)(ofs + i * 2));
debugger.Write(string.Format("{0:X4} ", val));
}
debugger.WriteLine();
break;
case "dw":
for (int i = 0; i < length; i++)
{
if ((i % 4 == 0))
{
if (i > 0)
{
debugger.WriteLine();
}
debugger.Write(string.Format("{0:X4}:{1:X4} ", seg, ofs + i * 4));
}
var val = debugger.CPU.MemoryBus.ReadDWord(seg, (ushort)(ofs + i * 4));
debugger.Write(string.Format("{0:X8} ", val));
}
debugger.WriteLine();
break;
case "i":
for (int i = 0; i < length; i++)
{
if ((i % 8 == 0))
{
if (i > 0)
{
debugger.WriteLine();
}
debugger.Write(string.Format("{0:X4}:{1:X4} ", seg, ofs + i * 2));
}
var val = debugger.CPU.MemoryBus.ReadWord(seg, (ushort)(ofs + i * 2));
debugger.Write(string.Format("{0,6} ", unchecked ((short)val)));
}
debugger.WriteLine();
break;
case "l":
for (int i = 0; i < length; i++)
{
if ((i % 4 == 0))
{
if (i > 0)
{
debugger.WriteLine();
}
debugger.Write(string.Format("{0:X4}:{1:X4} ", seg, ofs + i * 4));
}
var val = debugger.CPU.MemoryBus.ReadDWord(seg, (ushort)(ofs + i * 4));
debugger.Write(string.Format("{0,11} ", unchecked ((int)val)));
}
debugger.WriteLine();
break;
}
}
catch (CPUException)
{
debugger.WriteLine("#err");
}
}
