internal string GetDocumentInfoText(DocumentInfo DocInfo) { string elementPath = ""; if (System.IO.Path.IsPathRooted(DocInfo.FullPath)) { elementPath = DocInfo.FullPath; } else if (DocInfo.Project != null) { elementPath = GR.Path.Normalize(GR.Path.Append(DocInfo.Project.Settings.BasePath, DocInfo.FullPath), false); } else { elementPath = DocInfo.FullPath; } if (DocInfo.BaseDoc != null) { if (DocInfo.BaseDoc is SourceASMEx) { DateTime lastModificationTimeStamp = ((SourceASMEx)DocInfo.BaseDoc).LastChange; if ((GR.Path.IsPathEqual(PreviousSearchedFile, elementPath)) && (lastModificationTimeStamp <= PreviousSearchedFileTimeStamp)) { return(Core.Searching.PreviousSearchedFileContent); } PreviousSearchedFile = elementPath; PreviousSearchedFileTimeStamp = lastModificationTimeStamp; PreviousSearchedFileContent = ((SourceASMEx)DocInfo.BaseDoc).editSource.Text; return(PreviousSearchedFileContent); } else if (DocInfo.BaseDoc is SourceBasicEx) { PreviousSearchedFile = elementPath; return(((SourceBasicEx)DocInfo.BaseDoc).editSource.Text); } else if (DocInfo.BaseDoc is Disassembler) { PreviousSearchedFile = elementPath; return(((Disassembler)DocInfo.BaseDoc).editDisassembly.Text); } return(""); } // can we use cached text? bool cacheIsUpToDate = false; DateTime lastAccessTimeStamp; try { lastAccessTimeStamp = System.IO.File.GetLastWriteTime(elementPath); cacheIsUpToDate = (lastAccessTimeStamp <= PreviousSearchedFileTimeStamp); PreviousSearchedFileTimeStamp = lastAccessTimeStamp; } catch (Exception) { } if ((GR.Path.IsPathEqual(PreviousSearchedFile, elementPath)) && (cacheIsUpToDate) && (PreviousSearchedFileContent != null)) { return(PreviousSearchedFileContent); } PreviousSearchedFileContent = GR.IO.File.ReadAllText(elementPath); PreviousSearchedFile = elementPath; return(PreviousSearchedFileContent); }
public void SetProjectElement(ProjectElement Element) { DocumentInfo = Element.DocumentInfo; }
public bool DebugCompiledFile(DocumentInfo DocumentToDebug, DocumentInfo DocumentToRun) { if (DocumentToDebug == null) { Core.AddToOutput("Debug document not found, this is an internal error!"); return(false); } if (DocumentToDebug.Element == null) { Core.AddToOutput("Debugging " + DocumentToDebug.DocumentFilename + System.Environment.NewLine); } else { Core.AddToOutput("Debugging " + DocumentToDebug.Element.Name + System.Environment.NewLine); } ToolInfo toolRun = Core.DetermineTool(DocumentToRun, true); if (toolRun == null) { System.Windows.Forms.MessageBox.Show("No emulator tool has been configured yet!", "Missing emulator tool"); Core.AddToOutput("There is no emulator tool configured!"); return(false); } SetupDebugger(toolRun); if (!Debugger.CheckEmulatorVersion(toolRun)) { return(false); } DebuggedASMBase = DocumentToDebug; DebugBaseDocumentRun = DocumentToRun; Core.MainForm.m_DebugWatch.ReseatWatches(DocumentToDebug.ASMFileInfo); Debugger.ClearCaches(); MemoryViews.ForEach(mv => mv.MarkAllMemoryAsUnknown()); ReseatBreakpoints(DocumentToDebug.ASMFileInfo); AddVirtualBreakpoints(DocumentToDebug.ASMFileInfo); Debugger.ClearAllBreakpoints(); MarkedDocument = null; MarkedDocumentLine = -1; if (!Core.Executing.StartProcess(toolRun, DocumentToRun)) { return(false); } if (!System.IO.Directory.Exists(Core.Executing.RunProcess.StartInfo.WorkingDirectory.Trim(new char[] { '"' }))) { Core.AddToOutput("The determined working directory " + Core.Executing.RunProcess.StartInfo.WorkingDirectory + " does not exist" + System.Environment.NewLine); return(false); } // determine debug target type Types.CompileTargetType targetType = C64Studio.Types.CompileTargetType.NONE; if (DocumentToRun.Element != null) { targetType = DocumentToRun.Element.TargetType; } string fileToRun = ""; if (DocumentToRun.Element != null) { fileToRun = DocumentToRun.Element.TargetFilename; ProjectElement.PerConfigSettings configSetting = DocumentToRun.Element.Settings[DocumentToRun.Project.Settings.CurrentConfig.Name]; if (!string.IsNullOrEmpty(configSetting.DebugFile)) { targetType = configSetting.DebugFileType; } } if (targetType == C64Studio.Types.CompileTargetType.NONE) { targetType = Core.Compiling.m_LastBuildInfo.TargetType; } DebugType = targetType; string breakPointFile = PrepareAfterStartBreakPoints(); string command = toolRun.DebugArguments; if (Parser.ASMFileParser.IsCartridge(targetType)) { command = command.Replace("-initbreak 0x$(DebugStartAddressHex) ", ""); } if ((toolRun.PassLabelsToEmulator) && (DebuggedASMBase.ASMFileInfo != null)) { breakPointFile += DebuggedASMBase.ASMFileInfo.LabelsAsFile(EmulatorInfo.LabelFormat(toolRun)); } if (breakPointFile.Length > 0) { try { TempDebuggerStartupFilename = System.IO.Path.GetTempFileName(); System.IO.File.WriteAllText(TempDebuggerStartupFilename, breakPointFile); command += " -moncommands \"" + TempDebuggerStartupFilename + "\""; } catch (System.IO.IOException ioe) { System.Windows.Forms.MessageBox.Show(ioe.Message, "Error writing temporary file"); Core.AddToOutput("Error writing temporary file"); TempDebuggerStartupFilename = ""; return(false); } } //ParserASM.CompileTarget != Types.CompileTargetType.NONE ) ? ParserASM.CompileTarget : DocumentToRun.Element.TargetType; // need to adjust initial breakpoint address for late added store/load breakpoints? InitialBreakpointIsTemporary = true; //if ( BreakpointsToAddAfterStartup.Count > 0 ) { // yes LateBreakpointOverrideDebugStart = OverrideDebugStart; // special start addresses for different run types if (Parser.ASMFileParser.IsCartridge(targetType)) { OverrideDebugStart = Debugger.ConnectedMachine.InitialBreakpointAddressCartridge; } else { // directly after calling load from ram (as VICE does when autostarting a .prg file) // TODO - check with .t64, .tap, .d64 OverrideDebugStart = Debugger.ConnectedMachine.InitialBreakpointAddress; } } if ((DocumentToDebug.Project != null) && (LateBreakpointOverrideDebugStart == -1) && (!string.IsNullOrEmpty(DocumentToDebug.Project.Settings.CurrentConfig.DebugStartAddressLabel))) { int debugStartAddress = -1; if (!Core.MainForm.DetermineDebugStartAddress(DocumentToDebug, DocumentToDebug.Project.Settings.CurrentConfig.DebugStartAddressLabel, out debugStartAddress)) { Core.AddToOutput("Cannot determine value for debug start address from '" + DocumentToDebug.Project.Settings.CurrentConfig.DebugStartAddressLabel + "'" + System.Environment.NewLine); return(false); } if (debugStartAddress != 0) { InitialBreakpointIsTemporary = false; OverrideDebugStart = debugStartAddress; LateBreakpointOverrideDebugStart = debugStartAddress; } } if (Core.Settings.TrueDriveEnabled) { command = toolRun.TrueDriveOnArguments + " " + command; } else { command = toolRun.TrueDriveOffArguments + " " + command; } bool error = false; Core.Executing.RunProcess.StartInfo.Arguments = Core.MainForm.FillParameters(command, DocumentToRun, true, out error); if (error) { return(false); } if (Parser.ASMFileParser.IsCartridge(targetType)) { Core.Executing.RunProcess.StartInfo.Arguments += " " + Core.MainForm.FillParameters(toolRun.CartArguments, DocumentToRun, true, out error); } else { Core.Executing.RunProcess.StartInfo.Arguments += " " + Core.MainForm.FillParameters(toolRun.PRGArguments, DocumentToRun, true, out error); } if (error) { return(false); } Core.AddToOutput("Calling " + Core.Executing.RunProcess.StartInfo.FileName + " with " + Core.Executing.RunProcess.StartInfo.Arguments + System.Environment.NewLine); Core.Executing.RunProcess.Exited += new EventHandler(Core.MainForm.runProcess_Exited); Core.SetStatus("Running..."); Core.MainForm.SetGUIForWaitOnExternalTool(true); if (Core.Executing.RunProcess.Start()) { DateTime current = DateTime.Now; // new GTK VICE opens up with console window (yuck) which nicely interferes with WaitForInputIdle -> give it 5 seconds to open main window bool waitForInputIdleFailed = false; try { Core.Executing.RunProcess.WaitForInputIdle(5000); } catch (Exception ex) { Debug.Log("WaitForInputIdle failed: " + ex.ToString()); waitForInputIdleFailed = true; } // only connect with debugger if VICE int numConnectionAttempts = 1; if ((string.IsNullOrEmpty(Core.Executing.RunProcess.MainWindowTitle)) && (waitForInputIdleFailed)) { // assume GTK VICE numConnectionAttempts = 10; } if (EmulatorInfo.SupportsDebugging(toolRun)) { //Debug.Log( "Have " + numConnectionAttempts + " attempts" ); Core.AddToOutput("Connection attempt "); for (int i = 0; i < numConnectionAttempts; ++i) { //Debug.Log( "attempt" + i ); Core.AddToOutput((i + 1).ToString()); if (Debugger.ConnectToEmulator(Parser.ASMFileParser.IsCartridge(targetType))) { //Debug.Log( "-succeeded" ); Core.AddToOutput(" succeeded" + System.Environment.NewLine); Core.MainForm.m_CurrentActiveTool = toolRun; DebuggedProject = DocumentToRun.Project; Core.MainForm.AppState = Types.StudioState.DEBUGGING_RUN; Core.MainForm.SetGUIForDebugging(true); break; } // wait a second for (int j = 0; j < 20; ++j) { System.Threading.Thread.Sleep(50); System.Windows.Forms.Application.DoEvents(); } } if (Core.MainForm.AppState != Types.StudioState.DEBUGGING_RUN) { Core.AddToOutput("failed " + numConnectionAttempts + " times, giving up" + System.Environment.NewLine); return(false); } } else { Core.MainForm.m_CurrentActiveTool = toolRun; DebuggedProject = DocumentToRun.Project; Core.MainForm.AppState = Types.StudioState.DEBUGGING_RUN; Core.MainForm.SetGUIForDebugging(true); } } return(true); }
public bool NeedsRebuild(DocumentInfo DocInfo, string ConfigSetting) { if (DocInfo == null) { return(false); } // actual parsing and deducing dependencies if a rebuild is necessary! foreach (IDockContent dockContent in Core.MainForm.panelMain.Documents) { BaseDocument baseDoc = (BaseDocument)dockContent; if (baseDoc.Modified) { return(true); } } if (DocInfo.Element != null) { foreach (var dependency in DocInfo.Element.ForcedDependency.DependentOnFile) { ProjectElement elementDependency = DocInfo.Project.GetElementByFilename(dependency.Filename); if (elementDependency == null) { Core.AddToOutput("Could not find dependency for " + dependency + System.Environment.NewLine); return(true); } if (NeedsRebuild(elementDependency.DocumentInfo, ConfigSetting)) { return(true); } foreach (var rebuildFile in m_RebuiltFiles) { if (GR.Path.IsPathEqual(elementDependency.DocumentInfo.DocumentFilename, rebuildFile)) { Core.AddToOutput("Dependency " + elementDependency.DocumentInfo.DocumentFilename + " was rebuilt in this cycle, need to rebuild dependent element " + DocInfo.DocumentFilename + System.Environment.NewLine); return(true); } } } } if (DocInfo.Compilable) { if (!DocInfo.HasBeenSuccessfullyBuilt) { return(true); } } if (DocInfo.Project == null) { return(true); } if (DocInfo.DeducedDependency[ConfigSetting] == null) { // no build time stored yet, needs rebuild DocInfo.DeducedDependency[ConfigSetting] = new DependencyBuildState(); return(true); } foreach (KeyValuePair <string, DateTime> dependency in DocInfo.DeducedDependency[ConfigSetting].BuildState) { DateTime fileTime = new DateTime(); try { fileTime = System.IO.File.GetLastWriteTime(dependency.Key); } catch { } if (fileTime != dependency.Value) { //Debug.Log( "File time differs for " + dependency.Key ); return(true); } } return(false); }
public bool NeedsRebuild(DocumentInfo DocInfo, string ConfigSetting) { if (DocInfo == null) { return(false); } // actual parsing and deducing dependencies if a rebuild is necessary! foreach (IDockContent dockContent in Core.MainForm.panelMain.Documents) { BaseDocument baseDoc = (BaseDocument)dockContent; if (baseDoc.Modified) { return(true); } } if (DocInfo.Element != null) { foreach (var dependency in DocInfo.Element.ForcedDependency.DependentOnFile) { var project = Core.MainForm.m_Solution.GetProjectByName(dependency.Project); if (project == null) { Core.AddToOutput("Could not find dependency project " + dependency.Project + " for " + dependency + System.Environment.NewLine); return(true); } ProjectElement elementDependency = project.GetElementByFilename(dependency.Filename); if (elementDependency == null) { Core.AddToOutput("Could not find dependency " + dependency.Filename + " in project " + dependency.Project + " for " + dependency + System.Environment.NewLine); return(true); } if (NeedsRebuild(elementDependency.DocumentInfo, ConfigSetting)) { return(true); } foreach (var rebuildFile in m_RebuiltFiles) { if (GR.Path.IsPathEqual(elementDependency.DocumentInfo.DocumentFilename, rebuildFile)) { Core.AddToOutput("Dependency " + elementDependency.DocumentInfo.DocumentFilename + " was rebuilt in this cycle, need to rebuild dependent element " + DocInfo.DocumentFilename + System.Environment.NewLine); return(true); } } } if (DocInfo.DeducedDependency[ConfigSetting] != null) { // custom build overrides output file -> always rebuild if ((!string.IsNullOrEmpty(DocInfo.Element.Settings[ConfigSetting].CustomBuild)) && (!string.IsNullOrEmpty(DocInfo.Element.TargetFilename))) { Core.AddToOutput("Custom build always requires a rebuild" + System.Environment.NewLine); return(true); } foreach (var dependency in DocInfo.Element.ExternalDependencies.DependentOnFile) { string fullPath = BuildFullPath(DocInfo.Project.Settings.BasePath, dependency.Filename); DateTime fileTime = new DateTime(); try { if (System.IO.File.Exists(fullPath)) { fileTime = System.IO.File.GetLastWriteTime(fullPath); } } catch { } if (fileTime != DocInfo.DeducedDependency[ConfigSetting].BuildState[fullPath]) { Core.AddToOutput("External Dependency " + fullPath + " was modified, need to rebuild dependent element " + DocInfo.DocumentFilename + System.Environment.NewLine); DocInfo.DeducedDependency[ConfigSetting].BuildState.Add(fullPath, fileTime); return(true); } } } else { // no build time stored yet, needs rebuild DocInfo.DeducedDependency[ConfigSetting] = new DependencyBuildState(); return(true); } } if (DocInfo.Compilable) { if (!DocInfo.HasBeenSuccessfullyBuilt) { return(true); } } if (DocInfo.Project == null) { return(true); } if (DocInfo.DeducedDependency[ConfigSetting] == null) { // no build time stored yet, needs rebuild DocInfo.DeducedDependency[ConfigSetting] = new DependencyBuildState(); return(true); } foreach (KeyValuePair <string, DateTime> dependency in DocInfo.DeducedDependency[ConfigSetting].BuildState) { DateTime fileTime = new DateTime(); try { fileTime = System.IO.File.GetLastWriteTime(dependency.Key); } catch { } if (fileTime != dependency.Value) { //Debug.Log( "File time differs for " + dependency.Key ); return(true); } } return(false); }
private bool RunExternalCommand(string Command, DocumentInfo CommandDocument) { m_LastReceivedOutputTime = System.DateTime.Now; string fullCommand = Command; string args = ""; if (Command.StartsWith("\"")) { int nextQuote = Command.IndexOf('"', 1); if (nextQuote == -1) { // invalid file Core.AddToOutput("Invalid command specified (" + Command + ")"); return(false); } fullCommand = Command.Substring(1, nextQuote - 1); args = Command.Substring(nextQuote + 1).Trim(); } else if (Command.IndexOf(' ') != -1) { int spacePos = Command.IndexOf(' '); fullCommand = Command.Substring(0, spacePos); args = Command.Substring(spacePos + 1).Trim(); } fullCommand = "cmd.exe"; bool error = false; bool errorAtArgs = false; string command = Core.MainForm.FillParameters(Command, CommandDocument, false, out error); if (error) { return(false); } args = "/C \"" + command + "\""; args = Core.MainForm.FillParameters(args, CommandDocument, false, out errorAtArgs); if ((error) || (errorAtArgs)) { return(false); } //Debug.Log( "Args:" + args ); //string command = fullCommand + " " + args; Core.AddToOutput(command + System.Environment.NewLine); m_ExternalProcess = new System.Diagnostics.Process(); m_ExternalProcess.StartInfo.FileName = fullCommand; m_ExternalProcess.StartInfo.WorkingDirectory = Core.MainForm.FillParameters("$(BuildTargetPath)", CommandDocument, false, out error); if (error) { return(false); } if (!System.IO.Directory.Exists(m_ExternalProcess.StartInfo.WorkingDirectory + "/")) { Core.AddToOutput("The determined working directory \"" + m_ExternalProcess.StartInfo.WorkingDirectory + "\" does not exist" + System.Environment.NewLine); return(false); } m_ExternalProcess.StartInfo.CreateNoWindow = true; m_ExternalProcess.EnableRaisingEvents = true; m_ExternalProcess.StartInfo.Arguments = args; m_ExternalProcess.StartInfo.UseShellExecute = false; //m_ExternalProcess.Exited += new EventHandler( Core.MainForm.m_ExternalProcess_Exited ); m_ExternalProcess.OutputDataReceived += new System.Diagnostics.DataReceivedEventHandler(ExternalProcessOutputReceived); m_ExternalProcess.ErrorDataReceived += new System.Diagnostics.DataReceivedEventHandler(ExternalProcessOutputReceived); m_ExternalProcess.StartInfo.RedirectStandardError = true; m_ExternalProcess.StartInfo.RedirectStandardOutput = true; try { if (!m_ExternalProcess.Start()) { m_ExternalProcess.Close(); return(false); } m_ExternalProcess.BeginOutputReadLine(); m_ExternalProcess.BeginErrorReadLine(); } catch (Win32Exception ex) { m_ExternalProcess.Close(); Core.AddToOutput(ex.Message + System.Environment.NewLine); return(false); } //Debug.Log( "=============Start" ); while (!m_ExternalProcess.WaitForExit(5)) { Application.DoEvents(); } // DO NOT REMOVE: final DoEvents to let the app clear its invoke queue to the output display Application.DoEvents(); //Debug.Log( "=============Done" ); /* * // working wait * while ( ( System.DateTime.Now - m_LastReceivedOutputTime ).TotalMilliseconds < 500 ) * { * Application.DoEvents(); * System.Threading.Thread.Sleep( 20 ); * } */ bool success = (m_ExternalProcess.ExitCode == 0); if (!success) { Core.AddToOutput("External Command " + command + " exited with result code " + m_ExternalProcess.ExitCode.ToString() + System.Environment.NewLine); } m_ExternalProcess.Close(); return(success); }