public CorDebugProcess(DebugPort port, PortDefinition portDefinition)
{
m_port = port;
m_portDefinition = portDefinition;
m_guidProcessId = Guid.NewGuid();
m_syncTerminatingObject = new object();
}
int IVsDeployableProjectCfg.QueryStartDeploy(uint dwOptions, int[] pfSupported, int[] pfReady)
{
Debug.Assert(pfSupported == null || pfSupported.Length > 0);
Debug.Assert(pfReady == null || pfReady.Length > 0);
Debug.Assert(dwOptions == 0);
if (pfSupported != null)
{
pfSupported[0] = Utility.Boolean.TRUE;
}
if (pfReady != null)
{
pfReady[0] = Utility.Boolean.TRUE;
}
DebugPort port = GetDebugPort();
if (port != null && !port.IsLocalPort)
{
// run this prior to deploy to assure we get the assembly list before
// deploying, because build tasks are not allowed during deployment.
m_project.GetDependencies(true, true, false);
}
return(Utility.COM_HResults.S_OK);
}
private bool IsTargetBigEndian()
{
bool fBE;
DebugPort port = GetDebugPort();
if (port == null)
{
return(false);
}
if (!port.IsLocalPort)
{
CorDebugProcess process = GetDeviceProcess();
bool detach = !process.IsAttachedToEngine;
Engine engine = process.AttachToEngine();
fBE = engine.IsTargetBigEndian;
if (detach)
{
process.DetachFromEngine();
}
}
else
{
// emulator is little endian
fBE = false;
}
return(fBE);
}
internal CorDebugProcess GetDeviceProcess()
{
DebugPort port = GetDebugPort();
Debug.Assert(!port.IsLocalPort);
return(port.GetDeviceProcess(this.DeployDeviceName));
}
internal void EnsureDeviceProcess()
{
DebugPort port = GetDebugPort();
if (!port.IsLocalPort)
{
CorDebugProcess process = port.GetDeviceProcess(this.DeployDeviceName);
}
}
public override DebugPort FindPort(string name)
{
for (int i = 0; i < m_ports.Length; i++)
{
DebugPort port = m_ports [i];
if (String.Compare(port.Name, name, true) == 0)
{
return(port);
}
}
return(null);
}
new public int AddPort(IDebugPortRequest2 pRequest, out IDebugPort2 ppPort)
{
string name;
pRequest.GetPortName(out name);
ppPort = FindPort(name);
if (ppPort == null)
{
DebugPort port = m_ports[(int)PortFilter.TcpIp];
//hack, hack. Abusing the Attach to dialog box to force the NetworkDevice port to
//look for a TinyCLR process
if (port.TryAddProcess(name) != null)
{
ppPort = port;
}
}
return(Utility.COM_HResults.BOOL_TO_HRESULT_FAIL(ppPort != null));
}
private void InitializeDeployDevice(PortDefinition selected)
{
//What about EmulatorExe????
int iSelected = -1;
DebugPort port = this.SelectedDeployPort;
if (port == null)
{
return;
}
PortDefinition[] portDefinitions;
if (port.IsLocalPort)
{
PlatformInfo platformInfo = this.VsProjectFlavorCfg.PlatformInfo;
PlatformInfo.Emulator[] emulators = platformInfo.Emulators;
portDefinitions = new PortDefinition[emulators.Length];
for (int i = 0; i < emulators.Length; i++)
{
portDefinitions[i] = new PlatformInfo.PortDefinition_PeristableEmulator(emulators[i]);
}
}
else
{
portDefinitions = port.GetPersistablePortDefinitions();
}
m_cbDeployDevice.Items.Clear();
for (int iPortDefinition = 0; iPortDefinition < portDefinitions.Length; iPortDefinition++)
{
PortDefinition pd = portDefinitions[iPortDefinition];
ComboBoxItemDevice cbi = new ComboBoxItemDevice(pd);
m_cbDeployDevice.Items.Add(cbi);
if (Object.Equals(selected, pd))
{
iSelected = m_cbDeployDevice.Items.Count - 1;
}
}
if (m_cbDeployDevice.Items.Count == 0)
{
if (selected != null && port.PortFilter == PortFilter.TcpIp && selected is PortDefinition_Tcp)
{
m_cbDeployDevice.Items.Add(new ComboBoxItemDevice(selected));
}
else
{
ComboBoxItemDevice cbi = new ComboBoxItemDevice("<none>");
m_cbDeployDevice.Items.Insert(0, cbi);
}
iSelected = 0;
}
if (port.PortFilter != PortFilter.TcpIp)
{
iSelected = 0;
}
if (iSelected != -1)
{
m_cbDeployDevice.SelectedIndex = iSelected;
}
}
public ComboBoxItemPort(DebugPort port) : base(port.Name)
{
m_port = port;
}
public static CorDebugProcess CreateProcess (DebugPort pPort, string lpCommandLine)
{
CommandLineBuilder cb = new CommandLineBuilder (lpCommandLine);
string[] args = cb.Arguments;
string deployDeviceName = args [args.Length - 1];
//Extract deployDeviceName
if (!deployDeviceName.StartsWith (CorDebugProcess.c_DeployDeviceName))
throw new Exception (String.Format ("\"{0}\" does not appear to be a valid Micro Framework device name", deployDeviceName));
deployDeviceName = deployDeviceName.Substring (CorDebugProcess.c_DeployDeviceName.Length);
cb.RemoveArguments (args.Length - 1, 1);
lpCommandLine = cb.ToString ();
//CorDebugProcess process = port.GetDeviceProcess(deployDeviceName, 60);
CorDebugProcess process = pPort.GetDeviceProcess (deployDeviceName, 60);
if (process == null)
throw new Exception ("CorDebugProcess.CreateProcessEx() could not create or find the device process");
process.StoreAssemblyPaths (args);
bool fDidDeploy = true; //What if we did a launch but no deploy to a device...
if (!fDidDeploy) {
process.Engine.RebootDevice (Engine.RebootOption.RebootClrWaitForDebugger);
}
return process;
}
public ComboBoxItemPort(DebugPort port) : base(port.Name)
{
m_port = port;
}
private void InternalCreateProcess(
DebugPort port,
string lpApplicationName,
string lpCommandLine,
IntPtr lpProcessAttributes,
IntPtr lpThreadAttributes,
int bInheritHandles,
uint dwCreationFlags,
System.IntPtr lpEnvironment,
string lpCurrentDirectory,
ref _STARTUPINFO lpStartupInfo,
ref _PROCESS_INFORMATION lpProcessInformation,
uint debuggingFlags
)
{
if (port.IsLocalPort)
this.CreateEmulatorProcess(port, lpApplicationName, lpCommandLine, lpProcessAttributes, lpThreadAttributes, bInheritHandles, dwCreationFlags, lpEnvironment, lpCurrentDirectory, ref lpStartupInfo, ref lpProcessInformation, debuggingFlags);
else
this.CreateDeviceProcess(port, lpApplicationName, lpCommandLine, lpProcessAttributes, lpThreadAttributes, bInheritHandles, dwCreationFlags, lpEnvironment, lpCurrentDirectory, ref lpStartupInfo, ref lpProcessInformation, debuggingFlags);
}
private void UnInit()
{
if (m_assemblies != null)
{
foreach (CorDebugAssembly assembly in m_assemblies)
{
((IDisposable)assembly).Dispose();
}
m_assemblies = null;
}
if(m_win32process != null)
{
m_win32process.EnableRaisingEvents = false;
// If the process hasn't already exited, we'll wait another 2 sec and kill it.
for (int i = 1; !m_win32process.HasExited && i <= 2; i++)
{
if (i == 1)
{
Thread.Yield();
}
else
{
try
{
m_win32process.Kill();
}
catch(Win32Exception)
{
}
catch( NotSupportedException )
{
}
catch( InvalidOperationException )
{
}
}
}
m_win32process.Dispose();
m_win32process = null;
}
if (m_port != null)
{
m_port.RemoveProcess(this.m_portDefinition);
m_port = null;
}
m_appDomains = null;
m_events = null;
m_threads = null;
m_assemblyPaths = null;
m_breakpoints = null;
m_fExecutionPaused = false;
m_eventDispatch = null;
m_fUpdateBreakpoints = false;
m_cStopped = 0;
m_fLaunched = false;
m_fTerminating = false;
m_fDetaching = false;
m_dummyThreadEvent = null;
m_cEvalThreads = 0;
m_tdBuiltin = null;
m_scratchPad = null;
m_threadDispatch = null;
if (m_corDebug != null)
{
m_corDebug.UnregisterProcess(this);
m_corDebug = null;
}
}
private void CreateEmulatorProcess(
DebugPort port,
string lpApplicationName,
string lpCommandLine,
IntPtr lpProcessAttributes,
IntPtr lpThreadAttributes,
int bInheritHandles,
uint dwCreationFlags,
System.IntPtr lpEnvironment,
string lpCurrentDirectory,
ref _STARTUPINFO lpStartupInfo,
ref _PROCESS_INFORMATION lpProcessInformation,
uint debuggingFlags
)
{
VsPackage.MessageCentre.DeploymentMsg(String.Format(DiagnosticStrings.EmulatorCommandLine, lpCommandLine));
try
{
Process emuProcess = new Process();
emuProcess.StartInfo.FileName = lpApplicationName;
emuProcess.StartInfo.Arguments = lpCommandLine.Substring(lpApplicationName.Length+2);
emuProcess.StartInfo.UseShellExecute = false;
emuProcess.StartInfo.RedirectStandardOutput = true;
emuProcess.StartInfo.RedirectStandardError = true;
emuProcess.StartInfo.RedirectStandardInput = false;
// Set our event handler to asynchronously read the emulator's outputs.
emuProcess.OutputDataReceived += new DataReceivedEventHandler(VsPackage.MessageCentre.OutputMsgHandler);
emuProcess.ErrorDataReceived += new DataReceivedEventHandler(VsPackage.MessageCentre.ErrorMsgHandler);
emuProcess.StartInfo.WorkingDirectory = lpCurrentDirectory;
// Start the process.
if(!emuProcess.Start())
throw new Exception("Process.Start() returned false.");
// Start the asynchronous reads of the emulator's output streams
emuProcess.BeginOutputReadLine();
emuProcess.BeginErrorReadLine();
this.PortDefinition = new PortDefinition_Emulator("Emulator", emuProcess.Id);
this.SetPid((uint)emuProcess.Id);
port.AddProcess(this);
const int DUPLICATE_SAME_ACCESS = 0x00000002;
Utility.Kernel32.DuplicateHandle(Utility.Kernel32.GetCurrentProcess(), emuProcess.Handle,
Utility.Kernel32.GetCurrentProcess(), out lpProcessInformation.hProcess,
0, false, DUPLICATE_SAME_ACCESS);
lpProcessInformation.dwProcessId = (uint)emuProcess.Id;
CreateDummyThread(out lpProcessInformation.hThread, out lpProcessInformation.dwThreadId);
}
catch (Exception ex)
{
throw new ApplicationException(String.Format("Could not create emulator process."),ex);
}
}
private void CreateDeviceProcess(DebugPort port, string lpApplicationName, string lpCommandLine, System.IntPtr lpProcessAttributes, System.IntPtr lpThreadAttributes, int bInheritHandles, uint dwCreationFlags, System.IntPtr lpEnvironment, string lpCurrentDirectory, ref _STARTUPINFO lpStartupInfo, ref _PROCESS_INFORMATION lpProcessInformation, uint debuggingFlags)
{
bool fDidDeploy = true; //What if we did a launch but no deploy to a device...
if (!fDidDeploy)
{
this.Engine.RebootDevice(Engine.RebootOption.RebootClrWaitForDebugger);
}
DebugAssert(m_port == port);
lpProcessInformation.dwProcessId = m_pid;
CreateDummyThread(out lpProcessInformation.hThread, out lpProcessInformation.dwThreadId);
}
private void Deploy(DebugPort port)
{
Debug.Assert(port != null && !port.IsLocalPort);
VsPackage.MessageCentre.InternalErrorMsg(DiagnosticStrings.StartDeployAssemblies);
CorDebugProcess process = null;
bool fDeviceFound = false;
VsPackage.MessageCentre.DeploymentMsg(DiagnosticStrings.StartingDeviceDeployment);
for (int retries = 0; retries < 60; retries++)
{
VsPackage.MessageCentre.DeploymentMsg(String.Format(DiagnosticStrings.Iteration, retries));
try
{
process = GetDeviceProcess();
if (process != null)
{
switch (port.PortFilter)
{
case PortFilter.Serial:
case PortFilter.Usb:
case PortFilter.TcpIp:
//test the connection. This doesn't tell you if the connection will fail during the AttachToEngine,
//but it's a pretty good guess.
VsPackage.MessageCentre.DeploymentMsg(String.Format(DiagnosticStrings.OpeningPort, process.PortDefinition.Port));
fDeviceFound = process.PortDefinition.TryToOpen();
if (!fDeviceFound)
{
VsPackage.MessageCentre.DeploymentMsg(String.Format(DiagnosticStrings.PortNotFound, process.PortDefinition.Port));
}
break;
default:
SetDeployFailure(string.Format("Device {0} has an unsupported/unexpected port type", this.DeployDeviceDescription));
return;
}
if (fDeviceFound)
{
break;
}
}
}
catch (IOException)
{
}
Thread.Sleep(500);
}
if (!fDeviceFound || process == null)
{
SetDeployFailure(string.Format("Device not found or cannot be opened - {0}", this.DeployDeviceDescription));
return;
}
VsPackage.MessageCentre.DeploymentMsg(DiagnosticStrings.AttachingEngine);
Engine engine = process.AttachToEngine();
if (engine == null)
{
VsPackage.MessageCentre.DeploymentMsg(DiagnosticStrings.CannotAttachEngine);
SetDeployFailure(string.Format(DiagnosticStrings.UnableToCommunicate, this.DeployDeviceDescription));
return;
}
VsPackage.MessageCentre.DeploymentMsg(DiagnosticStrings.EngineAttached);
try
{
VsPackage.MessageCentre.DeploymentMsg(DiagnosticStrings.QueryingDeviceAssemblies);
ArrayList assemblies = new ArrayList();
Hashtable systemAssemblies = new Hashtable();
//Ensure Assemblies are loaded
if (process.IsDeviceInInitializeState())
{
engine.ResumeExecution();
Thread.Sleep(200);
while (process.IsDeviceInInitializeState())
{
VsPackage.MessageCentre.DeploymentMsg(DiagnosticStrings.WaitingInitialize);
//need to break out of this or timeout or something?
Thread.Sleep(200);
}
}
WireProtocol.Commands.Debugging_Resolve_Assembly[] assms = engine.ResolveAllAssemblies();
// find out which are the system assemblies
// we will insert each system assemblies in a hash table where the value will be the assembly version
foreach (Debugging_Resolve_Assembly resolvedAssembly in assms)
{
VsPackage.MessageCentre.DeploymentMsg(String.Format(DiagnosticStrings.FoundAssembly, resolvedAssembly.m_reply.Name, resolvedAssembly.m_reply.m_version.ToString()));
if ((resolvedAssembly.m_reply.m_flags & Debugging_Resolve_Assembly.Reply.c_Deployed) == 0)
{
systemAssemblies[resolvedAssembly.m_reply.Name.ToLower()] = resolvedAssembly.m_reply.m_version;
}
}
string[] pes = m_project.GetDependencies(true, true, engine.IsTargetBigEndian);
string[] dlls = m_project.GetDependencies(true, false, engine.IsTargetBigEndian);
Debug.Assert(pes.Length == dlls.Length);
// now we will re-deploy all system assemblies
for (int i = 0; i < pes.Length; ++i)
{
string assemblyPath = pes[i];
string dllPath = dlls[i];
//is this a system assembly?
string fileName = Path.ChangeExtension(Path.GetFileName(assemblyPath), null).ToLower();
bool fDeployNewVersion = true;
if (systemAssemblies.ContainsKey(fileName))
{
// get the version of the assembly on the device
Debugging_Resolve_Assembly.Version deviceVer = (WireProtocol.Commands.Debugging_Resolve_Assembly.Version)systemAssemblies[fileName];
// get the version of the assembly of the project
// We need to load the bytes for the assembly because other Load methods can override the path
// with gac or recently used paths. This is the only way we control the exact assembly that is loaded.
byte[] asmData = null;
using (FileStream sr = new FileStream(dllPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
asmData = new byte[sr.Length];
sr.Read(asmData, 0, (int)sr.Length);
}
System.Reflection.Assembly assm = Assembly.Load(asmData); Version deployVer = assm.GetName().Version;
// compare versions strictly, and deploy whatever assembly does not match the version on the device
if (VsProject.TargetFrameworkExactMatch(deviceVer, deployVer))
{
fDeployNewVersion = false;
}
else
{
////////////////////////////////////////////////
// !!! SPECIAL CASE !!! //
// //
// MSCORLIB cannot be deployed more than once //
////////////////////////////////////////////////
if (assm.GetName().Name.ToLower().Contains("mscorlib"))
{
string message = string.Format("Cannot deploy the base assembly '{9}', or any of his satellite assemblies, to device - {0} twice. Assembly '{9}' on the device has version {1}.{2}.{3}.{4}, while the program is trying to deploy version {5}.{6}.{7}.{8} ", this.DeployDeviceDescription, deviceVer.iMajorVersion, deviceVer.iMinorVersion, deviceVer.iBuildNumber, deviceVer.iRevisionNumber, deployVer.Major, deployVer.Minor, deployVer.Build, deployVer.Revision, assm.GetName().Name);
VsPackage.MessageCentre.DeploymentMsg(message);
SetDeployFailure(message);
return;
}
}
}
// append the assembly whose version does not match, or that still is not on the device, to the blob to deploy
if (fDeployNewVersion)
{
using (FileStream fs = File.Open(assemblyPath, FileMode.Open, FileAccess.Read))
{
VsPackage.MessageCentre.DeploymentMsg(String.Format(DiagnosticStrings.AddingPEtoBundle, assemblyPath));
long length = (fs.Length + 3) / 4 * 4;
byte[] buf = new byte[length];
fs.Read(buf, 0, (int)fs.Length);
assemblies.Add(buf);
}
}
}
VsPackage.MessageCentre.DeploymentMsg("Attempting deployment...");
if (!engine.Deployment_Execute(assemblies, false, VsPackage.MessageCentre.DeploymentMsg))
{
VsPackage.MessageCentre.DeploymentMsg(DiagnosticStrings.DeployFailed);
SetDeployFailure();
return;
}
}
finally
{
process.DetachFromEngine();
}
}
private void Deploy(DebugPort port)
{
Debug.Assert(port != null && !port.IsLocalPort);
VsPackage.MessageCentre.InternalErrorMsg(DiagnosticStrings.StartDeployAssemblies);
CorDebugProcess process = null;
bool fDeviceFound = false;
VsPackage.MessageCentre.DeploymentMsg(DiagnosticStrings.StartingDeviceDeployment);
for(int retries = 0; retries < 60; retries++)
{
VsPackage.MessageCentre.DeploymentMsg( String.Format( DiagnosticStrings.Iteration, port.Name, DeployDeviceName, retries ) );
try
{
process = GetDeviceProcess();
if (process != null)
{
switch (port.PortFilter)
{
case PortFilter.Serial:
case PortFilter.Usb:
case PortFilter.TcpIp:
//test the connection. This doesn't tell you if the connection will fail during the AttachToEngine,
//but it's a pretty good guess.
VsPackage.MessageCentre.DeploymentMsg(String.Format(DiagnosticStrings.OpeningPort, process.PortDefinition.Port));
fDeviceFound = process.PortDefinition.TryToOpen();
if(!fDeviceFound)
{
VsPackage.MessageCentre.DeploymentMsg(String.Format(DiagnosticStrings.PortNotFound, process.PortDefinition.Port));
}
break;
default:
SetDeployFailure(string.Format("Device {0} has an unsupported/unexpected port type", this.DeployDeviceDescription));
return;
}
if(fDeviceFound) break;
}
}
catch(IOException)
{
}
Thread.Sleep(500);
}
if (!fDeviceFound || process == null)
{
SetDeployFailure(string.Format("Device not found or cannot be opened - {0}", this.DeployDeviceDescription));
return;
}
VsPackage.MessageCentre.DeploymentMsg(DiagnosticStrings.AttachingEngine);
Engine engine = process.AttachToEngine();
if (engine == null)
{
VsPackage.MessageCentre.DeploymentMsg(DiagnosticStrings.CannotAttachEngine);
SetDeployFailure(string.Format(DiagnosticStrings.UnableToCommunicate, this.DeployDeviceDescription));
return;
}
VsPackage.MessageCentre.DeploymentMsg(DiagnosticStrings.EngineAttached);
try
{
VsPackage.MessageCentre.DeploymentMsg(DiagnosticStrings.QueryingDeviceAssemblies);
ArrayList assemblies = new ArrayList();
Hashtable systemAssemblies = new Hashtable();
//Ensure Assemblies are loaded
if(process.IsDeviceInInitializeState())
{
engine.ResumeExecution();
Thread.Sleep(200);
while (process.IsDeviceInInitializeState())
{
VsPackage.MessageCentre.DeploymentMsg(DiagnosticStrings.WaitingInitialize);
//need to break out of this or timeout or something?
Thread.Sleep(200);
}
}
WireProtocol.Commands.Debugging_Resolve_Assembly[] assms = engine.ResolveAllAssemblies();
// find out which are the system assemblies
// we will insert each system assemblies in a hash table where the value will be the assembly version
foreach (Debugging_Resolve_Assembly resolvedAssembly in assms)
{
VsPackage.MessageCentre.DeploymentMsg(String.Format(DiagnosticStrings.FoundAssembly, resolvedAssembly.m_reply.Name, resolvedAssembly.m_reply.m_version.ToString()));
if ((resolvedAssembly.m_reply.m_flags & Debugging_Resolve_Assembly.Reply.c_Deployed) == 0)
{
systemAssemblies[resolvedAssembly.m_reply.Name.ToLower()] = resolvedAssembly.m_reply.m_version;
}
}
string[] pes = m_project.GetDependencies(true, true, engine.IsTargetBigEndian);
string[] dlls = m_project.GetDependencies(true, false, engine.IsTargetBigEndian);
Debug.Assert( pes.Length == dlls.Length );
// now we will re-deploy all system assemblies
for(int i = 0; i < pes.Length; ++i)
{
string assemblyPath = pes[i];
string dllPath = dlls[i];
//is this a system assembly?
string fileName = Path.ChangeExtension(Path.GetFileName(assemblyPath), null).ToLower();
bool fDeployNewVersion = true;
if (systemAssemblies.ContainsKey(fileName))
{
// get the version of the assembly on the device
Debugging_Resolve_Assembly.Version deviceVer = (WireProtocol.Commands.Debugging_Resolve_Assembly.Version)systemAssemblies[fileName];
// get the version of the assembly of the project
// We need to load the bytes for the assembly because other Load methods can override the path
// with gac or recently used paths. This is the only way we control the exact assembly that is loaded.
byte[] asmData = null;
using(FileStream sr = new FileStream(dllPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
asmData = new byte[sr.Length];
sr.Read(asmData, 0, (int)sr.Length);
}
System.Reflection.Assembly assm = Assembly.Load(asmData); Version deployVer = assm.GetName().Version;
// compare versions strictly, and deploy whatever assembly does not match the version on the device
if (VsProject.TargetFrameworkExactMatch(deviceVer, deployVer))
{
fDeployNewVersion = false;
}
else
{
////////////////////////////////////////////////
// !!! SPECIAL CASE !!! //
// //
// MSCORLIB cannot be deployed more than once //
////////////////////////////////////////////////
if (assm.GetName().Name.ToLower().Contains("mscorlib"))
{
string message = string.Format("Cannot deploy the base assembly '{9}', or any of his satellite assemblies, to device - {0} twice. Assembly '{9}' on the device has version {1}.{2}.{3}.{4}, while the program is trying to deploy version {5}.{6}.{7}.{8} ", this.DeployDeviceDescription, deviceVer.iMajorVersion, deviceVer.iMinorVersion, deviceVer.iBuildNumber, deviceVer.iRevisionNumber, deployVer.Major, deployVer.Minor, deployVer.Build, deployVer.Revision, assm.GetName().Name);
VsPackage.MessageCentre.DeploymentMsg( message );
SetDeployFailure(message);
return;
}
}
}
// append the assembly whose version does not match, or that still is not on the device, to the blob to deploy
if (fDeployNewVersion)
{
using (FileStream fs = File.Open(assemblyPath, FileMode.Open, FileAccess.Read))
{
VsPackage.MessageCentre.DeploymentMsg(String.Format(DiagnosticStrings.AddingPEtoBundle, assemblyPath));
long length = (fs.Length + 3) / 4 * 4;
byte[] buf = new byte[length];
fs.Read(buf, 0, (int)fs.Length);
assemblies.Add(buf);
}
}
}
VsPackage.MessageCentre.DeploymentMsg("Attempting deployment...");
if (!engine.Deployment_Execute(assemblies, false, VsPackage.MessageCentre.DeploymentMsg))
{
VsPackage.MessageCentre.DeploymentMsg(DiagnosticStrings.DeployFailed);
SetDeployFailure();
return;
}
}
finally
{
process.DetachFromEngine();
}
}
public unsafe int DebugLaunch(uint grfLaunch)
{
try
{
if (!this.m_project.CanLaunch)
{
Utility.ShowMessageBox("The project must have either an output type of 'Console Application', or an output type of 'Class Library' and the start action set to a valid .NET MicroFramework application");
return(Utility.COM_HResults.E_FAIL);
}
//Consider Launching ourselves (at least for device), and then calling Attach.
//This would get rid of the ugly dummy thread hack in CorDebugProcess.
//However, we would need to jump through some other hoops, like resuming the process,
//perhaps setting up the entry point breakpoint ourselves, ..?
VsDebugTargetInfo2 vsDebugTargetInfo = new VsDebugTargetInfo2();
DebugPort port = GetDebugPort();
Process processWin32 = null;
bool fNoDebug = (__VSDBGLAUNCHFLAGS.DBGLAUNCH_NoDebug & (__VSDBGLAUNCHFLAGS)grfLaunch) != 0;
int hRes = Utility.COM_HResults.S_OK;
PlatformInfo.Emulator emulatorConfig = GetEmulatorConfig();
if (port == null)
{
throw new Exception("Cannot find port to deploy to");
}
string commandLine = GetCommandLineForLaunch(fNoDebug, emulatorConfig, IsTargetBigEndian());
string exe = port.IsLocalPort ? emulatorConfig.application : typeof(CorDebugProcess).Assembly.Location;
if (!fNoDebug)
{
commandLine = string.Format("{0} \"{1}{2}\"", commandLine, CorDebugProcess.c_DeployDeviceName, this.DeployDeviceName);
}
//use emulator args even though this may be a device launch. This is needed to store
//paths to assemblies.
vsDebugTargetInfo.bstrArg = commandLine;
vsDebugTargetInfo.bstrCurDir = (string)m_project.GetProperty(VSConstants.VSITEMID_ROOT, (int)__VSHPROPID.VSHPROPID_ProjectDir);
vsDebugTargetInfo.bstrEnv = null;
vsDebugTargetInfo.bstrExe = exe;
vsDebugTargetInfo.bstrOptions = null;
vsDebugTargetInfo.bstrPortName = DeployTransportName;
vsDebugTargetInfo.bstrRemoteMachine = null;
vsDebugTargetInfo.cbSize = (uint)Marshal.SizeOf(vsDebugTargetInfo);
vsDebugTargetInfo.dlo = (uint)DEBUG_LAUNCH_OPERATION.DLO_CreateProcess;
vsDebugTargetInfo.dwDebugEngineCount = 0;
vsDebugTargetInfo.dwProcessId = 0;
vsDebugTargetInfo.dwReserved = 0;
vsDebugTargetInfo.fSendToOutputWindow = 0;
vsDebugTargetInfo.guidLaunchDebugEngine = CorDebug.s_guidDebugEngine;
vsDebugTargetInfo.guidPortSupplier = DebugPortSupplier.s_guidPortSupplier;
vsDebugTargetInfo.guidProcessLanguage = Guid.Empty;
vsDebugTargetInfo.hStdError = 0;
vsDebugTargetInfo.hStdInput = 0;
vsDebugTargetInfo.hStdOutput = 0;
vsDebugTargetInfo.LaunchFlags = grfLaunch;
vsDebugTargetInfo.pDebugEngines = IntPtr.Zero;
vsDebugTargetInfo.pUnknown = null;
if (fNoDebug)
{
if (port.IsLocalPort)
{
processWin32 = new Process();
processWin32.StartInfo = new ProcessStartInfo();
processWin32.StartInfo.FileName = vsDebugTargetInfo.bstrExe;
processWin32.StartInfo.Arguments = vsDebugTargetInfo.bstrArg;
processWin32.StartInfo.WorkingDirectory = vsDebugTargetInfo.bstrCurDir;
processWin32.StartInfo.UseShellExecute = false;
processWin32.Start();
}
else
{
RebootAndResumeExecution();
}
}
else
{
byte * bpDebugTargetInfo = stackalloc byte[(int)vsDebugTargetInfo.cbSize];
IntPtr ipDebugTargetInfo = (IntPtr)bpDebugTargetInfo;
try
{
IVsDebugger2 iVsDebugger = ( IVsDebugger2 )ServiceProvider.GlobalProvider.GetService(typeof(IVsDebugger));
Marshal.StructureToPtr(vsDebugTargetInfo, ipDebugTargetInfo, false);
hRes = iVsDebugger.LaunchDebugTargets2(1, ipDebugTargetInfo);
}
finally
{
if (ipDebugTargetInfo != null)
{
Marshal.DestroyStructure(ipDebugTargetInfo, vsDebugTargetInfo.GetType());
}
}
}
return(hRes);
}
catch (Exception ex)
{
Utility.ShowMessageBox(String.Format("An exception occurred while attempting to launch the debugger: {0}", ex.Message));
return(Utility.COM_HResults.E_FAIL);
}
}
int IVsDeployableProjectCfg.StartDeploy(IVsOutputWindowPane pIVsOutputWindowPane, uint dwOptions)
{
VsPackage.MessageCentre.ClearDeploymentMsgs();
VsPackage.MessageCentre.StartProgressMsg(DiagnosticStrings.StartDeploy);
VsPackage.MessageCentre.DeploymentMsg(string.Format(DiagnosticStrings.LookingUpDevice, this.DeployTransportName));
int hr;
m_deployState = new DeployState();
m_deployState.m_outputWindowPane = pIVsOutputWindowPane;
foreach (IVsDeployStatusCallback dsc in m_connectionsDeployStatusCallback)
{
int iContinue = Utility.Boolean.TRUE;
dsc.OnStartDeploy(ref iContinue);
m_deployState.m_deploySuccess = m_deployState.m_deploySuccess && (iContinue == Utility.Boolean.TRUE);
}
DebugPort port = GetDebugPort();
if (port == null)
{
SetDeployFailure(string.Format("Invalid device transport setting '{0}', could not find a debug port", this.DeployTransportName));
}
//VsPackage.MessageCentre.DeploymentMsg(string.Format(DiagnosticStrings.FoundDevicePort, port.Name, port.PortId, port.PortFilter));
hr = m_deployState.m_deploySuccess ? Utility.COM_HResults.S_OK : Utility.COM_HResults.E_FAIL;
if (m_deployState.m_deploySuccess && !port.IsLocalPort)
{
m_deployState.m_deployCallbackControl = new System.Windows.Forms.Control();
m_deployState.m_deployCallbackControl.CreateControl();
m_deployState.m_threadDeploy = new Thread(delegate()
{
try
{
Deploy(port);
}
catch (Exception ex)
{
SetDeployFailure("An error has occurred: please check your hardware.",
"An error has occurred: please check your hardware.\n"
+ ex.Message + "\n"
+ "Source: " + ex.Source + "\n"
+ "Stack : \n"
+ ex.StackTrace + "\n"
);
}
m_deployState.m_deployCallbackControl.Invoke(new DeployState.EndDeployDelegate(OnEndDeploy));
});
m_deployState.m_threadDeploy.Start();
}
else
{
OnEndDeploy();
}
return(hr);
}
public VsProjectFlavorCfg(VsProject project, IVsCfg baseCfg)
{
m_vsCfg = baseCfg;
m_project = project;
m_innerIVsDebuggableProjectCfg = m_vsCfg as IVsDebuggableProjectCfg;
m_IVsBuildPropertyStorage = m_project as IVsBuildPropertyStorage;
Debug.Assert(m_innerIVsDebuggableProjectCfg != null);
m_connectionsDeployStatusCallback = new ConnectionPoint.Connections();
DeployPropertyPort = new ProjectBuildProperty("DeployTransport", m_IVsBuildPropertyStorage, this, _PersistStorageType.PST_USER_FILE, _PersistStorageType.PST_PROJECT_FILE, DebugPort.NameFromPortFilter(PortFilter.Emulator));
DeployPropertyDevice = new ProjectBuildProperty("DeployDevice", m_IVsBuildPropertyStorage, this, _PersistStorageType.PST_USER_FILE, _PersistStorageType.PST_PROJECT_FILE);
GenerateStubsFlag = new ProjectBuildPropertyBool("MF_GenerateStubs", m_IVsBuildPropertyStorage, this, _PersistStorageType.PST_USER_FILE);
GenerateStubsRootName = new ProjectBuildProperty("MF_GenerateStubsRootName", m_IVsBuildPropertyStorage, this, _PersistStorageType.PST_USER_FILE, _PersistStorageType.PST_PROJECT_FILE, "TARGET");
GenerateStubsDirectory = new ProjectBuildProperty("MF_GenerateStubsDirectory", m_IVsBuildPropertyStorage, this, _PersistStorageType.PST_USER_FILE, _PersistStorageType.PST_PROJECT_FILE, "DIRECTORY");
try
{
ActivateDebugEngine();
}
catch (Exception e)
{
VsPackage.MessageCentre.InternalErrorMsg(false, String.Format("Unable to register debug engine: {0}", e.Message));
}
}
