static void WriteSummaryResults(IProgressMonitor monitor, int succeeded, int warnings, int errors)
{
monitor.Log.WriteLine();
int total = succeeded + warnings + errors;
//this might not be correct for languages where pluralization affects the other arguments
//but gettext doesn't really have an answer for sentences with multiple plurals
monitor.Log.WriteLine(
GettextCatalog.GetPluralString(
"{0} file processed total. {1} generated successfully, {2} with warnings, {3} with errors",
"{0} files processed total. {1} generated successfully, {2} with warnings, {3} with errors",
total,
total, succeeded, warnings, errors)
);
//ends the root task
monitor.EndTask();
if (errors > 0)
{
monitor.ReportError(GettextCatalog.GetString("Errors in file generation."), null);
}
else if (warnings > 0)
{
monitor.ReportSuccess(GettextCatalog.GetString("Warnings in file generation."));
}
else
{
monitor.ReportSuccess(GettextCatalog.GetString("Generated files successfully."));
}
monitor.Dispose();
}
public void ReportSuccess(bool anyUpdates)
{
if (anyUpdates)
{
progressMonitor.ReportSuccess(GettextCatalog.GetString("Package updates are available."));
}
else if (eventMonitor.WarningReported)
{
progressMonitor.ReportWarning(progressMessage.Warning);
}
else
{
progressMonitor.ReportSuccess(progressMessage.Success);
}
}
protected override void DoClean(IProgressMonitor monitor, ConfigurationSelector configuration)
{
var cfg = GetConfiguration(configuration) as DProjectConfiguration;
// delete obj/res files
monitor.BeginTask("Delete intermediate files", Files.Count);
foreach (var f in Files)
{
try {
if (File.Exists(f.LastGenOutput))
{
File.Delete(f.LastGenOutput);
}
} catch (Exception ex) {
monitor.ReportError("Error while removing " + f, ex);
} finally {
f.LastGenOutput = string.Empty;
monitor.Step(1);
}
}
monitor.EndTask();
// delete target file
monitor.BeginTask("Delete output file", 1);
if (File.Exists(cfg.CompiledOutputName))
{
File.Delete(cfg.CompiledOutputName);
}
monitor.EndTask();
monitor.ReportSuccess("Cleanup successful!");
}
public void ReportSuccess(string message)
{
lock (monitor.SyncRoot)
{
monitor.ReportSuccess(message);
}
}
public void Convert(string guiFolderName, bool makeBackup)
{
GtkDesignInfo info = GtkDesignInfo.FromProject(project);
Stetic.Project gproject = GuiBuilderService.SteticApp.CreateProject(info);
//Stetic.Project does not implement IDisposable
try {
string newGuiFolderName = project.BaseDirectory.Combine(guiFolderName);
gproject.ConvertProject(info.SteticFile, newGuiFolderName);
info.ConvertGtkFolder(guiFolderName, makeBackup);
info.UpdateGtkFolder();
folderName = newGuiFolderName;
IProgressMonitor monitor = IdeApp.Workbench.ProgressMonitors.GetBuildProgressMonitor();
try {
ConfigurationSelector configuration = IdeApp.Workspace.ActiveConfiguration;
Generator generator = new Generator();
generator.Run(monitor, project, configuration);
monitor.ReportSuccess("Converting was succesfull");
} finally {
monitor.Dispose();
}
} finally {
gproject.Dispose();
}
}
public void CreateSchemaCommand()
{
try {
TaskService.Errors.Clear();
string xml = Editor.Text;
using (IProgressMonitor monitor = XmlEditorService.GetMonitor()) {
XmlDocument doc = XmlEditorService.ValidateWellFormedness(monitor, xml, FileName);
if (doc == null)
{
return;
}
monitor.BeginTask(GettextCatalog.GetString("Creating schema..."), 0);
try {
string schema = XmlEditorService.CreateSchema(Document, xml);
string fileName = XmlEditorService.GenerateFileName(FileName, "{0}.xsd");
IdeApp.Workbench.NewDocument(fileName, "application/xml", schema);
monitor.ReportSuccess(GettextCatalog.GetString("Schema created."));
} catch (Exception ex) {
string msg = GettextCatalog.GetString("Error creating XML schema.");
LoggingService.LogError(msg, ex);
monitor.ReportError(msg, ex);
}
}
} catch (Exception ex) {
MessageService.ShowError(ex.Message);
}
}
public Translation AddNewTranslation(string isoCode, IProgressMonitor monitor)
{
try
{
Translation tr = new Translation(this, isoCode);
translations.Add(tr);
string templateFile = Path.Combine(this.BaseDirectory, "messages.po");
string translationFile = GetFileName(isoCode);
if (!File.Exists(templateFile))
{
CreateDefaultCatalog(monitor);
}
File.Copy(templateFile, translationFile);
monitor.ReportSuccess(String.Format(GettextCatalog.GetString("Language '{0}' successfully added."), isoCode));
monitor.Step(1);
this.Save(monitor);
return(tr);
}
catch (Exception e)
{
monitor.ReportError(String.Format(GettextCatalog.GetString("Language '{0}' could not be added: "), isoCode), e);
return(null);
}
finally
{
monitor.EndTask();
}
}
public void RunXslTransformCommand()
{
if (string.IsNullOrEmpty(stylesheetFileName))
{
stylesheetFileName = XmlEditorService.BrowseForStylesheetFile();
if (string.IsNullOrEmpty(stylesheetFileName))
{
return;
}
}
using (IProgressMonitor monitor = XmlEditorService.GetMonitor())
{
try
{
string xsltContent;
try
{
xsltContent = GetFileContent(stylesheetFileName);
}
catch (System.IO.IOException)
{
monitor.ReportError(
GettextCatalog.GetString("Error reading file '{0}'.", stylesheetFileName), null);
return;
}
System.Xml.Xsl.XslTransform xslt =
XmlEditorService.ValidateStylesheet(monitor, xsltContent, stylesheetFileName);
if (xslt == null)
{
return;
}
XmlDocument doc = XmlEditorService.ValidateXml(monitor, Editor.Text, FileName);
if (doc == null)
{
return;
}
string newFileName = XmlEditorService.GenerateFileName(FileName, "-transformed{0}.xml");
monitor.BeginTask(GettextCatalog.GetString("Executing transform..."), 1);
using (XmlTextWriter output = XmlEditorService.CreateXmlTextWriter(Document))
{
xslt.Transform(doc, null, output);
IdeApp.Workbench.NewDocument(
newFileName, "application/xml", output.ToString());
}
monitor.ReportSuccess(GettextCatalog.GetString("Transform completed."));
monitor.EndTask();
}
catch (Exception ex)
{
string msg = GettextCatalog.GetString("Could not run transform.");
monitor.ReportError(msg, ex);
monitor.EndTask();
}
}
}
void CheckForPackageUpdates(
IProgressMonitor progressMonitor,
ProgressMonitorStatusMessage progressMessage,
PackageUpdatesEventMonitor eventMonitor)
{
updatedPackagesInSolution.CheckForUpdates();
if (updatedPackagesInSolution.AnyUpdates())
{
progressMonitor.ReportSuccess(GettextCatalog.GetString("Package updates are available."));
}
else if (eventMonitor.WarningReported)
{
progressMonitor.ReportWarning(progressMessage.Warning);
}
else
{
progressMonitor.ReportSuccess(progressMessage.Success);
}
}
private void executeProgramCallback(object sender, DataReceivedEventArgs e)
{
lock (this)
{
if (!String.IsNullOrEmpty(e.Data))
{
progressMonitor.ReportSuccess(e.Data);
executeProgramData = e.Data;
}
}
}
public void ReportResult(ProgressMonitorStatusMessage progressMessage)
{
if (HasWarnings)
{
progressMonitor.ReportWarning(progressMessage.Warning);
}
else
{
progressMonitor.ReportSuccess(progressMessage.Success);
}
}
protected override void Run()
{
IProgressMonitor monitor = Monitor;
foreach (VersionControlItemList list in items.SplitByRepository())
{
list[0].Repository.Add(list.Paths, true, monitor);
}
Gtk.Application.Invoke(delegate {
VersionControlService.NotifyFileStatusChanged(items);
});
monitor.ReportSuccess(GettextCatalog.GetString("Add operation completed."));
}
protected override void Clean(IProgressMonitor monitor, SolutionEntityItem entry, ConfigurationSelector configuration)
{
Project proj = entry as Project;
if (proj == null)
{
base.Clean(monitor, entry, configuration);
return;
}
MakefileData data = proj.ExtendedProperties ["MonoDevelop.Autotools.MakefileInfo"] as MakefileData;
if (data == null || !data.SupportsIntegration || String.IsNullOrEmpty(data.CleanTargetName))
{
base.Clean(monitor, entry, configuration);
return;
}
monitor.BeginTask(GettextCatalog.GetString("Cleaning project"), 1);
try
{
string baseDir = proj.BaseDirectory;
ProcessWrapper process = Runtime.ProcessService.StartProcess("make",
data.CleanTargetName,
baseDir,
monitor.Log,
monitor.Log,
null);
process.WaitForOutput();
if (process.ExitCode > 0)
{
throw new Exception(GettextCatalog.GetString("An unspecified error occurred while running '{0}'", "make " + data.CleanTargetName));
}
monitor.Step(1);
}
catch (Exception e)
{
monitor.ReportError(GettextCatalog.GetString("Project could not be cleaned: "), e);
return;
}
finally
{
monitor.EndTask();
}
monitor.ReportSuccess(GettextCatalog.GetString("Project successfully cleaned"));
}
void ReportOutcome(
IAsyncOperation operation,
IProgressMonitor progressMonitor,
ProgressMonitorStatusMessage progressMessage)
{
if (operation.Success)
{
progressMonitor.ReportSuccess(progressMessage.Success);
}
else
{
progressMonitor.ReportError(progressMessage.Error, null);
progressMonitor.ShowPackageConsole();
}
}
void RestorePackages(IProgressMonitor progressMonitor, ProgressMonitorStatusMessage progressMessage)
{
var action = new RestorePackagesAction(solution, packageManagementEvents);
if (project != null)
{
action.Project = project;
}
action.Execute();
RefreshProjectReferences();
ForceCreationOfSharedRepositoriesConfigFile();
progressMonitor.ReportSuccess(progressMessage.Success);
packageManagementEvents.OnPackagesRestored();
}
void LinkToTarget(BuildResult br, bool modificationsDone)
{
/// The target file to which all objects will be linked to
var LinkTargetFile = Project.GetOutputFileName(BuildConfig.Selector);
if (!modificationsDone &&
File.Exists(LinkTargetFile))
{
monitor.ReportSuccess("Build successful! - No new linkage needed");
monitor.Step(1);
return;
}
// b.Build linker argument string
// Build argument preparation
var linkArgs = FillInMacros(Arguments.LinkerArguments + " " + BuildConfig.ExtraLinkerArguments,
new DLinkerMacroProvider
{
ObjectsStringPattern = Commands.ObjectFileLinkPattern,
Objects = BuiltObjects.ToArray(),
TargetFile = LinkTargetFile,
RelativeTargetDirectory = BuildConfig.OutputDirectory.ToRelative(Project.BaseDirectory),
Libraries = BuildConfig.ReferencedLibraries
});
var linkerOutput = "";
var linkerErrorOutput = "";
var linkerExecutable = Commands.Linker;
if (!Path.IsPathRooted(linkerExecutable))
{
linkerExecutable = Path.Combine(Compiler.BinPath, Commands.Linker);
if (!File.Exists(linkerExecutable))
{
linkerExecutable = Commands.Linker;
}
}
int exitCode = ExecuteCommand(linkerExecutable, linkArgs, Project.BaseDirectory, monitor,
out linkerErrorOutput,
out linkerOutput);
HandleOptLinkOutput(br, linkerOutput);
HandleReturnCode(br, linkerExecutable, exitCode);
}
public IAsyncOperation Update(IProgressMonitor monitor)
{
System.Threading.ThreadPool.QueueUserWorkItem(delegate {
string[] statuses;
if (InitialUpdate)
{
statuses = new string [] { "NEW", "ASSIGNED", "NEEDINFO" }
}
;
else
{
statuses = new string [] { "NEW", "ASSIGNED", "NEEDINFO", "RESOLVED", "CLOSED", "VERIFIED" }
};
string[] severities = new string [] { "Critical", "Major", "Normal", "Minor", "Enhancement" };
DateTime t = DateTime.Now;
monitor.BeginTask("Updating from bugzilla server", 3);
try {
Connect();
int nb, mb;
// Bugs
int lastWork = -1;
Bug[] data = server.GetBugsForProduct(Product, statuses, severities, lastUpdate, delegate(int total, int current) {
if (lastWork == -1)
{
monitor.BeginStepTask("Getting bug data", total, 2);
lastWork = 0;
}
monitor.Step(current - lastWork);
lastWork = current;
});
monitor.EndTask();
UpdateBugData(data, out nb, out mb);
lastUpdate = t;
monitor.Step(1);
Save();
monitor.Step(1);
monitor.ReportSuccess(string.Format("Bug list updated ({0} added, {1} modified)", nb, mb));
} catch (Exception ex) {
monitor.ReportError("Update failed", ex);
} finally {
monitor.Dispose();
}
});
void CheckCompatibility()
{
PackageCompatibilityChecker checker = CreatePackageCompatibilityChecker(solution, registeredRepositories);
checker.CheckProjectPackages(project);
if (checker.AnyPackagesRequireReinstallation())
{
MarkPackagesForReinstallation(checker);
ReportPackageReinstallationWarning(checker);
}
else
{
if (checker.PackagesMarkedForReinstallationInPackageReferenceFile())
{
MarkPackagesForReinstallation(checker);
}
progressMonitor.ReportSuccess(progressMessage.Success);
}
}
public IAsyncOperation UpdateBugs(IProgressMonitor monitor, IEnumerable <BugInfo> bugs)
{
System.Threading.ThreadPool.QueueUserWorkItem(delegate {
monitor.BeginTask("Updating from bugzilla server", 1);
try {
Connect();
List <int> ids = new List <int>();
foreach (var b in bugs)
{
ids.Add(b.Id);
}
Bug[] data = server.GetBugs(ids.ToArray());
int nb, mb;
UpdateBugData(data, out nb, out mb);
Save();
monitor.ReportSuccess(string.Format("Bug list updated ({0} added, {1} modified)", nb, mb));
} catch (Exception ex) {
monitor.ReportError("Update failed", ex);
} finally {
monitor.Dispose();
}
});
return(monitor.AsyncOperation);
}
static void UpdateCompleted (IProgressMonitor monitor, AggregatedOperationMonitor aggOp,
ProjectFile file, ProjectFile genFile, SingleFileCustomToolResult result)
{
monitor.EndTask ();
aggOp.Dispose ();
if (monitor.IsCancelRequested) {
monitor.ReportError (GettextCatalog.GetString ("Cancelled"), null);
monitor.Dispose ();
return;
}
string genFileName;
try {
bool broken = false;
if (result.UnhandledException != null) {
broken = true;
string msg = GettextCatalog.GetString ("The '{0}' code generator crashed", file.Generator);
result.Errors.Add (new CompilerError (file.Name, 0, 0, "", msg + ": " + result.UnhandledException.Message));
monitor.ReportError (msg, result.UnhandledException);
LoggingService.LogError (msg, result.UnhandledException);
}
genFileName = result.GeneratedFilePath.IsNullOrEmpty?
null : result.GeneratedFilePath.ToRelative (file.FilePath.ParentDirectory);
bool validName = !string.IsNullOrEmpty (genFileName)
&& genFileName.IndexOfAny (new char[] { '/', '\\' }) < 0
&& FileService.IsValidFileName (genFileName);
if (!broken && !validName) {
broken = true;
string msg = GettextCatalog.GetString ("The '{0}' code generator output invalid filename '{1}'",
file.Generator, result.GeneratedFilePath);
result.Errors.Add (new CompilerError (file.Name, 0, 0, "", msg));
monitor.ReportError (msg, null);
}
if (result.Errors.Count > 0) {
foreach (CompilerError err in result.Errors)
TaskService.Errors.Add (new Task (file.FilePath, err.ErrorText, err.Column, err.Line,
err.IsWarning? TaskSeverity.Warning : TaskSeverity.Error,
TaskPriority.Normal, file.Project.ParentSolution, file));
}
if (broken)
return;
if (result.Success)
monitor.ReportSuccess ("Generated file successfully.");
else
monitor.ReportError ("Failed to generate file. See error pad for details.", null);
} finally {
monitor.Dispose ();
}
if (!result.GeneratedFilePath.IsNullOrEmpty && File.Exists (result.GeneratedFilePath)) {
Gtk.Application.Invoke (delegate {
if (genFile == null) {
genFile = file.Project.AddFile (result.GeneratedFilePath);
} else if (result.GeneratedFilePath != genFile.FilePath) {
genFile.Name = result.GeneratedFilePath;
}
file.LastGenOutput = genFileName;
genFile.DependsOn = file.FilePath.FileName;
IdeApp.ProjectOperations.Save (file.Project);
});
}
}
public override void Save(IProgressMonitor monitor)
{
monitor.ReportSuccess("Skip saving dub project.");
}
void ReportOutcome (
IAsyncOperation operation,
IProgressMonitor progressMonitor,
ProgressMonitorStatusMessage progressMessage)
{
if (operation.Success) {
progressMonitor.ReportSuccess (progressMessage.Success);
packageManagementEvents.OnPackagesRestored ();
} else {
progressMonitor.ReportError (progressMessage.Error, null);
progressMonitor.ShowPackageConsole ();
RestoreFailed = true;
}
}
// Note: This method may throw TimeoutException or AppleScriptException
public void UpdateProject (IProgressMonitor monitor, List<XcodeSyncedItem> allItems, XcodeProject emptyProject)
{
items = allItems;
monitor.BeginTask (GettextCatalog.GetString ("Updating Xcode project for {0}...", name), items.Count);
var ctx = new XcodeSyncContext (projectDir, syncTimeCache);
var toRemove = new HashSet<string> (itemMap.Keys);
var toClose = new HashSet<string> ();
var syncList = new List<XcodeSyncedItem> ();
bool updateProject = false;
foreach (var item in items) {
bool needsSync = item.NeedsSyncOut (monitor, ctx);
if (needsSync)
syncList.Add (item);
var files = item.GetTargetRelativeFileNames ();
foreach (var file in files) {
toRemove.Remove (file);
if (!itemMap.ContainsKey (file)) {
monitor.Log.WriteLine ("'{0}' needs to be updated.", file);
updateProject = true;
} else if (needsSync) {
monitor.Log.WriteLine ("'{0}' needs to be closed.", file);
toClose.Add (file);
}
itemMap[file] = item;
}
}
updateProject = updateProject || toRemove.Any ();
bool removedOldProject = false;
if (updateProject) {
if (pendingProjectWrite == null && ProjectExists ()) {
monitor.Log.WriteLine ("A project file needs to be updated, closing and removing old project.");
CloseProject ();
DeleteXcproj (monitor);
removedOldProject = true;
}
} else {
foreach (var f in toClose)
CloseFile (monitor, projectDir.Combine (f));
}
foreach (var f in toRemove) {
itemMap.Remove (f);
syncTimeCache.Remove (f);
var path = projectDir.Combine (f);
if (File.Exists (path))
File.Delete (path);
}
if (removedOldProject) {
HackRelocateProject (monitor);
ctx.ProjectDir = projectDir;
}
foreach (var item in items) {
if (updateProject)
item.AddToProject (emptyProject, projectDir);
}
foreach (var item in syncList) {
item.SyncOut (monitor, ctx);
monitor.Step (1);
}
if (updateProject) {
monitor.Log.WriteLine ("Queued write of '{0}'.", xcproj);
pendingProjectWrite = emptyProject;
}
monitor.EndTask ();
monitor.ReportSuccess (GettextCatalog.GetString ("Xcode project updated."));
}
public void Push (IProgressMonitor monitor, string remote, string remoteBranch)
{
RemoteConfig remoteConfig = new RemoteConfig (RootRepository.GetConfig (), remote);
Transport tp = Transport.Open (RootRepository, remoteConfig);
string remoteRef = "refs/heads/" + remoteBranch;
RemoteRefUpdate rr = new RemoteRefUpdate (RootRepository, RootRepository.GetBranch (), remoteRef, false, null, null);
List<RemoteRefUpdate> list = new List<RemoteRefUpdate> ();
list.Add (rr);
using (var gm = new GitMonitor (monitor))
tp.Push (gm, list);
switch (rr.GetStatus ()) {
case RemoteRefUpdate.Status.UP_TO_DATE: monitor.ReportSuccess (GettextCatalog.GetString ("Remote branch is up to date.")); break;
case RemoteRefUpdate.Status.REJECTED_NODELETE: monitor.ReportError (GettextCatalog.GetString ("The server is configured to deny deletion of the branch"), null); break;
case RemoteRefUpdate.Status.REJECTED_NONFASTFORWARD: monitor.ReportError (GettextCatalog.GetString ("The update is a non-fast-forward update. Merge the remote changes before pushing again."), null); break;
case RemoteRefUpdate.Status.OK:
monitor.ReportSuccess (GettextCatalog.GetString ("Push operation successfully completed."));
// Update the remote branch
ObjectId headId = rr.GetNewObjectId ();
RefUpdate updateRef = RootRepository.UpdateRef (Constants.R_REMOTES + remote + "/" + remoteBranch);
updateRef.SetNewObjectId(headId);
updateRef.Update();
break;
default:
string msg = rr.GetMessage ();
msg = !string.IsNullOrEmpty (msg) ? msg : GettextCatalog.GetString ("Push operation failed");
monitor.ReportError (msg, null);
break;
}
}
public override void ReportSuccess(string message)
{
base.ReportSuccess(message);
statusMonitor.ReportSuccess(message);
}
public void Push (IProgressMonitor monitor, string remote, string remoteBranch)
{
bool success = true;
var branch = RootRepository.Head;
if (branch.TrackedBranch == null) {
RootRepository.Branches.Update (branch, b => b.TrackedBranch = "refs/remotes/" + remote + "/" + remoteBranch);
}
RetryUntilSuccess (monitor, () =>
RootRepository.Network.Push (RootRepository.Network.Remotes [remote], "refs/heads/" + remoteBranch, new PushOptions {
OnPushStatusError = pushStatusErrors => success = false,
CredentialsProvider = GitCredentials.TryGet
})
);
if (!success)
return;
monitor.ReportSuccess (GettextCatalog.GetString ("Push operation successfully completed."));
}
protected override void OnRevertToRevision (FilePath localPath, Revision revision, IProgressMonitor monitor)
{
NGit.Repository repo = GetRepository (localPath);
NGit.Api.Git git = new NGit.Api.Git (repo);
GitRevision gitRev = (GitRevision)revision;
// Rewrite file data from selected revision.
foreach (var path in GetFilesInPaths (new FilePath[] { localPath })) {
MonoDevelop.Projects.Text.TextFile.WriteFile (path, GetCommitTextContent (gitRev.Commit, path), null);
}
monitor.ReportSuccess (GettextCatalog.GetString ("Successfully reverted {0} to revision {1}", localPath, gitRev));
}
static bool UpdateCompleted (IProgressMonitor monitor, AggregatedOperationMonitor aggOp,
ProjectFile file, ProjectFile genFile, SingleFileCustomToolResult result,
bool runMultipleFiles)
{
monitor.EndTask ();
if (aggOp != null)
aggOp.Dispose ();
if (monitor.IsCancelRequested) {
monitor.ReportError (GettextCatalog.GetString ("Cancelled"), null);
monitor.Dispose ();
return false;
}
string genFileName;
try {
bool broken = false;
if (result.UnhandledException != null) {
broken = true;
string msg = GettextCatalog.GetString ("The '{0}' code generator crashed", file.Generator);
result.Errors.Add (new CompilerError (file.Name, 0, 0, "", msg + ": " + result.UnhandledException.Message));
monitor.ReportError (msg, result.UnhandledException);
LoggingService.LogError (msg, result.UnhandledException);
}
genFileName = result.GeneratedFilePath.IsNullOrEmpty?
null : result.GeneratedFilePath.ToRelative (file.FilePath.ParentDirectory);
if (!string.IsNullOrEmpty (genFileName)) {
bool validName = genFileName.IndexOfAny (new [] { '/', '\\' }) < 0
&& FileService.IsValidFileName (genFileName);
if (!broken && !validName) {
broken = true;
string msg = GettextCatalog.GetString ("The '{0}' code generator output invalid filename '{1}'",
file.Generator, result.GeneratedFilePath);
result.Errors.Add (new CompilerError (file.Name, 0, 0, "", msg));
monitor.ReportError (msg, null);
}
}
if (result.Errors.Count > 0) {
DispatchService.GuiDispatch (delegate {
foreach (CompilerError err in result.Errors)
TaskService.Errors.Add (new Task (file.FilePath, err.ErrorText, err.Column, err.Line,
err.IsWarning? TaskSeverity.Warning : TaskSeverity.Error,
TaskPriority.Normal, file.Project.ParentSolution, file));
});
}
if (broken)
return true;
if (!runMultipleFiles) {
if (result.Success)
monitor.ReportSuccess ("Generated file successfully.");
else if (result.SuccessWithWarnings)
monitor.ReportSuccess ("Warnings in file generation.");
else
monitor.ReportError ("Errors in file generation.", null);
}
} finally {
if (!runMultipleFiles)
monitor.Dispose ();
}
if (result.GeneratedFilePath.IsNullOrEmpty || !File.Exists (result.GeneratedFilePath))
return true;
// broadcast a change event so text editors etc reload the file
FileService.NotifyFileChanged (result.GeneratedFilePath);
// add file to project, update file properties, etc
Gtk.Application.Invoke (delegate {
bool projectChanged = false;
if (genFile == null) {
genFile = file.Project.AddFile (result.GeneratedFilePath, result.OverrideBuildAction);
projectChanged = true;
} else if (result.GeneratedFilePath != genFile.FilePath) {
genFile.Name = result.GeneratedFilePath;
projectChanged = true;
}
if (file.LastGenOutput != genFileName) {
file.LastGenOutput = genFileName;
projectChanged = true;
}
if (genFile.DependsOn != file.FilePath.FileName) {
genFile.DependsOn = file.FilePath.FileName;
projectChanged = true;
}
if (projectChanged)
IdeApp.ProjectOperations.Save (file.Project);
});
return true;
}
BuildResult DoOneStepBuild()
{
var br = new BuildResult();
bool filesModified = false;
// Enum files & build resource files
foreach (var pf in Project.Files)
{
if (pf.BuildAction != BuildAction.Compile || pf.Subtype == Subtype.Directory)
{
continue;
}
DateTime dt;
if (Project.LastModificationTimes.TryGetValue(pf, out dt))
{
filesModified |= File.GetLastWriteTime(pf.FilePath) != dt;
}
else
{
filesModified = true;
}
Project.LastModificationTimes[pf] = File.GetLastWriteTime(pf.FilePath);
if (pf.FilePath.Extension.EndsWith(".rc", StringComparison.OrdinalIgnoreCase))
{
if (!CompileResourceScript(br, pf))
{
return(br);
}
}
else
{
BuiltObjects.Add(MakeRelativeToPrjBase(pf.FilePath));
}
}
// Build argument string
var target = Project.GetOutputFileName(BuildConfig.Selector);
if (!filesModified && Project.EnableIncrementalLinking &&
File.Exists(target))
{
monitor.ReportSuccess("Build successful! - No new linkage needed");
monitor.Step(1);
return(br);
}
var rawArgumentString = new StringBuilder();
if (!string.IsNullOrEmpty(AdditionalCompilerAttributes))
{
rawArgumentString.Append(AdditionalCompilerAttributes.Trim()).Append(' ');
}
rawArgumentString.Append(BuildArguments.OneStepBuildArguments.Trim());
if (!string.IsNullOrEmpty(BuildConfig.ExtraCompilerArguments))
{
rawArgumentString.Append(' ').Append(BuildConfig.ExtraCompilerArguments.Trim());
}
if (!string.IsNullOrEmpty(BuildConfig.ExtraLinkerArguments))
{
rawArgumentString.Append(' ').Append(PrefixedExtraLinkerFlags);
}
var argumentString = FillInMacros(rawArgumentString.ToString(),
new OneStepBuildArgumentMacroProvider
{
ObjectsStringPattern = Compiler.ArgumentPatterns.ObjectFileLinkPattern,
IncludesStringPattern = Compiler.ArgumentPatterns.IncludePathPattern,
SourceFiles = BuiltObjects,
Includes = FillCommonMacros(Project.IncludePaths),
Libraries = GetLibraries(BuildConfig, Compiler),
RelativeTargetDirectory = BuildConfig.OutputDirectory,
ObjectsDirectory = ObjectDirectory,
TargetFile = target,
}, commonMacros);
// Execute the compiler
var stdOut = "";
var stdError = "";
var linkerExecutable = Compiler.SourceCompilerCommand;
if (!Path.IsPathRooted(linkerExecutable) && !string.IsNullOrEmpty(Compiler.BinPath))
{
linkerExecutable = Path.Combine(Compiler.BinPath, LinkTargetCfg.Linker);
if (!File.Exists(linkerExecutable))
{
linkerExecutable = LinkTargetCfg.Linker;
}
}
monitor.Log.WriteLine("Current dictionary: " + Project.BaseDirectory);
string cmdLineFile;
HandleOverLongArgumentStrings(Compiler, true, ref argumentString, out cmdLineFile);
int exitCode = ExecuteCommand(linkerExecutable, argumentString, Project.BaseDirectory, monitor,
out stdError,
out stdOut);
ErrorExtracting.HandleCompilerOutput(Project, br, stdError);
ErrorExtracting.HandleCompilerOutput(Project, br, stdOut);
ErrorExtracting.HandleOptLinkOutput(Project, br, stdOut);
ErrorExtracting.HandleReturnCode(monitor, br, exitCode);
if (cmdLineFile != null)
{
File.Delete(cmdLineFile);
}
return(br);
}
static void UpdateCompleted(IProgressMonitor monitor, AggregatedOperationMonitor aggOp,
ProjectFile file, ProjectFile genFile, SingleFileCustomToolResult result)
{
monitor.EndTask();
aggOp.Dispose();
if (monitor.IsCancelRequested)
{
monitor.ReportError(GettextCatalog.GetString("Cancelled"), null);
monitor.Dispose();
return;
}
string genFileName;
try
{
bool broken = false;
if (result.UnhandledException != null)
{
broken = true;
string msg = GettextCatalog.GetString("The '{0}' code generator crashed", file.Generator);
result.Errors.Add(new CompilerError(file.Name, 0, 0, "", msg + ": " + result.UnhandledException.Message));
monitor.ReportError(msg, result.UnhandledException);
LoggingService.LogError(msg, result.UnhandledException);
}
genFileName = result.GeneratedFilePath.IsNullOrEmpty?
null : result.GeneratedFilePath.ToRelative(file.FilePath.ParentDirectory);
bool validName = !string.IsNullOrEmpty(genFileName) &&
genFileName.IndexOfAny(new char[] { '/', '\\' }) < 0 &&
FileService.IsValidFileName(genFileName);
if (!broken && !validName)
{
broken = true;
string msg = GettextCatalog.GetString("The '{0}' code generator output invalid filename '{1}'",
file.Generator, result.GeneratedFilePath);
result.Errors.Add(new CompilerError(file.Name, 0, 0, "", msg));
monitor.ReportError(msg, null);
}
if (result.Errors.Count > 0)
{
foreach (CompilerError err in result.Errors)
{
TaskService.Errors.Add(new Task(file.FilePath, err.ErrorText, err.Column, err.Line,
err.IsWarning? TaskSeverity.Warning : TaskSeverity.Error,
TaskPriority.Normal, file.Project.ParentSolution, file));
}
}
if (broken)
{
return;
}
if (result.Success)
{
monitor.ReportSuccess("Generated file successfully.");
}
else
{
monitor.ReportError("Failed to generate file. See error pad for details.", null);
}
}
finally
{
monitor.Dispose();
}
if (!result.GeneratedFilePath.IsNullOrEmpty && File.Exists(result.GeneratedFilePath))
{
Gtk.Application.Invoke(delegate
{
if (genFile == null)
{
genFile = file.Project.AddFile(result.GeneratedFilePath);
}
else if (result.GeneratedFilePath != genFile.FilePath)
{
genFile.Name = result.GeneratedFilePath;
}
file.LastGenOutput = genFileName;
genFile.DependsOn = file.FilePath.FileName;
IdeApp.ProjectOperations.Save(file.Project);
});
}
}
void RestorePackages (IProgressMonitor progressMonitor, ProgressMonitorStatusMessage progressMessage)
{
var msbuildTargetsMonitor = new MSBuildTargetsRestoredMonitor (packageManagementEvents);
using (msbuildTargetsMonitor) {
var action = new RestorePackagesAction (solution, packageManagementEvents);
if (project != null) {
action.Project = project;
}
action.Execute ();
}
RefreshProjectReferences (msbuildTargetsMonitor.AnyMSBuildTargetsRestored);
ForceCreationOfSharedRepositoriesConfigFile ();
progressMonitor.ReportSuccess (progressMessage.Success);
packageManagementEvents.OnPackagesRestored ();
}
// Note: This method may throw TimeoutException or AppleScriptException
public void UpdateProject(IProgressMonitor monitor, List <XcodeSyncedItem> allItems, XcodeProject emptyProject)
{
items = allItems;
monitor.BeginTask(GettextCatalog.GetString("Updating Xcode project for {0}...", name), items.Count);
var ctx = new XcodeSyncContext(projectDir, syncTimeCache);
var toRemove = new HashSet <string> (itemMap.Keys);
var toClose = new HashSet <string> ();
var syncList = new List <XcodeSyncedItem> ();
bool updateProject = false;
monitor.Log.WriteLine("Calculating sync list...");
foreach (var item in items)
{
bool needsSync = item.NeedsSyncOut(monitor, ctx);
if (needsSync)
{
syncList.Add(item);
}
var files = item.GetTargetRelativeFileNames();
foreach (var file in files)
{
toRemove.Remove(file);
if (!itemMap.ContainsKey(file))
{
monitor.Log.WriteLine(" '{0}' needs to be added.", file);
updateProject = true;
}
else if (needsSync)
{
monitor.Log.WriteLine(" '{0}' needs to be closed & updated.", file);
toClose.Add(file);
}
itemMap[file] = item;
}
}
updateProject = updateProject || toRemove.Any();
bool removedOldProject = false;
if (updateProject)
{
if (pendingProjectWrite == null && ProjectExists())
{
monitor.Log.WriteLine("The project.pbxproj file needs to be updated, closing and removing old project.");
CloseProject();
DeleteXcproj(monitor);
removedOldProject = true;
// All items need to be re-synced...
syncList.Clear();
foreach (var item in items)
{
syncList.Add(item);
var files = item.GetTargetRelativeFileNames();
foreach (var file in files)
{
itemMap[file] = item;
}
}
}
}
else
{
foreach (var f in toClose)
{
CloseFile(monitor, projectDir.Combine(f));
}
}
if (removedOldProject)
{
HackRelocateProject(monitor);
ctx.ProjectDir = projectDir;
syncTimeCache.Clear();
}
else
{
foreach (var f in toRemove)
{
itemMap.Remove(f);
syncTimeCache.Remove(f);
var path = projectDir.Combine(f);
try
{
if (File.Exists(path))
{
File.Delete(path);
}
}
catch
{
}
}
}
foreach (var item in items)
{
if (updateProject)
{
item.AddToProject(emptyProject, projectDir);
}
}
foreach (var item in syncList)
{
item.SyncOut(monitor, ctx);
monitor.Step(1);
}
if (updateProject)
{
monitor.Log.WriteLine("Queued write of '{0}'.", xcproj);
pendingProjectWrite = emptyProject;
}
monitor.EndTask();
monitor.ReportSuccess(GettextCatalog.GetString("Xcode project updated."));
}
public void UpdateProject(IProgressMonitor monitor, List <XcodeSyncedItem> allItems, XcodeProject emptyProject)
{
items = allItems;
monitor.BeginTask(GettextCatalog.GetString("Updating Xcode project..."), items.Count);
monitor.Log.WriteLine("Updating synced project with {0} items", items.Count);
XC4Debug.Log("Updating synced project with {0} items", items.Count);
var ctx = new XcodeSyncContext(projectDir, syncTimeCache);
var toRemove = new HashSet <string> (itemMap.Keys);
var toClose = new HashSet <string> ();
var syncList = new List <XcodeSyncedItem> ();
bool updateProject = false;
foreach (var item in items)
{
bool needsSync = item.NeedsSyncOut(ctx);
if (needsSync)
{
syncList.Add(item);
}
var files = item.GetTargetRelativeFileNames();
foreach (var f in files)
{
toRemove.Remove(f);
if (!itemMap.ContainsKey(f))
{
updateProject = true;
}
else if (needsSync)
{
toClose.Add(f);
}
itemMap [f] = item;
}
}
updateProject = updateProject || toRemove.Any();
bool removedOldProject = false;
if (updateProject)
{
if (pendingProjectWrite == null && ProjectExists())
{
monitor.Log.WriteLine("Project file needs to be updated, closing and removing old project");
CloseProject();
DeleteXcproj();
removedOldProject = true;
}
}
else
{
foreach (var f in toClose)
{
CloseFile(projectDir.Combine(f));
}
}
foreach (var f in toRemove)
{
itemMap.Remove(f);
syncTimeCache.Remove(f);
var path = projectDir.Combine(f);
if (File.Exists(path))
{
File.Delete(path);
}
}
if (removedOldProject)
{
HackRelocateProject();
}
foreach (var item in items)
{
if (updateProject)
{
item.AddToProject(emptyProject, projectDir);
}
}
foreach (var item in syncList)
{
monitor.Log.WriteLine("Syncing item {0}", item.GetTargetRelativeFileNames()[0]);
item.SyncOut(ctx);
monitor.Step(1);
}
if (updateProject)
{
monitor.Log.WriteLine("Queuing Xcode project {0} to write when opened", projectDir);
pendingProjectWrite = emptyProject;
}
monitor.EndTask();
monitor.ReportSuccess(GettextCatalog.GetString("Xcode project updated."));
}
/// <summary>
/// Compiles a D project.
/// </summary>
public static BuildResult Compile(
DProject Project,
ProjectFileCollection FilesToCompile,
DProjectConfiguration BuildConfig,
IProgressMonitor monitor)
{
var relObjDir = "objs";
var objDir = Path.Combine(Project.BaseDirectory, relObjDir);
if (!Directory.Exists(objDir))
{
Directory.CreateDirectory(objDir);
}
// List of created object files
var BuiltObjects = new List <string>();
var compilerResults = new CompilerResults(new TempFileCollection());
var buildResult = new BuildResult(compilerResults, "");
bool succesfullyBuilt = true;
bool modificationsDone = false;
var Compiler = Project.Compiler;
var Commands = Compiler.GetTargetConfiguration(Project.CompileTarget);
var Arguments = Commands.GetArguments(BuildConfig.DebugMode);
/// The target file to which all objects will be linked to
var LinkTarget = BuildConfig.OutputDirectory.Combine(BuildConfig.CompiledOutputName);
monitor.BeginTask("Build Project", FilesToCompile.Count + 1);
var SourceIncludePaths = new List <string>(Compiler.GlobalParseCache.DirectoryPaths);
SourceIncludePaths.AddRange(Project.LocalIncludeCache.DirectoryPaths);
#region Compile sources to objects
foreach (var f in FilesToCompile)
{
if (monitor.IsCancelRequested)
{
return(buildResult);
}
// If not compilable, skip it
if (f.BuildAction != BuildAction.Compile || !File.Exists(f.FilePath))
{
continue;
}
// a.Check if source file was modified and if object file still exists
if (Project.LastModificationTimes.ContainsKey(f) &&
Project.LastModificationTimes[f] == File.GetLastWriteTime(f.FilePath) &&
File.Exists(f.LastGenOutput))
{
// File wasn't edited since last build
// but add the built object to the objs array
BuiltObjects.Add(f.LastGenOutput);
monitor.Step(1);
continue;
}
else
{
modificationsDone = true;
}
#region Resource file
if (f.Name.EndsWith(".rc", StringComparison.OrdinalIgnoreCase))
{
var res = Path.Combine(objDir, Path.GetFileNameWithoutExtension(f.FilePath)) + ".res";
if (File.Exists(res))
{
File.Delete(res);
}
// Build argument string
var resCmpArgs = FillInMacros(Win32ResourceCompiler.Instance.Arguments,
new Win32ResourceCompiler.ArgProvider {
RcFile = f.FilePath.ToString(),
ResFile = res
});
// Execute compiler
string output;
int _exitCode = ExecuteCommand(Win32ResourceCompiler.Instance.Executable,
resCmpArgs,
Project.BaseDirectory,
monitor,
out output);
// Error analysis
if (!string.IsNullOrEmpty(output))
{
compilerResults.Errors.Add(new CompilerError {
FileName = f.FilePath, ErrorText = output
});
}
CheckReturnCode(_exitCode, compilerResults);
monitor.Step(1);
if (_exitCode != 0)
{
buildResult.FailedBuildCount++;
succesfullyBuilt = false;
break;
}
else
{
f.LastGenOutput = res;
buildResult.BuildCount++;
Project.LastModificationTimes[f] = File.GetLastWriteTime(f.FilePath);
// Especially when compiling large projects, do only add the relative part of the r file due to command shortness
if (res.StartsWith(Project.BaseDirectory))
{
BuiltObjects.Add(res.Substring(Project.BaseDirectory.ToString().Length).TrimStart(Path.DirectorySeparatorChar));
}
else
{
BuiltObjects.Add(res);
}
}
continue;
}
#endregion
// Create object file path
var obj = Path.Combine(objDir, Path.GetFileNameWithoutExtension(f.FilePath)) + ObjectExtension;
if (File.Exists(obj))
{
File.Delete(obj);
}
// Prevent duplicates e.g. when having the samely-named source files in different sub-packages
int i = 2;
while (File.Exists(obj))
{
// Simply add a number between the obj name and its extension
obj = Path.Combine(objDir, Path.GetFileNameWithoutExtension(f.FilePath)) + i + ObjectExtension;
i++;
}
// Create argument string for source file compilation.
var dmdArgs = FillInMacros(Arguments.CompilerArguments + " " + BuildConfig.ExtraCompilerArguments, new DCompilerMacroProvider
{
IncludePathConcatPattern = Commands.IncludePathPattern,
SourceFile = f.FilePath,
ObjectFile = obj,
Includes = SourceIncludePaths,
});
// b.Execute compiler
string dmdOutput;
int exitCode = ExecuteCommand(Commands.Compiler, dmdArgs, Project.BaseDirectory, monitor, out dmdOutput);
ParseCompilerOutput(dmdOutput, compilerResults);
CheckReturnCode(exitCode, compilerResults);
monitor.Step(1);
if (exitCode != 0)
{
buildResult.FailedBuildCount++;
succesfullyBuilt = false;
break;
}
else
{
f.LastGenOutput = obj;
buildResult.BuildCount++;
Project.LastModificationTimes[f] = File.GetLastWriteTime(f.FilePath);
// Especially when compiling large projects, do only add the relative part of the obj file due to command shortness
if (obj.StartsWith(Project.BaseDirectory))
{
BuiltObjects.Add(obj.Substring(Project.BaseDirectory.ToString().Length).TrimStart(Path.DirectorySeparatorChar));
}
else
{
BuiltObjects.Add(obj);
}
}
}
#endregion
#region Link files
if (succesfullyBuilt)
{
// a.
if ((!modificationsDone) && lastLinkerActionSuccessfull)
{
// Only return if build target is still existing
if (File.Exists(LinkTarget))
{
monitor.Step(1);
return(new BuildResult(compilerResults, ""));
}
}
// b.Build linker argument string
// Build argument preparation
/*
* var libPaths=new List<string>(Compiler.DefaultLibPaths);
* libPaths.AddRange(Project.LibraryPaths);
*/
var libs = new List <string>(Compiler.DefaultLibraries);
libs.AddRange(Project.ExtraLibraries);
var linkArgs = FillInMacros(Arguments.LinkerArguments + " " + BuildConfig.ExtraLinkerArguments,
new DLinkerMacroProvider {
ObjectsStringPattern = Commands.ObjectFileLinkPattern,
Objects = BuiltObjects.ToArray(),
TargetFile = LinkTarget,
RelativeTargetDirectory = BuildConfig.OutputDirectory.ToRelative(Project.BaseDirectory),
//LibraryPaths=libPaths,
Libraries = libs
});
var linkerOutput = "";
int exitCode = ExecuteCommand(Commands.Linker, linkArgs, Project.BaseDirectory, monitor, out linkerOutput);
compilerResults.NativeCompilerReturnValue = exitCode;
CheckReturnCode(exitCode, compilerResults);
lastLinkerActionSuccessfull = (exitCode == 0);
if (lastLinkerActionSuccessfull)
{
monitor.ReportSuccess("Build successful!");
monitor.Step(1);
}
}
#endregion
return(new BuildResult(compilerResults, ""));
}
static void WriteSummaryResults (IProgressMonitor monitor, int succeeded, int warnings, int errors)
{
monitor.Log.WriteLine ();
int total = succeeded + warnings + errors;
//this might not be correct for languages where pluralization affects the other arguments
//but gettext doesn't really have an answer for sentences with multiple plurals
monitor.Log.WriteLine (
GettextCatalog.GetPluralString (
"{0} file processed total. {1} generated successfully, {2} with warnings, {3} with errors",
"{0} files processed total. {1} generated successfully, {2} with warnings, {3} with errors",
total,
total, succeeded, warnings, errors)
);
//ends the root task
monitor.EndTask ();
if (errors > 0)
monitor.ReportError (GettextCatalog.GetString ("Errors in file generation."), null);
else if (warnings > 0)
monitor.ReportSuccess (GettextCatalog.GetString ("Warnings in file generation."));
else
monitor.ReportSuccess (GettextCatalog.GetString ("Generated files successfully."));
monitor.Dispose ();
}
public bool Deploy ( DeployContext ctx, Solution solution, string defaultConf, string targetDir, bool generateFiles, IProgressMonitor monitor )
{
if (generateFiles) {
if ( !GenerateFiles ( ctx, solution, defaultConf, monitor ) )
return false;
}
monitor.BeginTask ( GettextCatalog.GetString( "Deploying Solution to Tarball" ) , 3 );
try
{
string baseDir = Path.GetDirectoryName ( solution.FileName);
ProcessWrapper ag_process = Runtime.ProcessService.StartProcess ( "sh",
generateAutotools ? "autogen.sh" : "configure",
baseDir,
monitor.Log,
monitor.Log,
null );
ag_process.WaitForOutput ();
if ( ag_process.ExitCode > 0 )
throw new Exception ( GettextCatalog.GetString ("An unspecified error occurred while running '{0}'", generateAutotools ? "autogen.sh" : "configure") );
monitor.Step ( 1 );
StringWriter sw = new StringWriter ();
LogTextWriter chainedOutput = new LogTextWriter ();
chainedOutput.ChainWriter (monitor.Log);
chainedOutput.ChainWriter (sw);
ProcessWrapper process = Runtime.ProcessService.StartProcess ( "make",
"dist",
baseDir,
chainedOutput,
monitor.Log,
null );
process.WaitForOutput ();
if ( process.ExitCode > 0 )
throw new Exception ( GettextCatalog.GetString ("An unspecified error occurred while running '{0}'", "make dist") );
monitor.Step ( 1 );
// FIXME: hackish way to get the created tarball's filename
string output = sw.ToString();
int targz = output.LastIndexOf ( "tar.gz" );
int begin = output.LastIndexOf ( '>', targz );
string filename = output.Substring ( begin + 1, (targz - begin) + 5 ).Trim ();
FileService.CopyFile (Path.Combine (baseDir, filename), Path.Combine (targetDir, filename));
monitor.Step ( 1 );
}
catch ( Exception e )
{
monitor.ReportError ( GettextCatalog.GetString ("Solution could not be deployed: "), e );
return false;
}
finally
{
monitor.EndTask ();
}
monitor.ReportSuccess (GettextCatalog.GetString ("Solution was successfully deployed."));
return true;
}
protected override void DoClean(IProgressMonitor monitor, ConfigurationSelector configuration)
{
var cfg = GetConfiguration (configuration) as DProjectConfiguration;
// delete obj/res files
monitor.BeginTask ("Delete intermediate files", Files.Count);
foreach (var f in Files) {
try {
if (File.Exists (f.LastGenOutput))
File.Delete (f.LastGenOutput);
} catch (Exception ex) {
monitor.ReportError ("Error while removing " + f, ex);
} finally {
f.LastGenOutput = string.Empty;
monitor.Step (1);
}
}
monitor.EndTask ();
// delete target file
monitor.BeginTask ("Delete output file", 1);
if (File.Exists (cfg.CompiledOutputName))
File.Delete (cfg.CompiledOutputName);
monitor.EndTask ();
monitor.ReportSuccess ("Cleanup successful!");
}
public bool GenerateFiles (DeployContext ctx, Solution solution, string defaultConf, IProgressMonitor monitor )
{
string filesString = generateAutotools ? "Autotools files" : "Makefiles";
monitor.BeginTask ( GettextCatalog.GetString ("Generating {0} for Solution {1}", filesString, solution.Name), 1 );
try
{
solution_dir = Path.GetDirectoryName(solution.FileName);
string[] configs = new string [ solution.Configurations.Count ];
for (int ii=0; ii < configs.Length; ii++ )
configs [ii] = solution.Configurations[ii].Id;
MakefileType mt = generateAutotools ? MakefileType.AutotoolsMakefile : MakefileType.SimpleMakefile;
context = new AutotoolsContext ( ctx, solution_dir, configs, mt );
context.TargetSolution = solution;
context.Switches = switchs;
IMakefileHandler handler = AutotoolsContext.GetMakefileHandler (solution.RootFolder, mt);
if (handler == null)
throw new Exception (string.Format (
"{0} does not currently support generating {1} for one (or more) child projects.",
filesString, BrandingService.ApplicationName
));
solution_name = solution.Name;
solution_version = AutotoolsContext.EscapeStringForAutoconf (solution.Version, true);
if (string.IsNullOrEmpty (solution_version))
solution_version = "0.1";
Makefile makefile = handler.Deploy ( context, solution.RootFolder, monitor );
string path = Path.Combine (solution_dir, "Makefile");
if (generateAutotools) {
context.AddAutoconfFile (path);
CreateAutoGenDotSH (context, monitor);
CreateConfigureDotAC (solution, defaultConf, monitor, context);
CreateMacros ();
} else {
CreateConfigureScript (solution, defaultConf, context, monitor);
monitor.Log.WriteLine ( GettextCatalog.GetString ("Creating rules.make"));
string rules_make_path = Path.Combine (solution_dir, "rules.make");
File.Copy (Path.Combine (context.TemplateDir, "rules.make"), rules_make_path, true);
context.AddGeneratedFile (rules_make_path);
}
CreateMakefileInclude ( context, monitor );
AddTopLevelMakefileVars ( makefile, monitor );
if (generateAutotools)
path = path + ".am";
StreamWriter writer = new StreamWriter (path);
makefile.Write ( writer );
writer.Close ();
context.AddGeneratedFile (path);
monitor.ReportSuccess ( GettextCatalog.GetString ("{0} were successfully generated.", filesString ) );
monitor.Step (1);
}
catch ( Exception e )
{
monitor.ReportError ( GettextCatalog.GetString ("{0} could not be generated: ", filesString ), e );
LoggingService.LogError (GettextCatalog.GetString ("{0} could not be generated: ", filesString ), e);
DeleteGeneratedFiles ( context );
return false;
}
finally
{
monitor.EndTask ();
}
return true;
}
public void Push (IProgressMonitor monitor, string remote, string remoteBranch)
{
string remoteRef = "refs/heads/" + remoteBranch;
IEnumerable<PushResult> res;
var push = new NGit.Api.Git (RootRepository).Push ();
// We only have one pushed branch.
push.SetRemote (remote).SetRefSpecs (new RefSpec (remoteRef));
using (var gm = new GitMonitor (monitor)) {
push.SetProgressMonitor (gm);
res = push.Call ();
}
foreach (var pr in res) {
var remoteUpdate = pr.GetRemoteUpdate (remoteRef);
switch (remoteUpdate.GetStatus ()) {
case RemoteRefUpdate.Status.UP_TO_DATE: monitor.ReportSuccess (GettextCatalog.GetString ("Remote branch is up to date.")); break;
case RemoteRefUpdate.Status.REJECTED_NODELETE: monitor.ReportError (GettextCatalog.GetString ("The server is configured to deny deletion of the branch"), null); break;
case RemoteRefUpdate.Status.REJECTED_NONFASTFORWARD: monitor.ReportError (GettextCatalog.GetString ("The update is a non-fast-forward update. Merge the remote changes before pushing again."), null); break;
case RemoteRefUpdate.Status.OK:
monitor.ReportSuccess (GettextCatalog.GetString ("Push operation successfully completed."));
// Update the remote branch
ObjectId headId = remoteUpdate.GetNewObjectId ();
RefUpdate updateRef = RootRepository.UpdateRef (Constants.R_REMOTES + remote + "/" + remoteBranch);
updateRef.SetNewObjectId(headId);
updateRef.Update();
break;
default:
string msg = remoteUpdate.GetMessage ();
msg = !string.IsNullOrEmpty (msg) ? msg : GettextCatalog.GetString ("Push operation failed");
monitor.ReportError (msg, null);
break;
}
}
}
void CheckForPackageUpdates (
IProgressMonitor progressMonitor,
ProgressMonitorStatusMessage progressMessage,
PackageUpdatesEventMonitor eventMonitor)
{
updatedPackagesInSolution.CheckForUpdates ();
if (updatedPackagesInSolution.AnyUpdates ()) {
progressMonitor.ReportSuccess (GettextCatalog.GetString ("Package updates are available."));
} else if (eventMonitor.WarningReported) {
progressMonitor.ReportWarning (progressMessage.Warning);
} else {
progressMonitor.ReportSuccess (progressMessage.Success);
}
}
/// <summary>
/// Compiles a D project.
/// </summary>
public static BuildResult Compile(
DProject Project,
ProjectFileCollection FilesToCompile,
DProjectConfiguration BuildConfig,
IProgressMonitor monitor)
{
var relObjDir = "objs";
var objDir = Path.Combine(Project.BaseDirectory, relObjDir);
if(!Directory.Exists(objDir))
Directory.CreateDirectory(objDir);
// List of created object files
var BuiltObjects = new List<string>();
var compilerResults = new CompilerResults(new TempFileCollection());
var buildResult = new BuildResult(compilerResults, "");
bool succesfullyBuilt = true;
bool modificationsDone = false;
var Compiler = Project.Compiler;
var Commands = Compiler.GetTargetConfiguration(Project.CompileTarget);
var Arguments= Commands.GetArguments(BuildConfig.DebugMode);
/// The target file to which all objects will be linked to
var LinkTarget = BuildConfig.OutputDirectory.Combine(BuildConfig.CompiledOutputName);
monitor.BeginTask("Build Project", FilesToCompile.Count + 1);
var SourceIncludePaths=new List<string>(Compiler.GlobalParseCache.DirectoryPaths);
SourceIncludePaths.AddRange(Project.LocalIncludeCache.DirectoryPaths);
#region Compile sources to objects
foreach (var f in FilesToCompile)
{
if (monitor.IsCancelRequested)
return buildResult;
// If not compilable, skip it
if (f.BuildAction != BuildAction.Compile || !File.Exists(f.FilePath))
continue;
// a.Check if source file was modified and if object file still exists
if (Project.LastModificationTimes.ContainsKey(f) &&
Project.LastModificationTimes[f] == File.GetLastWriteTime(f.FilePath) &&
File.Exists(f.LastGenOutput))
{
// File wasn't edited since last build
// but add the built object to the objs array
BuiltObjects.Add(f.LastGenOutput);
monitor.Step(1);
continue;
}
else
modificationsDone=true;
#region Resource file
if(f.Name.EndsWith(".rc",StringComparison.OrdinalIgnoreCase))
{
var res = Path.Combine(objDir, Path.GetFileNameWithoutExtension(f.FilePath))+ ".res";
if(File.Exists(res))
File.Delete(res);
// Build argument string
var resCmpArgs = FillInMacros(Win32ResourceCompiler.Instance.Arguments,
new Win32ResourceCompiler.ArgProvider{
RcFile=f.FilePath.ToString(),
ResFile=res
});
// Execute compiler
string output;
int _exitCode = ExecuteCommand(Win32ResourceCompiler.Instance.Executable,
resCmpArgs,
Project.BaseDirectory,
monitor,
out output);
// Error analysis
if(!string.IsNullOrEmpty(output))
compilerResults.Errors.Add(new CompilerError{ FileName=f.FilePath, ErrorText=output});
CheckReturnCode(_exitCode, compilerResults);
monitor.Step(1);
if (_exitCode != 0)
{
buildResult.FailedBuildCount++;
succesfullyBuilt = false;
break;
}
else
{
f.LastGenOutput = res;
buildResult.BuildCount++;
Project.LastModificationTimes[f] = File.GetLastWriteTime(f.FilePath);
// Especially when compiling large projects, do only add the relative part of the r file due to command shortness
if (res.StartsWith(Project.BaseDirectory))
BuiltObjects.Add(res.Substring(Project.BaseDirectory.ToString().Length).TrimStart(Path.DirectorySeparatorChar));
else
BuiltObjects.Add(res);
}
continue;
}
#endregion
// Create object file path
var obj = Path.Combine(objDir, Path.GetFileNameWithoutExtension(f.FilePath)) + ObjectExtension;
if (File.Exists(obj))
File.Delete(obj);
// Prevent duplicates e.g. when having the samely-named source files in different sub-packages
int i=2;
while(File.Exists(obj))
{
// Simply add a number between the obj name and its extension
obj= Path.Combine(objDir, Path.GetFileNameWithoutExtension(f.FilePath))+i + ObjectExtension;
i++;
}
// Create argument string for source file compilation.
var dmdArgs = FillInMacros(Arguments.CompilerArguments + " " + BuildConfig.ExtraCompilerArguments, new DCompilerMacroProvider
{
IncludePathConcatPattern=Commands.IncludePathPattern,
SourceFile = f.FilePath,
ObjectFile = obj,
Includes=SourceIncludePaths,
});
// b.Execute compiler
string dmdOutput;
int exitCode = ExecuteCommand(Commands.Compiler, dmdArgs, Project.BaseDirectory, monitor, out dmdOutput);
ParseCompilerOutput(dmdOutput, compilerResults);
CheckReturnCode(exitCode, compilerResults);
monitor.Step(1);
if (exitCode != 0)
{
buildResult.FailedBuildCount++;
succesfullyBuilt = false;
break;
}
else
{
f.LastGenOutput = obj;
buildResult.BuildCount++;
Project.LastModificationTimes[f] = File.GetLastWriteTime(f.FilePath);
// Especially when compiling large projects, do only add the relative part of the obj file due to command shortness
if (obj.StartsWith(Project.BaseDirectory))
BuiltObjects.Add(obj.Substring(Project.BaseDirectory.ToString().Length).TrimStart(Path.DirectorySeparatorChar));
else
BuiltObjects.Add(obj);
}
}
#endregion
#region Link files
if (succesfullyBuilt)
{
// a.
if ((!modificationsDone) && lastLinkerActionSuccessfull)
{
// Only return if build target is still existing
if (File.Exists(LinkTarget))
{
monitor.Step(1);
return new BuildResult(compilerResults, "");
}
}
// b.Build linker argument string
// Build argument preparation
/*
var libPaths=new List<string>(Compiler.DefaultLibPaths);
libPaths.AddRange(Project.LibraryPaths);
*/
var libs=new List<string>(Compiler.DefaultLibraries);
libs.AddRange(Project.ExtraLibraries);
var linkArgs = FillInMacros(Arguments.LinkerArguments + " "+BuildConfig.ExtraLinkerArguments,
new DLinkerMacroProvider {
ObjectsStringPattern=Commands.ObjectFileLinkPattern,
Objects=BuiltObjects.ToArray(),
TargetFile=LinkTarget,
RelativeTargetDirectory=BuildConfig.OutputDirectory.ToRelative(Project.BaseDirectory),
//LibraryPaths=libPaths,
Libraries=libs
});
var linkerOutput = "";
int exitCode = ExecuteCommand(Commands.Linker,linkArgs,Project.BaseDirectory,monitor,out linkerOutput);
compilerResults.NativeCompilerReturnValue = exitCode;
CheckReturnCode(exitCode, compilerResults);
lastLinkerActionSuccessfull = (exitCode == 0);
if (lastLinkerActionSuccessfull)
{
monitor.ReportSuccess("Build successful!");
monitor.Step(1);
}
}
#endregion
return new BuildResult(compilerResults,"");
}
void BuildDone (IProgressMonitor monitor, BuildResult result, IBuildTarget entry, ITimeTracker tt)
{
Task[] tasks = null;
tt.Trace ("Begin reporting build result");
try {
if (result != null) {
lastResult = result;
monitor.Log.WriteLine ();
monitor.Log.WriteLine (GettextCatalog.GetString ("---------------------- Done ----------------------"));
tt.Trace ("Updating task service");
tasks = new Task [result.Errors.Count];
for (int n=0; n<tasks.Length; n++) {
tasks [n] = new Task (result.Errors [n]);
tasks [n].Owner = this;
}
TaskService.Errors.AddRange (tasks);
TaskService.Errors.ResetLocationList ();
IdeApp.Workbench.ActiveLocationList = TaskService.Errors;
tt.Trace ("Reporting result");
string errorString = GettextCatalog.GetPluralString("{0} error", "{0} errors", result.ErrorCount, result.ErrorCount);
string warningString = GettextCatalog.GetPluralString("{0} warning", "{0} warnings", result.WarningCount, result.WarningCount);
if (result.ErrorCount == 0 && result.WarningCount == 0 && lastResult.FailedBuildCount == 0) {
monitor.ReportSuccess (GettextCatalog.GetString ("Build successful."));
} else if (result.ErrorCount == 0 && result.WarningCount > 0) {
monitor.ReportWarning(GettextCatalog.GetString("Build: ") + errorString + ", " + warningString);
} else if (result.ErrorCount > 0) {
monitor.ReportError(GettextCatalog.GetString("Build: ") + errorString + ", " + warningString, null);
} else {
monitor.ReportError(GettextCatalog.GetString("Build failed."), null);
}
tt.Trace ("End build event");
OnEndBuild (monitor, lastResult.FailedBuildCount == 0, lastResult, entry as SolutionItem);
} else {
tt.Trace ("End build event");
OnEndBuild (monitor, false);
}
tt.Trace ("Showing results pad");
try {
Pad errorsPad = IdeApp.Workbench.GetPad<MonoDevelop.Ide.Gui.Pads.ErrorListPad> ();
switch (IdeApp.Preferences.ShowErrorPadAfterBuild) {
case BuildResultStates.Always:
if (!errorsPad.Visible)
errorsPad.IsOpenedAutomatically = true;
errorsPad.Visible = true;
errorsPad.BringToFront ();
break;
case BuildResultStates.Never:
break;
case BuildResultStates.OnErrors:
if (TaskService.Errors.Any (task => task.Severity == TaskSeverity.Error))
goto case BuildResultStates.Always;
goto case BuildResultStates.Never;
case BuildResultStates.OnErrorsOrWarnings:
if (TaskService.Errors.Any (task => task.Severity == TaskSeverity.Error || task.Severity == TaskSeverity.Warning))
goto case BuildResultStates.Always;
goto case BuildResultStates.Never;
}
} catch {}
if (tasks != null) {
Task jumpTask = null;
switch (IdeApp.Preferences.JumpToFirstErrorOrWarning) {
case JumpToFirst.Error:
jumpTask = tasks.FirstOrDefault (t => t.Severity == TaskSeverity.Error && TaskStore.IsProjectTaskFile (t));
break;
case JumpToFirst.ErrorOrWarning:
jumpTask = tasks.FirstOrDefault (t => (t.Severity == TaskSeverity.Error || t.Severity == TaskSeverity.Warning) && TaskStore.IsProjectTaskFile (t));
break;
}
if (jumpTask != null) {
tt.Trace ("Jumping to first result position");
jumpTask.JumpToPosition ();
}
}
} finally {
monitor.Dispose ();
tt.End ();
}
}
public Translation AddNewTranslation (string isoCode, IProgressMonitor monitor)
{
try {
Translation tr = new Translation (this, isoCode);
translations.Add (tr);
string templateFile = Path.Combine (this.BaseDirectory, "messages.po");
string translationFile = GetFileName (isoCode);
if (!File.Exists (templateFile))
CreateDefaultCatalog (monitor);
File.Copy (templateFile, translationFile);
monitor.ReportSuccess (String.Format (GettextCatalog.GetString ("Language '{0}' successfully added."), isoCode));
monitor.Step (1);
this.Save (monitor);
return tr;
} catch (Exception e) {
monitor.ReportError (String.Format ( GettextCatalog.GetString ("Language '{0}' could not be added: "), isoCode), e);
return null;
} finally {
monitor.EndTask ();
}
}
void ReportOutcome (
IAsyncOperation operation,
IProgressMonitor progressMonitor,
ProgressMonitorStatusMessage progressMessage)
{
if (operation.Success) {
progressMonitor.ReportSuccess (progressMessage.Success);
} else {
progressMonitor.ReportError (progressMessage.Error, null);
progressMonitor.ShowPackageConsole ();
}
}
public override void RevertRevision (FilePath localPath, Revision revision, IProgressMonitor monitor)
{
var git = new NGit.Api.Git (GetRepository (localPath));
var gitRev = (GitRevision)revision;
var revert = git.Revert ().Include (gitRev.Commit.ToObjectId ());
var newRevision = revert.Call ();
var revertResult = revert.GetFailingResult ();
if (revertResult == null) {
monitor.ReportSuccess (GettextCatalog.GetString ("Revision {0} successfully reverted", gitRev));
} else {
var errorMessage = GettextCatalog.GetString ("Could not revert commit {0}", gitRev);
var description = GettextCatalog.GetString ("The following files had merge conflicts");
description += Environment.NewLine + string.Join (Environment.NewLine, revertResult.GetFailingPaths ().Keys);
monitor.ReportError (errorMessage, new UserException (errorMessage, description));
}
}
public bool GenerateFiles(DeployContext ctx, Solution solution, string defaultConf, IProgressMonitor monitor)
{
string filesString = generateAutotools ? "Autotools files" : "Makefiles";
monitor.BeginTask(GettextCatalog.GetString("Generating {0} for Solution {1}", filesString, solution.Name), 1);
try
{
solution_dir = Path.GetDirectoryName(solution.FileName);
string[] configs = new string [solution.Configurations.Count];
for (int ii = 0; ii < configs.Length; ii++)
{
configs [ii] = solution.Configurations[ii].Id;
}
MakefileType mt = generateAutotools ? MakefileType.AutotoolsMakefile : MakefileType.SimpleMakefile;
context = new AutotoolsContext(ctx, solution_dir, configs, mt);
context.TargetSolution = solution;
context.Switches = switchs;
IMakefileHandler handler = AutotoolsContext.GetMakefileHandler(solution.RootFolder, mt);
if (handler == null)
{
throw new Exception(GettextCatalog.GetString("MonoDevelop does not currently support generating {0} for one (or more) child projects.", filesString));
}
solution_name = solution.Name;
solution_version = AutotoolsContext.EscapeStringForAutoconf(solution.Version, true);
if (string.IsNullOrEmpty(solution_version))
{
solution_version = "0.1";
}
Makefile makefile = handler.Deploy(context, solution.RootFolder, monitor);
string path = Path.Combine(solution_dir, "Makefile");
if (generateAutotools)
{
context.AddAutoconfFile(path);
CreateAutoGenDotSH(context, monitor);
CreateConfigureDotAC(solution, defaultConf, monitor, context);
CreateMacros();
}
else
{
CreateConfigureScript(solution, defaultConf, context, monitor);
monitor.Log.WriteLine(GettextCatalog.GetString("Creating rules.make"));
string rules_make_path = Path.Combine(solution_dir, "rules.make");
File.Copy(Path.Combine(context.TemplateDir, "rules.make"), rules_make_path, true);
context.AddGeneratedFile(rules_make_path);
}
CreateMakefileInclude(context, monitor);
AddTopLevelMakefileVars(makefile, monitor);
if (generateAutotools)
{
path = path + ".am";
}
StreamWriter writer = new StreamWriter(path);
makefile.Write(writer);
writer.Close();
context.AddGeneratedFile(path);
monitor.ReportSuccess(GettextCatalog.GetString("{0} were successfully generated.", filesString));
monitor.Step(1);
}
catch (Exception e)
{
monitor.ReportError(GettextCatalog.GetString("{0} could not be generated: ", filesString), e);
LoggingService.LogError(GettextCatalog.GetString("{0} could not be generated: ", filesString), e);
DeleteGeneratedFiles(context);
return(false);
}
finally
{
monitor.EndTask();
}
return(true);
}
public override void Save(IProgressMonitor monitor)
{
monitor.ReportSuccess("Skip saving dub project.");
}
BuildResult DoOneStepBuild()
{
var br = new BuildResult();
bool filesModified = false;
// Enum files & build resource files
foreach (var pf in Project.Files)
{
if (pf.BuildAction != BuildAction.Compile || pf.Subtype == Subtype.Directory)
{
continue;
}
DateTime dt;
if (Project.LastModificationTimes.TryGetValue(pf, out dt))
{
filesModified |= File.GetLastWriteTime(pf.FilePath) != dt;
}
else
{
filesModified = true;
}
Project.LastModificationTimes[pf] = File.GetLastWriteTime(pf.FilePath);
if (pf.FilePath.Extension.EndsWith(".rc", StringComparison.OrdinalIgnoreCase))
{
if (!CompileResourceScript(br, pf))
{
return(br);
}
}
else
{
BuiltObjects.Add(MakeRelativeToPrjBase(Project, pf.FilePath));
}
}
// Build argument string
var target = Project.GetOutputFileName(BuildConfig.Selector);
if (!Project.NeedsFullRebuild && !filesModified && Project.EnableIncrementalLinking &&
File.Exists(target))
{
monitor.ReportSuccess("Build successful! - No new linkage needed");
monitor.Step(1);
return(br);
}
var argumentString = BuildOneStepBuildString(Project, BuiltObjects, BuildConfig.Selector);
// Execute the compiler
var stdOut = "";
var stdError = "";
var linkCfg = LinkTargetCfg(BuildConfig);
var linkerExecutable = Compiler.SourceCompilerCommand;
if (!Path.IsPathRooted(linkerExecutable) && !string.IsNullOrEmpty(Compiler.BinPath))
{
linkerExecutable = Path.Combine(Compiler.BinPath, linkCfg.Linker);
if (!File.Exists(linkerExecutable))
{
linkerExecutable = linkCfg.Linker;
}
}
monitor.Log.WriteLine("Current dictionary: " + Project.BaseDirectory);
string cmdLineFile;
HandleOverLongArgumentStrings(monitor, Compiler, true, ref argumentString, out cmdLineFile);
int exitCode = ExecuteCommand(linkerExecutable, argumentString, Project.BaseDirectory, monitor,
out stdError,
out stdOut);
ErrorExtracting.HandleCompilerOutput(Project, br, stdError);
ErrorExtracting.HandleCompilerOutput(Project, br, stdOut);
ErrorExtracting.HandleOptLinkOutput(Project, br, stdOut);
ErrorExtracting.HandleLdOutput(Project, br, stdOut);
ErrorExtracting.HandleReturnCode(monitor, br, exitCode);
if (cmdLineFile != null)
{
File.Delete(cmdLineFile);
}
if (!br.Failed)
{
Project.CopySupportFiles(monitor, this.BuildConfig.Selector);
Project.NeedsFullRebuild = false;
}
return(br);
}
protected override void Clean (IProgressMonitor monitor, SolutionEntityItem entry, ConfigurationSelector configuration)
{
Project proj = entry as Project;
if (proj == null) {
base.Clean (monitor, entry, configuration);
return;
}
MakefileData data = proj.ExtendedProperties ["MonoDevelop.Autotools.MakefileInfo"] as MakefileData;
if (data == null || !data.SupportsIntegration || String.IsNullOrEmpty (data.CleanTargetName)) {
base.Clean (monitor, entry, configuration);
return;
}
monitor.BeginTask (GettextCatalog.GetString ("Cleaning project"), 1);
try {
string baseDir = proj.BaseDirectory;
ProcessWrapper process = Runtime.ProcessService.StartProcess (data.AbsoluteMakeCommand,
data.CleanTargetName,
baseDir,
monitor.Log,
monitor.Log,
null);
process.WaitForOutput ();
if (process.ExitCode > 0)
throw new Exception ( GettextCatalog.GetString ("An unspecified error occurred while running '{0} {1}'", data.AbsoluteMakeCommand, data.CleanTargetName) );
monitor.Step (1);
} catch (Exception e) {
monitor.ReportError (GettextCatalog.GetString ("Project could not be cleaned: "), e);
return;
} finally {
monitor.EndTask ();
}
monitor.ReportSuccess (GettextCatalog.GetString ("Project successfully cleaned"));
}
void BuildDone(IProgressMonitor monitor, ICompilerResult result)
{
lastResult = result;
monitor.Log.WriteLine ();
monitor.Log.WriteLine (String.Format (GettextCatalog.GetString ("---------------------- Done ----------------------")));
foreach (CompilerError err in result.CompilerResults.Errors) {
Runtime.TaskService.AddTask (new Task(null, err));
}
if (result.ErrorCount == 0 && result.WarningCount == 0 && lastResult.FailedBuildCount == 0) {
monitor.ReportSuccess (GettextCatalog.GetString ("Build successful."));
} else if (result.ErrorCount == 0 && result.WarningCount > 0) {
monitor.ReportWarning (String.Format (GettextCatalog.GetString ("Build: {0} errors, {1} warnings."), result.ErrorCount, result.WarningCount));
} else if (result.ErrorCount > 0) {
monitor.ReportError (String.Format (GettextCatalog.GetString ("Build: {0} errors, {1} warnings."), result.ErrorCount, result.WarningCount), null);
} else {
monitor.ReportError (String.Format (GettextCatalog.GetString ("Build failed.")), null);
}
OnEndBuild (lastResult.FailedBuildCount == 0);
}
static bool UpdateCompleted(IProgressMonitor monitor, AggregatedOperationMonitor aggOp,
ProjectFile file, ProjectFile genFile, SingleFileCustomToolResult result,
bool runMultipleFiles)
{
monitor.EndTask();
if (aggOp != null)
{
aggOp.Dispose();
}
if (monitor.IsCancelRequested)
{
monitor.ReportError(GettextCatalog.GetString("Cancelled"), null);
monitor.Dispose();
return(false);
}
string genFileName;
try {
bool broken = false;
if (result.UnhandledException != null)
{
broken = true;
string msg = GettextCatalog.GetString("The '{0}' code generator crashed", file.Generator);
result.Errors.Add(new CompilerError(file.Name, 0, 0, "", msg + ": " + result.UnhandledException.Message));
monitor.ReportError(msg, result.UnhandledException);
LoggingService.LogError(msg, result.UnhandledException);
}
genFileName = result.GeneratedFilePath.IsNullOrEmpty?
null : result.GeneratedFilePath.ToRelative(file.FilePath.ParentDirectory);
if (!string.IsNullOrEmpty(genFileName))
{
bool validName = genFileName.IndexOfAny(new [] { '/', '\\' }) < 0 &&
FileService.IsValidFileName(genFileName);
if (!broken && !validName)
{
broken = true;
string msg = GettextCatalog.GetString("The '{0}' code generator output invalid filename '{1}'",
file.Generator, result.GeneratedFilePath);
result.Errors.Add(new CompilerError(file.Name, 0, 0, "", msg));
monitor.ReportError(msg, null);
}
}
if (result.Errors.Count > 0)
{
DispatchService.GuiDispatch(delegate {
foreach (CompilerError err in result.Errors)
{
TaskService.Errors.Add(new Task(file.FilePath, err.ErrorText, err.Column, err.Line,
err.IsWarning? TaskSeverity.Warning : TaskSeverity.Error,
TaskPriority.Normal, file.Project.ParentSolution, file));
}
});
}
if (broken)
{
return(true);
}
if (!runMultipleFiles)
{
if (result.Success)
{
monitor.ReportSuccess("Generated file successfully.");
}
else if (result.SuccessWithWarnings)
{
monitor.ReportSuccess("Warnings in file generation.");
}
else
{
monitor.ReportError("Errors in file generation.", null);
}
}
} finally {
if (!runMultipleFiles)
{
monitor.Dispose();
}
}
if (result.GeneratedFilePath.IsNullOrEmpty || !File.Exists(result.GeneratedFilePath))
{
return(true);
}
// broadcast a change event so text editors etc reload the file
FileService.NotifyFileChanged(result.GeneratedFilePath);
// add file to project, update file properties, etc
Gtk.Application.Invoke(delegate {
bool projectChanged = false;
if (genFile == null)
{
genFile = file.Project.AddFile(result.GeneratedFilePath, result.OverrideBuildAction);
projectChanged = true;
}
else if (result.GeneratedFilePath != genFile.FilePath)
{
genFile.Name = result.GeneratedFilePath;
projectChanged = true;
}
if (file.LastGenOutput != genFileName)
{
file.LastGenOutput = genFileName;
projectChanged = true;
}
if (genFile.DependsOn != file.FilePath.FileName)
{
genFile.DependsOn = file.FilePath.FileName;
projectChanged = true;
}
if (projectChanged)
{
IdeApp.ProjectOperations.Save(file.Project);
}
});
return(true);
}
public void Push (IProgressMonitor monitor, string remote, string remoteBranch)
{
RunCommand ("push " + remote + " HEAD:" + remoteBranch, true, monitor);
monitor.ReportSuccess ("Repository successfully pushed");
}
void CleanDone (IProgressMonitor monitor, IBuildTarget entry, ITimeTracker tt)
{
tt.Trace ("Begin reporting clean result");
try {
monitor.Log.WriteLine ();
monitor.Log.WriteLine (GettextCatalog.GetString ("---------------------- Done ----------------------"));
tt.Trace ("Reporting result");
monitor.ReportSuccess (GettextCatalog.GetString ("Clean successful."));
OnEndClean (monitor, tt);
} finally {
monitor.Dispose ();
tt.End ();
}
}
public bool Deploy(DeployContext ctx, Solution solution, string defaultConf, string targetDir, bool generateFiles, IProgressMonitor monitor)
{
if (generateFiles)
{
if (!GenerateFiles(ctx, solution, defaultConf, monitor))
{
return(false);
}
}
monitor.BeginTask(GettextCatalog.GetString("Deploying Solution to Tarball"), 3);
try
{
string baseDir = Path.GetDirectoryName(solution.FileName);
ProcessWrapper ag_process = Runtime.ProcessService.StartProcess("sh",
generateAutotools ? "autogen.sh" : "configure",
baseDir,
monitor.Log,
monitor.Log,
null);
ag_process.WaitForOutput();
if (ag_process.ExitCode > 0)
{
throw new Exception(GettextCatalog.GetString("An unspecified error occurred while running '{0}'", generateAutotools ? "autogen.sh" : "configure"));
}
monitor.Step(1);
StringWriter sw = new StringWriter();
LogTextWriter chainedOutput = new LogTextWriter();
chainedOutput.ChainWriter(monitor.Log);
chainedOutput.ChainWriter(sw);
ProcessWrapper process = Runtime.ProcessService.StartProcess("make",
"dist",
baseDir,
chainedOutput,
monitor.Log,
null);
process.WaitForOutput();
if (process.ExitCode > 0)
{
throw new Exception(GettextCatalog.GetString("An unspecified error occurred while running '{0}'", "make dist"));
}
monitor.Step(1);
// FIXME: hackish way to get the created tarball's filename
string output = sw.ToString();
int targz = output.LastIndexOf("tar.gz");
int begin = output.LastIndexOf('>', targz);
string filename = output.Substring(begin + 1, (targz - begin) + 5).Trim();
FileService.CopyFile(Path.Combine(baseDir, filename), Path.Combine(targetDir, filename));
monitor.Step(1);
}
catch (Exception e)
{
monitor.ReportError(GettextCatalog.GetString("Solution could not be deployed: "), e);
return(false);
}
finally
{
monitor.EndTask();
}
monitor.ReportSuccess(GettextCatalog.GetString("Solution was successfully deployed."));
return(true);
}