void LoadEngine ()
{
if (!gotEngine) {
gotEngine = true;
engine = (IDebuggerEngine) node.GetInstance ();
}
}
void LoadEngine()
{
if (!gotEngine)
{
gotEngine = true;
engine = (IDebuggerEngine)node.GetInstance();
}
}
public AsyncEngine(IDebuggerEngine aEngine)
{
engine = aEngine;
pause = true;
running = false;
live = false;
brake = 0;
}
private string Execute(string command, params string[] parameters)
{
IDebuggerEngine debugger = Context.Debugger;
ISymbolProvider symbolProvider = Context.SymbolProvider;
string output = DbgEngDll.ExecuteAndCapture(command, parameters);
Context.InitializeDebugger(debugger, symbolProvider);
return(output);
}
/// <summary>
/// Initializes the Context with the specified debugger engine interface.
/// It will also <see cref="IDebuggerEngine.EndSession"/> for previous debugger engine.
/// </summary>
/// <param name="debuggerEngine">The debugger engine interface.</param>
/// <param name="symbolProvider">The symbol provider interface.</param>
public static void InitializeDebugger(IDebuggerEngine debuggerEngine, ISymbolProvider symbolProvider)
{
if (Debugger != debuggerEngine)
{
Debugger?.EndSession();
}
ClearCache();
Debugger = debuggerEngine;
SymbolProvider = symbolProvider;
}
public BreakPoint ShouldBreak(IDebuggerEngine engine, out string reason)
{
foreach (BreakPoint breakPoint in this)
{
string rea = breakPoint.ShouldBreak(engine);
if (rea != null)
{
reason = rea;
return(breakPoint);
}
}
reason = null;
return(null);
}
public IEngine CreateEngine(IEngine engine)
{
IDebuggerEngine en = engine as IDebuggerEngine;
if (en == null)
{
throw new ArgumentException(
"Argument should implement IDebuggerEngine interface for usage with EngineASync");
}
AsyncEngine e = new AsyncEngine(en);
e.Module = this;
return(e);
}
public override string ShouldBreak(IDebuggerEngine engine)
{
for (int address = AddressStart; address <= AddressEnd; address++)
{
if (address > engine.CoreSize)
{
address = 0;
}
CoreEventRecord record = engine.CoreEvents[address];
InstructionEvent instructionEvent = record.Event & Event;
if (record.Cycle == engine.Cycle - 1 && instructionEvent != InstructionEvent.None)
{
return("Core event " + instructionEvent + " on address " + address);
}
}
return(null);
}
public abstract string ShouldBreak(IDebuggerEngine engine);
/// <summary>
/// Initializes the Context with the specified debugger engine interface.
/// </summary>
/// <param name="debuggerEngine">The debugger engine interface.</param>
public static void InitializeDebugger(IDebuggerEngine debuggerEngine)
{
InitializeDebugger(debuggerEngine, debuggerEngine.GetDefaultSymbolProvider());
}
/// <summary>
/// Initializes the Context with the specified debugger engine interface.
/// </summary>
/// <param name="debuggerEngine">The debugger engine interface.</param>
/// <param name="symbolProvider">The symbol provider interface.</param>
public static void InitializeDebugger(IDebuggerEngine debuggerEngine, ISymbolProvider symbolProvider)
{
ClearCache();
Debugger = debuggerEngine;
SymbolProvider = symbolProvider;
}
public LegacyDebuggerEngineBackend (IDebuggerEngine engine)
{
this.engine = engine;
}
public LegacyDebuggerEngineBackend(IDebuggerEngine engine)
{
this.engine = engine;
}
/// <summary>
/// Initializes the Context with the specified debugger engine interface.
/// </summary>
/// <param name="debuggerEngine">The debugger engine interface.</param>
public static void InitializeDebugger(IDebuggerEngine debuggerEngine)
{
Debugger = debuggerEngine;
//SymbolProvider = Debugger.CreateDefaultSymbolProvider();
SymbolProvider = DiaSymbolProvider;
}
/// <summary>
/// Initializes the Context with the specified DbgEng.dll Client interface.
/// </summary>
/// <param name="client">The DbgEng.dll Client interface.</param>
public static void Initalize(IDebugClient client)
{
Debugger = new DbgEngDll(client);
SymbolProvider = Debugger.CreateDefaultSymbolProvider();
SymbolProvider = DiaSymbolProvider;
}
