from various points.
In class/Microsoft.Build.Engine:
* Microsoft.Build.Engine.dll.sources: Add
UnknownToolsVersionException.cs
In class/Microsoft.Build.Engine/Microsoft.Build.BuildEngine:
Correctly handle precedence of ToolsVersion value coming
from various points.
* BuildEngine.cs (BuildProjectFile): Restore project.ToolsVersion .
* Engine.cs: Likewise. Also validate DefaultToolsVersion .
* Project.cs: Handle invalid tools version specified in the project
file, and fall back to engine's version.
* MSBuild.cs: Fix the precedence order, and validate.
* UnknownToolsVersionException.cs: New.
In class/Microsoft.Build.Tasks:
* Microsoft.Build.Tasks.dll.sources: Use
UnknownToolsVersionException.cs from Engine.
In class/Microsoft.Build.Tasks/Test/Microsoft.Build.Tasks:
* MessageTest (TestExecution): Additional messages with 'low'
importance get emitted, so don't expect sequential messages.
In tools/xbuild:
* Main.cs: Use tools version specified on the command line, if
any.
* xbuild.exe.sources: Include UnknownToolsVersionException.cs from
MS.B.Engine
svn path=/trunk/mcs/; revision=160133
+2010-07-09 Ankit Jain <jankit@novell.com>
+
+ * Microsoft.Build.Engine.dll.sources: Add
+ UnknownToolsVersionException.cs
+
2010-04-06 Ankit Jain <jankit@novell.com>
* Makefile (EXTRA_DISTFILES): Remove TestTasks.dll.config .
IDictionary targetOutputs, string toolsVersion)
{
if (String.IsNullOrEmpty (projectFileName)) {
+ string oldProjectToolsVersion = project.ToolsVersion;
project.ToolsVersion = toolsVersion;
- return engine.BuildProject (project, targetNames, targetOutputs,
+ try {
+ return engine.BuildProject (project, targetNames, targetOutputs,
BuildSettings.DoNotResetPreviouslyBuiltTargets);
+ } finally {
+ project.ToolsVersion = oldProjectToolsVersion;
+ }
} else {
BuildPropertyGroup bpg = new BuildPropertyGroup ();
if (globalProperties != null)
+2010-07-09 Ankit Jain <jankit@novell.com>
+
+ Correctly handle precedence of ToolsVersion value coming
+ from various points.
+ * BuildEngine.cs (BuildProjectFile): Restore project.ToolsVersion .
+ * Engine.cs: Likewise. Also validate DefaultToolsVersion .
+ * Project.cs: Handle invalid tools version specified in the project
+ file, and fall back to engine's version.
+ * MSBuild.cs: Fix the precedence order, and validate.
+ * UnknownToolsVersionException.cs: New.
+
2010-06-23 Ankit Jain <jankit@novell.com>
* TargetBatchingImpl.cs (BuildTargetNeeded): Fix var names to
this.Toolsets = new ToolsetCollection ();
LoadDefaultToolsets ();
defaultTasksTableByToolsVersion = new Dictionary<string, TaskDatabase> ();
- GetDefaultTasks (DefaultToolsVersion);
}
//FIXME: should be loaded from config file
}
try {
+ string oldProjectToolsVersion = project.ToolsVersion;
if (String.IsNullOrEmpty (toolsVersion) && defaultToolsVersion != null)
- // it has been explicitly set, xbuild does this..
- //FIXME: should this be cleared after building?
+ // no tv specified, let the project inherit it from the
+ // engine. 'defaultToolsVersion' will be effective only
+ // it has been overridden. Otherwise, the project's own
+ // tv will be used.
project.ToolsVersion = defaultToolsVersion;
else
project.ToolsVersion = toolsVersion;
- return project.Build (targetNames, targetOutputs, buildFlags);
+ try {
+ return project.Build (targetNames, targetOutputs, buildFlags);
+ } finally {
+ project.ToolsVersion = oldProjectToolsVersion;
+ }
} finally {
if (globalProperties != null) {
GlobalProperties = engine_old_grp;
var toolset = Toolsets [toolsVersion];
if (toolset == null)
- throw new Exception ("Unknown toolsversion: " + toolsVersion);
+ throw new UnknownToolsVersionException (toolsVersion);
string toolsPath = toolset.ToolsPath;
string tasksFile = Path.Combine (toolsPath, defaultTasksProjectName);
return defaultToolsVersion;
}
- set { defaultToolsVersion = value; }
+ set {
+ if (Toolsets [value] == null)
+ throw new UnknownToolsVersionException (value);
+ defaultToolsVersion = value;
+ }
}
public bool IsBuilding {
targets = new TargetCollection (this);
last_item_group_containing = new Dictionary <string, BuildItemGroup> ();
+ string effective_tools_version = GetToolsVersionToUse ();
taskDatabase = new TaskDatabase ();
- taskDatabase.CopyTasks (ParentEngine.GetDefaultTasks (GetToolsVersionToUse ()));
+ taskDatabase.CopyTasks (ParentEngine.GetDefaultTasks (effective_tools_version));
initialTargets = new List<string> ();
defaultTargets = new string [0];
- PrepareForEvaluate ();
+ PrepareForEvaluate (effective_tools_version);
ProcessElements (xmlDocument.DocumentElement, null);
isDirty = false;
}
}
- void PrepareForEvaluate ()
+ void PrepareForEvaluate (string effective_tools_version)
{
evaluatedItems = new BuildItemGroup (null, this, null, true);
evaluatedItemsIgnoringCondition = new BuildItemGroup (null, this, null, true);
if (building && current_settings == BuildSettings.None)
RemoveBuiltTargets ();
- InitializeProperties ();
+ InitializeProperties (effective_tools_version);
}
void Evaluate ()
ParentEngine.BuiltTargetsOutputByName.Remove (key);
}
- void InitializeProperties ()
+ void InitializeProperties (string effective_tools_version)
{
BuildProperty bp;
EvaluatedProperties.AddProperty (new BuildProperty ("MSBuildProjectName",
Path.GetFileNameWithoutExtension (fullFileName),
PropertyType.Reserved));
- string toolsVersionToUse = GetToolsVersionToUse ();
- string toolsPath = parentEngine.Toolsets [toolsVersionToUse].ToolsPath;
+ string toolsPath = parentEngine.Toolsets [effective_tools_version].ToolsPath;
if (toolsPath == null)
- throw new Exception ("Unknown toolsVersion: " + toolsVersionToUse);
+ throw new Exception (String.Format ("Invalid tools version '{0}', no tools path set for this.", effective_tools_version));
EvaluatedProperties.AddProperty (new BuildProperty ("MSBuildBinPath", toolsPath, PropertyType.Reserved));
EvaluatedProperties.AddProperty (new BuildProperty ("MSBuildToolsPath", toolsPath, PropertyType.Reserved));
- EvaluatedProperties.AddProperty (new BuildProperty ("MSBuildToolsVersion", toolsVersionToUse, PropertyType.Reserved));
+ EvaluatedProperties.AddProperty (new BuildProperty ("MSBuildToolsVersion", effective_tools_version, PropertyType.Reserved));
EvaluatedProperties.AddProperty (new BuildProperty ("MSBuildExtensionsPath", ExtensionsPath, PropertyType.Reserved));
EvaluatedProperties.AddProperty (new BuildProperty ("MSBuildExtensionsPath32", ExtensionsPath, PropertyType.Reserved));
EvaluatedProperties.AddProperty (new BuildProperty ("MSBuildProjectDefaultTargets", DefaultTargets, PropertyType.Reserved));
EvaluatedProperties.AddProperty (new BuildProperty ("MSBuildProjectDirectory", projectDir, PropertyType.Reserved));
}
+ // precedence:
+ // ToolsVersion property
+ // ToolsVersion attribute on the project
+ // parentEngine's DefaultToolsVersion
string GetToolsVersionToUse ()
{
- if (String.IsNullOrEmpty (ToolsVersion)) {
- if (HasToolsVersionAttribute)
- return DefaultToolsVersion;
- else
- return parentEngine.DefaultToolsVersion;
- } else {
+ if (!String.IsNullOrEmpty (ToolsVersion))
return ToolsVersion;
+
+ if (!HasToolsVersionAttribute)
+ return parentEngine.DefaultToolsVersion;
+
+ if (parentEngine.Toolsets [DefaultToolsVersion] == null) {
+ LogWarning (FullFileName, "Project has unknown ToolsVersion '{0}'. Using the default tools version '{1}' instead.",
+ DefaultToolsVersion, parentEngine.DefaultToolsVersion);
+ return parentEngine.DefaultToolsVersion;
}
+
+ return DefaultToolsVersion;
}
void AddProjectExtensions (XmlElement xmlElement)
--- /dev/null
+//
+// UnknownToolsVersionException.cs
+//
+// Author:
+// Ankit Jain (jankit@novell.com)
+//
+// Copyright 2010 Novell, Inc (http://www.novell.com)
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+#if NET_2_0
+
+using System;
+using System.Runtime.Serialization;
+using System.Text;
+
+namespace Microsoft.Build.BuildEngine {
+ [Serializable]
+ internal class UnknownToolsVersionException : Exception {
+ string message;
+
+ public UnknownToolsVersionException (string toolsVersion)
+ {
+ this.message = GetErrorMessage (toolsVersion);
+ }
+
+ public UnknownToolsVersionException (string toolsVersion, string message)
+ {
+ this.message = String.Format ("{0}. {1}", message, GetErrorMessage (toolsVersion));
+ }
+
+ public UnknownToolsVersionException (string message,
+ Exception innerException)
+ : base (message, innerException)
+ {
+ }
+
+ protected UnknownToolsVersionException (SerializationInfo info,
+ StreamingContext context)
+ : base (info, context)
+ {
+ }
+
+ public override string Message {
+ get { return message; }
+ }
+
+ string GetErrorMessage (string toolsVersion)
+ {
+ StringBuilder sb = new StringBuilder ();
+ sb.AppendFormat ("Unknown tools version: '{0}' . Known versions:", toolsVersion);
+
+ foreach (var ts in Engine.GlobalEngine.Toolsets)
+ sb.AppendFormat (" '{0}'", ts.ToolsVersion);
+
+ return sb.ToString ();
+ }
+ }
+}
+
+#endif
Microsoft.Build.BuildEngine/Toolset.cs
Microsoft.Build.BuildEngine/ToolsetCollection.cs
Microsoft.Build.BuildEngine/ToolsetDefinitionLocations.cs
+Microsoft.Build.BuildEngine/UnknownToolsVersionException.cs
Microsoft.Build.BuildEngine/UsingTask.cs
Microsoft.Build.BuildEngine/UsingTaskCollection.cs
Microsoft.Build.BuildEngine/Utilities.cs
+2010-07-09 Ankit Jain <jankit@novell.com>
+
+ * Microsoft.Build.Tasks.dll.sources: Use
+ UnknownToolsVersionException.cs from Engine.
+
2010-04-03 Ankit Jain <jankit@novell.com>
* Makefile: Import tools/xbuild/xbuild_targets.make, which copies
Mono.XBuild.Tasks.GenerateResourceInternal/TxtResourceReader.cs
Mono.XBuild.Tasks.GenerateResourceInternal/TxtResourceWriter.cs
../Microsoft.Build.Engine/Microsoft.Build.BuildEngine/DirectoryScanner.cs
+../Microsoft.Build.Engine/Microsoft.Build.BuildEngine/UnknownToolsVersionException.cs
try {
// Order of precedence:
- // %(Project.ToolsVersion) , ToolsVersion property
- string tv = project.GetMetadata ("ToolsVersion");
+ // ToolsVersion property, %(Project.ToolsVersion)
+ string tv = ToolsVersion;
if (String.IsNullOrEmpty (tv))
- tv = ToolsVersion;
- ThrowIfNotValidToolsVersion (tv);
+ // metadata on the Project item
+ tv = project.GetMetadata ("ToolsVersion");
+
+ if (!String.IsNullOrEmpty (tv) && Engine.GlobalEngine.Toolsets [tv] == null)
+ throw new UnknownToolsVersionException (tv);
result = BuildEngine2.BuildProjectFile (filename, targets, global_properties, outputs, tv);
} catch (InvalidProjectFileException e) {
return result;
}
- void ThrowIfNotValidToolsVersion (string toolsVersion)
+ void ThrowIfInvalidToolsVersion (string toolsVersion)
{
if (!String.IsNullOrEmpty (toolsVersion) && Engine.GlobalEngine.Toolsets [toolsVersion] == null)
- throw new Exception (String.Format ("Unknown ToolsVersion : {0}", toolsVersion));
+ throw new UnknownToolsVersionException (toolsVersion);
}
[Required]
+2010-07-09 Ankit Jain <jankit@novell.com>
+
+ * MessageTest (TestExecution): Additional messages with 'low'
+ importance get emitted, so don't expect sequential messages.
+
2010-04-06 Ankit Jain <jankit@novell.com>
* Consts.cs: Remove.
string documentString = @"
<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<Target Name='1'>
- <Message Text='Text' Importance='Low'/>
- <Message Text='Text' Importance='Normal'/>
- <Message Text='Text' Importance='High'/>
- <Message Text='Text' Importance='low'/>
- <Message Text='Text' Importance='normal'/>
- <Message Text='Text' Importance='high'/>
- <Message Text='Text' />
- <Message Text='Text' Importance='weird_importance'/>
+ <Message Text='Text1' Importance='Low'/>
+ <Message Text='Text2' Importance='Normal'/>
+ <Message Text='Text3' Importance='High'/>
+ <Message Text='Text4' Importance='low'/>
+ <Message Text='Text5' Importance='normal'/>
+ <Message Text='Text6' Importance='high'/>
+ <Message Text='Text7' />
+ <Message Text='Text8' Importance='weird_importance'/>
</Target>
</Project>
";
project = engine.CreateNewProject ();
project.LoadXml (documentString);
- project.Build ("1");
+ if (project.Build ("1")) {
+ testLogger.DumpMessages ();
+ Assert.Fail ("Build should have failed");
+ }
- Assert.AreEqual (0, testLogger.CheckHead ("Text", MessageImportance.Low), "A1");
- Assert.AreEqual (0, testLogger.CheckHead ("Text", MessageImportance.Normal), "A2");
- Assert.AreEqual (0, testLogger.CheckHead ("Text", MessageImportance.High), "A3");
- Assert.AreEqual (0, testLogger.CheckHead ("Text", MessageImportance.Low), "A4");
- Assert.AreEqual (0, testLogger.CheckHead ("Text", MessageImportance.Normal), "A5");
- Assert.AreEqual (0, testLogger.CheckHead ("Text", MessageImportance.High), "A6");
- Assert.AreEqual (0, testLogger.CheckHead ("Text", MessageImportance.Normal), "A7");
- Assert.AreEqual (1, testLogger.CheckHead ("Text", MessageImportance.Normal), "A8");
+ testLogger.DumpMessages ();
+ Assert.AreEqual (0, testLogger.CheckAny ("Text1", MessageImportance.Low), "A1");
+ Assert.AreEqual (0, testLogger.CheckAny ("Text2", MessageImportance.Normal), "A2");
+ Assert.AreEqual (0, testLogger.CheckAny ("Text3", MessageImportance.High), "A3");
+ Assert.AreEqual (0, testLogger.CheckAny ("Text4", MessageImportance.Low), "A4");
+ Assert.AreEqual (0, testLogger.CheckAny ("Text5", MessageImportance.Normal), "A5");
+ Assert.AreEqual (0, testLogger.CheckAny ("Text6", MessageImportance.High), "A6");
+ Assert.AreEqual (0, testLogger.CheckAny ("Text7", MessageImportance.Normal), "A7");
+ Assert.AreEqual (1, testLogger.CheckAny ("Text8", MessageImportance.Normal), "A8");
}
}
+2010-07-09 Ankit Jain <jankit@novell.com>
+
+ * Main.cs: Use tools version specified on the command line, if
+ any.
+ * xbuild.exe.sources: Include UnknownToolsVersionException.cs from
+ MS.B.Engine
+
2010-06-23 Ankit Jain <jankit@novell.com>
* xbuild/Microsoft.CSharp.targets (CoreCompile): Fix inputs.
using System.Collections;
using System.IO;
using System.Reflection;
+using System.Text;
using Microsoft.Build.BuildEngine;
using Microsoft.Build.Framework;
using Microsoft.Build.Utilities;
if (parameters.DisplayVersion)
ErrorUtilities.ShowVersion (false);
- //FIXME: cmd line arg to set toolsversion
engine = Engine.GlobalEngine;
if (!String.IsNullOrEmpty (parameters.ToolsVersion)) {
if (engine.Toolsets [parameters.ToolsVersion] == null)
- ErrorUtilities.ReportError (0, String.Format ("Unknown tools version : {0}", parameters.ToolsVersion));
+ ErrorUtilities.ReportError (0, new UnknownToolsVersionException (parameters.ToolsVersion).Message);
engine.DefaultToolsVersion = parameters.ToolsVersion;
}
return;
}
- project.Load (projectFile);
-
- string oldCurrentDirectory = Environment.CurrentDirectory;
- string dir = Path.GetDirectoryName (projectFile);
- if (!String.IsNullOrEmpty (dir))
- Directory.SetCurrentDirectory (dir);
- result = engine.BuildProject (project, parameters.Targets, null);
- Directory.SetCurrentDirectory (oldCurrentDirectory);
+ result = engine.BuildProjectFile (projectFile, parameters.Targets, null, null, BuildSettings.None, parameters.ToolsVersion);
}
catch (InvalidProjectFileException ipfe) {
}
}
-
}
// code from mcs/report.cs
../../build/common/Consts.cs
+../../class/Microsoft.Build.Engine/Microsoft.Build.BuildEngine/UnknownToolsVersionException.cs
../../class/Microsoft.Build.Framework/Mono.XBuild.Framework/AssemblyLoadInfo.cs
AssemblyInfo.cs
CommandLineException.cs
projects / mono.git / commitdiff