public static Expression Parse(ExpressionWalker ew, Expression left = null) { var fc = new CallExpression(); fc.FunctionName = left ?? IdentityExpression.Parse(ew); fc.Arguments = ArgumentsExpression.Parse(ew, ExpressionToken.LeftParen, ExpressionToken.RightParen, true); return(InteractableExpression.TryExpand(fc, ew)); }
//todo this is not the best choice of design, IdentityExpression.Parse does the same, this is just more intuitive. both can co-exist. /// <summary> /// In cases like: property(1,2)[0] we have chained interaction, this resolves if current <see cref="result"/> has more interactions. If so, parses them. /// </summary> /// <param name="result">The result expression</param> /// <param name="ew">The walker with position right after <see cref="result"/></param> /// <param name="caller">Internal use.</param> /// <returns></returns> public static Expression TryExpand(Expression result, ExpressionWalker ew, Type caller = null) { if (ew.Current.Token == ExpressionToken.Period) { return(IdentityExpression.Parse(ew, caller, result)); } if (ew.Current.Token == ExpressionToken.LeftBracet) { return(IndexerCallExpression.Parse(ew, result)); } if (ew.Current.Token == ExpressionToken.LeftParen) { return(CallExpression.Parse(ew, result)); } return(result); }
public static Expression Parse(ExpressionWalker ew, Expression left = null) { var ret = new IndexerCallExpression(left ?? IdentityExpression.Parse(ew), ArgumentsExpression.Parse(ew, ExpressionToken.LeftBracet, ExpressionToken.RightBracet, false)); return(InteractableExpression.TryExpand(ret, ew)); }
public static Expression ParseExpression(ExpressionWalker ew, Type caller = null) { Expression ret = null; _retry: bool isOperatorCall = caller == typeof(OperatorExpression) || caller == typeof(RightOperatorExpression) || caller == typeof(ForeachExpression); var current = ew.Current.Token; if (current == ExpressionToken.Literal) { //cases like variable(.., variable[.., variable + .., variable if (ew.HasNext) { var peak = ew.PeakNextOrThrow().Token; if (peak == ExpressionToken.LeftParen) { ret = CallExpression.Parse(ew); } else if (peak == ExpressionToken.Period && caller != typeof(IdentityExpression) && caller != typeof(InteractableExpression)) { ret = IdentityExpression.Parse(ew); } else if (peak == ExpressionToken.LeftBracet) { ret = IndexerCallExpression.Parse(ew); } else if (peak == ExpressionToken.New) { ret = NewExpression.Parse(ew); } else if (RightOperatorExpression.IsNextAnRightUniOperation(ew, caller) && caller != typeof(RightOperatorExpression)) { ret = RightOperatorExpression.Parse(ew); } else if (OperatorExpression.IsNextAnOperation(ew) && !isOperatorCall) { ret = OperatorExpression.Parse(ew); } else { ret = IdentityExpression.Parse(ew, caller); } } else { ret = IdentityExpression.Parse(ew, caller); } } else if (LeftOperatorExpression.IsCurrentAnLeftUniOperation(ew)) { ret = LeftOperatorExpression.Parse(ew); } else if (current == ExpressionToken.NumberLiteral) { ret = NumberLiteral.Parse(ew); } else if (current == ExpressionToken.StringLiteral) { ret = StringLiteral.Parse(ew); } else if (current == ExpressionToken.LeftParen) { ret = GroupExpression.Parse(ew, ExpressionToken.LeftParen, ExpressionToken.RightParen); } else if (current == ExpressionToken.LeftBracet) { ret = ArrayExpression.Parse(ew); } else if (current == ExpressionToken.New) { ret = NewExpression.Parse(ew); } else if (current == ExpressionToken.Boolean) { ret = BooleanLiteral.Parse(ew); } else if (current == ExpressionToken.CharLiteral) { ret = CharLiteral.Parse(ew); } else if (current == ExpressionToken.Throw) { ret = ThrowExpression.Parse(ew); } else if (current == ExpressionToken.Hashtag && ew.HasNext && ew.PeakNext.Token == ExpressionToken.NumberLiteral) { ret = HashtagReferenceExpression.Parse(ew, caller); } else if (current == ExpressionToken.Null) { ret = NullIdentity.Parse(ew); } else if (current == ExpressionToken.NewLine) { ew.NextOrThrow(); goto _retry; } else { throw new UnexpectedTokenException($"Token was not expected to be a {ew.Current.Token}"); } //here we parse chained math operations while (OperatorExpression.IsCurrentAnOperation(ew) && !isOperatorCall) { if (RightOperatorExpression.IsCurrentAnRightUniOperation(ew) && caller != typeof(OperatorExpression)) { ret = RightOperatorExpression.Parse(ew, ret); } else if (OperatorExpression.IsCurrentAnOperation(ew)) { ret = OperatorExpression.Parse(ew, ret); } } return(ret); }