public static void FillArguments(ExpressionParserHelper parseHelper)
{
var brackets = (SquareBrackets)parseHelper.Pop();
var property = (Property)parseHelper.Top;
property.AddBracketIndexer(brackets);
}
public void Parse(ExpressionParserHelper parseHelper)
{
Token token = parseHelper.Current;
if (token.Contents.Equals(AdditionalToken.Token))
{
if (!parseHelper.AnyOnStack(ParsedTypes))
{
throw ParseException.ExpectedToken(DistinctToken.Token, token.Contents, $"TernaryExpressionParser<{typeof(T).Name}>").Decorate(token);
}
parseHelper.Expect(AdditionalToken.Token);
parseHelper.Reduce(typeof(T));
return;
}
if (ShouldReduce(parseHelper))
{
parseHelper.Reduce(typeof(T));
}
Expression first = parseHelper.Pop();
parseHelper.Expect(DistinctToken.Token);
TernaryExpression subResult = Create(first);
subResult.Token = token;
subResult.FirstSign = DistinctToken.Token;
subResult.SecondSign = AdditionalToken.Token;
parseHelper.Push(subResult);
parseHelper.ParseExpression();
}
public void Parse(ExpressionParserHelper parseHelper)
{
if (parseHelper.At(BRACKETS_OPEN))
{
var token = parseHelper.Current;
parseHelper.Expect(BRACKETS_OPEN);
var brackets = new Brackets(_functionArgument, _arguments, _paramsArgument)
{
Token = token
};
parseHelper.Push(brackets);
parseHelper.ParseExpression();
}
else
{
Brackets brackets;
if (!parseHelper.PreviousWas(BRACKETS_OPEN))
{
parseHelper.Reduce(TYPE);
var nested = parseHelper.Pop();
parseHelper.Expect(nameof(BracketsParser), SIGNS);
brackets = ((Brackets)parseHelper.Top);
brackets.FillNext(nested);
}
else
{
brackets = ((Brackets)parseHelper.Top);
}
if (parseHelper.At(BRACKETS_CLOSE) && brackets.PartOfFunction)
{
FunctionParser.FillArguments(parseHelper);
}
}
}
public void Parse(ExpressionParserHelper parseHelper)
{
Token start = parseHelper.Current;
parseHelper.Expect(FunctionSign);
var helperExpressionLib = parseHelper.ExpressionLib;
parseHelper.PushNewTokenConfiguration(new TokenizerConfiguration('\\', _lib.FunctionNamesSet, _lib.FunctionNameSetMaxLength, helperExpressionLib.WhiteSpaceOperandsSet, helperExpressionLib.WhiteSpaceOperandsSetMaxLength, null, true, true), ResetIndex.CurrentAndLookAhead);
Token token = parseHelper.Next();
var function = _lib.Obtain(token.Contents);
parseHelper.PopTokenConfiguration(ResetIndex.MaintainPosition);
parseHelper.Next();
function.Token = start;
function.PreFix = start.Contents;
parseHelper.Push(function);
if (function.Arguments.Length == 0)
{
BracketsParser.MunchEmptyBrackets(parseHelper);
}
else if (function.IsParamsFunctions())
{
var bp = new BracketsParser(true, function.Arguments.Length, true);
bp.Parse(parseHelper);
}
else
{
var bp = new BracketsParser(true, function.Arguments.Length);
bp.Parse(parseHelper);
}
}
public void Parse(ExpressionParserHelper parseHelper)
{
var token = parseHelper.Expand();
var property = new Property(token.Contents.Trim());
property.Token = token;
parseHelper.Push(property);
}
internal void Parse(ExpressionParserHelper parseHelper)
{
IgnoreSpaces(parseHelper);
if (!parseHelper.HasMore())
{
return;
}
parseHelper.Next();
Token current = parseHelper.Current;
IExpressionParser parser = null;
if (current.Type == TokenType.Seperator)
{
parser = PARSERS_BY_STR[current.Contents];
}
else
{
parser = PARSERS_BY_TYPE[typeof(PropertyOrConstant)];
}
parser.Parse(parseHelper);
if (parseHelper.HasMore())
{
Parse(parseHelper);
}
}
public void Parse(ExpressionParserHelper parseHelper)
{
Token token = parseHelper.Current;
parseHelper.Reduce(typeof(T));
Expression lhs = parseHelper.Pop();
if (AdditionalToken != null)
{
parseHelper.Expect($"TupleExpressionParser<{typeof(T).Name}>", Tokens);
}
else
{
parseHelper.Expect(DistinctToken.Token);
}
TupleExpression subResult = Create(lhs);
subResult.Token = token;
parseHelper.Push(subResult);
parseHelper.ParseExpression();
if (subResult.Rhs == null)
{
subResult.FillInRhs(parseHelper.Pop());
}
}
public void Parse(ExpressionParserHelper parseHelper)
{
Token start = parseHelper.Current;
var helperExpressionLib = parseHelper.ExpressionLib;
parseHelper.PushNewTokenConfiguration(new TokenizerConfiguration('\\', new HashSet <string> {
_func.Name
}, _func.Name.Length, helperExpressionLib.WhiteSpaceOperandsSet, helperExpressionLib.WhiteSpaceOperandsSetMaxLength, null, true, true), ResetIndex.CurrentAndLookAhead);
parseHelper.Expect(_func.Name);
parseHelper.PopTokenConfiguration(ResetIndex.LookAhead);
var function = new Function(_func);
function.Token = start;
parseHelper.Push(function);
parseHelper.Next();
if (function.Arguments.Length == 0)
{
BracketsParser.MunchEmptyBrackets(parseHelper);
}
else
{
var bp = new BracketsParser(true, function.Arguments.Length);
bp.Parse(parseHelper);
}
}
private void GuardPartOfPropertyAccess(ExpressionParserHelper helper)
{
if (helper.Top as Property == null)
{
throw ExpressionParseException.SquareBracketsAreNotUsedInPropertyAccess().Decorate(helper.Current);
}
}
public void Parse(ExpressionParserHelper parseHelper)
{
var token = parseHelper.Expand();
var property = new Property(token.Contents.Trim());
property.Token = token;
parseHelper.Push(property);
}
private static void IgnoreSpaces(ExpressionParserHelper parseHelper)
{
while (
parseHelper.HasMore() &&
parseHelper.Lookahead.Contents.Trim().Length == 0)
{
parseHelper.Next();
}
}
public void Parse(ExpressionParserHelper parseHelper)
{
var token = parseHelper.Expand();
var property = parseHelper.IsAhead(SquareBracketsParser.BRACKETS_OPEN)?
new Property(token.Contents.Trim()) as Expression :
new PropertyOrConstant(token.Contents.Trim()) as Expression;
property.Token = token;
parseHelper.Push(property);
}
public void Parse(ExpressionParserHelper parseHelper)
{
Token token = parseHelper.Current;
parseHelper.Expect(nameof(NotParser), NOT_SIGN, ADDITIONAL_SIGN);
parseHelper.ParseExpression();
var not = new Not(parseHelper.Pop());
not.Token = token;
parseHelper.Push(not);
}
public void Parse(ExpressionParserHelper parseHelper)
{
Token token = parseHelper.Current;
parseHelper.Expect(CONSTANT_SIGN);
String constantStr = parseHelper.ReadUntil(TokenType.Seperator, CONSTANT_SIGN);
parseHelper.Expect(CONSTANT_SIGN);
var constant = new Constant(constantStr);
constant.Token = token;
parseHelper.Push(constant);
}
public void Parse(ExpressionParserHelper parseHelper)
{
var token = parseHelper.Expand();
var property = parseHelper.IsAhead(SquareBracketsParser.BRACKETS_OPEN)?
new Property(token.Contents.Trim()) as Expression :
new PropertyOrConstant(token.Contents.Trim()) as Expression;
property.Token = token;
parseHelper.Push(property);
}
public bool Reduce(ExpressionParserHelper parseHelper, Expression you, int priority)
{
bool reduced = OperatorPrecedence.IsHigherThan(you.GetType(), priority);
if (reduced)
{
((T)you).FillInRhs(parseHelper.Pop());
}
return(reduced);
}
public void Parse(ExpressionParserHelper parseHelper)
{
Token token = parseHelper.Current;
parseHelper.Expect(nameof(NotParser), SIGNS);
parseHelper.ParseExpression();
var not = new Not(parseHelper.Pop());
not.Token = token;
parseHelper.Push(not);
}
public Expression Parse(string expression, ParseContext offset = null)
{
var tokenizer = new Tokenizer(expression, configuration).AddOffSet(offset);
var parseHelper = new ExpressionParserHelper(this, tokenizer);
parseHelper.Init();
Parse(parseHelper);
var result = parseHelper.Yield();
result.GuardTypeSafety();
return(result);
}
public static void FillArguments(ExpressionParserHelper parseHelper)
{
var brackets = (Brackets) parseHelper.Pop();
var function = (Function) parseHelper.Top;
if (brackets.Nodes.Count < function.Arguments.Length)
{
throw ExpressionParseException.ExpectedMoreParameter(function, brackets.Nodes.Count,
function.Arguments.Length).Decorate(
parseHelper.Lookahead ?? parseHelper.Current);
}
function.FillNested(brackets);
}
public static void FillArguments(ExpressionParserHelper parseHelper)
{
var brackets = (Brackets)parseHelper.Pop();
var function = (Function)parseHelper.Top;
if (brackets.Nodes.Count < function.Arguments.Where(a => !a.Params).Count())
{
throw ExpressionParseException.ExpectedMoreParameter(function, brackets.Nodes.Count,
function.Arguments.Length).Decorate(
parseHelper.Lookahead ?? parseHelper.Current);
}
function.FillNested(brackets);
}
public void Parse(ExpressionParserHelper parseHelper)
{
Token token = parseHelper.Current;
parseHelper.Expect(CONSTANT_SIGN);
String constantStr = parseHelper.ReadUntil(TokenType.Seperator, CONSTANT_SIGN);
parseHelper.Expect(CONSTANT_SIGN);
var constant = new Constant(constantStr);
constant.Token = token;
parseHelper.Push(constant);
}
private bool ShouldReduce(ExpressionParserHelper parseHelper)
{
if (parseHelper.PeekOnStack == null)
{
return(true);
}
var myPriority = OperatorPrecedence.Of(typeof(T));
var stackPriority = OperatorPrecedence.Of(parseHelper.PeekOnStack.GetType());
if (myPriority != stackPriority)
{
return(true);
}
return(false);
}
public bool Reduce(ExpressionParserHelper parseHelper, Expression you, int priority)
{
bool reduced = OperatorPrecedence.IsHigherThan(you.GetType(), priority);
if (reduced)
{
var subResult = ((T)you);
if (subResult.Second == null)
{
subResult.FillInSecond(parseHelper.Pop());
}
else
{
subResult.FillInThird(parseHelper.Pop());
}
}
return(reduced);
}
public void Parse(ExpressionParserHelper parseHelper)
{
Token start = parseHelper.Current;
parseHelper.PushNewTokenConfiguration(true, true,'\\', new string[] {_func.Name}, parseHelper.ExpressionLib.WhiteSpaceOperands, null, ResetIndex.CurrentAndLookAhead);
parseHelper.Expect(_func.Name);
parseHelper.PopTokenConfiguration(ResetIndex.LookAhead);
var function = new Function(_func);
function.Token = start;
parseHelper.Push(function);
parseHelper.Next();
if (function.Arguments.Length == 0)
{
BracketsParser.MunchEmptyBrackets(parseHelper);
}
else
{
var bp = new BracketsParser(true, function.Arguments.Length);
bp.Parse(parseHelper);
}
}
public void Parse(ExpressionParserHelper parseHelper)
{
if (parseHelper.At(BRACKETS_OPEN))
{
GuardPartOfPropertyAccess(parseHelper);
var token = parseHelper.Current;
parseHelper.Expect(BRACKETS_OPEN);
var brackets = new SquareBrackets {
Token = token
};
parseHelper.Push(brackets);
parseHelper.ParseExpression();
}
else
{
parseHelper.Reduce(TYPE);
var nested = parseHelper.Pop();
parseHelper.Expect(nameof(SquareBracketsParser), BRACKETS_CLOSE);
var brackets = ((SquareBrackets)parseHelper.Top);
brackets.Fill(nested);
PropertyParser.FillArguments(parseHelper);
}
}
public static void MunchEmptyBrackets(ExpressionParserHelper parseHelper)
{
parseHelper.Expect(BRACKETS_OPEN);
parseHelper.Read(BRACKETS_CLOSE);
}
public void Parse(ExpressionParserHelper parseHelper)
{
if (parseHelper.At(BRACKETS_OPEN))
{
var token = parseHelper.Current;
parseHelper.Expect(BRACKETS_OPEN);
var brackets = new Brackets(_functionArgument, _arguments) {Token = token};
parseHelper.Push(brackets);
parseHelper.ParseExpression();
}
else
{
parseHelper.Reduce(TYPE);
var nested = parseHelper.Pop();
parseHelper.Expect(nameof(BracketsParser), BRACKETS_CLOSE, BRACKETS_COMMA);
var brackets = ((Brackets) parseHelper.Top);
brackets.FillNext(nested);
if (parseHelper.At(BRACKETS_CLOSE) && brackets.PartOfFunction)
{
FunctionParser.FillArguments(parseHelper);
}
}
}
public void Parse(ExpressionParserHelper parseHelper)
{
Token start = parseHelper.Current;
parseHelper.Expect(FunctionSign);
parseHelper.PushNewTokenConfiguration(true, true, '\\', _lib.Functions.Select(f=>f.Name).ToArray(), parseHelper.ExpressionLib.WhiteSpaceOperands, null, ResetIndex.CurrentAndLookAhead);
Token token = parseHelper.Next();
var function = _lib.Obtain(token.Contents);
parseHelper.PopTokenConfiguration(ResetIndex.MaintainPosition);
parseHelper.Next();
function.Token = start;
function.PreFix = start.Contents;
parseHelper.Push(function);
if (function.Arguments.Length == 0)
{
BracketsParser.MunchEmptyBrackets(parseHelper);
}
else
{
var bp = new BracketsParser(true, function.Arguments.Length);
bp.Parse(parseHelper);
}
}
public static void MunchEmptyBrackets(ExpressionParserHelper parseHelper)
{
parseHelper.Expect(BRACKETS_OPEN);
parseHelper.Read(BRACKETS_CLOSE);
}
public bool Reduce(ExpressionParserHelper parseHelper, Expression you, int priorty)
{
return false;
}
public bool Reduce(ExpressionParserHelper parseHelper, Expression you, int priorty)
{
return(false);
}
public static void FillArguments(ExpressionParserHelper parseHelper)
{
var brackets = (SquareBrackets)parseHelper.Pop();
var property = (Property)parseHelper.Top;
property.AddBracketIndexer(brackets);
}
