Пример #1
0
        private ExpressionCombinator ParseCombinatorType(StyleSyntaxTokenizer tokenizer)
        {
            var type = ExpressionCombinator.None;

            StyleSyntaxToken token = tokenizer.current;

            while (!IsExpressionEnd(token) && type == ExpressionCombinator.None)
            {
                StyleSyntaxToken next = tokenizer.PeekNext();
                switch (token.type)
                {
                case StyleSyntaxTokenType.Space:
                    if (!IsCombinator(next) && next.type != StyleSyntaxTokenType.CloseBracket)
                    {
                        type = ExpressionCombinator.Juxtaposition;
                    }
                    break;

                case StyleSyntaxTokenType.SingleBar:
                    type = ExpressionCombinator.Or;
                    break;

                case StyleSyntaxTokenType.DoubleBar:
                    type = ExpressionCombinator.OrOr;
                    break;

                case StyleSyntaxTokenType.DoubleAmpersand:
                    type = ExpressionCombinator.AndAnd;
                    break;

                default:
                    throw new Exception($"Unexpected token '{token.type}' in expression. Expected combinator token");
                }

                token = tokenizer.MoveNext();
            }

            // Remove space after the combinator if any
            EatSpace(tokenizer);

            return(type);
        }
        private ExpressionCombinator ParseCombinatorType(StyleSyntaxTokenizer tokenizer)
        {
            ExpressionCombinator expressionCombinator = ExpressionCombinator.None;
            StyleSyntaxToken     styleSyntaxToken     = tokenizer.current;

            while (!StyleSyntaxParser.IsExpressionEnd(styleSyntaxToken) && expressionCombinator == ExpressionCombinator.None)
            {
                StyleSyntaxToken styleSyntaxToken2 = tokenizer.PeekNext();
                switch (styleSyntaxToken.type)
                {
                case StyleSyntaxTokenType.Space:
                {
                    bool flag = !StyleSyntaxParser.IsCombinator(styleSyntaxToken2) && styleSyntaxToken2.type != StyleSyntaxTokenType.CloseBracket;
                    if (flag)
                    {
                        expressionCombinator = ExpressionCombinator.Juxtaposition;
                    }
                    break;
                }

                case StyleSyntaxTokenType.SingleBar:
                    expressionCombinator = ExpressionCombinator.Or;
                    break;

                case StyleSyntaxTokenType.DoubleBar:
                    expressionCombinator = ExpressionCombinator.OrOr;
                    break;

                case StyleSyntaxTokenType.DoubleAmpersand:
                    expressionCombinator = ExpressionCombinator.AndAnd;
                    break;

                default:
                    throw new Exception(string.Format("Unexpected token '{0}' in expression. Expected combinator token", styleSyntaxToken.type));
                }
                styleSyntaxToken = tokenizer.MoveNext();
            }
            StyleSyntaxParser.EatSpace(tokenizer);
            return(expressionCombinator);
        }