public AD7Thread(AD7Engine engine, DebuggedThread debuggedThread)//ThreadMirror threadMirror)
{
_engine = engine;
ThreadMirror = debuggedThread.Thread;
_debuggedThread = debuggedThread;
}
public AD7BoundBreakpoint(AD7Engine aEngine, uint aAddress, AD7PendingBreakpoint aPendingBP, AD7BreakpointResolution breakpointResolution) {
mEngine = aEngine;
mAddress = aAddress;
m_pendingBreakpoint = aPendingBP;
m_breakpointResolution = breakpointResolution;
mRemoteID = mEngine.BPMgr.RemoteEnable(this);
}
public AD7BoundBreakpoint(uint aAddress)
{
mEngine = null;
mAddress = aAddress;
m_pendingBreakpoint = null;
m_breakpointResolution = null;
}
public DebuggedThread(ThreadMirror thread, AD7Engine engine)
{
Thread = thread;
Id = thread.TID;
Name = "";
TargetId = thread.TID;
AD7Thread ad7Thread = new AD7Thread(engine, this);
Client = ad7Thread;
}
public AD7PendingBreakpoint(IDebugBreakpointRequest2 pBPRequest, AD7Engine engine, BreakpointManager bpManager) {
m_pBPRequest = pBPRequest;
BP_REQUEST_INFO[] requestInfo = new BP_REQUEST_INFO[1];
EngineUtils.CheckOk(m_pBPRequest.GetRequestInfo(enum_BPREQI_FIELDS.BPREQI_BPLOCATION, requestInfo));
mBpRequestInfo = requestInfo[0];
EngineUtils.CheckOk(m_pBPRequest.GetRequestInfo(enum_BPREQI_FIELDS.BPREQI_THREAD, requestInfo));
mEngine = engine;
mBPMgr = bpManager;
}
public DebuggedThread(ThreadMirror thread, AD7Engine engine)
{
Thread = thread;
Id = thread.TID;
Name = "";
TargetId = thread.TID;
AD7Thread ad7Thread = new AD7Thread(engine, this);
Client = ad7Thread;
}
public AD7PendingBreakpoint(IDebugBreakpointRequest2 pBpRequest, AD7Engine engine, BreakpointManager bpManager)
{
this._bpRequest = pBpRequest;
var requestInfo = new BP_REQUEST_INFO[1];
EngineUtils.CheckOk(this._bpRequest.GetRequestInfo(enum_BPREQI_FIELDS.BPREQI_BPLOCATION | enum_BPREQI_FIELDS.BPREQI_CONDITION | enum_BPREQI_FIELDS.BPREQI_ALLFIELDS, requestInfo));
this._bpRequestInfo = requestInfo[0];
this._engine = engine;
this._bpManager = bpManager;
this._enabled = true;
this._deleted = false;
}
public DebuggedProcess(AD7Engine engine, IPAddress ipAddress, EngineCallback callback)
{
_engine = engine;
_ipAddress = ipAddress;
Instance = this;
// we do NOT have real Win32 process IDs, so we use a guid
AD_PROCESS_ID pid = new AD_PROCESS_ID();
pid.ProcessIdType = (int)enum_AD_PROCESS_ID.AD_PROCESS_ID_GUID;
pid.guidProcessId = Guid.NewGuid();
this.Id = pid;
_callback = callback;
}
public AD7PendingBreakpoint(IDebugBreakpointRequest2 pBPRequest, AD7Engine engine, BreakpointManager bpManager)
{
_bpRequest = pBPRequest;
BP_REQUEST_INFO[] requestInfo = new BP_REQUEST_INFO[1];
EngineUtils.CheckOk(_bpRequest.GetRequestInfo(enum_BPREQI_FIELDS.BPREQI_BPLOCATION | enum_BPREQI_FIELDS.BPREQI_CONDITION | enum_BPREQI_FIELDS.BPREQI_ALLFIELDS, requestInfo));
_bpRequestInfo = requestInfo[0];
_engine = engine;
_bpManager = bpManager;
_boundBreakpoints = new System.Collections.Generic.List <AD7BoundBreakpoint>();
_enabled = true;
_deleted = false;
}
private void OnEnterBreakMode(EnvDTE.dbgEventReason Reason, ref EnvDTE.dbgExecutionAction ExecutionAction)
{
int activeProcessId = _serviceProvider.GetDTE().Debugger.CurrentProcess.ProcessID;
AD7Engine engine = AD7Engine.GetEngines().SingleOrDefault(target => target.Process != null && target.Process.Id == activeProcessId);
if (engine != null)
{
long?activeThreadId = ((IThreadIdMapper)engine).GetPythonThreadId((uint)_serviceProvider.GetDTE().Debugger.CurrentThread.ID);
if (activeThreadId != null)
{
AttachProcess(engine.Process, engine);
ChangeActiveThread(activeThreadId.Value, false);
}
}
}
private void OnReadyForInput()
{
if (IsInDebugBreakMode())
{
foreach (var engine in AD7Engine.GetEngines())
{
if (engine.Process != null)
{
if (!_evaluators.ContainsKey(engine.Process.Id))
{
AttachProcess(engine.Process, engine);
}
}
}
}
}
private async Task OnReadyForInputAsync()
{
if (IsInDebugBreakMode())
{
foreach (var engine in AD7Engine.GetEngines())
{
if (engine.Process != null)
{
if (!_evaluators.ContainsKey(engine.Process.Id))
{
await AttachProcessAsync(engine.Process, engine);
}
}
}
}
}
public static string GetAddressDescription(/*DebuggedModule module,*/AD7Engine engine, uint ip)
{
AD7StackFrame d = new AD7StackFrame(engine, engine.mThread, engine.mProcess);
FRAMEINFO info;
d.SetFrameInfo(enum_FRAMEINFO_FLAGS.FIF_FUNCNAME | enum_FRAMEINFO_FLAGS.FIF_FUNCNAME_ARGS, out info);
return info.m_bstrFuncName;
//string location = ip.ToString("x8", CultureInfo.InvariantCulture);
//if (module != null)
{
// string moduleName = System.IO.Path.GetFileName(module.Name);
// location = string.Concat(moduleName, "!", location);
}
//return location;
}
public AD7MemoryAddress(AD7Engine engine, string filename, uint lineno, PythonStackFrame frame = null)
{
_engine = engine;
_lineNo = (uint)lineno;
_filename = filename;
_frame = frame;
var span = _engine.Process.GetStatementSpan(_filename, (int)_lineNo + 1, 0);
var startPos = new TEXT_POSITION {
dwLine = (uint)(span.Start.Line - 1), dwColumn = (uint)(span.Start.Column - 1)
};
var endPos = new TEXT_POSITION {
dwLine = (uint)(span.End.Line - 1), dwColumn = (uint)(span.End.Column - 1)
};
_documentContext = new AD7DocumentContext(filename, startPos, endPos, this, frame != null ? frame.Kind : FrameKind.None);
}
/// <summary>
/// Sends the event.
/// </summary>
/// <param name="engine"> The AD7Engine object that represents the DE. </param>
/// <param name="exitCode"> The thread's exit code. </param>
/// <param name="thread"> The AD7Thread object that represents the thread. </param>
internal static void Send(AD7Engine engine, uint exitCode, AD7Thread thread)
{
var eventObject = new AD7ThreadDestroyEvent(exitCode);
if (thread == null)
{
foreach (AD7Thread t in engine.thread)
{
engine.Callback.Send(eventObject, IID, t);
}
engine._currentThreadIndex = -1;
}
else
{
engine.Callback.Send(eventObject, IID, thread);
}
}
public static string GetAddressDescription(/*DebuggedModule module,*/ AD7Engine engine, uint ip)
{
var d = new AD7StackFrame(engine, engine.mThread, engine.mProcess);
d.SetFrameInfo(enum_FRAMEINFO_FLAGS.FIF_FUNCNAME | enum_FRAMEINFO_FLAGS.FIF_FUNCNAME_ARGS, out var info);
return(info.m_bstrFuncName);
//string location = ip.ToString("x8", CultureInfo.InvariantCulture);
//if (module != null)
{
// string moduleName = System.IO.Path.GetFileName(module.Name);
// location = string.Concat(moduleName, "!", location);
}
//return location;
}
internal static async System.Threading.Tasks.Task RefreshVariableViews(this IServiceProvider serviceProvider)
{
EnvDTE.Debugger debugger = serviceProvider.GetDTE().Debugger;
AD7Engine engine = AD7Engine.GetEngineForProcess(debugger.CurrentProcess);
if (engine != null)
{
await engine.RefreshThreadFrames(debugger.CurrentThread.ID);
var vsDebugger = (IDebugRefreshNotification140)serviceProvider.GetShellDebugger();
if (vsDebugger != null)
{
// Passing fCallstackFormattingAffected = TRUE to OnExpressionEvaluationRefreshRequested to force refresh
vsDebugger.OnExpressionEvaluationRefreshRequested(1);
}
}
}
private void GotoTemplateSourceCode(object sender, EventArgs args) {
var dte = (EnvDTE.DTE)GetService(typeof(EnvDTE.DTE));
var curFrame = (StackFrame2)dte.Debugger.CurrentStackFrame;
var frameId = curFrame.Depth;
var thread = curFrame.Parent;
var threadId = thread.ID;
var process = thread.Program;
var processId = process.Process.ProcessID;
var mappingDoc = AD7Engine.GetCodeMappingDocument(processId, threadId, (int)(frameId - 1));
if(mappingDoc != null) {
var debugger = (IVsDebugger2)GetService(typeof(IVsDebugger));
IVsTextView view;
ErrorHandler.ThrowOnFailure(debugger.ShowSource(mappingDoc, 1, 1, 1, 0, out view));
}
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="aEngine"> The AD7Engine object that represents the DE. </param>
/// <param name="id"> Thread's ID. </param>
/// <param name="targetID"> Process' ID + Thread's ID. </param>
/// <param name="state"> Thread's state. </param>
/// <param name="priority"> Thread's priority. </param>
/// <param name="name"> Thread's name. </param>
/// <param name="fullname"> Full short path file name. </param>
/// <param name="line"> Line number. </param>
public AD7Thread(AD7Engine aEngine, string id, string targetID, string state, string priority, string name, string fullname, string line)//, DebuggedThread debuggedThread)
{
_engine = aEngine;
_suspendCount = 0;
if (id == "1")
{
_threadDisplayName = "Main Thread";
}
else
{
_threadDisplayName = (name != "") ? name : "<No Name>";
}
if (fullname.Contains("~"))
{
// Need to lengthen the path used by Visual Studio.
StringBuilder longPathName = new StringBuilder(1024);
GetLongPathName(fullname, longPathName, longPathName.Capacity);
_filename = longPathName.ToString();
}
else
{
_filename = fullname;
}
try
{
_line = Convert.ToUInt32(line);
}
catch
{
_line = 0;
}
_id = id;
_state = state;
_targetID = targetID;
_priority = priority;
}
internal static async Task RefreshVariableViewsAsync(this IServiceProvider serviceProvider, CancellationToken ct = default(CancellationToken))
{
serviceProvider.GetUIThread().MustBeCalledFromUIThread();
EnvDTE.Debugger debugger = serviceProvider.GetDTE()?.Debugger;
if (debugger == null)
{
return;
}
AD7Engine engine = AD7Engine.GetEngineForProcess(debugger.CurrentProcess);
if (engine != null)
{
await engine.RefreshThreadFrames(debugger.CurrentThread.ID, ct);
var vsDebugger = serviceProvider.GetShellDebugger() as IDebugRefreshNotification140;
if (vsDebugger != null)
{
// Passing fCallstackFormattingAffected = TRUE to OnExpressionEvaluationRefreshRequested to force refresh
vsDebugger.OnExpressionEvaluationRefreshRequested(1);
}
}
}
public AD7StackFrame(AD7Engine engine, AD7Thread thread, Mono.Debugger.Soft.StackFrame threadContext)
{
Debug.Assert(threadContext != null, "ThreadContext is null");
Engine = engine;
this.Thread = thread;
this.ThreadContext = threadContext;
_textPosition = RoslynHelper.GetStatementRange(ThreadContext.FileName, ThreadContext.LineNumber, ThreadContext.ColumnNumber);
_functionName = threadContext.Method.Name;
//if(threadContext.IsNativeTransition)
//{
//}
if (_textPosition != null)
{
docContext = new AD7DocumentContext(_textPosition);
}
this.LocalVariables = threadContext.GetVisibleVariables().Select(x => new MonoProperty(threadContext, x)).ToList();
}
public AD7BreakpointResolution(AD7Engine engine, PythonBreakpoint address, AD7DocumentContext documentContext)
{
m_engine = engine;
m_address = address;
m_documentContext = documentContext;
}
// Gets the language associated with this document context.
// The language for this sample is always C++
int IDebugDocumentContext2.GetLanguageInfo(ref string pbstrLanguage, ref Guid pguidLanguage)
{
AD7Engine.MapLanguageInfo(FileName, out pbstrLanguage, out pguidLanguage);
return(VSConstants.S_OK);
}
/// <summary>
/// Sends the event.
/// </summary>
/// <param name="engine"> The AD7Engine object that represents the DE. </param>
public static void Send(AD7Engine engine)
{
var xEvent = new AD7EntryPointEvent();
engine.Callback.Send(xEvent, IID, engine.currentThread());
}
/// <summary>
/// Sends the event.
/// </summary>
/// <param name="aEngine"> The AD7Engine object that represents the DE. </param>
/// <param name="aThread"> The AD7Thread object that represents the thread. </param>
internal static void Send(AD7Engine aEngine, AD7Thread aThread)
{
var xMessage = new AD7LoadCompleteEvent();
aEngine.Callback.Send(xMessage, IID, aThread);
}
/// <summary>
/// Sends the event.
/// </summary>
/// <param name="engine"> The AD7Engine object that represents the DE. </param>
/// <param name="exitCode"> The program's exit code. </param>
internal static void Send(AD7Engine engine, uint exitCode)
{
var eventObject = new AD7ProgramDestroyEvent(exitCode);
engine.Callback.Send(eventObject, IID, null);
}
/// <summary>
/// Sends the event.
/// </summary>
/// <param name="engine"> The AD7Engine object that represents the DE. </param>
internal static void Send(AD7Engine engine)
{
AD7ProgramCreateEvent eventObject = new AD7ProgramCreateEvent();
engine.Callback.Send(eventObject, IID, null);
}
public EngineCallback(AD7Engine engine, IDebugEventCallback2 ad7Callback) {
m_ad7Callback = ad7Callback;
m_engine = engine;
}
internal AD7Process(NameValueCollection aDebugInfo, EngineCallback aCallback, AD7Engine aEngine, IDebugPort2 aPort)
{
mCallback = aCallback;
mDebugInfo = aDebugInfo;
mLaunch = (LaunchType)Enum.Parse(typeof(LaunchType), aDebugInfo[BuildPropertyNames.LaunchString]);
if (mDebugDownPipe == null)
{
mDebugDownPipe = new Cosmos.Debug.Common.PipeClient(Pipes.DownName);
mDebugUpPipe = new Cosmos.Debug.Common.PipeServer(Pipes.UpName);
mDebugUpPipe.DataPacketReceived += mDebugUpPipe_DataPacketReceived;
mDebugUpPipe.Start();
}
else
{
mDebugUpPipe.CleanHandlers();
mDebugUpPipe.DataPacketReceived += mDebugUpPipe_DataPacketReceived;
}
// Must be after mDebugDownPipe is initialized
OutputClear();
OutputText("Debugger process initialized.");
mISO = mDebugInfo["ISOFile"];
OutputText("Using ISO file " + mISO + ".");
mProjectFile = mDebugInfo["ProjectFile"];
//
bool xUseGDB = string.Equals(mDebugInfo[BuildPropertyNames.EnableGDBString], "true", StringComparison.InvariantCultureIgnoreCase);
OutputText("GDB " + (xUseGDB ? "Enabled" : "Disabled") + ".");
//
var xGDBClient = false;
Boolean.TryParse(mDebugInfo[BuildPropertyNames.StartCosmosGDBString], out xGDBClient);
switch (mLaunch)
{
case LaunchType.VMware:
mHost = new Host.VMware(mDebugInfo, xUseGDB);
break;
case LaunchType.Slave:
mHost = new Host.Slave(mDebugInfo, xUseGDB);
break;
case LaunchType.Bochs:
// The project has been created on another machine or Bochs has been uninstalled since the project has
// been created.
if (!BochsSupport.BochsEnabled) { throw new Exception(ResourceStrings.BochsIsNotInstalled); }
string bochsConfigurationFileName = mDebugInfo[BuildProperties.BochsEmulatorConfigurationFileString];
if (string.IsNullOrEmpty(bochsConfigurationFileName))
{
bochsConfigurationFileName = BuildProperties.BochsDefaultConfigurationFileName;
}
if (!Path.IsPathRooted(bochsConfigurationFileName))
{
// Assume the configuration file name is relative to project output path.
bochsConfigurationFileName = Path.Combine(new FileInfo(mDebugInfo["ProjectFile"]).Directory.FullName,
mDebugInfo["OutputPath"], bochsConfigurationFileName);
}
FileInfo bochsConfigurationFile = new FileInfo(bochsConfigurationFileName);
// TODO : What if the configuration file doesn't exist ? This will throw a FileNotFoundException in
// the Bochs class constructor. Is this appropriate behavior ?
mHost = new Host.Bochs(mDebugInfo, xUseGDB, bochsConfigurationFile);
//((Host.Bochs)mHost).FixBochsConfiguration(new KeyValuePair<string, string>[] { new KeyValuePair<string, string>("IsoFileName", mISO) });
break;
case LaunchType.IntelEdison:
mHost = new Host.IntelEdison(mDebugInfo, false);
break;
default:
throw new Exception("Invalid Launch value: '" + mLaunch + "'.");
}
mHost.OnShutDown += HostShutdown;
string xDbPath = Path.ChangeExtension(mISO, "cdb");
if (!File.Exists(xDbPath))
{
throw new Exception("Debug data file " + xDbPath + " not found. Could be a omitted build process of Cosmos project so that not created.");
}
mDebugInfoDb = new DebugInfo(xDbPath);
mDebugInfoDb.LoadLookups();
CreateDebugConnector();
aEngine.BPMgr.SetDebugConnector(mDbgConnector);
mEngine = aEngine;
mThread = new AD7Thread(aEngine, this);
mCallback.OnThreadStart(mThread);
mPort = aPort;
if (xUseGDB && xGDBClient)
{
LaunchGdbClient();
}
}
public static void Send(AD7Engine engine)
{
AD7EngineCreateEvent eventObject = new AD7EngineCreateEvent(engine);
engine.Callback.Send(eventObject, IID, null, null);
}
public AD7StackFrame(AD7Engine aEngine, AD7Thread aThread, AD7Process aProcess)
{
mEngine = aEngine;
mThread = aThread;
mProcess = aProcess;
var xProcess = mEngine.mProcess;
if (mHasSource = xProcess.mCurrentAddress.HasValue)
{
UInt32 xAddress = xProcess.mCurrentAddress.Value;
var xSourceInfos = xProcess.mDebugInfoDb.GetSourceInfos(xAddress);
if (!xSourceInfos.ContainsKey(xAddress))
{
//Attempt to find the ASM address of the first ASM line of the C# line that contains
//the current ASM address line
// Because of Asm breakpoints the address we have might be in the middle of a C# line.
// So we find the closest address to ours that is less or equal to ours.
var xQry = from x in xSourceInfos
where x.Key <= xAddress
orderby x.Key descending
select x.Key;
if(xQry.Count() > 0)
{
xAddress = xQry.First();
}
}
if (mHasSource = xSourceInfos.ContainsKey(xAddress))
{
var xSourceInfo = xSourceInfos[xAddress];
mDocName = xSourceInfo.SourceFile;
mFunctionName = xSourceInfo.MethodName;
mLineNum = (uint)xSourceInfo.Line;
// Multiple labels that point to a single address can happen because of exception handling exits etc.
// Because of this given an address, we might find more than one label that matches the address.
// Currently, the label we are looking for will always be the first one so we choose that one.
// In the future this might "break", so be careful about this. In the future we may need to classify
// labels in the output and mark them somehow.
var xLabelsForAddr = xProcess.mDebugInfoDb.GetLabels(xAddress);
if (xLabelsForAddr.Length > 0)
{
MethodIlOp xSymbolInfo;
string xLabel = xLabelsForAddr[0]; // Necessary for LINQ
xSymbolInfo = aProcess.mDebugInfoDb.Connection.Query<MethodIlOp>(new SQLinq<MethodIlOp>().Where(q => q.LabelName == xLabel)).FirstOrDefault();
if (xSymbolInfo != null)
{
var xMethod = mProcess.mDebugInfoDb.Connection.Get<Method>(xSymbolInfo.MethodID);
var xAllInfos = aProcess.mDebugInfoDb.Connection.Query<LOCAL_ARGUMENT_INFO>(new SQLinq<LOCAL_ARGUMENT_INFO>().Where(q => q.METHODLABELNAME == xMethod.LabelCall));
mLocalInfos = xAllInfos.Where(q => !q.IsArgument).ToArray();
mArgumentInfos = xAllInfos.Where(q => q.IsArgument).ToArray();
if (mArgumentInfos.Length > 0)
{
mParams = new DebugLocalInfo[mArgumentInfos.Length];
for (int i = 0; i < mArgumentInfos.Length; i++)
{
mParams[i] = new DebugLocalInfo
{
Name = mArgumentInfos[i].NAME,
Index = i,
IsLocal = false
};
}
mParams = mParams.OrderBy(i => i.Name, StringComparer.OrdinalIgnoreCase).ToArray();
}
if (mLocalInfos.Length > 0)
{
mLocals = new DebugLocalInfo[mLocalInfos.Length];
for (int i = 0; i < mLocalInfos.Length; i++)
{
mLocals[i] = new DebugLocalInfo
{
Name = mLocalInfos[i].NAME,
Index = i,
IsLocal = true
};
}
mLocals = mLocals.OrderBy(i => i.Name, StringComparer.OrdinalIgnoreCase).ToArray();
}
}
}
else
{
MessageBox.Show("No Symbol found for address 0x" + xAddress.ToString("X8").ToUpper());
}
xProcess.DebugMsg(String.Format("StackFrame: Returning: {0}#{1}[{2}]", mDocName, mFunctionName, mLineNum));
}
}
if (!mHasSource)
{
xProcess.DebugMsg("StackFrame: No Source available");
}
// If source information is available, create the collections of locals and parameters and populate them with
// values from the debuggee.
//if (m_hasSource) {
//if (mArgumentInfos.Length > 0) {
//m_parameters = new VariableInformation[m_numParameters];
//m_engine.DebuggedProcess.GetFunctionArgumentsByIP(m_threadContext.eip, m_threadContext.ebp, m_parameters);
//}
//if (mLocalInfos.Length > 0) {
//m_locals = new VariableInformation[m_numLocals];
//m_engine.DebuggedProcess.GetFunctionLocalsByIP(m_threadContext.eip, m_threadContext.ebp, m_locals);
//}
//}
}
public AD7MemoryAddress(AD7Engine engine, uint address)
{
m_engine = engine;
m_address = address;
}
public BreakpointManager(AD7Engine aEngine) {
mEngine = aEngine;
}
public EngineCallback(AD7Engine engine, IDebugEventCallback2 pCallback)
{
_engine = engine;
_eventCallback = pCallback;
}
public VisualizerWrapper(string name, AD7Engine engine, IVariableInformation underlyingVariable, Natvis.VisualizerInfo viz, bool isVisualizerView)
: base(name, engine, underlyingVariable)
{
Visualizer = viz;
_isVisualizerView = isVisualizerView;
}
AD7EngineCreateEvent(AD7Engine engine)
{
m_engine = engine;
}
internal static void Send(AD7Engine engine, IDebugThread2 aThread)
{
var eventObject = new AD7ThreadCreateEvent();
engine.Callback.Send(eventObject, IID, aThread);
}
public SimpleWrapper(string name, AD7Engine engine, IVariableInformation underlyingVariable)
{
Parent = underlyingVariable;
Name = name;
_engine = engine;
}
/// <summary>
/// Sends the event.
/// </summary>
/// <param name="engine"> The AD7Engine object that represents the DE. </param>
public static void Send(AD7Engine engine)
{
AD7EngineCreateEvent eventObject = new AD7EngineCreateEvent(engine);
engine.Callback.Send(eventObject, IID, null, null);
}
public AD7Thread(AD7Engine engine, PythonThread debuggedThread)
{
_engine = engine;
_debuggedThread = debuggedThread;
_vsTid = engine.RegisterThreadId(debuggedThread.Id);
}
/// <summary>
/// Sends the event.
/// </summary>
/// <param name="engine"> The AD7Engine object that represents the DE. </param>
/// <param name="aModule"> The IDebugModule2 object that represents the module which is loading or unloading. </param>
/// <param name="fLoad"> onzero (TRUE) if the module is loading and zero (FALSE) if the module is unloading. </param>
internal static void Send(AD7Engine engine, AD7Module aModule, bool fLoad)
{
var eventObject = new AD7ModuleLoadEvent(aModule, fLoad);
engine.Callback.Send(eventObject, IID, null);
}
internal static void Send(AD7Engine engine, AD7Module aModule, bool fLoad)
{
var eventObject = new AD7ModuleLoadEvent(aModule, fLoad);
engine.Callback.Send(eventObject, IID, null);
}
internal static void Send(AD7Engine aEngine, AD7Thread aThread)
{
var xMessage = new AD7LoadCompleteEvent();
aEngine.Callback.Send(xMessage, IID, aThread);
}
public AD7BreakpointResolution(AD7Engine engine, uint address, AD7DocumentContext documentContext) {
m_engine = engine;
m_address = address;
m_documentContext = documentContext;
}
/// <summary>
/// Sends the event.
/// </summary>
/// <param name="engine"> The AD7Engine object that represents the DE. </param>
public static void Send(AD7Engine engine)
{
var xEvent = new AD7StepCompletedEvent();
engine.Callback.Send(xEvent, IID, engine.currentThread());
}
public AD7Thread(AD7Engine engine, NodeThread debuggedThread)
{
this._engine = engine;
this._debuggedThread = debuggedThread;
}
internal static void Send(AD7Engine aEngine, IDebugThread2 aThread, uint aExitCode)
{
var xObj = new AD7ThreadDestroyEvent(aExitCode);
aEngine.Callback.Send(xObj, IID, aThread);
}
public static void Send(AD7Engine engine)
{
var xEvent = new AD7StepCompletedEvent();
engine.Callback.Send(xEvent, IID, engine.mProcess.Thread);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="engine"> The AD7Engine object that represents the DE. </param>
/// <param name="ad7Callback"> The IDebugEventCallback2 object that receives debugger events. </param>
public EngineCallback(AD7Engine engine, IDebugEventCallback2 ad7Callback)
{
m_ad7Callback = ad7Callback;
m_engine = engine;
}
public static void Send(AD7Engine aEngine)
{
aEngine.Callback.Send(new AD7EntrypointEvent(), IID, null);
}
public BreakpointManager(AD7Engine aEngine)
{
mEngine = aEngine;
}
//private AD7EngineCreateEvent(AD7Engine engine)
public AD7EngineCreateEvent(AD7Engine engine)
{
_engine = engine;
}
public SimpleWrapper(string name, AD7Engine engine, IVariableInformation underlyingVariable)
{
Parent = underlyingVariable;
Name = name;
_engine = engine;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="engine"> The AD7Engine object that represents the DE. </param>
AD7EngineCreateEvent(AD7Engine engine)
{
m_engine = engine;
}
public VisualizerWrapper(string name, AD7Engine engine, IVariableInformation underlyingVariable, Natvis.VisualizerInfo viz, bool isVisualizerView)
: base(name, engine, underlyingVariable)
{
Visualizer = viz;
_isVisualizerView = isVisualizerView;
}
public AD7Thread(AD7Engine aEngine, AD7Process aProcess) { //, DebuggedThread debuggedThread)
mEngine = aEngine;
mProcess = aProcess;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="aEngine"> The AD7Engine object that represents the DE. </param>
/// <param name="aPort"> The IDebugPort2 object that represents the port on which the process was launched. </param>
public AD7Process(AD7Engine aEngine, IDebugPort2 aPort)
{
_engine = aEngine;
_port = aPort;
m_program = aEngine.m_program;
}
internal static void Send(AD7Engine engine)
{
AD7ProgramCreateEvent eventObject = new AD7ProgramCreateEvent();
engine.Callback.Send(eventObject, IID, null);
}
