X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mcs%2Fclass%2FMicrosoft.Build%2FMicrosoft.Build.Evaluation%2FProject.cs;h=4f7fbd168ce50eaec7965274a649ac78f697af20;hb=96edd46e16619fe64e26ea017330c22bf893f0dd;hp=64d4cb6eadbdf555cd5d9d3ea2b9ca06d600a784;hpb=f12f734432a245d8de5c83f5597c183a98c6c748;p=mono.git

diff --git a/mcs/class/Microsoft.Build/Microsoft.Build.Evaluation/Project.cs b/mcs/class/Microsoft.Build/Microsoft.Build.Evaluation/Project.cs
index 64d4cb6eadb..4f7fbd168ce 100644
--- a/mcs/class/Microsoft.Build/Microsoft.Build.Evaluation/Project.cs
+++ b/mcs/class/Microsoft.Build/Microsoft.Build.Evaluation/Project.cs
@@ -37,12 +37,40 @@ using System.Linq;
 using System.Text;
 using System.Xml;
 using Microsoft.Build.Construction;
-using Microsoft.Build.Internal;
+using Microsoft.Build.Exceptions;
 using Microsoft.Build.Execution;
 using Microsoft.Build.Framework;
+using Microsoft.Build.Internal;
+using Microsoft.Build.Internal.Expressions;
 using Microsoft.Build.Logging;
 using System.Collections;
 
+// Basically there are two semantic Project object models and their relationship is not obvious
+// (apart from Microsoft.Build.Construction.ProjectRootElement which is a "construction rule").
+//
+// Microsoft.Build.Evaluation.Project holds some "editable" project model, and it supports
+// detailed loader API (such as Items and AllEvaluatedItems).
+// ProjectPoperty holds UnevaluatedValue and gives EvaluatedValue too.
+//
+// Microsoft.Build.Execution.ProjectInstance holds "snapshot" of a project, and it lacks
+// detailed loader API. It does not give us Unevaluated property value.
+// On the other hand, it supports Targets object model. What Microsoft.Build.Evaluation.Project
+// offers there is actually a list of Microsoft.Build.Execution.ProjectInstance objects.
+// It should be also noted that only ProjectInstance has Evaluate() method (Project doesn't).
+//
+// And both API holds different set of descendant types for each and cannot really share the
+// loader code. That is lame.
+//
+// So, can either of them be used to construct the other model? Both API models share the same
+// "governor", which is Microsoft.Build.Evaluation.ProjectCollection/ Project is added to
+// its LoadedProjects list, while ProjectInstance isn't. Project cannot be loaded to load
+// a ProjectInstance, at least within the same ProjectCollection.
+//
+// On the other hand, can ProjectInstance be used to load a Project? Maybe. Since Project and
+// its descendants need Microsoft.Build.Construction.ProjectElement family as its API model
+// is part of the public API. Then I still have to understand how those AllEvaluatedItems/
+// AllEvaluatedProperties members make sense. EvaluationCounter is another propery in question.
+
 namespace Microsoft.Build.Evaluation
 {
 	[DebuggerDisplay ("{FullPath} EffectiveToolsVersion={ToolsVersion} #GlobalProperties="
@@ -145,7 +173,6 @@ namespace Microsoft.Build.Evaluation
 		List<ResolvedImport> raw_imports;
 		List<ProjectItem> raw_items;
 		List<ProjectItem> all_evaluated_items;
-		List<string> item_types;
 		List<ProjectProperty> properties;
 		Dictionary<string, ProjectTargetInstance> targets;
 
@@ -154,45 +181,101 @@ namespace Microsoft.Build.Evaluation
 			dir_path = Directory.GetCurrentDirectory ();
 			raw_imports = new List<ResolvedImport> ();
 			item_definitions = new Dictionary<string, ProjectItemDefinition> ();
-			item_types = new List<string> ();
-			properties = new List<ProjectProperty> ();
 			targets = new Dictionary<string, ProjectTargetInstance> ();
 			raw_items = new List<ProjectItem> ();
 			
-			ProcessXml ();
-		}
-		
-		static readonly char [] item_sep = {';'};
+			properties = new List<ProjectProperty> ();
 		
-		void ProcessXml ()
-		{
 			foreach (DictionaryEntry p in Environment.GetEnvironmentVariables ())
-				this.properties.Add (new EnvironmentProjectProperty (this, (string)p.Key, (string)p.Value));
+				// FIXME: this is kind of workaround for unavoidable issue that PLATFORM=* is actually given
+				// on some platforms and that prevents setting default "PLATFORM=AnyCPU" property.
+				if (!string.Equals ("PLATFORM", (string) p.Key, StringComparison.OrdinalIgnoreCase))
+					this.properties.Add (new EnvironmentProjectProperty (this, (string)p.Key, (string)p.Value));
 			foreach (var p in GlobalProperties)
 				this.properties.Add (new GlobalProjectProperty (this, p.Key, p.Value));
+			var tools = ProjectCollection.GetToolset (this.ToolsVersion) ?? ProjectCollection.GetToolset (this.ProjectCollection.DefaultToolsVersion);
+			foreach (var p in ProjectCollection.GetReservedProperties (tools, this))
+				this.properties.Add (p);
+			foreach (var p in ProjectCollection.GetWellKnownProperties (this))
+				this.properties.Add (p);
 
+			ProcessXml ();
+			
+			ProjectCollection.AddProject (this);
+		}
+		
+		void ProcessXml ()
+		{
+			// this needs to be initialized here (regardless of that items won't be evaluated at property evaluation;
+			// Conditions could incorrectly reference items and lack of this list causes NRE.
 			all_evaluated_items = new List<ProjectItem> ();
-			foreach (var child in Xml.Children) {
+
+			// property evaluation happens couple of times.
+			// At first step, all non-imported properties are evaluated TOO, WHILE those properties are being evaluated.
+			// This means, Include and IncludeGroup elements with Condition attribute MAY contain references to
+			// properties and they will be expanded.
+			var elements = EvaluatePropertiesAndImports (Xml.Children).ToArray (); // ToArray(): to not lazily evaluate elements.
+			
+			// next, evaluate items
+			EvaluateItems (elements);
+			
+			// finally, evaluate targets and tasks
+			EvaluateTargets (elements);
+		}
+		
+		IEnumerable<ProjectElement> EvaluatePropertiesAndImports (IEnumerable<ProjectElement> elements)
+		{
+			// First step: evaluate Properties
+			foreach (var child in elements) {
+				yield return child;
 				var pge = child as ProjectPropertyGroupElement;
-				if (pge != null)
+				if (pge != null && Evaluate (pge.Condition))
 					foreach (var p in pge.Properties)
-						this.properties.Add (new XmlProjectProperty (this, p, PropertyType.Normal));
+						// do not allow overwriting reserved or well-known properties by user
+						if (!this.properties.Any (_ => (_.IsReservedProperty || _.IsWellKnownProperty) && _.Name.Equals (p.Name, StringComparison.InvariantCultureIgnoreCase)))
+							if (Evaluate (p.Condition))
+								this.properties.Add (new XmlProjectProperty (this, p, PropertyType.Normal, ProjectCollection.OngoingImports.Any ()));
+
+				var ige = child as ProjectImportGroupElement;
+				if (ige != null && Evaluate (ige.Condition)) {
+					foreach (var incc in ige.Imports) {
+						if (Evaluate (incc.Condition))
+							foreach (var e in Import (incc))
+								yield return e;
+					}
+				}
+				var inc = child as ProjectImportElement;
+				if (inc != null && Evaluate (inc.Condition))
+					foreach (var e in Import (inc))
+						yield return e;
+			}
+		}
+		
+		internal IEnumerable<T> GetAllItems<T> (string include, string exclude, Func<string,T> creator, Func<string,ITaskItem> taskItemCreator, Func<string,bool> itemTypeCheck, Action<T,string> assignRecurse)
+		{
+			return ProjectCollection.GetAllItems<T> (ExpandString, include, exclude, creator, taskItemCreator, DirectoryPath, assignRecurse,
+				t => all_evaluated_items.Any (i => i.EvaluatedInclude == t.ItemSpec && itemTypeCheck (i.ItemType)));
+		}
+
+		void EvaluateItems (IEnumerable<ProjectElement> elements)
+		{
+			foreach (var child in elements) {
 				var ige = child as ProjectItemGroupElement;
 				if (ige != null) {
 					foreach (var p in ige.Items) {
-						var inc = ExpandString (p.Include);
-						foreach (var each in inc.Split (item_sep, StringSplitOptions.RemoveEmptyEntries)) {
-							var item = new ProjectItem (this, p, each);
-							this.raw_items.Add (item);
-							if (ShouldInclude (ige.Condition) && ShouldInclude (p.Condition))
-								all_evaluated_items.Add (item);
+						if (!Evaluate (ige.Condition) || !Evaluate (p.Condition))
+							continue;
+						Func<string,ProjectItem> creator = s => new ProjectItem (this, p, s);
+						foreach (var item in GetAllItems<ProjectItem> (p.Include, p.Exclude, creator, s => new ProjectTaskItem (p, s), it => string.Equals (it, p.ItemType, StringComparison.OrdinalIgnoreCase), (t, s) => t.RecursiveDir = s)) {
+							raw_items.Add (item);
+							all_evaluated_items.Add (item);
 						}
 					}
 				}
 				var def = child as ProjectItemDefinitionGroupElement;
 				if (def != null) {
 					foreach (var p in def.ItemDefinitions) {
-						if (ShouldInclude (p.Condition)) {
+						if (Evaluate (p.Condition)) {
 							ProjectItemDefinition existing;
 							if (!item_definitions.TryGetValue (p.ItemType, out existing))
 								item_definitions.Add (p.ItemType, (existing = new ProjectItemDefinition (this, p.ItemType)));
@@ -203,6 +286,40 @@ namespace Microsoft.Build.Evaluation
 			}
 			all_evaluated_items.Sort ((p1, p2) => string.Compare (p1.ItemType, p2.ItemType, StringComparison.OrdinalIgnoreCase));
 		}
+		
+		void EvaluateTargets (IEnumerable<ProjectElement> elements)
+		{
+			foreach (var child in elements) {
+				var te = child as ProjectTargetElement;
+				if (te != null)
+					// It overwrites same name target.
+					this.targets [te.Name] = new ProjectTargetInstance (te);
+			}
+		}
+		
+		IEnumerable<ProjectElement> Import (ProjectImportElement import)
+		{
+			string dir = ProjectCollection.GetEvaluationTimeThisFileDirectory (() => FullPath);
+			string path = WindowsCompatibilityExtensions.FindMatchingPath (ExpandString (import.Project));
+			path = Path.IsPathRooted (path) ? path : dir != null ? Path.Combine (dir, path) : Path.GetFullPath (path);
+			if (ProjectCollection.OngoingImports.Contains (path)) {
+				switch (load_settings) {
+				case ProjectLoadSettings.RejectCircularImports:
+					throw new InvalidProjectFileException (import.Location, null, string.Format ("Circular imports was detected: {0} (resolved as \"{1}\") is already on \"importing\" stack", import.Project, path));
+				}
+				return new ProjectElement [0]; // do not import circular references
+			}
+			ProjectCollection.OngoingImports.Push (path);
+			try {
+				using (var reader = XmlReader.Create (path)) {
+					var root = ProjectRootElement.Create (reader, ProjectCollection);
+					raw_imports.Add (new ResolvedImport (import, root, true));
+					return this.EvaluatePropertiesAndImports (root.Children).ToArray ();
+				}
+			} finally {
+				ProjectCollection.OngoingImports.Pop ();
+			}
+		}
 
 		public ICollection<ProjectItem> GetItemsIgnoringCondition (string itemType)
 		{
@@ -245,15 +362,17 @@ namespace Microsoft.Build.Evaluation
 		{
 			throw new NotImplementedException ();
 		}
+		
+		static readonly char [] target_sep = new char[] {';'};
 
 		public bool Build ()
 		{
-			return Build (Xml.DefaultTargets.Split (';'));
+			return Build (Xml.DefaultTargets.Split (target_sep, StringSplitOptions.RemoveEmptyEntries));
 		}
 
 		public bool Build (IEnumerable<ILogger> loggers)
 		{
-			return Build (Xml.DefaultTargets.Split (';'), loggers);
+			return Build (Xml.DefaultTargets.Split (target_sep, StringSplitOptions.RemoveEmptyEntries), loggers);
 		}
 
 		public bool Build (string target)
@@ -268,7 +387,7 @@ namespace Microsoft.Build.Evaluation
 
 		public bool Build (ILogger logger)
 		{
-			return Build (Xml.DefaultTargets.Split (';'), new ILogger [] {logger});
+			return Build (Xml.DefaultTargets.Split (target_sep, StringSplitOptions.RemoveEmptyEntries), new ILogger [] {logger});
 		}
 
 		public bool Build (string[] targets, IEnumerable<ILogger> loggers)
@@ -278,7 +397,7 @@ namespace Microsoft.Build.Evaluation
 
 		public bool Build (IEnumerable<ILogger> loggers, IEnumerable<ForwardingLoggerRecord> remoteLoggers)
 		{
-			return Build (Xml.DefaultTargets.Split (';'), loggers, remoteLoggers);
+			return Build (Xml.DefaultTargets.Split (target_sep, StringSplitOptions.RemoveEmptyEntries), loggers, remoteLoggers);
 		}
 
 		public bool Build (string target, IEnumerable<ILogger> loggers)
@@ -307,14 +426,14 @@ namespace Microsoft.Build.Evaluation
 			return ret;
 		}
 		
-		bool ShouldInclude (string unexpandedValue)
+		bool Evaluate (string unexpandedValue)
 		{
 			return string.IsNullOrWhiteSpace (unexpandedValue) || new ExpressionEvaluator (this).EvaluateAsBoolean (unexpandedValue);
 		}
 
 		public string ExpandString (string unexpandedValue)
 		{
-			return new ExpressionEvaluator (this).Evaluate (unexpandedValue);
+			return WindowsCompatibilityExtensions.NormalizeFilePath (new ExpressionEvaluator (this).Evaluate (unexpandedValue));
 		}
 
 		public static string GetEvaluatedItemIncludeEscaped (ProjectItem item)
@@ -324,6 +443,7 @@ namespace Microsoft.Build.Evaluation
 
 		public static string GetEvaluatedItemIncludeEscaped (ProjectItemDefinition item)
 		{
+			// ?? ItemDefinition does not have Include attribute. What's the point here?
 			throw new NotImplementedException ();
 		}
 
@@ -349,13 +469,13 @@ namespace Microsoft.Build.Evaluation
 
 		public static string GetMetadataValueEscaped (ProjectItem item, string name)
 		{
-			var md = item.GetMetadata (name);
+			var md = item.Metadata.FirstOrDefault (m => m.Name.Equals (name, StringComparison.OrdinalIgnoreCase));
 			return md != null ? ProjectCollection.Escape (md.EvaluatedValue) : null;
 		}
 
 		public static string GetMetadataValueEscaped (ProjectItemDefinition item, string name)
 		{
-			var md = item.Metadata.FirstOrDefault (m => m.Name == name);
+			var md = item.Metadata.FirstOrDefault (m => m.Name.Equals (name, StringComparison.OrdinalIgnoreCase));
 			return md != null ? ProjectCollection.Escape (md.EvaluatedValue) : null;
 		}
 
@@ -367,6 +487,8 @@ namespace Microsoft.Build.Evaluation
 
 		public static string GetPropertyValueEscaped (ProjectProperty property)
 		{
+			// WTF happens here.
+			//return ProjectCollection.Escape (property.EvaluatedValue);
 			return property.EvaluatedValue;
 		}
 
@@ -398,7 +520,7 @@ namespace Microsoft.Build.Evaluation
 
 		public bool RemoveProperty (ProjectProperty property)
 		{
-			var removed = properties.FirstOrDefault (p => p.Name == property.Name);
+			var removed = properties.FirstOrDefault (p => p.Name.Equals (property.Name, StringComparison.OrdinalIgnoreCase));
 			if (removed == null)
 				return false;
 			properties.Remove (removed);
@@ -457,7 +579,7 @@ namespace Microsoft.Build.Evaluation
 		}
 
 		public ICollection<ProjectProperty> AllEvaluatedProperties {
-			get { throw new NotImplementedException (); }
+			get { return properties; }
 		}
 
 		public IDictionary<string, List<string>> ConditionedProperties {
@@ -485,9 +607,23 @@ namespace Microsoft.Build.Evaluation
 			get { return Xml.FullPath; }
 			set { Xml.FullPath = value; }
 		}
+		
+		class ResolvedImportComparer : IEqualityComparer<ResolvedImport>
+		{
+			public static ResolvedImportComparer Instance = new ResolvedImportComparer ();
+			
+			public bool Equals (ResolvedImport x, ResolvedImport y)
+			{
+				return x.ImportedProject.FullPath.Equals (y.ImportedProject.FullPath);
+			}
+			public int GetHashCode (ResolvedImport obj)
+			{
+				return obj.ImportedProject.FullPath.GetHashCode ();
+			}
+		}
 
 		public IList<ResolvedImport> Imports {
-			get { throw new NotImplementedException (); }
+			get { return raw_imports.Distinct (ResolvedImportComparer.Instance).ToList (); }
 		}
 
 		public IList<ResolvedImport> ImportsIncludingDuplicates {
@@ -520,8 +656,9 @@ namespace Microsoft.Build.Evaluation
 			get { return new CollectionFromEnumerable<string> (raw_items.Select (i => i.ItemType).Distinct ()); }
 		}
 
+		[MonoTODO ("should be different from AllEvaluatedProperties")]
 		public ICollection<ProjectProperty> Properties {
-			get { return properties; }
+			get { return AllEvaluatedProperties; }
 		}
 
 		public bool SkipEvaluation { get; set; }
@@ -534,5 +671,26 @@ namespace Microsoft.Build.Evaluation
 		IDictionary<string, ProjectTargetInstance> Targets {
 			get { return targets; }
 		}
+		
+		// These are required for reserved property, represents dynamically changing property values.
+		// This should resolve to either the project file path or that of the imported file.
+		internal string GetEvaluationTimeThisFileDirectory ()
+		{
+			var file = GetEvaluationTimeThisFile ();
+			var dir = Path.IsPathRooted (file) ? Path.GetDirectoryName (file) : Directory.GetCurrentDirectory ();
+			return dir + Path.DirectorySeparatorChar;
+		}
+
+		internal string GetEvaluationTimeThisFile ()
+		{
+			return ProjectCollection.OngoingImports.Count > 0 ? ProjectCollection.OngoingImports.Peek () : FullPath ?? string.Empty;
+		}
+		
+		internal string GetFullPath (string pathRelativeToProject)
+		{
+			if (Path.IsPathRooted (pathRelativeToProject))
+				return pathRelativeToProject;
+			return Path.GetFullPath (Path.Combine (DirectoryPath, pathRelativeToProject));
+		}
 	}
 }