public static EvaluationResult Parse(string expression, Type type, BuildArgument arg)
{
try
{
var param = type.CreateParameterExpression();
var rootNode = Parse(new ExpressionReader(expression), param, arg);
if (arg.InvalidProperties.Count > 0 || arg.InvalidVariables.Count > 0)
{
return(new EvaluationResult
{
InvalidProperties = arg.InvalidProperties,
InvalidVariables = arg.InvalidVariables
});
}
var body = rootNode.Build(arg);
return(new EvaluationResult
{
Result = Expression.Lambda(body, param),
Succeeded = true
});
}
catch (Exception ex)
{
return(new EvaluationResult
{
Exception = ex,
InvalidProperties = new List <string>(0),
InvalidVariables = new List <string>(0),
InvalidValues = arg.InvalidValues
});
}
}
public override Expression Build(BuildArgument arg)
{
try
{
Expression left = null;
Expression right = null;
Type inOperatorDataType = typeof(string);
if (Left is Constant c && Right is Property p)
{
if (c.Type == null)
{
var propEx = (MemberExpression)p.Build(arg);
c.Type = propEx.Type;
left = c.Build(arg);
right = propEx;
}
else
{
left = c.Build(arg);
right = p.Build(arg);
}
}
else if (Left is Property p2 && Right is Constant c2)
{
var propEx = (MemberExpression)p2.Build(arg);
c2.Type = propEx.Type;
left = propEx;
right = c2.Build(arg);
}
public override Expression Build(BuildArgument arg)
{
try
{
return(Param.CreatePropertyExpression(arg.MapProperty(Name)));
}
catch (Exception ex)
{
throw new FormatException(GetErrorMessage(), ex);
}
}
private static Node BuildNode(ParameterExpression param, GroupParser parser, BuildArgument arg)
{
if (parser.BuiltNode != null)
{
return(parser.BuiltNode);
}
var result = new Group {
Node = BuildNode(param, parser.Body, arg), StartIndex = parser.StartIndex, StartChar = parser.StartChar
};
parser.BuiltNode = result;
return(result);
}
public override Expression Build(BuildArgument arg)
{
ParseValues();
var arr = Array.CreateInstance(Type, StringValues.Count);
var i = 0;
StringValues.ForEach((p) =>
{
var value = p.Cast(Type);
arr.SetValue(value, i++);
});
return(Expression.Constant(arr));
}
public override Expression Build(BuildArgument arg)
{
if (Node == null)
{
throw new FormatException(GetErrorMessage());
}
try
{
return(Expression.Not(Node.Build(arg)));
}
catch (Exception ex)
{
throw new FormatException(GetErrorMessage(), ex);
}
}
public override Expression Build(BuildArgument arg)
{
try
{
if (IsVariable && arg.VariableResolver.TryResolve(Value, out var value))
{
return(Expression.Constant(Convert.ChangeType(value, Type)));
}
return(Expression.Constant(Value.Cast(Type), Type));
}
catch (Exception ex)
{
arg.InvalidValues.Add(Value);
throw new FormatException(GetErrorMessage(), ex);
}
}
public override Expression Build(BuildArgument arg)
{
Operator = Operator.ToLower();
switch (Operator)
{
case Interpreter.LogicalAnd:
case Interpreter.LogicalAnd2:
return(Expression.AndAlso(Left.Build(arg), Right.Build(arg)));
case Interpreter.LogicalOr:
case Interpreter.LogicalOr2:
return(Expression.OrElse(Left.Build(arg), Right.Build(arg)));
default:
return(null);
}
}
private static Node BuildNode(ParameterExpression param, ComparisonFunctionOperatorParser parser, List <Parser> list, ref int currentIndex, BuildArgument arg)
{
if (parser.BuiltNode != null)
{
return(parser.BuiltNode);
}
var result = new Comparison
{
Left = BuildNode(param, list[currentIndex - 1], list, ref currentIndex, arg),
Right = BuildNode(param, parser.Body, arg),
Operator = GetStandardOperator(parser.Result),
StartIndex = parser.StartIndex,
StartChar = parser.StartChar
};
parser.BuiltNode = result;
list[currentIndex - 1] = null;
return(result);
}
public override Expression Build(BuildArgument arg)
{
return(Node.Build(arg));
}
private static Node BuildNode(ParameterExpression param, List <Parser> parsers, BuildArgument arg)
{
foreach (var step in BuildSteps)
{
for (var index = 0; index < parsers.Count; ++index)
{
var parser = parsers[index];
if (parsers[index] != null && step(parser.GetType(), parser))
{
BuildNode(param, parser, parsers, ref index, arg);
}
}
parsers = parsers.Where(p => p != null).ToList();
}
return(parsers[0].BuiltNode);
}
private static Node Parse(ExpressionReader reader, ParameterExpression parameter, BuildArgument arg)
{
var acceptedParsers = GetBeginningParsers();
var keepTrack = false;
var groups = new Stack <Parser>();
reader.IgnoreWhiteSpace();
while (!reader.IsEnd)
{
var noOfWhiteSpaceIgnored = 0;
if (!keepTrack)
{
noOfWhiteSpaceIgnored = reader.IgnoreWhiteSpace();
}
var c = reader.Read();
var parsers = acceptedParsers;
acceptedParsers = new List <Parser>();
var isStartGroup = false;
Parser group = null;
foreach (var parser in parsers)
{
if (parser.Accept(c, noOfWhiteSpaceIgnored, reader.CurrentIndex, ref keepTrack, ref isStartGroup))
{
if (isStartGroup)
{
group = parser;
}
else
{
acceptedParsers.Add(parser);
}
}
else
{
if (parser.Done && parser.Validate())
{
if (groups.Count > 0)
{
groups.Peek().LastSuccess = parser;
}
var nextParsers = parser.GetNextParsers(c);
foreach (var nextParser in nextParsers)
{
if (nextParser.Accept(c, 0, reader.CurrentIndex, ref keepTrack, ref isStartGroup))
{
if (isStartGroup)
{
group = nextParser;
}
else
{
acceptedParsers.Add(nextParser);
}
}
}
}
}
if (group != null)
{
groups.Push(group);
acceptedParsers = group.GetNextParsers(c);
continue;
}
}
if (acceptedParsers.Count == 0)
{
if (groups.Count > 0 && (group = groups.Pop()).Accept(c, noOfWhiteSpaceIgnored, reader.CurrentIndex, ref keepTrack, ref isStartGroup))
{
if (reader.HasNext)
{
acceptedParsers = group.GetNextParsers(c);
}
else
{
acceptedParsers.Add(group);
}
group.Body = BuildChain(group, group.LastSuccess);
}
else
{
ThrowFormatException(c, reader.CurrentIndex);
}
}
}
Parser lastestParser = null;
var acceptedCount = 0;
foreach (var acceptedParser in acceptedParsers)
{
acceptedParser.EndExpression();
if (acceptedParser.Validate())
{
++acceptedCount;
lastestParser = acceptedParser;
}
}
if (acceptedCount != 1 || groups.Count > 0)
{
ThrowFormatException(reader.LastChar, reader.Length - 1);
}
var chain = BuildChain(null, lastestParser);
return(BuildNode(parameter, chain, arg));
void ThrowFormatException(char c, int index) => throw new FormatException($"Incorrect syntax near '{c}', index {index}");
}
private static Node BuildNode(ParameterExpression param, LogicalOperatorParser parser, List <Parser> list, ref int currentIndex, BuildArgument arg)
{
if (parser.BuiltNode != null)
{
return(parser.BuiltNode);
}
var result = new Logicality
{
Left = BuildNode(param, list[currentIndex - 1], list, ref currentIndex, arg),
Right = BuildNode(param, list[currentIndex + 1], list, ref currentIndex, arg),
Operator = GetStandardOperator(parser.Result),
StartIndex = parser.StartIndex,
StartChar = parser.StartChar
};
parser.BuiltNode = result;
list[currentIndex - 1] = null;
list[currentIndex] = null;
list[currentIndex + 1] = parser;
++currentIndex;
return(result);
}
private static Node BuildNode(ParameterExpression param, PropertyParser parser, BuildArgument arg)
{
if (parser.BuiltNode != null)
{
return(parser.BuiltNode);
}
var result = parser.Result;
Node builtNode;
if (parser.IsNull)
{
builtNode = new Constant {
Value = null, StartIndex = parser.StartIndex, StartChar = parser.StartChar
};
}
else if (parser.IsBoolean)
{
builtNode = new Constant {
Value = result.ToLower(), Type = typeof(bool), StartIndex = parser.StartIndex, StartChar = parser.StartChar
};
}
else if (arg.VariableResolver.IsVariable(result))
{
builtNode = new Constant {
Value = result, StartIndex = parser.StartIndex, StartChar = parser.StartChar, IsVariable = true
};
}
else
{
if (parser.IsVariable)
{
arg.InvalidVariables.Add(result);
}
else
{
arg.IsValidProperty(result);
}
builtNode = new Property {
Name = result, Param = param, StartIndex = parser.StartIndex, StartChar = parser.StartChar
};
}
parser.BuiltNode = builtNode;
return(builtNode);
}
public abstract Expression Build(BuildArgument arg);
private static Node BuildNode(ParameterExpression param, NotOperatorParser parser, List <Parser> list, ref int currentIndex, BuildArgument arg)
{
if (parser.BuiltNode != null)
{
return(parser.BuiltNode);
}
var index = currentIndex;
var nextParser = list[++currentIndex];
var result = new Not {
Node = BuildNode(param, nextParser, list, ref currentIndex, arg), StartIndex = parser.StartIndex, StartChar = '!'
};
list[index + 1] = null;
parser.BuiltNode = result;
return(result);
}
private static Node BuildNode(ParameterExpression param, Parser parser, List <Parser> list, ref int currentIndex, BuildArgument arg)
{
switch (parser)
{
case StringParser sp:
return(BuildNode(sp));
case PropertyParser pp:
return(BuildNode(param, pp, arg));
case NumberParser np:
return(BuildNode(np));
case NotOperatorParser nop:
return(BuildNode(param, nop, list, ref currentIndex, arg));
case NotFunctionParser nfp:
return(BuildNode(param, nfp, arg));
case LogicalOperatorParser lop:
return(BuildNode(param, lop, list, ref currentIndex, arg));
case GroupParser gp:
return(BuildNode(param, gp, arg));
case ComparisonOparatorParser cop:
return(BuildNode(param, cop, list, ref currentIndex, arg));
case ComparisonFunctionOperatorParser cfop:
return(BuildNode(param, cfop, list, ref currentIndex, arg));
case ArrayParser ap:
return(BuildNode(ap));
default: return(null);
}
}
