public void LoadConfigurationFromXml(string configurationFile)
{
XmlDocument xmlDocument = new XmlDocument();
xmlDocument.Load(configurationFile);
XmlNodeList nodes = xmlDocument.SelectNodes("/configuration/parser/expressionReplacements/expressionReplacement");
foreach (XmlNode node in nodes)
{
// Get the expression,
string expression = node.SelectSingleNode("@expression").Value;
expression = expression.Replace("\\n", "\n");
// Get the replacement.
string replacement = node.SelectSingleNode("@replacement").Value;
replacement = replacement.Replace("\\n", "\n");
// Build the expression replacement.
ExpressionReplacement expressionReplacement =
new ExpressionReplacement(expression, replacement);
this.ExpressionReplacements.Add(expressionReplacement);
}
nodes = xmlDocument.SelectNodes("/configuration/tags/tag");
foreach (XmlNode node in nodes)
{
string tag = node.SelectSingleNode("@name").InnerText;
string replacement = node.SelectSingleNode("@replacement").InnerText;
string alternativeReplacement = node.SelectSingleNode("@alternativeReplacement") != null ? node.SelectSingleNode("@alternativeReplacement").InnerText : null;
try
{
bool parseContent = Boolean.Parse(node.SelectSingleNode("@parseContent").InnerText);
this.TagConfigurations.Add(new TagConfiguration(tag, replacement, alternativeReplacement, parseContent));
}
catch (NullReferenceException)
{
this.TagConfigurations.Add(new TagConfiguration(tag, replacement, alternativeReplacement));
}
}
}
internal static List <ExpressionReplacement> ComputeExpressionReplacements(IEnumerable <ActivityWithResult> expressions, EditingContext context, ArgumentAccessorWrapperCache argumentAccessorWrapperCache)
{
Fx.Assert(expressions != null, "expressions cannot be null.");
Fx.Assert(context != null, "context cannot be null.");
Fx.Assert(argumentAccessorWrapperCache != null, "argumentAccessorWrapperCache cannot be null.");
HashSet <Assign> assignsWithRValueToFix = new HashSet <Assign>();
Dictionary <Assign, Type> assignLValueTypes = new Dictionary <Assign, Type>();
List <ExpressionReplacement> expressionReplacements = new List <ExpressionReplacement>();
foreach (ActivityWithResult expression in expressions)
{
Activity parentActivity = ValidationService.GetParent(expression);
if (parentActivity == null)
{
continue;
}
Assign assignActivity = parentActivity as Assign;
if (assignActivity != null && !ExpressionHelper.IsGenericLocationExpressionType(expression))
{
assignsWithRValueToFix.Add(assignActivity);
}
else
{
ExpressionReplacement expressionReplacement = ComputeExpressionReplacement(expression, parentActivity, context, argumentAccessorWrapperCache);
if (expressionReplacement != null)
{
expressionReplacements.Add(expressionReplacement);
if (assignActivity != null)
{
Type expectedReturnType = expressionReplacement.NewArgument.ArgumentType;
assignLValueTypes[assignActivity] = expectedReturnType;
}
}
}
}
// Special handle Assign R-Values: Assign.To.ArgumentType must be the same as Assign.Value.ArgumentType.
foreach (Assign assignWithRValueToFix in assignsWithRValueToFix)
{
Type expectedReturnType;
if (assignLValueTypes.TryGetValue(assignWithRValueToFix, out expectedReturnType))
{
assignLValueTypes.Remove(assignWithRValueToFix);
}
else if (assignWithRValueToFix.To != null)
{
expectedReturnType = assignWithRValueToFix.To.ArgumentType;
}
ExpressionReplacement expressionReplacement = ComputeExpressionReplacement(assignWithRValueToFix.Value.Expression, assignWithRValueToFix, context, argumentAccessorWrapperCache, expectedReturnType);
if (expressionReplacement != null)
{
expressionReplacements.Add(expressionReplacement);
}
}
// These Assign activities have their L-value argument (To) changed but not the R-value argument (Value).
// Now make sure that the R-value arguments are compatible with the L-value argument.
foreach (KeyValuePair <Assign, Type> kvp in assignLValueTypes)
{
Assign remainingAssign = kvp.Key;
Type expectedReturnType = kvp.Value;
if (remainingAssign.Value != null && remainingAssign.Value.Expression != null)
{
ActivityWithResult expression = remainingAssign.Value.Expression;
if (expression.ResultType != expectedReturnType)
{
ExpressionReplacement expressionReplacement = ComputeExpressionReplacement(expression, remainingAssign, context, argumentAccessorWrapperCache, expectedReturnType);
if (expressionReplacement != null)
{
expressionReplacements.Add(expressionReplacement);
}
}
}
}
return(expressionReplacements);
}
