//New evaluation system with parenthesis and complex expressions support
private static string EvaluateExpression(ref bool conditionResult, List <string> features, params string[] conditions)
{
if (conditions.Length <= 2)
{
return("Invalid condition block");
}
var expression = "";
for (var n = 2; n < conditions.Length; n++)
{
expression += conditions[n];
}
var result = false;
try
{
ExpressionLeaf.EvaluateFunction evalFunc = s => features.Contains(s);
result = EvaluateExpression(expression, evalFunc);
}
catch (Exception e)
{
return("Incorrect condition in template file\nError returned:\n" + e.Message);
}
conditionResult = result;
return(null);
}
//--------------------------------------------------------------------------------------------------------------------------------
// Main Function to use
public static bool EvaluateExpression(string expression, ExpressionLeaf.EvaluateFunction evalFunction)
{
if (!cachedTokenEnumerators.ContainsKey(expression))
{
//Remove white spaces and double && ||
var cleanExpr = new StringBuilder();
for (var i = 0; i < expression.Length; i++)
{
switch (expression[i])
{
case ' ': break;
case '&': cleanExpr.Append(expression[i]); i++; break;
case '|': cleanExpr.Append(expression[i]); i++; break;
default: cleanExpr.Append(expression[i]); break;
}
}
var tokens = new List <Token>();
var reader = new StringReader(cleanExpr.ToString());
Token t = null;
do
{
t = new Token(reader);
tokens.Add(t);
} while (t.type != Token.TokenType.EXPR_END);
var polishNotation = Token.TransformToPolishNotation(tokens);
var tokensEnumerator = polishNotation.GetEnumerator();
tokensEnumerator.MoveNext();
cachedTokenEnumerators.Add(expression, tokensEnumerator);
}
var enumerator = cachedTokenEnumerators[expression];
var root = MakeExpression(ref enumerator, evalFunction);
return(root.Evaluate());
}
//--------------------------------------------------------------------------------------------------------------------------------
// Main Function to use
static public bool EvaluateExpression(string expression, ExpressionLeaf.EvaluateFunction evalFunction)
{
//Remove white spaces and double && ||
string cleanExpr = "";
for (int i = 0; i < expression.Length; i++)
{
switch (expression[i])
{
case ' ': break;
case '&': cleanExpr += expression[i]; i++; break;
case '|': cleanExpr += expression[i]; i++; break;
default: cleanExpr += expression[i]; break;
}
}
List <Token> tokens = new List <Token>();
StringReader reader = new StringReader(cleanExpr);
Token t = null;
do
{
t = new Token(reader);
tokens.Add(t);
} while (t.type != Token.TokenType.EXPR_END);
List <Token> polishNotation = Token.TransformToPolishNotation(tokens);
var enumerator = polishNotation.GetEnumerator();
enumerator.MoveNext();
Expression root = MakeExpression(ref enumerator, evalFunction);
return(root.Evaluate());
}
public static Expression MakeExpression(ref List <Token> .Enumerator polishNotationTokensEnumerator, ExpressionLeaf.EvaluateFunction _evalFunction)
{
if (polishNotationTokensEnumerator.Current.type == Token.TokenType.LITERAL)
{
Expression lit = new ExpressionLeaf(_evalFunction, polishNotationTokensEnumerator.Current.value);
polishNotationTokensEnumerator.MoveNext();
return(lit);
}
if (polishNotationTokensEnumerator.Current.value == "NOT")
{
polishNotationTokensEnumerator.MoveNext();
var operand = MakeExpression(ref polishNotationTokensEnumerator, _evalFunction);
return(new ExpressionNot(operand));
}
if (polishNotationTokensEnumerator.Current.value == "AND")
{
polishNotationTokensEnumerator.MoveNext();
var left = MakeExpression(ref polishNotationTokensEnumerator, _evalFunction);
var right = MakeExpression(ref polishNotationTokensEnumerator, _evalFunction);
return(new ExpressionAnd(left, right));
}
if (polishNotationTokensEnumerator.Current.value == "OR")
{
polishNotationTokensEnumerator.MoveNext();
var left = MakeExpression(ref polishNotationTokensEnumerator, _evalFunction);
var right = MakeExpression(ref polishNotationTokensEnumerator, _evalFunction);
return(new ExpressionOr(left, right));
}
return(null);
}
