public static Process LaunchWithoutDebugger(string exe, string args, bool ShowConsole) { StopExecution(); if (!File.Exists(exe)) { ErrorLogger.Log(exe + " not found", ErrorType.Error, ErrorOrigin.Program); return(null); } IDEManager.Instance.MainWindow.LeftStatusText = "Launch " + Path.GetFileName(exe) + " without debugger"; // Make all documents read-only WorkbenchLogic.Instance.AllDocumentsReadOnly = true; try { if (ShowConsole) { CurrentProcess = FileExecution.ExecuteAsync(exe, args, Path.GetDirectoryName(exe), CurrentProcess_Exited); } else { CurrentProcess = FileExecution.ExecuteSilentlyAsync(exe, args, Path.GetDirectoryName(exe), CurrentProcess_OutputDataReceived, CurrentProcess_ErrorDataReceived, CurrentProcess_Exited); } } catch (Exception ex) { ErrorLogger.Log(ex, ErrorType.Error, ErrorOrigin.Program); } Instance.UpdateGUI(); return(CurrentProcess); }
public Processor(ProcessorArgs processorArgs) { ProcessorArgs = processorArgs; // ExternalTools = new ExternalTools(ProcessorArgs.ConfigurationMain.Paths); FileExecution = new FileExecution(ExternalTools); FilePreparation = new FilePreparation(ExternalTools); FileInformation = new FileInformation(); }
public static void DoUpdate() { if (!File.Exists(UpdaterExe)) { ErrorLogger.Log(UpdaterExe + " not found! Cannot proceed with update!", ErrorType.Error, ErrorOrigin.System); return; } // Start the updater var upt = FileExecution.ExecuteAsync(UpdaterExe, "-a -o \"" + ApplicationStartUpPath + "\"", ApplicationStartUpPath, null); // Close main window - the D-IDE.exe will be overwritten! IDEManager.Instance.MainWindow.Dispatcher.Invoke(new Action(() => IDEManager.Instance.MainWindow.Close())); }
public BuildResult CompileSource(SourceModule Module, DMDConfig dmd, bool DebugCompile, string objFile, string execDirectory) { var obj = Path.ChangeExtension(objFile, ".obj"); var br = new BuildResult() { SourceFile = Module.AbsoluteFileName, TargetFile = obj, Successful = true }; ErrorLogger.Log("Compile " + (Module.Project != null?Module.Project.ToRelativeFileName(Module.FileName):Module.FileName), ErrorType.Information, ErrorOrigin.Build); var dmd_exe = dmd.SoureCompiler; // Always enable it to use environment paths to find dmd.exe if (!Path.IsPathRooted(dmd_exe) && Directory.Exists(dmd.BaseDirectory)) { dmd_exe = Path.Combine(dmd.BaseDirectory, dmd.SoureCompiler); } TempPrc = FileExecution.ExecuteSilentlyAsync(dmd_exe, BuildDSourceCompileArgumentString(dmd.BuildArguments(DebugCompile).SoureCompiler, Module.AbsoluteFileName, obj, dmd.ImportDirectories), // Compile our program always in debug mode execDirectory, OnOutput, delegate(string s) { var err = ParseErrorMessage(s); if (Module.Project != null && Module.Project.ContainsFile(err.FileName)) { err.Project = Module.Project; } if (err.Type == GenericError.ErrorType.Error) { br.Successful = false; } br.BuildErrors.Add(err); }, OnExit); if (TempPrc != null && !TempPrc.HasExited) { TempPrc.WaitForExit(MaxCompilationTime); } br.Successful = br.Successful && TempPrc != null && TempPrc.ExitCode == 0 && File.Exists(obj); return(br); }
private void StartProcess3(object o) { try { ProcessorArgs processorArgs = (ProcessorArgs)o; ConfigurationMain mainCfg = processorArgs.ConfigurationMain; // FileExecution.ExecuteTreat(processorArgs.Orders, mainCfg, false); // if (mainCfg.PassBsa.Enabled) { if (mainCfg.PassBsa.MustRepack()) { FileExecution.RepackBsa(processorArgs.BsaOrders, mainCfg.PassBsa.GameParameter, mainCfg.IsUseMultithreading, mainCfg.IsVerbose); } if (mainCfg.PassBsa.MustClean()) { FileExecution.CleanBsa(processorArgs.BsaOrders, mainCfg.IsVerbose); } } // if (mainCfg.IsMergeActivated) { if (mainCfg.IsUnmergeActivated) { FileExecution.DeleteFiles(mainCfg, processorArgs.DeleteOrders); } else { FileExecution.Merge(mainCfg, processorArgs.CopyOrders); } } // if (mainCfg.PassBsa.Enabled && mainCfg.PassBsa.IsRepackLooseFilesInBsa) { var bsaToProcess = mainCfg.PassBsa.IsIntelligentPacking ? FileUtils.GetIntelligentPacking(mainCfg.Selection, mainCfg.PathSource, mainCfg.PassBsa.GameParameter, mainCfg.PassBsa.IsRepackCreateDummy, mainCfg.IsVerbose) : FileUtils.PrepareForPacking(mainCfg.PassBsa.Repacks, mainCfg.PathSource, mainCfg.PassBsa.GameParameter, true, mainCfg.IsVerbose); List <DirectoryInfo> dirToDeleteIfFail = new List <DirectoryInfo>(); foreach (InformationRepackBsa informationRepackBsa in bsaToProcess) { ExternalTools.CallBsaPack(Path.Combine(informationRepackBsa.Source.FullName, informationRepackBsa.CurrentBsaName), informationRepackBsa.CurrentTarget.FullName, informationRepackBsa.IsCompressed, informationRepackBsa.GameParameter, mainCfg.IsUseMultithreading, mainCfg.IsVerbose); // informationRepackBsa.CurrentTarget.Refresh(); if (informationRepackBsa.CurrentTarget.Exists) { try { FileUtils.DeleteCompleteDirectory(informationRepackBsa.CurrentTarget); } catch { dirToDeleteIfFail.Add(informationRepackBsa.CurrentTarget); } } } // foreach (DirectoryInfo directoryInfo in dirToDeleteIfFail) { FileUtils.DeleteCompleteDirectory(directoryInfo); } } //Cleaning empty subdir if (mainCfg.IsBackupActivated && mainCfg.IsRefreshBackup) { FileInformation.CleanEmptySubdir(mainCfg.PathBackup); } //Cleaning no present source subdir if (mainCfg.IsBackupActivated && mainCfg.IsCleanBackup) { FileInformation.CleanBackupFromSource(mainCfg.PathSource, mainCfg.PathBackup); } // if (mainCfg.IsShowResults) { var infoTextures = new DirectoryInfo(mainCfg.PathSource); // foreach (var directoryInfo in infoTextures.GetDirectories()) { processorArgs.Folders[directoryInfo.Name].NewSize = FileUtils.CalculateDirectorySizeMo(directoryInfo, mainCfg.PassBsa.Enabled); } processorArgs.Folders[infoTextures.Name].NewSize = FileUtils.CalculateDirectorySizeMo(infoTextures, mainCfg.PassBsa.Enabled); // Show sizes before/after resizes Logger.Log("Results: (Size before resize in Mo => current size in Mo)"); foreach (var keyValuePair in processorArgs.Folders.OrderBy(e => e.Value.Size)) { Logger.Log("{0,15:F2} Mo => {1,15:F2} Mo {2}", keyValuePair.Value.Size, keyValuePair.Value.NewSize, keyValuePair.Key); } } OnProcessorEnded(-1); } catch (AggregateException e) { Logger.Log(e); foreach (Exception innerException in e.InnerExceptions) { Logger.Log(innerException); } OnProcessorEnded(-1); } catch (Exception e) { Logger.Log(e); OnProcessorEnded(-1); } }
private void StartProcess1(object o) { try { ProcessorArgs processorArgs = (ProcessorArgs)o; ConfigurationMain mainCfg = processorArgs.ConfigurationMain; // if (mainCfg.IsShowResults) { Logger.Log("Preparing futur results data"); var infoTextures = new DirectoryInfo(mainCfg.PathSource); // foreach (var directoryInfo in infoTextures.GetDirectories()) { processorArgs.Folders.Add(directoryInfo.Name, new InformationDirectory { Size = FileUtils.CalculateDirectorySizeMo(directoryInfo, mainCfg.PassBsa.Enabled) }); } processorArgs.Folders.Add(infoTextures.Name, new InformationDirectory { Size = FileUtils.CalculateDirectorySizeMo(infoTextures, mainCfg.PassBsa.Enabled) }); } // if (mainCfg.PassBsa.Enabled) { FileInformation.GetFileInfos(mainCfg.PathSource, mainCfg.PathBackup, processorArgs.FilesBsa, true, mainCfg); FilePreparation.PrepareTreat(processorArgs.FilesBsa, mainCfg, processorArgs.BsaOrders, null, null, true); FileExecution.ExecuteTreat(processorArgs.BsaOrders, mainCfg, true); if (mainCfg.PassBsa.MustUnpack()) { FileExecution.UnpackBsa(processorArgs.BsaOrders, mainCfg); } if (mainCfg.PassBsa.IsCopyAsLoose) { if (mainCfg.PassBsa.IsCopyAsLooseIfDummy) { List <InformationOrder> confirmedBsaUnpack = new List <InformationOrder>(); List <InformationCopy> confirmedDeletes = new List <InformationCopy>(); foreach (InformationOrder bsaOrder in processorArgs.BsaOrders) { var bsaName = Path.GetFileNameWithoutExtension(bsaOrder.FileSource.FullName); var espName = bsaName.ToUpper().Replace(" - TEXTURES", "").Replace("- TEXTURES", ""); var espFile = Path.Combine(bsaOrder.FileSource.Directory.FullName, string.Format("{0}.esp", espName)); FileInfo dummy = new FileInfo("dummy.esp"); if (!dummy.Exists) { throw new Exception("No dummy esp to compare from. A dummy.esp file must be present in Octagon directory."); } FileInfo esp = new FileInfo(espFile); if (esp.Exists && dummy.Length == esp.Length) { confirmedBsaUnpack.Add(bsaOrder); if (!confirmedDeletes.Any(e => string.Equals(e.Target, espFile, StringComparison.OrdinalIgnoreCase))) { confirmedDeletes.Add(new InformationCopy(null, espFile, false, false)); } } } FileExecution.CopyBsaAsLooseSimplified(confirmedBsaUnpack, mainCfg); foreach (InformationCopy confirmedDelete in confirmedDeletes) { FileUtils.ExecuteCopyOrDelete(confirmedDelete); } } else { FileExecution.CopyBsaAsLooseSimplified(processorArgs.BsaOrders, mainCfg); } } } // if (mainCfg.HasTextureOperation() || (mainCfg.IsBackupActivated && mainCfg.IsRecopyOriginal)) { FileInformation.GetFileInfos(mainCfg.PathSource, mainCfg.PathBackup, processorArgs.FilesDds, false, mainCfg); } OnProcessorEnded(2); } catch (AggregateException e) { Logger.Log(e); foreach (Exception innerException in e.InnerExceptions) { Logger.Log(innerException); } OnProcessorEnded(-1); } catch (Exception e) { Logger.Log(e); OnProcessorEnded(-1); } }
/// <summary> /// Launch the debugger asynchronously /// </summary> public static void LaunchWithDebugger(string exe, string args, string sourcePath, bool showConsole) { StopExecution(); // Make all documents read-only WorkbenchLogic.Instance.AllDocumentsReadOnly = true; // If there's an external debugger specified and if it's wanted to launch it, start that one if (GlobalProperties.Instance.UseExternalDebugger) { IDEManager.Instance.MainWindow.LeftStatusText = "Launch external debugger"; CurrentProcess = FileExecution.ExecuteAsync(GlobalProperties.Instance.ExternalDebugger_Bin, AbstractBuildSupport.BuildArgumentString(GlobalProperties.Instance.ExternalDebugger_Arguments, new Dictionary <string, string> { { "$sourcePath", sourcePath }, { "$targetDir", Path.GetDirectoryName(exe) }, { "$target", exe }, { "$exe", Path.ChangeExtension(exe, ".exe") }, { "$dll", Path.ChangeExtension(exe, ".dll") }, { "$args", args } }), // %WINDBG_ARGS% Program.exe Arg1 Arg2 Path.GetDirectoryName(exe), CurrentProcess_Exited); Instance.UpdateGUI(); return; } IDEManager.Instance.MainWindow.LeftStatusText = "Start debugging " + Path.GetFileName(exe); if (!dbgEngineInited) { InitDebugger(); } IsDebugging = true; Instance.UpdateGUI(); EngineStarting = true; StopWaitingForEvents = false; DebugCreateProcessOptions opt = new DebugCreateProcessOptions(); opt.CreateFlags = CreateFlags.DebugOnlyThisProcess | (showConsole ? CreateFlags.CreateNewConsole : 0); opt.EngCreateFlags = EngCreateFlags.Default; Engine.CreateProcessAndAttach(0, exe + (string.IsNullOrWhiteSpace(args) ? "" : (" " + args)), opt, Path.GetDirectoryName(exe), "", 0, 0); Engine.Symbols.SourcePath = string.IsNullOrWhiteSpace(sourcePath) ? sourcePath : Path.GetDirectoryName(exe); Engine.IsSourceCodeOrientedStepping = true; Engine.WaitForEvent(); Engine.Execute("bc"); // Clear breakpoint list Engine.WaitForEvent(); CoreManager.DebugManagement.CurrentDebugSupport.PostlaunchInit(Engine); BreakpointManagement.SetupBreakpoints(); EngineStarting = false; WaitForDebugEvent(); // Wait for the first breakpoint/exception/program exit to occur }
public override void BuildModule(SourceModule Module, string OutputDirectory, string ExecDirectory, bool DebugCompile, bool LinkToStandAlone) { var src = Module.AbsoluteFileName; var outputDir = Path.IsPathRooted(OutputDirectory) ? OutputDirectory : Path.Combine(Path.GetDirectoryName(src), OutputDirectory); // Ensure that target directory exists Util.CreateDirectoryRecursively(outputDir); // Compile .rc source file to res var res = Path.Combine(outputDir, Path.GetFileNameWithoutExtension(src) + ".res"); // Check if creation can be skipped if (GlobalProperties.Instance.EnableIncrementalBuild && !Module.Modified && File.Exists(res)) { Module.LastBuildResult = new BuildResult() { SourceFile = src, TargetFile = res, Successful = true, NoBuildNeeded = true }; return; } // Init returned BuildResult-object var br = new BuildResult() { SourceFile = src, TargetFile = res, Successful = true }; // Print verbose information message ErrorLogger.Log("Compile " + (Module.Project != null ? Module.Project.ToRelativeFileName(Module.FileName) : Module.FileName), ErrorType.Information, ErrorOrigin.Build); var resourceCompiler = ResConfig.Instance.ResourceCompilerPath; // Prefer the resource compiler located in D-IDE's bin root // Otherwise let the system search along the %PATH% environment variable to find the resource compiler if (!Path.IsPathRooted(resourceCompiler) && File.Exists(Path.Combine(Util.ApplicationStartUpPath, resourceCompiler))) { resourceCompiler = Path.Combine(Util.ApplicationStartUpPath, resourceCompiler); } TempPrc = FileExecution.ExecuteSilentlyAsync(resourceCompiler, BuildResArgumentString( ResConfig.Instance.ResourceCompilerArguments, src, res, outputDir), ExecDirectory, // Output handling delegate(string s) { var err = ParseErrorMessage(s); if (Module.Project != null && Module.Project.ContainsFile(err.FileName)) { err.Project = Module.Project; } br.BuildErrors.Add(err); br.Successful = false; if (!GlobalProperties.Instance.VerboseBuildOutput) { ErrorLogger.Log(s, ErrorType.Message, ErrorOrigin.Build); } }, // Error handling delegate(string s) { br.Successful = false; ErrorLogger.Log(s, ErrorType.Error, ErrorOrigin.Build); }, OnExit); if (TempPrc != null && !TempPrc.HasExited) { TempPrc.WaitForExit(MaxCompilationTime); } br.Successful = br.Successful && TempPrc != null && TempPrc.ExitCode == 0 && File.Exists(res); if (br.Successful) { Module.ResetModifiedTime(); } Module.LastBuildResult = br; }
/// <summary> /// Calls the cv2pdb program /// </summary> public BuildResult CreatePDBFromExe(string Executable) { var pdb = Path.ChangeExtension(Executable, ".pdb"); var br = new BuildResult() { SourceFile = Executable, TargetFile = pdb }; if (!File.Exists(Executable)) { br.BuildErrors.Add(new GenericError() { Message = "Debug information database creation failed - " + Executable + " does not exist" }); return(br); } if (File.Exists(pdb)) { File.Delete(pdb); // Enforce recreation of the database } string cv2pdb = DSettings.Instance.cv2pdb_exe; // By default, check if there's a cv2pdb.exe at the program's main directory if (!Path.IsPathRooted(cv2pdb) && File.Exists(Util.ApplicationStartUpPath + "\\" + cv2pdb)) { cv2pdb = Util.ApplicationStartUpPath + "\\" + cv2pdb; } ErrorLogger.Log("Create debug information database " + Path.GetFileName(pdb), ErrorType.Information, ErrorOrigin.Build); try { var prc = FileExecution.ExecuteSilentlyAsync(cv2pdb, "\"" + Executable + "\"", Path.GetDirectoryName(Executable), OnOutput, delegate(string s){ br.BuildErrors.Add(new GenericError() { Message = s }); }, delegate() { if (File.Exists(pdb)) { if (GlobalProperties.Instance.VerboseBuildOutput) { ErrorLogger.Log("Debug information database created successfully", ErrorType.Information, ErrorOrigin.Build); } br.Successful = true; } else { br.BuildErrors.Add(new GenericError() { Message = "Debug information database creation failed", Type = GenericError.ErrorType.Warning }); } }); if (prc != null && !prc.HasExited) { prc.WaitForExit(10000); // A time out of 10 seconds should be enough } } catch (Exception ex) { ErrorLogger.Log(ex); } return(br); }
/// <summary> /// Links several object files to an executable, dynamic or static library /// </summary> public BuildResult LinkFiles(DMDConfig dmd, string linkerExe, string linkerArgs, string startDirectory, string targetFile, bool CreatePDB, params string[] files) { var errList = new List <GenericError>(); var br = new BuildResult() { TargetFile = targetFile, Successful = true }; ErrorLogger.Log("Link files to " + Path.GetFileName(targetFile), ErrorType.Information, ErrorOrigin.Build); if (File.Exists(targetFile)) { try { File.Delete(targetFile); } catch (Exception ex) // Perhaps our targetFile is still in use { br.BuildErrors.Add(new GenericError() { Message = ex.Message }); return(br); } } // Ensure that target directory exists var tarDir = Path.GetDirectoryName(targetFile); try { Util.CreateDirectoryRecursively(tarDir); } catch (Exception ex) { ErrorLogger.Log(ex, ErrorType.Error, ErrorOrigin.Build); br.Successful = false; return(br); } // Always enable it to use environment paths to find dmd.exe if (!Path.IsPathRooted(linkerExe) && Directory.Exists(dmd.BaseDirectory)) { linkerExe = Path.Combine(dmd.BaseDirectory, linkerExe); } //CRITICAL: Execute linker exe TempPrc = FileExecution.ExecuteSilentlyAsync( linkerExe, BuildDLinkerArgumentString(linkerArgs, startDirectory, targetFile, dmd.ImportDirectories, files), startDirectory, OnOutput, delegate(string s) { var err = ParseErrorMessage(s); if (err.Type == GenericError.ErrorType.Error) { br.Successful = false; } br.BuildErrors.Add(err); }, OnExit); if (TempPrc != null && !TempPrc.HasExited) { TempPrc.WaitForExit(MaxCompilationTime); } br.Successful = br.Successful && TempPrc.ExitCode == 0 && File.Exists(targetFile); // If targetFile is executable or dynamic linked library, create PDB if (br.Successful && CreatePDB && (targetFile.EndsWith(".exe") || targetFile.EndsWith(".dll"))) { var br_ = CreatePDBFromExe(targetFile); br.BuildErrors.AddRange(br_.BuildErrors); br.AdditionalFiles = new[] { br_.TargetFile }; } return(br); }