/****************************************************************************
|
**
|
** Copyright (C) 2018 The Qt Company Ltd.
|
** Contact: https://www.qt.io/licensing/
|
**
|
** This file is part of the Qt VS Tools.
|
**
|
** $QT_BEGIN_LICENSE:GPL-EXCEPT$
|
** Commercial License Usage
|
** Licensees holding valid commercial Qt licenses may use this file in
|
** accordance with the commercial license agreement provided with the
|
** Software or, alternatively, in accordance with the terms contained in
|
** a written agreement between you and The Qt Company. For licensing terms
|
** and conditions see https://www.qt.io/terms-conditions. For further
|
** information use the contact form at https://www.qt.io/contact-us.
|
**
|
** GNU General Public License Usage
|
** Alternatively, this file may be used under the terms of the GNU
|
** General Public License version 3 as published by the Free Software
|
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
|
** included in the packaging of this file. Please review the following
|
** information to ensure the GNU General Public License requirements will
|
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
|
**
|
** $QT_END_LICENSE$
|
**
|
****************************************************************************/
|
|
using System;
|
using System.Collections.Generic;
|
using System.IO;
|
using System.Linq;
|
using System.Text;
|
using System.Threading;
|
using System.Windows.Threading;
|
using Microsoft.VisualStudio;
|
using Microsoft.VisualStudio.Debugger.Interop;
|
using Microsoft.VisualStudio.Shell;
|
using Microsoft.VisualStudio.Shell.Interop;
|
using QtVsTools.VisualStudio;
|
|
namespace QtVsTools.Qml.Debug.AD7
|
{
|
sealed partial class Program : Disposable, IDebuggerEventSink,
|
|
IDebugProgramNode2, // "This interface represents a program that can be debugged."
|
|
IDebugProgram3, // "This interface represents a program that is running in a process."
|
|
IDebugProcess2, // "This interface represents a process running on a port. If the
|
// port is the local port, then IDebugProcess2 usually represents
|
// a physical process on the local machine."
|
|
IDebugThread2, // "This interface represents a thread running in a program."
|
IDebugThread100,
|
|
IDebugModule3, // "This interface represents a module -- that is, an executable unit
|
// of a program -- such as a DLL."
|
|
IDebugEventCallback2 // "This interface is used by the debug engine (DE) to send debug
|
// events to the session debug manager (SDM)."
|
{
|
public QmlDebugger Debugger { get; private set; }
|
|
public QmlEngine Engine { get; private set; }
|
|
public List<StackFrame> CurrentFrames { get; private set; }
|
|
public const string Name = "QML Debugger";
|
public Guid ProcessId { get; private set; }
|
public Guid ProgramId { get; set; }
|
public IDebugProcess2 NativeProc { get; private set; }
|
public uint NativeProcId { get; private set; }
|
public string ExecPath { get; private set; }
|
public string ExecArgs { get; private set; }
|
public IVsDebugger VsDebugger { get; private set; }
|
Dispatcher vsDebuggerThreadDispatcher;
|
|
private readonly static object criticalSectionGlobal = new object();
|
static bool originalBreakAllProcesses = BreakAllProcesses;
|
static int runningPrograms = 0;
|
|
public static Program Create(
|
QmlEngine engine,
|
IDebugProcess2 nativeProc,
|
string execPath,
|
string execArgs)
|
{
|
var _this = new Program();
|
return _this.Initialize(engine, nativeProc, execPath, execArgs) ? _this : null;
|
}
|
|
private Program()
|
{ }
|
|
private bool Initialize(
|
QmlEngine engine,
|
IDebugProcess2 nativeProc,
|
string execPath,
|
string execArgs)
|
{
|
Engine = engine;
|
NativeProc = nativeProc;
|
|
var nativeProcId = new AD_PROCESS_ID[1];
|
nativeProc.GetPhysicalProcessId(nativeProcId);
|
NativeProcId = nativeProcId[0].dwProcessId;
|
|
ExecPath = execPath;
|
ExecArgs = execArgs;
|
|
Debugger = QmlDebugger.Create(this, execPath, execArgs);
|
if (Debugger == null)
|
return false;
|
|
VsDebugger = VsServiceProvider.GetService<IVsDebugger>();
|
if (VsDebugger != null)
|
VsDebugger.AdviseDebugEventCallback(this as IDebugEventCallback2);
|
vsDebuggerThreadDispatcher = Dispatcher.CurrentDispatcher;
|
|
ProcessId = Guid.NewGuid();
|
CurrentFrames = new List<StackFrame>();
|
|
lock (criticalSectionGlobal) {
|
if (runningPrograms == 0)
|
originalBreakAllProcesses = BreakAllProcesses;
|
runningPrograms++;
|
}
|
|
return true;
|
}
|
|
public override bool CanDispose
|
{
|
get
|
{
|
return !Engine.ProgramIsRunning(this);
|
}
|
}
|
|
protected override void DisposeManaged()
|
{
|
Debugger.Dispose();
|
if (VsDebugger != null)
|
VsDebugger.UnadviseDebugEventCallback(this as IDebugEventCallback2);
|
|
lock (criticalSectionGlobal) {
|
runningPrograms--;
|
if (runningPrograms == 0)
|
BreakAllProcesses = originalBreakAllProcesses;
|
}
|
}
|
|
public void OutputWriteLine(string msg)
|
{
|
var execFileName = Path.GetFileName(ExecPath);
|
Engine.OutputWriteLine(string.Format("'{0}' (QML): {1}", execFileName, msg));
|
}
|
|
bool IDebuggerEventSink.QueryRuntimeFrozen()
|
{
|
var debugMode = new DBGMODE[1];
|
int res = VSConstants.S_FALSE;
|
vsDebuggerThreadDispatcher
|
.BeginInvoke(new Action(() => res = VsDebugger.GetMode(debugMode)), new object[0])
|
.Wait();
|
|
if (res != VSConstants.S_OK)
|
return false;
|
return (debugMode[0] != DBGMODE.DBGMODE_Run);
|
}
|
|
void IDebuggerEventSink.NotifyError(string errorMessage)
|
{
|
OutputWriteLine(errorMessage);
|
}
|
|
int IDebugEventCallback2.Event(
|
IDebugEngine2 pEngine,
|
IDebugProcess2 pProcess,
|
IDebugProgram2 pProgram,
|
IDebugThread2 pThread,
|
IDebugEvent2 pEvent,
|
ref Guid riidEvent,
|
uint dwAttrib)
|
{
|
if (pEngine == Engine)
|
return VSConstants.S_OK;
|
|
if (pProcess == null && pProgram == null)
|
return VSConstants.S_OK;
|
|
if (pProcess == null) {
|
if (pProgram.GetProcess(out pProcess) != VSConstants.S_OK || pProcess == null)
|
return VSConstants.S_OK;
|
}
|
|
var pProcessId = new AD_PROCESS_ID[1];
|
if (pProcess.GetPhysicalProcessId(pProcessId) != VSConstants.S_OK)
|
return VSConstants.S_OK;
|
|
if (pProcessId[0].dwProcessId != NativeProcId)
|
return VSConstants.S_OK;
|
|
if (riidEvent == typeof(IDebugProgramDestroyEvent2).GUID)
|
TerminateProcess();
|
|
return VSConstants.S_OK;
|
}
|
|
void IDebuggerEventSink.NotifyClientDisconnected()
|
{
|
TerminateProcess();
|
}
|
|
bool terminated = false;
|
void TerminateProcess()
|
{
|
if (!terminated) {
|
terminated = true;
|
var engineLaunch = Engine as IDebugEngineLaunch2;
|
engineLaunch.TerminateProcess(this as IDebugProcess2);
|
}
|
}
|
|
|
#region //////////////////// Execution Control ////////////////////////////////////////////
|
|
public int /*IDebugProgram3*/ Continue(IDebugThread2 pThread)
|
{
|
Debugger.Run();
|
return VSConstants.S_OK;
|
}
|
|
public int /*IDebugProgram3*/ ExecuteOnThread(IDebugThread2 pThread)
|
{
|
Debugger.Run();
|
return VSConstants.S_OK;
|
}
|
|
public int /*IDebugProgram3*/ Step(
|
IDebugThread2 pThread,
|
enum_STEPKIND sk,
|
enum_STEPUNIT Step)
|
{
|
if (sk == enum_STEPKIND.STEP_OVER)
|
Debugger.StepOver();
|
else if (sk == enum_STEPKIND.STEP_INTO)
|
Debugger.StepInto();
|
else if (sk == enum_STEPKIND.STEP_OUT)
|
Debugger.StepOut();
|
else
|
return VSConstants.E_FAIL;
|
return VSConstants.S_OK;
|
}
|
|
void IDebuggerEventSink.NotifyBreak()
|
{
|
BreakAllProcesses = false;
|
DebugEvent.Send(new StepCompleteEvent(this));
|
}
|
|
#endregion //////////////////// Execution Control /////////////////////////////////////////
|
|
|
#region //////////////////// Breakpoints //////////////////////////////////////////////////
|
|
public void SetBreakpoint(Breakpoint breakpoint)
|
{
|
Debugger.SetBreakpoint(breakpoint);
|
}
|
|
public void NotifyBreakpointSet(Breakpoint breakpoint)
|
{
|
DebugEvent.Send(new BreakpointBoundEvent(breakpoint));
|
}
|
|
public void ClearBreakpoint(Breakpoint breakpoint)
|
{
|
Debugger.ClearBreakpoint(breakpoint);
|
}
|
|
public void NotifyBreakpointCleared(Breakpoint breakpoint)
|
{
|
breakpoint.Parent.DisposeBreakpoint(breakpoint);
|
}
|
|
public void NotifyBreakpointHit(Breakpoint breakpoint)
|
{
|
BreakAllProcesses = false;
|
DebugEvent.Send(new BreakpointEvent(this, BoundBreakpointsEnum.Create(breakpoint)));
|
}
|
|
static bool BreakAllProcesses
|
{
|
get
|
{
|
return ((bool)QtVsToolsPackage.Instance.Dte
|
.Properties["Debugging", "General"]
|
.Item("BreakAllProcesses")
|
.Value);
|
}
|
set
|
{
|
QtVsToolsPackage.Instance.Dte
|
.Properties["Debugging", "General"]
|
.Item("BreakAllProcesses")
|
.let_Value(value ? "True" : "False");
|
}
|
}
|
|
#endregion //////////////////// Breakpoints ///////////////////////////////////////////////
|
|
|
#region //////////////////// Call Stack ///////////////////////////////////////////////////
|
|
void IDebuggerEventSink.NotifyStackContext(IList<FrameInfo> frames)
|
{
|
CurrentFrames.Clear();
|
foreach (var frame in frames) {
|
CurrentFrames.Add(StackFrame.Create(frame.Name, frame.Number, frame.Scopes,
|
CodeContext.Create(Engine, this,
|
Engine.FileSystem[frame.QrcPath].FilePath, (uint)frame.Line)));
|
}
|
}
|
|
public void Refresh()
|
{
|
CurrentFrames.ForEach(x => x.Refresh());
|
}
|
|
int IDebugThread2.EnumFrameInfo(
|
enum_FRAMEINFO_FLAGS dwFieldSpec,
|
uint nRadix,
|
out IEnumDebugFrameInfo2 ppEnum)
|
{
|
ppEnum = null;
|
|
if (CurrentFrames == null || CurrentFrames.Count == 0) {
|
ppEnum = FrameInfoEnum.Create();
|
return VSConstants.S_OK;
|
}
|
|
var frameInfos = new List<FRAMEINFO>();
|
foreach (var frame in CurrentFrames) {
|
var frameInfo = new FRAMEINFO[1];
|
(frame as IDebugStackFrame2).GetInfo(dwFieldSpec, nRadix, frameInfo);
|
frameInfos.Add(frameInfo[0]);
|
}
|
|
ppEnum = FrameInfoEnum.Create(frameInfos);
|
return VSConstants.S_OK;
|
}
|
|
#endregion //////////////////// Call Stack ////////////////////////////////////////////////
|
|
|
#region //////////////////// Info /////////////////////////////////////////////////////////
|
|
class ProgramInfo : InfoHelper<ProgramInfo>
|
{
|
public uint? ThreadId { get; set; }
|
public uint? SuspendCount { get; set; }
|
public uint? ThreadState { get; set; }
|
public string Priority { get; set; }
|
public string Name { get; set; }
|
public string Location { get; set; }
|
public string DisplayName { get; set; }
|
public uint? DisplayNamePriority { get; set; }
|
public uint? ThreadCategory { get; set; }
|
public uint? AffinityMask { get; set; }
|
public int? PriorityId { get; set; }
|
public string ModuleName { get; set; }
|
public string ModuleUrl { get; set; }
|
}
|
|
ProgramInfo Info
|
{
|
get
|
{
|
return new ProgramInfo
|
{
|
ThreadId = Debugger.ThreadId,
|
SuspendCount = 0,
|
ThreadCategory = 0,
|
AffinityMask = 0,
|
PriorityId = 0,
|
ThreadState = (uint)enum_THREADSTATE.THREADSTATE_RUNNING,
|
Priority = "Normal",
|
Location = "",
|
Name = Name,
|
DisplayName = Name,
|
DisplayNamePriority = 10, // Give this display name a higher priority
|
// than the default (0) so that it will
|
// actually be displayed
|
ModuleName = Path.GetFileName(ExecPath),
|
ModuleUrl = ExecPath
|
|
};
|
}
|
}
|
|
static readonly ProgramInfo.Mapping MappingToTHREADPROPERTIES =
|
|
#region //////////////////// THREADPROPERTIES <-- ProgramInfo /////////////////////////////
|
// r: Ref<THREADPROPERTIES>
|
// f: enum_THREADPROPERTY_FIELDS
|
// i: ProgramInfo
|
// v: value of i.<<property>>
|
|
new ProgramInfo.Mapping<THREADPROPERTIES, enum_THREADPROPERTY_FIELDS>
|
((r, f) => r.s.dwFields |= f)
|
{
|
{ enum_THREADPROPERTY_FIELDS.TPF_ID,
|
(r, v) => r.s.dwThreadId = v, i => i.ThreadId },
|
|
{ enum_THREADPROPERTY_FIELDS.TPF_SUSPENDCOUNT,
|
(r, v) => r.s.dwSuspendCount = v, i => i.SuspendCount },
|
|
{ enum_THREADPROPERTY_FIELDS.TPF_STATE,
|
(r, v) => r.s.dwThreadState = v, i => i.ThreadState },
|
|
{ enum_THREADPROPERTY_FIELDS.TPF_PRIORITY,
|
(r, v) => r.s.bstrPriority = v, i => i.Priority },
|
|
{ enum_THREADPROPERTY_FIELDS.TPF_NAME,
|
(r, v) => r.s.bstrName = v, i => i.Name },
|
|
{ enum_THREADPROPERTY_FIELDS.TPF_LOCATION,
|
(r, v) => r.s.bstrLocation = v, i => i.Location },
|
};
|
|
#endregion //////////////////// THREADPROPERTIES <-- ProgramInfo //////////////////////////
|
|
|
static readonly ProgramInfo.Mapping MappingToTHREADPROPERTIES100 =
|
|
#region //////////////////// THREADPROPERTIES100 <-- ProgramInfo //////////////////
|
// r: Ref<THREADPROPERTIES100>
|
// f: enum_THREADPROPERTY_FIELDS100
|
// i: ProgramInfo
|
// v: value of i.<<property>>
|
|
new ProgramInfo.Mapping<THREADPROPERTIES100, enum_THREADPROPERTY_FIELDS100>
|
((r, f) => r.s.dwFields |= (uint)f)
|
{
|
{ enum_THREADPROPERTY_FIELDS100.TPF100_ID,
|
(r, v) => r.s.dwThreadId = v, i => i.ThreadId },
|
|
{ enum_THREADPROPERTY_FIELDS100.TPF100_SUSPENDCOUNT,
|
(r, v) => r.s.dwSuspendCount = v, i => i.SuspendCount },
|
|
{ enum_THREADPROPERTY_FIELDS100.TPF100_STATE,
|
(r, v) => r.s.dwThreadState = v, i => i.ThreadState },
|
|
{ enum_THREADPROPERTY_FIELDS100.TPF100_PRIORITY,
|
(r, v) => r.s.bstrPriority = v, i => i.Priority },
|
|
{ enum_THREADPROPERTY_FIELDS100.TPF100_NAME,
|
(r, v) => r.s.bstrName = v, i => i.Name },
|
|
{ enum_THREADPROPERTY_FIELDS100.TPF100_LOCATION,
|
(r, v) => r.s.bstrLocation = v, i => i.Location },
|
|
{ enum_THREADPROPERTY_FIELDS100.TPF100_DISPLAY_NAME,
|
(r, v) => r.s.bstrDisplayName = v, i => i.DisplayName },
|
|
{ enum_THREADPROPERTY_FIELDS100.TPF100_DISPLAY_NAME,
|
enum_THREADPROPERTY_FIELDS100.TPF100_DISPLAY_NAME_PRIORITY,
|
(r, v) => r.s.DisplayNamePriority = v, i => i.DisplayNamePriority },
|
|
{ enum_THREADPROPERTY_FIELDS100.TPF100_CATEGORY,
|
(r, v) => r.s.dwThreadCategory = v, i => i.ThreadCategory },
|
|
{ enum_THREADPROPERTY_FIELDS100.TPF100_AFFINITY,
|
(r, v) => r.s.AffinityMask = v, i => i.AffinityMask },
|
|
{ enum_THREADPROPERTY_FIELDS100.TPF100_PRIORITY_ID,
|
(r, v) => r.s.priorityId = v, i => i.PriorityId },
|
};
|
|
#endregion //////////////////// THREADPROPERTIES100 <-- ProgramInfo ///////////////////////
|
|
|
static readonly ProgramInfo.Mapping MappingToMODULE_INFO =
|
|
#region //////////////////// MODULE_INFO <-- ProgramInfo //////////////////////////////////
|
// r: Ref<MODULE_INFO>
|
// f: enum_MODULE_INFO_FIELDS
|
// i: ProgramInfo
|
// v: value of i.<<property>>
|
|
new ProgramInfo.Mapping<MODULE_INFO, enum_MODULE_INFO_FIELDS>
|
((r, bit) => r.s.dwValidFields |= bit)
|
{
|
{ enum_MODULE_INFO_FIELDS.MIF_NAME,
|
(r, v) => r.s.m_bstrName = v, i => i.ModuleName },
|
|
{ enum_MODULE_INFO_FIELDS.MIF_URL,
|
(r, v) => r.s.m_bstrUrl = v, i => i.ModuleUrl },
|
};
|
|
#endregion //////////////////// MODULE_INFO <-- ProgramInfo ///////////////////////////////
|
|
|
public int /*IDebugProgram3*/ GetName(out string pbstrName)
|
{
|
pbstrName = Program.Name;
|
return VSConstants.S_OK;
|
}
|
|
int IDebugProgramNode2.GetProgramName(out string pbstrProgramName)
|
{
|
return GetName(out pbstrProgramName);
|
}
|
|
int IDebugProgramNode2.GetEngineInfo(out string pbstrEngine, out Guid pguidEngine)
|
{
|
pbstrEngine = "QML";
|
pguidEngine = QmlEngine.Id;
|
return VSConstants.S_OK;
|
}
|
|
int IDebugProgramNode2.GetHostPid(AD_PROCESS_ID[] pHostProcessId)
|
{
|
pHostProcessId[0].ProcessIdType = (uint)enum_AD_PROCESS_ID.AD_PROCESS_ID_GUID;
|
pHostProcessId[0].guidProcessId = ProcessId;
|
return VSConstants.S_OK;
|
}
|
|
int IDebugProcess2.GetPhysicalProcessId(AD_PROCESS_ID[] pProcessId)
|
{
|
pProcessId[0].ProcessIdType = (uint)enum_AD_PROCESS_ID.AD_PROCESS_ID_GUID;
|
pProcessId[0].guidProcessId = ProcessId;
|
return VSConstants.S_OK;
|
}
|
|
int IDebugProcess2.GetProcessId(out Guid pguidProcessId)
|
{
|
pguidProcessId = ProcessId;
|
return VSConstants.S_OK;
|
}
|
|
int IDebugProcess2.GetPort(out IDebugPort2 ppPort)
|
{
|
return NativeProc.GetPort(out ppPort);
|
}
|
|
public int /*IDebugProgram3*/ GetProgramId(out Guid pguidProgramId)
|
{
|
pguidProgramId = ProgramId;
|
return VSConstants.S_OK;
|
}
|
|
int IDebugThread2.GetThreadProperties(
|
enum_THREADPROPERTY_FIELDS dwFields,
|
THREADPROPERTIES[] ptp)
|
{
|
Info.Map(MappingToTHREADPROPERTIES, dwFields, out ptp[0]);
|
return VSConstants.S_OK;
|
}
|
|
int IDebugThread100.GetThreadProperties100(uint dwFields, THREADPROPERTIES100[] ptp)
|
{
|
Info.Map(MappingToTHREADPROPERTIES100, dwFields, out ptp[0]);
|
return VSConstants.S_OK;
|
}
|
|
int IDebugThread2.GetName(out string pbstrName)
|
{
|
pbstrName = Name;
|
return VSConstants.S_OK;
|
}
|
|
int IDebugThread2.GetThreadId(out uint pdwThreadId)
|
{
|
pdwThreadId = (uint)Debugger.ThreadId;
|
return VSConstants.S_OK;
|
}
|
|
public int /*IDebugModule3*/ GetInfo(enum_MODULE_INFO_FIELDS dwFields, MODULE_INFO[] pinfo)
|
{
|
Info.Map(MappingToMODULE_INFO, dwFields, out pinfo[0]);
|
return VSConstants.S_OK;
|
}
|
|
public int /*IDebugProgram3*/ EnumThreads(out IEnumDebugThreads2 ppEnum)
|
{
|
ppEnum = ThreadEnum.Create(this);
|
return VSConstants.S_OK;
|
}
|
|
public int /*IDebugProgram3*/ EnumModules(out IEnumDebugModules2 ppEnum)
|
{
|
ppEnum = ModuleEnum.Create(this);
|
return VSConstants.S_OK;
|
}
|
|
#endregion //////////////////// Info //////////////////////////////////////////////////////
|
|
}
|
}
|
