Merge branch 'BigIntegerParse'

[mono.git] / mcs / class / Microsoft.Build.Utilities / Microsoft.Build.Utilities / TaskItem.cs

diff --git a/mcs/class/Microsoft.Build.Utilities/Microsoft.Build.Utilities/TaskItem.cs b/mcs/class/Microsoft.Build.Utilities/Microsoft.Build.Utilities/TaskItem.cs
index a5eab1571e46d256d80ded6ea478d6a8e9304b31..0928d929335a78ef2d7a4319e3c24b847dcf729e 100644 (file)
--- a/mcs/class/Microsoft.Build.Utilities/Microsoft.Build.Utilities/TaskItem.cs
+++ b/mcs/class/Microsoft.Build.Utilities/Microsoft.Build.Utilities/TaskItem.cs
@@ -36,24 +36,41 @@ using Mono.XBuild.Utilities;
 
 namespace Microsoft.Build.Utilities
 {
-       public sealed class TaskItem : MarshalByRefObject, ITaskItem
+#if !MICROSOFT_BUILD_DLL
+       public
+#endif
+       sealed class TaskItem : MarshalByRefObject, ITaskItem
+#if NET_4_0
+               , ITaskItem2
+#endif
        {
-               IDictionary             metadata;
-               string                  itemSpec;
+               IDictionary             escapedMetadata;
+               string                  escapedItemSpec;
 
                public TaskItem ()
                {
-                       this.itemSpec = String.Empty;
-                       this.metadata = CollectionsUtil.CreateCaseInsensitiveHashtable ();
+                       this.escapedItemSpec = String.Empty;
+                       this.escapedMetadata = CollectionsUtil.CreateCaseInsensitiveHashtable ();
                }
 
                public TaskItem (ITaskItem sourceItem)
                {
                        if (sourceItem == null)
                                throw new ArgumentNullException ("sourceItem");
-                       
-                       this.itemSpec = sourceItem.ItemSpec;
-                       this.metadata = sourceItem.CloneCustomMetadata ();
+
+#if NET_4_0
+                       var ti2 = sourceItem as ITaskItem2;
+                       if (ti2 != null) {
+                               escapedItemSpec = ti2.EvaluatedIncludeEscaped;
+                               escapedMetadata = ti2.CloneCustomMetadataEscaped ();
+                       } else
+#endif
+                       {
+                               escapedItemSpec = MSBuildUtils.Escape (sourceItem.ItemSpec);
+                               escapedMetadata = sourceItem.CloneCustomMetadata ();
+                               foreach (string key in new ArrayList (escapedMetadata.Keys))
+                                       escapedMetadata [key] = MSBuildUtils.Escape ((string)escapedMetadata [key]);
+                       }
                }
 
                public TaskItem (string itemSpec)
@@ -61,8 +78,8 @@ namespace Microsoft.Build.Utilities
                        if (itemSpec == null)
                                throw new ArgumentNullException ("itemSpec");
                        
-                       this.ItemSpec = itemSpec;
-                       this.metadata = CollectionsUtil.CreateCaseInsensitiveHashtable ();
+                       escapedItemSpec = itemSpec;
+                       escapedMetadata = CollectionsUtil.CreateCaseInsensitiveHashtable ();
                }
 
                public TaskItem (string itemSpec, IDictionary itemMetadata)
@@ -73,23 +90,35 @@ namespace Microsoft.Build.Utilities
                        if (itemMetadata == null)
                                throw new ArgumentNullException ("itemMetadata");
                        
-                       this.itemSpec = itemSpec;
-                       this.metadata = CollectionsUtil.CreateCaseInsensitiveHashtable (itemMetadata);
+                       escapedItemSpec = itemSpec;
+                       escapedMetadata = CollectionsUtil.CreateCaseInsensitiveHashtable (itemMetadata);
                }
 
                public IDictionary CloneCustomMetadata ()
                {
                        IDictionary clonedMetadata = CollectionsUtil.CreateCaseInsensitiveHashtable ();
-                       foreach (DictionaryEntry de in metadata)
-                               clonedMetadata.Add (de.Key, de.Value);
+                       foreach (DictionaryEntry de in escapedMetadata)
+                               clonedMetadata.Add (de.Key, MSBuildUtils.Unescape ((string) de.Value));
                        return clonedMetadata;
                }
 
+               IDictionary CloneCustomMetadataEscaped ()
+               {
+                       return CollectionsUtil.CreateCaseInsensitiveHashtable (escapedMetadata);
+               }
+
+#if NET_4_0
+               IDictionary ITaskItem2.CloneCustomMetadataEscaped ()
+               {
+                       return CloneCustomMetadataEscaped ();
+               }
+#endif
+
                public void CopyMetadataTo (ITaskItem destinationItem)
                {
-                       foreach (DictionaryEntry e in metadata) {
+                       foreach (DictionaryEntry e in escapedMetadata) {
                                if (destinationItem.GetMetadata ((string)e.Key) == String.Empty) {
-                                       destinationItem.SetMetadata ((string)e.Key, (string)e.Value);
+                                       destinationItem.SetMetadata ((string)e.Key, MSBuildUtils.Unescape ((string)e.Value));
                                }
                        }
                }
@@ -100,15 +129,24 @@ namespace Microsoft.Build.Utilities
                }
 
                public string GetMetadata (string metadataName)
+               {
+                       return MSBuildUtils.Unescape (GetMetadataValue (metadataName));
+               }
+
+               string GetMetadataValue (string metadataName)
                {
                        if (ReservedNameUtils.IsReservedMetadataName (metadataName))
-                               return ReservedNameUtils.GetReservedMetadata (ItemSpec, metadataName);
-                       else if (metadata.Contains (metadataName))
-                               return (string) metadata [metadataName];
-                       else
-                               return String.Empty;
+                               return ReservedNameUtils.GetReservedMetadata (ItemSpec, metadataName, escapedMetadata);
+                       return ((string) escapedMetadata [metadataName]) ?? String.Empty;
                }
 
+#if NET_4_0
+               string ITaskItem2.GetMetadataValueEscaped (string metadataName)
+               {
+                       return GetMetadataValue (metadataName);
+               }
+#endif
+
                public override object InitializeLifetimeService ()
                {
                        return null;
@@ -120,8 +158,7 @@ namespace Microsoft.Build.Utilities
                                throw new ArgumentNullException ("metadataName");
                        if (ReservedNameUtils.IsReservedMetadataName (metadataName))
                                throw new ArgumentException ("Can't remove reserved metadata");
-                       if (metadata.Contains (metadataName))
-                               metadata.Remove (metadataName);
+                       escapedMetadata.Remove (metadataName);
                }
 
                public void SetMetadata (string metadataName, string metadataValue)
@@ -130,26 +167,40 @@ namespace Microsoft.Build.Utilities
                                throw new ArgumentNullException ("metadataName");
                        if (metadataValue == null)
                                throw new ArgumentNullException ("metadataValue");
-                       if (ReservedNameUtils.IsReservedMetadataName (metadataName))
+
+                       // allow RecursiveDir to be set, it gets set by DirectoryScanner
+                       if (String.Compare (metadataName, "RecursiveDir", StringComparison.InvariantCultureIgnoreCase) != 0 &&
+                               ReservedNameUtils.IsReservedMetadataName (metadataName))
                                throw new ArgumentException ("Can't modify reserved metadata");
                                
-                       if (metadata.Contains (metadataName))
-                               metadata.Remove (metadataName);
-                       metadata.Add (metadataName, metadataValue);
+                       escapedMetadata [metadataName] = metadataValue;
                }
 
+#if NET_4_0
+               void ITaskItem2.SetMetadataValueLiteral (string metadataName, string metadataValue)
+               {
+                       SetMetadata (metadataName, MSBuildUtils.Escape (metadataValue));
+               }
+#endif
                public override string ToString ()
                {
-                       return itemSpec;
+                       return escapedItemSpec;
                }
                
                public string ItemSpec {
-                       get { return itemSpec; }
-                       set { itemSpec = value; }
+                       get { return MSBuildUtils.Unescape (escapedItemSpec); }
+                       set { escapedItemSpec = value; }
                }
 
+#if NET_4_0
+               string ITaskItem2.EvaluatedIncludeEscaped {
+                       get { return escapedItemSpec; }
+                       set { escapedItemSpec = value; }
+               }
+#endif
+
                public int MetadataCount {
-                       get { return metadata.Count + 11; }
+                       get { return escapedMetadata.Count + 11; }
                }
 
                public ICollection MetadataNames {
@@ -158,12 +209,13 @@ namespace Microsoft.Build.Utilities
                                
                                foreach (string s in ReservedNameUtils.ReservedMetadataNames)
                                        list.Add (s);
-                               foreach (string s in metadata.Keys)
+                               foreach (string s in escapedMetadata.Keys)
                                        list.Add (s);
 
                                return list;
                        }
                }
+
        }
 }