Ejemplo n.º 1
0
 internal bool IsNext(Token.TokenType type)
 {
     return(_lookahead.IsToken(type));
 }
Ejemplo n.º 2
0
        internal bool Advance()
        {
            if (_errorState)
            {
                return(false);
            }

            if (_lookahead?.IsToken(Token.TokenType.EndOfInput) == true)
            {
                return(true);
            }

            SkipWhiteSpace();

            // Update error position after skipping whitespace
            _errorPosition = _parsePoint + 1;

            if (_parsePoint >= _expression.Length)
            {
                _lookahead = Token.EndOfInput;
            }
            else
            {
                switch (_expression[_parsePoint])
                {
                case ',':
                    _lookahead = Token.Comma;
                    _parsePoint++;
                    break;

                case '(':
                    _lookahead = Token.LeftParenthesis;
                    _parsePoint++;
                    break;

                case ')':
                    _lookahead = Token.RightParenthesis;
                    _parsePoint++;
                    break;

                case '$':
                    if (!ParseProperty())
                    {
                        return(false);
                    }
                    break;

                case '%':
                    if (!ParseItemMetadata())
                    {
                        return(false);
                    }
                    break;

                case '@':
                    int start = _parsePoint;
                    // If the caller specified that he DOESN'T want to allow item lists ...
                    if ((_options & ParserOptions.AllowItemLists) == 0)
                    {
                        if ((_parsePoint + 1) < _expression.Length && _expression[_parsePoint + 1] == '(')
                        {
                            _errorPosition = start + 1;
                            _errorState    = true;
                            _errorResource = "ItemListNotAllowedInThisConditional";
                            return(false);
                        }
                    }
                    if (!ParseItemList())
                    {
                        return(false);
                    }
                    break;

                case '!':
                    // negation and not-equal
                    if ((_parsePoint + 1) < _expression.Length && _expression[_parsePoint + 1] == '=')
                    {
                        _lookahead   = Token.NotEqualTo;
                        _parsePoint += 2;
                    }
                    else
                    {
                        _lookahead = Token.Not;
                        _parsePoint++;
                    }
                    break;

                case '>':
                    // gt and gte
                    if ((_parsePoint + 1) < _expression.Length && _expression[_parsePoint + 1] == '=')
                    {
                        _lookahead   = Token.GreaterThanOrEqualTo;
                        _parsePoint += 2;
                    }
                    else
                    {
                        _lookahead = Token.GreaterThan;
                        _parsePoint++;
                    }
                    break;

                case '<':
                    // lt and lte
                    if ((_parsePoint + 1) < _expression.Length && _expression[_parsePoint + 1] == '=')
                    {
                        _lookahead   = Token.LessThanOrEqualTo;
                        _parsePoint += 2;
                    }
                    else
                    {
                        _lookahead = Token.LessThan;
                        _parsePoint++;
                    }
                    break;

                case '=':
                    if ((_parsePoint + 1) < _expression.Length && _expression[_parsePoint + 1] == '=')
                    {
                        _lookahead   = Token.EqualTo;
                        _parsePoint += 2;
                    }
                    else
                    {
                        _errorPosition = _parsePoint + 2;     // expression[parsePoint + 1], counting from 1
                        _errorResource = "IllFormedEqualsInCondition";
                        if ((_parsePoint + 1) < _expression.Length)
                        {
                            // store the char we found instead
                            _unexpectedlyFound = Convert.ToString(_expression[_parsePoint + 1], CultureInfo.InvariantCulture);
                        }
                        else
                        {
                            _unexpectedlyFound = EndOfInput;
                        }
                        _parsePoint++;
                        _errorState = true;
                        return(false);
                    }
                    break;

                case '\'':
                    if (!ParseQuotedString())
                    {
                        return(false);
                    }
                    break;

                default:
                    // Simple strings, function calls, decimal numbers, hex numbers
                    if (!ParseRemaining())
                    {
                        return(false);
                    }
                    break;
                }
            }
            return(true);
        }