Implement multi-core builds in MSVS

visual_studio/NativeClientVSAddIn/NaCl.Build.CPPTasks/XamlParser.cs

 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
+using System.IO;
 
 using Microsoft.Build.Framework;
 using System.Xaml;
 using Microsoft.Build.Framework.XamlTypes;
 using Microsoft.Build.Utilities;
 
 namespace NaCl.Build.CPPTasks
 {
     class XamlParser
     {
@@ skipping 17 matching lines @@
 
             InitFunctionMap();
         }
 
         private void InitFunctionMap()
         {
             m_typeFunctionMap = new Dictionary<Type, Action<CommandLineBuilder, BaseProperty, string>>
             {
                 { typeof(StringListProperty), GenerateArgumentStringList },
                 { typeof(StringProperty), GenerateArgumentString },
-                { typeof(IntProperty), GenerateArgumentString },
+                { typeof(IntProperty), GenerateArgumentInt },
                 { typeof(BoolProperty), GenerateArgumentBool },
                 { typeof(EnumProperty), GenerateArgumentEnum }
             };
         }
 
-        public string Parse(ITaskItem taskItem)
+        public string Parse(ITaskItem taskItem, bool fullOutputName)
         {
             CommandLineBuilder builder = new CommandLineBuilder();
 
             foreach (string name in taskItem.MetadataNames)
             {
                 string value = taskItem.GetMetadata(name);
+                if (fullOutputName && name == "ObjectFileName")
+                {
+                    if ((File.GetAttributes(value) & FileAttributes.Directory) != 0)
+                    {
+                        value = Path.Combine(value, Path.GetFileName(taskItem.ItemSpec));
+                        value = Path.ChangeExtension(value, ".obj");
+                    }
+                }
                 AppendArgumentForProperty(builder, name, value);
             }
 
             string result = builder.ToString();
             result = result.Replace('\\', '/'); // posix paths
             return result;
         }
 
         private string AppendArgumentForProperty(CommandLineBuilder builder, string name, string value)
         {
@@ skipping 54 matching lines @@
             }
         }
 
         private void GenerateArgumentString(CommandLineBuilder builder, BaseProperty property, string value)
         {
             // could cache this SubType test off in property wrapper or somewhere if performance were an issue
             StringProperty casted = (StringProperty)property;
             AppendStringValue(builder, property, casted.Subtype, value);
         }
 
+        private void GenerateArgumentInt(CommandLineBuilder builder, BaseProperty property, string value)
+        {
+            // Currently we only have one Int property and it doesn't correspond to a
+            // command line arguemnt (ProcessorNumber) so we ignore it here.
+        }
+
         private void GenerateArgumentBool(CommandLineBuilder builder, BaseProperty property, string value)
         {
             if (value == "true")
             {
                 builder.AppendSwitchUnquotedIfNotNull(m_parsedBuildRule.SwitchPrefix, property.Switch);
             }
             else if (value == "false" && ((BoolProperty)property).ReverseSwitch != null)
             {
                 builder.AppendSwitchUnquotedIfNotNull(m_parsedBuildRule.SwitchPrefix, ((BoolProperty)property).ReverseSwitch);
             }
@@ skipping 12 matching lines @@
         } // class
 
         private Rule m_parsedBuildRule;
         private Dictionary<string, PropertyWrapper> ToolProperties { get; set; }
 
         // function mapping for easy property function calling
         private Dictionary<Type, Action<CommandLineBuilder, BaseProperty, string>> m_typeFunctionMap;
     } // XamlParser
 } // namespace NaCl.Build.CPPTasks