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);
         }
     }
 }
Beispiel #2
0
        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)
        {
            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());
            }
        }
Beispiel #4
0
 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);
 }
Beispiel #5
0
        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);
        }
Beispiel #6
0
 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);
     }
 }
Beispiel #7
0
 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);
         }
     }
 }