public bool TryParse(PrioritizedString expr, ParameterInfo paramInfo, out Expression parsed)
{
expr = expr.Trim();
foreach (var constName in ConstantsSorted.Where(constName => expr.Input == constName))
{
parsed = Expression.Constant(Constants[constName]);
return(true);
}
parsed = null;
return(false);
}
public Expression Parse(PrioritizedString expr, ParameterInfo input)
{
foreach (var parser in OrderedParsers
.Select(keyValue => keyValue.Value))
{
if (parser.TryParse(expr, input, out var parsed))
{
return(parsed);
}
}
throw new ParseException($"Unknown expression {expr.Input}");
}
public bool TryParse(PrioritizedString expr, ParameterInfo paramInfo, out Expression parsed)
{
var minPriorityInds = expr.Priorities.GetMinIndexes();
var whereParts = expr.SplitOnSubset("where", minPriorityInds);
if (whereParts.Length > 2)
{
throw new ParseException("Too many 'where'!");
}
if (whereParts.Length == 1)
{
parsed = null;
return(false);
}
var mainFunc = whereParts[0];
if (mainFunc.Input.Last() == ',')
{
mainFunc = mainFunc.Substring(0, mainFunc.Input.Length - 1);
}
var parameterExpressions = new Dictionary <string, PrioritizedString>();
foreach (Match match in ParameterRe.Matches(whereParts[1].Input))
{
var(paramName, paramExpr) = (match.Groups["paramName"].Value, match.Groups["paramExpr"].Value);
if (paramInfo.Parameters.ContainsKey(paramName))
{
throw new ParseException($"Parameter {paramName} is defined multiple times");
}
paramInfo.Parameters[paramName] = Expression.Parameter(typeof(double), paramName);
parameterExpressions[paramName] = new PrioritizedString(paramExpr);
}
var parameterExprs = parameterExpressions
.ToDictionary(
nameWithExpr => nameWithExpr.Key,
nameWithExpr => Combinator.ParseFunctionalExpression(nameWithExpr.Value, paramInfo)
);
var mainExpr = Combinator.ParseFunctionalExpression(mainFunc, paramInfo);
var paramReplacer = new ParameterReplacerVisitor(parameterExprs);
parsed = paramReplacer.Visit(mainExpr);
return(true);
}
public bool TryParse(PrioritizedString expr, ParameterInfo paramInfo, out Expression parsed)
{
expr = expr.Trim();
var exprStr = expr.Input;
if (!Brackets.AreMatching(exprStr.First(), exprStr.Last()))
{
parsed = null;
return(false);
}
var exprWithoutBrackets = expr.Substring(1, expr.Input.Length - 2);
parsed = Combinator.ParseFunctionalExpression(exprWithoutBrackets, paramInfo);
return(true);
}
public bool TryParse(PrioritizedString expr, ParameterInfo paramInfo, out Expression parsed)
{
expr = expr.Trim();
if (double.TryParse(
expr.Input,
NumberStyles.AllowDecimalPoint | NumberStyles.AllowLeadingSign,
CultureInfo.InvariantCulture,
out var num)
)
{
parsed = Expression.Constant(num);
return(true);
}
parsed = default;
return(false);
}
public bool TryParse(
PrioritizedString expr, ParameterInfo paramInfo, out Expression parsed)
{
var minPriorityInds = expr.Priorities.GetMinIndexes();
var splitBySymbol = expr.SplitOnSubset(Symbol, minPriorityInds);
if (splitBySymbol.Length > 1 && splitBySymbol[0].Trim().Input == "")
{
splitBySymbol[1] = new PrioritizedString(Symbol).Concat(splitBySymbol[1]);
splitBySymbol = splitBySymbol.Skip(1).ToArray();
}
if (splitBySymbol.Length == 1)
{
parsed = null;
return(false);
}
parsed = ParseToExpression(splitBySymbol, paramInfo);
return(true);
}
public bool TryParse(PrioritizedString expr, ParameterInfo paramInfo, out Expression parsed)
{
expr = expr.Trim();
var exprStr = expr.Input;
if (paramInfo.Parameters.TryGetValue(exprStr, out var param))
{
parsed = param;
return(true);
}
if (paramInfo.MainParameter is null && ParameterRe.IsMatch(exprStr))
{
paramInfo.MainParameter = exprStr;
var mainParam = Expression.Parameter(typeof(double), exprStr);
paramInfo.Parameters[exprStr] = mainParam;
parsed = mainParam;
return(true);
}
parsed = default;
return(false);
}
public bool TryParse(PrioritizedString expr, ParameterInfo paramInfo, out Expression parsed)
{
expr = expr.Trim();
bool isUnaryPlus;
if (expr.Input.StartsWith("+"))
{
isUnaryPlus = true;
}
else if (expr.Input.StartsWith("-"))
{
isUnaryPlus = false;
}
else
{
parsed = default;
return(false);
}
var arg = expr.Substring(1, expr.Length - 1).Trim();
if (arg.Length == 0)
{
throw new ParseException("Found plus sign without argument");
}
if (arg.Input[0] == '-' || arg.Input[0] == '+')
{
throw new ParseException("Unary minus/plus cannot be followed by unary minus/plus");
}
parsed = isUnaryPlus
? Combinator.Parse(arg, paramInfo, Order)
: Expression.Negate(Combinator.Parse(arg, paramInfo, Order));
return(true);
}
public Expression ParseFunctionalExpression(PrioritizedString expr, ParameterInfo input)
{
return(Parse(expr, input, ParserOrder.Where));
}
public PrioritizedString Concat(PrioritizedString other)
{
return(new PrioritizedString(Input + other.Input));
}
private PrioritizedString(PrioritizedString fullString, int startInd, int length)
{
Input = fullString.Input.Substring(startInd, length);
Priorities = fullString.Priorities.Skip(startInd).Take(length).ToArray();
}
