/// <summary>
/// Reads in the nodes of the xml file one by one and builds the data structure of all existing properties
/// </summary>
private bool ParseParameterGroupOrParameter(XamlTypes.BaseProperty baseProperty, LinkedList <Property> propertyList, Property property, Dictionary <string, Property> argumentDependencyLookup)
{
// node is a property
if (!ParseParameter(baseProperty, propertyList, property, argumentDependencyLookup))
{
return(false);
}
return(true);
}
public PropertyWrapper(Type newType, BaseProperty newProperty)
{
PropertyType = newType;
Property = newProperty;
}
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);
}
}
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 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 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 bool ParseParameterGroupOrParameter(BaseProperty baseProperty, LinkedList<Property> propertyList, Property property)
{
if (!this.ParseParameter(baseProperty, propertyList, property))
{
return false;
}
return true;
}
/// <summary>
/// Fills in the property data structure
/// </summary>
private bool ParseParameter(XamlTypes.BaseProperty baseProperty, LinkedList <Property> propertyList, Property property, Dictionary <string, Property> argumentDependencyLookup)
{
Property propertyToAdd = ObtainAttributes(baseProperty, property);
if (String.IsNullOrEmpty(propertyToAdd.Name))
{
propertyToAdd.Name = "AlwaysAppend";
}
// generate the list of parameters in order
if (!_switchOrderList.Contains(propertyToAdd.Name))
{
_switchOrderList.Add(propertyToAdd.Name);
}
else
{
throw new XamlParseException(ResourceUtilities.FormatResourceStringIgnoreCodeAndKeyword("Xaml.DuplicatePropertyName", propertyToAdd.Name));
}
// Inherit the Prefix from the Tool
if (String.IsNullOrEmpty(propertyToAdd.Prefix))
{
propertyToAdd.Prefix = DefaultPrefix;
}
// If the property is an enum type, parse that.
XamlTypes.EnumProperty enumProperty = baseProperty as XamlTypes.EnumProperty;
if (enumProperty != null)
{
foreach (XamlTypes.EnumValue enumValue in enumProperty.AdmissibleValues)
{
var value = new Value
{
Name = enumValue.Name,
SwitchName = enumValue.Switch
};
if (value.SwitchName == null)
{
value.SwitchName = String.Empty;
}
value.DisplayName = enumValue.DisplayName;
value.Description = enumValue.Description;
value.Prefix = enumValue.SwitchPrefix;
if (String.IsNullOrEmpty(value.Prefix))
{
value.Prefix = enumProperty.SwitchPrefix;
}
if (String.IsNullOrEmpty(value.Prefix))
{
value.Prefix = DefaultPrefix;
}
if (enumValue.Arguments.Count > 0)
{
value.Arguments = new List <Argument>();
foreach (XamlTypes.Argument argument in enumValue.Arguments)
{
var arg = new Argument
{
Parameter = argument.Property,
Separator = argument.Separator,
Required = argument.IsRequired
};
value.Arguments.Add(arg);
}
}
if (value.Prefix == null)
{
value.Prefix = propertyToAdd.Prefix;
}
propertyToAdd.Values.Add(value);
}
}
// build the dependencies and the values for a parameter
foreach (XamlTypes.Argument argument in baseProperty.Arguments)
{
// To refactor into a separate func
if (propertyToAdd.Arguments == null)
{
propertyToAdd.Arguments = new List <Argument>();
}
var arg = new Argument
{
Parameter = argument.Property,
Separator = argument.Separator,
Required = argument.IsRequired
};
propertyToAdd.Arguments.Add(arg);
}
if (argumentDependencyLookup != null && !argumentDependencyLookup.ContainsKey(propertyToAdd.Name))
{
argumentDependencyLookup.Add(propertyToAdd.Name, propertyToAdd);
}
// We've read any enumerated values and any dependencies, so we just
// have to add the property
propertyList.AddLast(propertyToAdd);
return(true);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
private void GenerateArgumentString (CommandLineBuilder builder, BaseProperty property, string value)
{
StringProperty casted = (StringProperty)property;
AppendStringValue (builder, property, casted.Subtype, value.Trim (new char [] { ' ', '\"' }));
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
private void GenerateArgumentStringList (CommandLineBuilder builder, BaseProperty property, string value)
{
string [] arguments = value.Split (new char [] { ';' }, StringSplitOptions.RemoveEmptyEntries);
if (arguments.Length > 0)
{
StringListProperty casted = (StringListProperty)property;
if (casted.CommandLineValueSeparator != null)
{
List<string> sanitised = new List<string> ();
foreach (string argument in arguments)
{
if (argument.Length > 0)
{
sanitised.Add (argument.Trim (new char [] { ' ', '\"' }));
}
}
if (sanitised.Count > 0)
{
AppendStringListValue (builder, property, casted.Subtype, sanitised.ToArray (), casted.CommandLineValueSeparator);
}
}
else
{
foreach (string argument in arguments)
{
if (argument.Length > 0)
{
AppendStringValue (builder, property, casted.Subtype, argument.Trim (new char [] { ' ', '\"' }));
}
}
}
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
private void AppendIntValue (CommandLineBuilder builder, BaseProperty property, string value)
{
value = value.Trim ();
string switchName = m_parsedBuildRule.SwitchPrefix + property.Switch;
switchName += property.Separator;
builder.AppendSwitchUnquotedIfNotNull (switchName, value);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
private void AppendStringListValue (CommandLineBuilder builder, BaseProperty property, string subtype, string [] value, string delimiter)
{
string switchName = m_parsedBuildRule.SwitchPrefix + property.Switch;
switchName += property.Separator;
if (subtype == "file" || subtype == "folder")
{
builder.AppendSwitchUnquotedIfNotNull (switchName, value, delimiter);
}
else if (!string.IsNullOrEmpty (property.Switch))
{
builder.AppendSwitchUnquotedIfNotNull (switchName, value, delimiter);
}
else if (value.Length > 0)
{
foreach (string entry in value)
{
builder.AppendTextUnquoted (entry + delimiter);
}
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
private void AppendStringValue (CommandLineBuilder builder, BaseProperty property, string subtype, string value)
{
string switchName = property.SwitchPrefix;
if (string.IsNullOrEmpty (property.SwitchPrefix))
{
switchName = m_parsedBuildRule.SwitchPrefix;
}
switchName += property.Switch + property.Separator;
if (subtype == "file" || subtype == "folder")
{
if (!string.IsNullOrWhiteSpace (switchName))
{
builder.AppendSwitchIfNotNull (switchName, value);
}
else
{
builder.AppendTextUnquoted (" " + PathUtils.QuoteIfNeeded (value));
}
}
else if (!string.IsNullOrEmpty (property.Switch))
{
builder.AppendSwitchUnquotedIfNotNull (switchName, value);
}
else if (!string.IsNullOrEmpty (value))
{
builder.AppendTextUnquoted (" " + value);
}
}
private Property ObtainAttributes(BaseProperty baseProperty, Property parameterGroup)
{
Property property;
if (parameterGroup != null)
{
property = parameterGroup.Clone();
}
else
{
property = new Property();
}
BoolProperty property2 = baseProperty as BoolProperty;
DynamicEnumProperty property3 = baseProperty as DynamicEnumProperty;
EnumProperty property4 = baseProperty as EnumProperty;
IntProperty property5 = baseProperty as IntProperty;
StringProperty property6 = baseProperty as StringProperty;
StringListProperty property7 = baseProperty as StringListProperty;
if (baseProperty.Name != null)
{
property.Name = baseProperty.Name;
}
if ((property2 != null) && !string.IsNullOrEmpty(property2.ReverseSwitch))
{
property.Reversible = "true";
}
if (property2 != null)
{
property.Type = PropertyType.Boolean;
}
else if (property4 != null)
{
property.Type = PropertyType.String;
}
else if (property3 != null)
{
property.Type = PropertyType.String;
}
else if (property5 != null)
{
property.Type = PropertyType.Integer;
}
else if (property6 != null)
{
property.Type = PropertyType.String;
}
else if (property7 != null)
{
property.Type = PropertyType.StringArray;
}
if (((baseProperty.DataSource != null) && !string.IsNullOrEmpty(baseProperty.DataSource.SourceType)) && baseProperty.DataSource.SourceType.Equals("Item", StringComparison.OrdinalIgnoreCase))
{
property.Type = PropertyType.ItemArray;
}
if (property5 != null)
{
property.Max = property5.MaxValue.HasValue ? property5.MaxValue.ToString() : null;
property.Min = property5.MinValue.HasValue ? property5.MinValue.ToString() : null;
}
if (property2 != null)
{
property.ReverseSwitchName = property2.ReverseSwitch;
}
if (baseProperty.Switch != null)
{
property.SwitchName = baseProperty.Switch;
}
if (property7 != null)
{
property.Separator = property7.Separator;
}
if (baseProperty.Default != null)
{
property.DefaultValue = baseProperty.Default;
}
property.Required = baseProperty.IsRequired.ToString().ToLower(CultureInfo.InvariantCulture);
if (baseProperty.Category != null)
{
property.Category = baseProperty.Category;
}
if (baseProperty.DisplayName != null)
{
property.DisplayName = baseProperty.DisplayName;
}
if (baseProperty.Description != null)
{
property.Description = baseProperty.Description;
}
if (baseProperty.SwitchPrefix != null)
{
property.Prefix = baseProperty.SwitchPrefix;
}
return property;
}
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);
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
private void GenerateArgumentInt (CommandLineBuilder builder, BaseProperty property, string value)
{
AppendIntValue (builder, property, value);
}
// 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
string switchName = m_parsedBuildRule.SwitchPrefix + property.Switch;
switchName += property.Separator;
if (subtype == "file" || subtype == "folder")
{
// for switches that contains files or folders we need quoting
builder.AppendSwitchIfNotNull(switchName, value);
}
else if (!string.IsNullOrEmpty(property.Switch))
{
builder.AppendSwitchUnquotedIfNotNull(switchName, value);
}
else if (!string.IsNullOrEmpty(value))
{
// for non-switches such as AdditionalOptions we just append the value
builder.AppendTextUnquoted(" " + value);
}
}
/// <summary>
/// Gets all the attributes assigned in the xml file for this parameter or all of the nested switches for
/// this parameter group
/// </summary>
private static Property ObtainAttributes(XamlTypes.BaseProperty baseProperty, Property parameterGroup)
{
Property parameter;
if (parameterGroup != null)
{
parameter = parameterGroup.Clone();
}
else
{
parameter = new Property();
}
XamlTypes.BoolProperty boolProperty = baseProperty as XamlTypes.BoolProperty;
XamlTypes.DynamicEnumProperty dynamicEnumProperty = baseProperty as XamlTypes.DynamicEnumProperty;
XamlTypes.EnumProperty enumProperty = baseProperty as XamlTypes.EnumProperty;
XamlTypes.IntProperty intProperty = baseProperty as XamlTypes.IntProperty;
XamlTypes.StringProperty stringProperty = baseProperty as XamlTypes.StringProperty;
XamlTypes.StringListProperty stringListProperty = baseProperty as XamlTypes.StringListProperty;
parameter.IncludeInCommandLine = baseProperty.IncludeInCommandLine;
if (baseProperty.Name != null)
{
parameter.Name = baseProperty.Name;
}
if (boolProperty != null && !String.IsNullOrEmpty(boolProperty.ReverseSwitch))
{
parameter.Reversible = "true";
}
// Determine the type for this property.
if (boolProperty != null)
{
parameter.Type = PropertyType.Boolean;
}
else if (enumProperty != null)
{
parameter.Type = PropertyType.String;
}
else if (dynamicEnumProperty != null)
{
parameter.Type = PropertyType.String;
}
else if (intProperty != null)
{
parameter.Type = PropertyType.Integer;
}
else if (stringProperty != null)
{
parameter.Type = PropertyType.String;
}
else if (stringListProperty != null)
{
parameter.Type = PropertyType.StringArray;
}
// We might need to override this type based on the data source, if it specifies a source type of 'Item'.
if (baseProperty.DataSource != null)
{
if (!String.IsNullOrEmpty(baseProperty.DataSource.SourceType))
{
if (baseProperty.DataSource.SourceType.Equals("Item", StringComparison.OrdinalIgnoreCase))
{
parameter.Type = PropertyType.ItemArray;
}
}
}
if (intProperty != null)
{
parameter.Max = intProperty.MaxValue != null?intProperty.MaxValue.ToString() : null;
parameter.Min = intProperty.MinValue != null?intProperty.MinValue.ToString() : null;
}
if (boolProperty != null)
{
parameter.ReverseSwitchName = boolProperty.ReverseSwitch;
}
if (baseProperty.Switch != null)
{
parameter.SwitchName = baseProperty.Switch;
}
if (stringListProperty != null)
{
parameter.Separator = stringListProperty.Separator;
}
if (baseProperty.Default != null)
{
parameter.DefaultValue = baseProperty.Default;
}
parameter.Required = baseProperty.IsRequired.ToString().ToLower(CultureInfo.InvariantCulture);
if (baseProperty.Category != null)
{
parameter.Category = baseProperty.Category;
}
if (baseProperty.DisplayName != null)
{
parameter.DisplayName = baseProperty.DisplayName;
}
if (baseProperty.Description != null)
{
parameter.Description = baseProperty.Description;
}
if (baseProperty.SwitchPrefix != null)
{
parameter.Prefix = baseProperty.SwitchPrefix;
}
return(parameter);
}
private bool ParseParameter(BaseProperty baseProperty, LinkedList<Property> propertyList, Property property)
{
Property property2 = this.ObtainAttributes(baseProperty, property);
if (string.IsNullOrEmpty(property2.Name))
{
property2.Name = "AlwaysAppend";
}
if (!this.switchesAdded.Contains(property2.Name))
{
this.switchOrderList.Add(property2.Name);
}
if (string.IsNullOrEmpty(property2.Prefix))
{
property2.Prefix = this.DefaultPrefix;
}
EnumProperty property3 = baseProperty as EnumProperty;
if (property3 != null)
{
foreach (EnumValue value2 in property3.AdmissibleValues)
{
Value value3 = new Value {
Name = value2.Name,
SwitchName = value2.Switch
};
if (value3.SwitchName == null)
{
value3.SwitchName = string.Empty;
}
value3.DisplayName = value2.DisplayName;
value3.Description = value2.Description;
value3.Prefix = value2.SwitchPrefix;
if (string.IsNullOrEmpty(value3.Prefix))
{
value3.Prefix = property3.SwitchPrefix;
}
if (string.IsNullOrEmpty(value3.Prefix))
{
value3.Prefix = this.DefaultPrefix;
}
if (value2.Arguments.Count > 0)
{
value3.Arguments = new ArrayList();
foreach (Microsoft.Build.Framework.XamlTypes.Argument argument in value2.Arguments)
{
Microsoft.Build.Tasks.Xaml.Argument argument2 = new Microsoft.Build.Tasks.Xaml.Argument {
Parameter = argument.Property,
Separator = argument.Separator,
Required = argument.IsRequired
};
value3.Arguments.Add(argument2);
}
}
if (value3.Prefix == null)
{
value3.Prefix = property2.Prefix;
}
property2.Values.Add(value3);
}
}
foreach (Microsoft.Build.Framework.XamlTypes.Argument argument3 in baseProperty.Arguments)
{
if (property2.Arguments == null)
{
property2.Arguments = new ArrayList();
}
Microsoft.Build.Tasks.Xaml.Argument argument4 = new Microsoft.Build.Tasks.Xaml.Argument {
Parameter = argument3.Property,
Separator = argument3.Separator,
Required = argument3.IsRequired
};
property2.Arguments.Add(argument4);
}
propertyList.AddLast(property2);
return true;
}
