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); }