NaCl settings and completed install scripts.

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

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+using Microsoft.Build.Framework;
+using System.Xaml;
+using Microsoft.Build.Framework.XamlTypes;
+using Microsoft.Build.Utilities;
+
+namespace NaCl.Build.CPPTasks
+{
+    class XamlParser
+    {
+        public XamlParser(string path)
+        {
+            // load and store properties from xaml file
+            m_parsedBuildRule = (Rule)XamlServices.Load(path);
+
+            // NOTE: 
+            // There are MSBuild classes which support command line building, 
+            // argument switch encapsulation and more.  Code within VCToolTask, 
+            // a hidden interface, uses some these classes to generate command line 
+            // switches given project settings. As the VCToolTask class is a hidden 
+            // class and the MSBuild documentation is very sparse, we are going 
+            // with a small custom solution.  For reference see the 
+            // Microsoft.Build.Tasks.Xaml, Microsoft.Build.Framework.XamlTypes namespaces.
+
+            // move the properties to a property name keyed dictionary for faster lookup
+            ToolProperties = new Dictionary<string, PropertyWrapper>();
+            ToolProperties = m_parsedBuildRule.Properties.ToDictionary(x => x.Name, x => (new PropertyWrapper(x.GetType(), x)));
+
+            InitFunctionMap();
+        }
+
+        private void InitFunctionMap()
+        {
+            m_typeFunctionMap = new Dictionary<Type, Action<CommandLineBuilder, BaseProperty, string>>
+            {
+                { typeof(StringListProperty), GenerateArgumentStringList },
+                { typeof(StringProperty), GenerateArgumentString },
+                { typeof(IntProperty), GenerateArgumentString },
+                { typeof(BoolProperty), GenerateArgumentBool },
+                { typeof(EnumProperty), GenerateArgumentEnum }
+            };
+        }
+
+        public string Parse(ITaskItem taskItem)
+        {
+            CommandLineBuilder builder = new CommandLineBuilder();
+
+            foreach (string name in taskItem.MetadataNames)
+            {
+                string value = taskItem.GetMetadata(name);
+                AppendArgumentForProperty(builder, name, value);
+            }
+
+            string result = builder.ToString();
+            result = result.Replace('\\', '/'); // posix paths
+            return result;
+        }
+
+        private string AppendArgumentForProperty(CommandLineBuilder builder, string name, string value)
+        {
+            PropertyWrapper current;
+            ToolProperties.TryGetValue(name, out current);
+            if (current != null && value.Length > 0)
+            {
+                // call appropriate function for type
+                m_typeFunctionMap[current.PropertyType](builder, current.Property, value);
+            }
+            return string.Empty;
+        }
+
+        private void GenerateArgumentEnum(CommandLineBuilder builder, BaseProperty property, string value)
+        {
+            var result = ((EnumProperty)property).AdmissibleValues.Find(x => (x.Name == value));
+            if (result != null)
+            {
+                builder.AppendSwitchUnquotedIfNotNull(m_parsedBuildRule.SwitchPrefix, result.Switch);
+            }
+        }
+
+        // helper for string-based properties
+        private void AppendStringValue(CommandLineBuilder builder, BaseProperty property, string subtype, string value)
+        {
+            value = value.Trim();
+
+            // could cache this SubType test off in property wrapper or somewhere if performance were an issue
+            if (subtype == "file" || subtype == "folder")
+            {
+                builder.AppendSwitchIfNotNull(m_parsedBuildRule.SwitchPrefix + property.Switch + property.Separator, value);
+            }
+            else
+            {
+                builder.AppendSwitchUnquotedIfNotNull(m_parsedBuildRule.SwitchPrefix + property.Switch + property.Separator, value);
+            }
+        }
+
+        private void GenerateArgumentStringList(CommandLineBuilder builder, BaseProperty property, string value)
+        {
+                        string [] arguments = value.Split(';');
+
+            foreach (string argument in arguments)
+            {
+                if (argument.Length > 0)
+                {
+                    StringListProperty casted = (StringListProperty)property;
+                    AppendStringValue(builder, property, casted.Subtype, argument);
+                }
+            }
+        }
+
+        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 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);
+            }
+        }
+
+        // to store off MSBuild property type and allow faster searching on them
+        private class PropertyWrapper
+        {
+            public PropertyWrapper(Type newType, BaseProperty newProperty)
+            {
+                PropertyType = newType;
+                Property = newProperty;
+            }
+            public Type PropertyType { get; set; }
+            public BaseProperty Property { get; set; }
+        } // 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
+