xpath_lexer Class Reference

Public Member Functions
	xpath_lexer (const char_t *query)
const char_t *	state () const
void	next ()
lexeme_t	current () const
const char_t *	current_pos () const
const xpath_lexer_string &	contents () const

Detailed Description

Definition at line 9247 of file pugixml.cc.

Constructor & Destructor Documentation

xpath_lexer()

xpath_lexer::xpath_lexer ( const char_t * query )

inlineexplicit

Definition at line 9256 of file pugixml.cc.

                                                 : _cur(query)
        {
            next();
        }

Member Function Documentation

contents()

const xpath_lexer_string & xpath_lexer::contents ( ) const

inline

Definition at line 9545 of file pugixml.cc.

        {
            assert(_cur_lexeme == lex_var_ref || _cur_lexeme == lex_number || _cur_lexeme == lex_string || _cur_lexeme == lex_quoted_string);
 
            return _cur_lexeme_contents;
        }

Referenced by xpath_parser::binary_op_t::parse().

current()

lexeme_t xpath_lexer::current ( ) const

inline

Definition at line 9535 of file pugixml.cc.

        {
            return _cur_lexeme;
        }

Referenced by xpath_parser::binary_op_t::parse().

current_pos()

const char_t * xpath_lexer::current_pos ( ) const

inline

Definition at line 9540 of file pugixml.cc.

        {
            return _cur_lexeme_pos;
        }

next()

void xpath_lexer::next ( )

inline

Definition at line 9266 of file pugixml.cc.

        {
            const char_t* cur = _cur;
 
            while (PUGI__IS_CHARTYPE(*cur, ct_space)) ++cur;
 
            // save lexeme position for error reporting
            _cur_lexeme_pos = cur;
 
            switch (*cur)
            {
            case 0:
                _cur_lexeme = lex_eof;
                break;
 
            case '>':
                if (*(cur+1) == '=')
                {
                    cur += 2;
                    _cur_lexeme = lex_greater_or_equal;
                }
                else
                {
                    cur += 1;
                    _cur_lexeme = lex_greater;
                }
                break;
 
            case '<':
                if (*(cur+1) == '=')
                {
                    cur += 2;
                    _cur_lexeme = lex_less_or_equal;
                }
                else
                {
                    cur += 1;
                    _cur_lexeme = lex_less;
                }
                break;
 
            case '!':
                if (*(cur+1) == '=')
                {
                    cur += 2;
                    _cur_lexeme = lex_not_equal;
                }
                else
                {
                    _cur_lexeme = lex_none;
                }
                break;
 
            case '=':
                cur += 1;
                _cur_lexeme = lex_equal;
 
                break;
 
            case '+':
                cur += 1;
                _cur_lexeme = lex_plus;
 
                break;
 
            case '-':
                cur += 1;
                _cur_lexeme = lex_minus;
 
                break;
 
            case '*':
                cur += 1;
                _cur_lexeme = lex_multiply;
 
                break;
 
            case '|':
                cur += 1;
                _cur_lexeme = lex_union;
 
                break;
 
            case '$':
                cur += 1;
 
                if (PUGI__IS_CHARTYPEX(*cur, ctx_start_symbol))
                {
                    _cur_lexeme_contents.begin = cur;
 
                    while (PUGI__IS_CHARTYPEX(*cur, ctx_symbol)) cur++;
 
                    if (cur[0] == ':' && PUGI__IS_CHARTYPEX(cur[1], ctx_symbol)) // qname
                    {
                        cur++; // :
 
                        while (PUGI__IS_CHARTYPEX(*cur, ctx_symbol)) cur++;
                    }
 
                    _cur_lexeme_contents.end = cur;
 
                    _cur_lexeme = lex_var_ref;
                }
                else
                {
                    _cur_lexeme = lex_none;
                }
 
                break;
 
            case '(':
                cur += 1;
                _cur_lexeme = lex_open_brace;
 
                break;
 
            case ')':
                cur += 1;
                _cur_lexeme = lex_close_brace;
 
                break;
 
            case '[':
                cur += 1;
                _cur_lexeme = lex_open_square_brace;
 
                break;
 
            case ']':
                cur += 1;
                _cur_lexeme = lex_close_square_brace;
 
                break;
 
            case ',':
                cur += 1;
                _cur_lexeme = lex_comma;
 
                break;
 
            case '/':
                if (*(cur+1) == '/')
                {
                    cur += 2;
                    _cur_lexeme = lex_double_slash;
                }
                else
                {
                    cur += 1;
                    _cur_lexeme = lex_slash;
                }
                break;
 
            case '.':
                if (*(cur+1) == '.')
                {
                    cur += 2;
                    _cur_lexeme = lex_double_dot;
                }
                else if (PUGI__IS_CHARTYPEX(*(cur+1), ctx_digit))
                {
                    _cur_lexeme_contents.begin = cur; // .
 
                    ++cur;
 
                    while (PUGI__IS_CHARTYPEX(*cur, ctx_digit)) cur++;
 
                    _cur_lexeme_contents.end = cur;
 
                    _cur_lexeme = lex_number;
                }
                else
                {
                    cur += 1;
                    _cur_lexeme = lex_dot;
                }
                break;
 
            case '@':
                cur += 1;
                _cur_lexeme = lex_axis_attribute;
 
                break;
 
            case '"':
            case '\'':
            {
                char_t terminator = *cur;
 
                ++cur;
 
                _cur_lexeme_contents.begin = cur;
                while (*cur && *cur != terminator) cur++;
                _cur_lexeme_contents.end = cur;
 
                if (!*cur)
                    _cur_lexeme = lex_none;
                else
                {
                    cur += 1;
                    _cur_lexeme = lex_quoted_string;
                }
 
                break;
            }
 
            case ':':
                if (*(cur+1) == ':')
                {
                    cur += 2;
                    _cur_lexeme = lex_double_colon;
                }
                else
                {
                    _cur_lexeme = lex_none;
                }
                break;
 
            default:
                if (PUGI__IS_CHARTYPEX(*cur, ctx_digit))
                {
                    _cur_lexeme_contents.begin = cur;
 
                    while (PUGI__IS_CHARTYPEX(*cur, ctx_digit)) cur++;
 
                    if (*cur == '.')
                    {
                        cur++;
 
                        while (PUGI__IS_CHARTYPEX(*cur, ctx_digit)) cur++;
                    }
 
                    _cur_lexeme_contents.end = cur;
 
                    _cur_lexeme = lex_number;
                }
                else if (PUGI__IS_CHARTYPEX(*cur, ctx_start_symbol))
                {
                    _cur_lexeme_contents.begin = cur;
 
                    while (PUGI__IS_CHARTYPEX(*cur, ctx_symbol)) cur++;
 
                    if (cur[0] == ':')
                    {
                        if (cur[1] == '*') // namespace test ncname:*
                        {
                            cur += 2; // :*
                        }
                        else if (PUGI__IS_CHARTYPEX(cur[1], ctx_symbol)) // namespace test qname
                        {
                            cur++; // :
 
                            while (PUGI__IS_CHARTYPEX(*cur, ctx_symbol)) cur++;
                        }
                    }
 
                    _cur_lexeme_contents.end = cur;
 
                    _cur_lexeme = lex_string;
                }
                else
                {
                    _cur_lexeme = lex_none;
                }
            }
 
            _cur = cur;
        }

Referenced by xpath_lexer().

state()

const char_t * xpath_lexer::state ( ) const

inline

Definition at line 9261 of file pugixml.cc.

        {
            return _cur;
        }

---

The documentation for this class was generated from the following file:

• pugixml.cc