xpath_parser Struct Reference

Classes
struct	binary_op_t

Public Member Functions
xpath_ast_node *	error (const char *message)
xpath_ast_node *	error_oom ()
xpath_ast_node *	error_rec ()
void *	alloc_node ()
xpath_ast_node *	alloc_node (ast_type_t type, xpath_value_type rettype, const char_t *value)
xpath_ast_node *	alloc_node (ast_type_t type, xpath_value_type rettype, double value)
xpath_ast_node *	alloc_node (ast_type_t type, xpath_value_type rettype, xpath_variable *value)
xpath_ast_node *	alloc_node (ast_type_t type, xpath_value_type rettype, xpath_ast_node *left=0, xpath_ast_node *right=0)
xpath_ast_node *	alloc_node (ast_type_t type, xpath_ast_node *left, axis_t axis, nodetest_t test, const char_t *contents)
xpath_ast_node *	alloc_node (ast_type_t type, xpath_ast_node *left, xpath_ast_node *right, predicate_t test)
const char_t *	alloc_string (const xpath_lexer_string &value)
xpath_ast_node *	parse_function (const xpath_lexer_string &name, size_t argc, xpath_ast_node *args[2])
axis_t	parse_axis_name (const xpath_lexer_string &name, bool &specified)
nodetest_t	parse_node_test_type (const xpath_lexer_string &name)
xpath_ast_node *	parse_primary_expression ()
xpath_ast_node *	parse_filter_expression ()
xpath_ast_node *	parse_step (xpath_ast_node *set)
xpath_ast_node *	parse_relative_location_path (xpath_ast_node *set)
xpath_ast_node *	parse_location_path ()
xpath_ast_node *	parse_path_or_unary_expression ()
xpath_ast_node *	parse_expression_rec (xpath_ast_node *lhs, int limit)
xpath_ast_node *	parse_expression (int limit=0)
	xpath_parser (const char_t *query, xpath_variable_set *variables, xpath_allocator *alloc, xpath_parse_result *result)
xpath_ast_node *	parse ()

Static Public Member Functions
static xpath_ast_node *	parse (const char_t *query, xpath_variable_set *variables, xpath_allocator *alloc, xpath_parse_result *result)

Public Attributes
xpath_allocator *	_alloc
xpath_lexer	_lexer
const char_t *	_query
xpath_variable_set *	_variables
xpath_parse_result *	_result
char_t	_scratch [32]
size_t	_depth

Detailed Description

Definition at line 11305 of file pugixml.cc.

Constructor & Destructor Documentation

xpath_parser()

xpath_parser::xpath_parser ( const char_t * query, xpath_variable_set * variables, xpath_allocator * alloc, xpath_parse_result * result )

inline

Definition at line 12226 of file pugixml.cc.

                                                                                                                            : _alloc(alloc), _lexer(query), _query(query), _variables(variables), _result(result), _depth(0)
        {
        }

Referenced by parse().

Member Function Documentation

alloc_node() [1/7]

void * xpath_parser::alloc_node ( )

inline

Definition at line 11340 of file pugixml.cc.

        {
            return _alloc->allocate(sizeof(xpath_ast_node));
        }

Referenced by alloc_node(), alloc_node(), alloc_node(), alloc_node(), alloc_node(), alloc_node(), parse_expression_rec(), parse_filter_expression(), parse_function(), parse_location_path(), parse_path_or_unary_expression(), parse_primary_expression(), parse_relative_location_path(), and parse_step().

alloc_node() [2/7]

xpath_ast_node * xpath_parser::alloc_node ( ast_type_t type, xpath_ast_node * left, axis_t axis, nodetest_t test, const char_t * contents )

inline

Definition at line 11369 of file pugixml.cc.

        {
            void* memory = alloc_node();
            return memory ? new (memory) xpath_ast_node(type, left, axis, test, contents) : 0;
        }

alloc_node() [3/7]

xpath_ast_node * xpath_parser::alloc_node ( ast_type_t type, xpath_ast_node * left, xpath_ast_node * right, predicate_t test )

inline

Definition at line 11375 of file pugixml.cc.

        {
            void* memory = alloc_node();
            return memory ? new (memory) xpath_ast_node(type, left, right, test) : 0;
        }

alloc_node() [4/7]

xpath_ast_node * xpath_parser::alloc_node ( ast_type_t type, xpath_value_type rettype, const char_t * value )

inline

Definition at line 11345 of file pugixml.cc.

        {
            void* memory = alloc_node();
            return memory ? new (memory) xpath_ast_node(type, rettype, value) : 0;
        }

alloc_node() [5/7]

xpath_ast_node * xpath_parser::alloc_node ( ast_type_t type, xpath_value_type rettype, double value )

inline

Definition at line 11351 of file pugixml.cc.

        {
            void* memory = alloc_node();
            return memory ? new (memory) xpath_ast_node(type, rettype, value) : 0;
        }

alloc_node() [6/7]

xpath_ast_node * xpath_parser::alloc_node ( ast_type_t type, xpath_value_type rettype, xpath_ast_node * left = 0, xpath_ast_node * right = 0 )

inline

Definition at line 11363 of file pugixml.cc.

        {
            void* memory = alloc_node();
            return memory ? new (memory) xpath_ast_node(type, rettype, left, right) : 0;
        }

alloc_node() [7/7]

xpath_ast_node * xpath_parser::alloc_node ( ast_type_t type, xpath_value_type rettype, xpath_variable * value )

inline

Definition at line 11357 of file pugixml.cc.

        {
            void* memory = alloc_node();
            return memory ? new (memory) xpath_ast_node(type, rettype, value) : 0;
        }

alloc_string()

const char_t * xpath_parser::alloc_string ( const xpath_lexer_string & value )

inline

Definition at line 11381 of file pugixml.cc.

        {
            if (!value.begin)
                return PUGIXML_TEXT("");
 
            size_t length = static_cast<size_t>(value.end - value.begin);
 
            char_t* c = static_cast<char_t*>(_alloc->allocate((length + 1) * sizeof(char_t)));
            if (!c) return 0;
 
            memcpy(c, value.begin, length * sizeof(char_t));
            c[length] = 0;
 
            return c;
        }

Referenced by parse_primary_expression(), and parse_step().

error()

xpath_ast_node * xpath_parser::error ( const char * message )

inline

Definition at line 11319 of file pugixml.cc.

        {
            _result->error = message;
            _result->offset = _lexer.current_pos() - _query;
 
            return 0;
        }

Referenced by error_rec(), parse(), parse_expression_rec(), parse_filter_expression(), parse_function(), parse_path_or_unary_expression(), parse_primary_expression(), and parse_step().

error_oom()

xpath_ast_node * xpath_parser::error_oom ( )

inline

Definition at line 11327 of file pugixml.cc.

        {
            assert(_alloc->_error);
            *_alloc->_error = true;
 
            return 0;
        }

Referenced by parse_primary_expression().

error_rec()

xpath_ast_node * xpath_parser::error_rec ( )

inline

Definition at line 11335 of file pugixml.cc.

        {
            return error("Exceeded maximum allowed query depth");
        }

Referenced by parse_expression(), parse_expression_rec(), parse_filter_expression(), parse_primary_expression(), parse_relative_location_path(), and parse_step().

parse() [1/2]

xpath_ast_node * xpath_parser::parse ( )

inline

Definition at line 12230 of file pugixml.cc.

        {
            xpath_ast_node* n = parse_expression();
            if (!n) return 0;
 
            assert(_depth == 0);
 
            // check if there are unparsed tokens left
            if (_lexer.current() != lex_eof)
                return error("Incorrect query");
 
            return n;
        }

Referenced by parse().

parse() [2/2]

xpath_ast_node * xpath_parser::parse ( const char_t * query, xpath_variable_set * variables, xpath_allocator * alloc, xpath_parse_result * result )

inlinestatic

Definition at line 12244 of file pugixml.cc.

        {
            xpath_parser parser(query, variables, alloc, result);
 
            return parser.parse();
        }

parse_axis_name()

axis_t xpath_parser::parse_axis_name ( const xpath_lexer_string & name, bool & specified )

inline

Definition at line 11517 of file pugixml.cc.

        {
            specified = true;
 
            switch (name.begin[0])
            {
            case 'a':
                if (name == PUGIXML_TEXT("ancestor"))
                    return axis_ancestor;
                else if (name == PUGIXML_TEXT("ancestor-or-self"))
                    return axis_ancestor_or_self;
                else if (name == PUGIXML_TEXT("attribute"))
                    return axis_attribute;
 
                break;
 
            case 'c':
                if (name == PUGIXML_TEXT("child"))
                    return axis_child;
 
                break;
 
            case 'd':
                if (name == PUGIXML_TEXT("descendant"))
                    return axis_descendant;
                else if (name == PUGIXML_TEXT("descendant-or-self"))
                    return axis_descendant_or_self;
 
                break;
 
            case 'f':
                if (name == PUGIXML_TEXT("following"))
                    return axis_following;
                else if (name == PUGIXML_TEXT("following-sibling"))
                    return axis_following_sibling;
 
                break;
 
            case 'n':
                if (name == PUGIXML_TEXT("namespace"))
                    return axis_namespace;
 
                break;
 
            case 'p':
                if (name == PUGIXML_TEXT("parent"))
                    return axis_parent;
                else if (name == PUGIXML_TEXT("preceding"))
                    return axis_preceding;
                else if (name == PUGIXML_TEXT("preceding-sibling"))
                    return axis_preceding_sibling;
 
                break;
 
            case 's':
                if (name == PUGIXML_TEXT("self"))
                    return axis_self;
 
                break;
 
            default:
                break;
            }
 
            specified = false;
            return axis_child;
        }

Referenced by parse_step().

parse_expression()

xpath_ast_node * xpath_parser::parse_expression ( int limit = 0 )

inline

Definition at line 12209 of file pugixml.cc.

        {
            size_t old_depth = _depth;
 
            if (++_depth > xpath_ast_depth_limit)
                return error_rec();
 
            xpath_ast_node* n = parse_path_or_unary_expression();
            if (!n) return 0;
 
            n = parse_expression_rec(n, limit);
 
            _depth = old_depth;
 
            return n;
        }

Referenced by parse(), parse_filter_expression(), parse_path_or_unary_expression(), parse_primary_expression(), and parse_step().

parse_expression_rec()

xpath_ast_node * xpath_parser::parse_expression_rec ( xpath_ast_node * lhs, int limit )

inline

Definition at line 12155 of file pugixml.cc.

        {
            binary_op_t op = binary_op_t::parse(_lexer);
 
            while (op.asttype != ast_unknown && op.precedence >= limit)
            {
                _lexer.next();
 
                if (++_depth > xpath_ast_depth_limit)
                    return error_rec();
 
                xpath_ast_node* rhs = parse_path_or_unary_expression();
                if (!rhs) return 0;
 
                binary_op_t nextop = binary_op_t::parse(_lexer);
 
                while (nextop.asttype != ast_unknown && nextop.precedence > op.precedence)
                {
                    rhs = parse_expression_rec(rhs, nextop.precedence);
                    if (!rhs) return 0;
 
                    nextop = binary_op_t::parse(_lexer);
                }
 
                if (op.asttype == ast_op_union && (lhs->rettype() != xpath_type_node_set || rhs->rettype() != xpath_type_node_set))
                    return error("Union operator has to be applied to node sets");
 
                lhs = alloc_node(op.asttype, op.rettype, lhs, rhs);
                if (!lhs) return 0;
 
                op = binary_op_t::parse(_lexer);
            }
 
            return lhs;
        }

Referenced by parse_expression(), and parse_expression_rec().

parse_filter_expression()

xpath_ast_node * xpath_parser::parse_filter_expression ( )

inline

Definition at line 11734 of file pugixml.cc.

        {
            xpath_ast_node* n = parse_primary_expression();
            if (!n) return 0;
 
            size_t old_depth = _depth;
 
            while (_lexer.current() == lex_open_square_brace)
            {
                _lexer.next();
 
                if (++_depth > xpath_ast_depth_limit)
                    return error_rec();
 
                if (n->rettype() != xpath_type_node_set)
                    return error("Predicate has to be applied to node set");
 
                xpath_ast_node* expr = parse_expression();
                if (!expr) return 0;
 
                n = alloc_node(ast_filter, n, expr, predicate_default);
                if (!n) return 0;
 
                if (_lexer.current() != lex_close_square_brace)
                    return error("Expected ']' to match an opening '['");
 
                _lexer.next();
            }
 
            _depth = old_depth;
 
            return n;
        }

Referenced by parse_path_or_unary_expression().

parse_function()

xpath_ast_node * xpath_parser::parse_function ( const xpath_lexer_string & name, size_t argc, xpath_ast_node * args[2] )

inline

Definition at line 11397 of file pugixml.cc.

        {
            switch (name.begin[0])
            {
            case 'b':
                if (name == PUGIXML_TEXT("boolean") && argc == 1)
                    return alloc_node(ast_func_boolean, xpath_type_boolean, args[0]);
 
                break;
 
            case 'c':
                if (name == PUGIXML_TEXT("count") && argc == 1)
                {
                    if (args[0]->rettype() != xpath_type_node_set) return error("Function has to be applied to node set");
                    return alloc_node(ast_func_count, xpath_type_number, args[0]);
                }
                else if (name == PUGIXML_TEXT("contains") && argc == 2)
                    return alloc_node(ast_func_contains, xpath_type_boolean, args[0], args[1]);
                else if (name == PUGIXML_TEXT("concat") && argc >= 2)
                    return alloc_node(ast_func_concat, xpath_type_string, args[0], args[1]);
                else if (name == PUGIXML_TEXT("ceiling") && argc == 1)
                    return alloc_node(ast_func_ceiling, xpath_type_number, args[0]);
 
                break;
 
            case 'f':
                if (name == PUGIXML_TEXT("false") && argc == 0)
                    return alloc_node(ast_func_false, xpath_type_boolean);
                else if (name == PUGIXML_TEXT("floor") && argc == 1)
                    return alloc_node(ast_func_floor, xpath_type_number, args[0]);
 
                break;
 
            case 'i':
                if (name == PUGIXML_TEXT("id") && argc == 1)
                    return alloc_node(ast_func_id, xpath_type_node_set, args[0]);
 
                break;
 
            case 'l':
                if (name == PUGIXML_TEXT("last") && argc == 0)
                    return alloc_node(ast_func_last, xpath_type_number);
                else if (name == PUGIXML_TEXT("lang") && argc == 1)
                    return alloc_node(ast_func_lang, xpath_type_boolean, args[0]);
                else if (name == PUGIXML_TEXT("local-name") && argc <= 1)
                {
                    if (argc == 1 && args[0]->rettype() != xpath_type_node_set) return error("Function has to be applied to node set");
                    return alloc_node(argc == 0 ? ast_func_local_name_0 : ast_func_local_name_1, xpath_type_string, args[0]);
                }
 
                break;
 
            case 'n':
                if (name == PUGIXML_TEXT("name") && argc <= 1)
                {
                    if (argc == 1 && args[0]->rettype() != xpath_type_node_set) return error("Function has to be applied to node set");
                    return alloc_node(argc == 0 ? ast_func_name_0 : ast_func_name_1, xpath_type_string, args[0]);
                }
                else if (name == PUGIXML_TEXT("namespace-uri") && argc <= 1)
                {
                    if (argc == 1 && args[0]->rettype() != xpath_type_node_set) return error("Function has to be applied to node set");
                    return alloc_node(argc == 0 ? ast_func_namespace_uri_0 : ast_func_namespace_uri_1, xpath_type_string, args[0]);
                }
                else if (name == PUGIXML_TEXT("normalize-space") && argc <= 1)
                    return alloc_node(argc == 0 ? ast_func_normalize_space_0 : ast_func_normalize_space_1, xpath_type_string, args[0], args[1]);
                else if (name == PUGIXML_TEXT("not") && argc == 1)
                    return alloc_node(ast_func_not, xpath_type_boolean, args[0]);
                else if (name == PUGIXML_TEXT("number") && argc <= 1)
                    return alloc_node(argc == 0 ? ast_func_number_0 : ast_func_number_1, xpath_type_number, args[0]);
 
                break;
 
            case 'p':
                if (name == PUGIXML_TEXT("position") && argc == 0)
                    return alloc_node(ast_func_position, xpath_type_number);
 
                break;
 
            case 'r':
                if (name == PUGIXML_TEXT("round") && argc == 1)
                    return alloc_node(ast_func_round, xpath_type_number, args[0]);
 
                break;
 
            case 's':
                if (name == PUGIXML_TEXT("string") && argc <= 1)
                    return alloc_node(argc == 0 ? ast_func_string_0 : ast_func_string_1, xpath_type_string, args[0]);
                else if (name == PUGIXML_TEXT("string-length") && argc <= 1)
                    return alloc_node(argc == 0 ? ast_func_string_length_0 : ast_func_string_length_1, xpath_type_number, args[0]);
                else if (name == PUGIXML_TEXT("starts-with") && argc == 2)
                    return alloc_node(ast_func_starts_with, xpath_type_boolean, args[0], args[1]);
                else if (name == PUGIXML_TEXT("substring-before") && argc == 2)
                    return alloc_node(ast_func_substring_before, xpath_type_string, args[0], args[1]);
                else if (name == PUGIXML_TEXT("substring-after") && argc == 2)
                    return alloc_node(ast_func_substring_after, xpath_type_string, args[0], args[1]);
                else if (name == PUGIXML_TEXT("substring") && (argc == 2 || argc == 3))
                    return alloc_node(argc == 2 ? ast_func_substring_2 : ast_func_substring_3, xpath_type_string, args[0], args[1]);
                else if (name == PUGIXML_TEXT("sum") && argc == 1)
                {
                    if (args[0]->rettype() != xpath_type_node_set) return error("Function has to be applied to node set");
                    return alloc_node(ast_func_sum, xpath_type_number, args[0]);
                }
 
                break;
 
            case 't':
                if (name == PUGIXML_TEXT("translate") && argc == 3)
                    return alloc_node(ast_func_translate, xpath_type_string, args[0], args[1]);
                else if (name == PUGIXML_TEXT("true") && argc == 0)
                    return alloc_node(ast_func_true, xpath_type_boolean);
 
                break;
 
            default:
                break;
            }
 
            return error("Unrecognized function or wrong parameter count");
        }

Referenced by parse_primary_expression().

parse_location_path()

xpath_ast_node * xpath_parser::parse_location_path ( )

inline

Definition at line 11983 of file pugixml.cc.

        {
            if (_lexer.current() == lex_slash)
            {
                _lexer.next();
 
                xpath_ast_node* n = alloc_node(ast_step_root, xpath_type_node_set);
                if (!n) return 0;
 
                // relative location path can start from axis_attribute, dot, double_dot, multiply and string lexemes; any other lexeme means standalone root path
                lexeme_t l = _lexer.current();
 
                if (l == lex_string || l == lex_axis_attribute || l == lex_dot || l == lex_double_dot || l == lex_multiply)
                    return parse_relative_location_path(n);
                else
                    return n;
            }
            else if (_lexer.current() == lex_double_slash)
            {
                _lexer.next();
 
                xpath_ast_node* n = alloc_node(ast_step_root, xpath_type_node_set);
                if (!n) return 0;
 
                n = alloc_node(ast_step, n, axis_descendant_or_self, nodetest_type_node, 0);
                if (!n) return 0;
 
                return parse_relative_location_path(n);
            }
 
            // else clause moved outside of if because of bogus warning 'control may reach end of non-void function being inlined' in gcc 4.0.1
            return parse_relative_location_path(0);
        }

Referenced by parse_path_or_unary_expression().

parse_node_test_type()

nodetest_t xpath_parser::parse_node_test_type ( const xpath_lexer_string & name )

inline

Definition at line 11585 of file pugixml.cc.

        {
            switch (name.begin[0])
            {
            case 'c':
                if (name == PUGIXML_TEXT("comment"))
                    return nodetest_type_comment;
 
                break;
 
            case 'n':
                if (name == PUGIXML_TEXT("node"))
                    return nodetest_type_node;
 
                break;
 
            case 'p':
                if (name == PUGIXML_TEXT("processing-instruction"))
                    return nodetest_type_pi;
 
                break;
 
            case 't':
                if (name == PUGIXML_TEXT("text"))
                    return nodetest_type_text;
 
                break;
 
            default:
                break;
            }
 
            return nodetest_none;
        }

Referenced by parse_path_or_unary_expression(), and parse_step().

parse_path_or_unary_expression()

xpath_ast_node * xpath_parser::parse_path_or_unary_expression ( )

inline

Definition at line 12023 of file pugixml.cc.

        {
            // Clarification.
            // PathExpr begins with either LocationPath or FilterExpr.
            // FilterExpr begins with PrimaryExpr
            // PrimaryExpr begins with '$' in case of it being a variable reference,
            // '(' in case of it being an expression, string literal, number constant or
            // function call.
            if (_lexer.current() == lex_var_ref || _lexer.current() == lex_open_brace ||
                _lexer.current() == lex_quoted_string || _lexer.current() == lex_number ||
                _lexer.current() == lex_string)
            {
                if (_lexer.current() == lex_string)
                {
                    // This is either a function call, or not - if not, we shall proceed with location path
                    const char_t* state = _lexer.state();
 
                    while (PUGI__IS_CHARTYPE(*state, ct_space)) ++state;
 
                    if (*state != '(')
                        return parse_location_path();
 
                    // This looks like a function call; however this still can be a node-test. Check it.
                    if (parse_node_test_type(_lexer.contents()) != nodetest_none)
                        return parse_location_path();
                }
 
                xpath_ast_node* n = parse_filter_expression();
                if (!n) return 0;
 
                if (_lexer.current() == lex_slash || _lexer.current() == lex_double_slash)
                {
                    lexeme_t l = _lexer.current();
                    _lexer.next();
 
                    if (l == lex_double_slash)
                    {
                        if (n->rettype() != xpath_type_node_set)
                            return error("Step has to be applied to node set");
 
                        n = alloc_node(ast_step, n, axis_descendant_or_self, nodetest_type_node, 0);
                        if (!n) return 0;
                    }
 
                    // select from location path
                    return parse_relative_location_path(n);
                }
 
                return n;
            }
            else if (_lexer.current() == lex_minus)
            {
                _lexer.next();
 
                // precedence 7+ - only parses union expressions
                xpath_ast_node* n = parse_expression(7);
                if (!n) return 0;
 
                return alloc_node(ast_op_negate, xpath_type_number, n);
            }
            else
            {
                return parse_location_path();
            }
        }

Referenced by parse_expression(), and parse_expression_rec().

parse_primary_expression()

xpath_ast_node * xpath_parser::parse_primary_expression ( )

inline

Definition at line 11621 of file pugixml.cc.

        {
            switch (_lexer.current())
            {
            case lex_var_ref:
            {
                xpath_lexer_string name = _lexer.contents();
 
                if (!_variables)
                    return error("Unknown variable: variable set is not provided");
 
                xpath_variable* var = 0;
                if (!get_variable_scratch(_scratch, _variables, name.begin, name.end, &var))
                    return error_oom();
 
                if (!var)
                    return error("Unknown variable: variable set does not contain the given name");
 
                _lexer.next();
 
                return alloc_node(ast_variable, var->type(), var);
            }
 
            case lex_open_brace:
            {
                _lexer.next();
 
                xpath_ast_node* n = parse_expression();
                if (!n) return 0;
 
                if (_lexer.current() != lex_close_brace)
                    return error("Expected ')' to match an opening '('");
 
                _lexer.next();
 
                return n;
            }
 
            case lex_quoted_string:
            {
                const char_t* value = alloc_string(_lexer.contents());
                if (!value) return 0;
 
                _lexer.next();
 
                return alloc_node(ast_string_constant, xpath_type_string, value);
            }
 
            case lex_number:
            {
                double value = 0;
 
                if (!convert_string_to_number_scratch(_scratch, _lexer.contents().begin, _lexer.contents().end, &value))
                    return error_oom();
 
                _lexer.next();
 
                return alloc_node(ast_number_constant, xpath_type_number, value);
            }
 
            case lex_string:
            {
                xpath_ast_node* args[2] = {0};
                size_t argc = 0;
 
                xpath_lexer_string function = _lexer.contents();
                _lexer.next();
 
                xpath_ast_node* last_arg = 0;
 
                if (_lexer.current() != lex_open_brace)
                    return error("Unrecognized function call");
                _lexer.next();
 
                size_t old_depth = _depth;
 
                while (_lexer.current() != lex_close_brace)
                {
                    if (argc > 0)
                    {
                        if (_lexer.current() != lex_comma)
                            return error("No comma between function arguments");
                        _lexer.next();
                    }
 
                    if (++_depth > xpath_ast_depth_limit)
                        return error_rec();
 
                    xpath_ast_node* n = parse_expression();
                    if (!n) return 0;
 
                    if (argc < 2) args[argc] = n;
                    else last_arg->set_next(n);
 
                    argc++;
                    last_arg = n;
                }
 
                _lexer.next();
 
                _depth = old_depth;
 
                return parse_function(function, argc, args);
            }
 
            default:
                return error("Unrecognizable primary expression");
            }
        }

Referenced by parse_filter_expression().

parse_relative_location_path()

xpath_ast_node * xpath_parser::parse_relative_location_path ( xpath_ast_node * set )

inline

Definition at line 11949 of file pugixml.cc.

        {
            xpath_ast_node* n = parse_step(set);
            if (!n) return 0;
 
            size_t old_depth = _depth;
 
            while (_lexer.current() == lex_slash || _lexer.current() == lex_double_slash)
            {
                lexeme_t l = _lexer.current();
                _lexer.next();
 
                if (l == lex_double_slash)
                {
                    n = alloc_node(ast_step, n, axis_descendant_or_self, nodetest_type_node, 0);
                    if (!n) return 0;
 
                    ++_depth;
                }
 
                if (++_depth > xpath_ast_depth_limit)
                    return error_rec();
 
                n = parse_step(n);
                if (!n) return 0;
            }
 
            _depth = old_depth;
 
            return n;
        }

Referenced by parse_location_path(), and parse_path_or_unary_expression().

parse_step()

xpath_ast_node * xpath_parser::parse_step ( xpath_ast_node * set )

inline

Definition at line 11773 of file pugixml.cc.

        {
            if (set && set->rettype() != xpath_type_node_set)
                return error("Step has to be applied to node set");
 
            bool axis_specified = false;
            axis_t axis = axis_child; // implied child axis
 
            if (_lexer.current() == lex_axis_attribute)
            {
                axis = axis_attribute;
                axis_specified = true;
 
                _lexer.next();
            }
            else if (_lexer.current() == lex_dot)
            {
                _lexer.next();
 
                if (_lexer.current() == lex_open_square_brace)
                    return error("Predicates are not allowed after an abbreviated step");
 
                return alloc_node(ast_step, set, axis_self, nodetest_type_node, 0);
            }
            else if (_lexer.current() == lex_double_dot)
            {
                _lexer.next();
 
                if (_lexer.current() == lex_open_square_brace)
                    return error("Predicates are not allowed after an abbreviated step");
 
                return alloc_node(ast_step, set, axis_parent, nodetest_type_node, 0);
            }
 
            nodetest_t nt_type = nodetest_none;
            xpath_lexer_string nt_name;
 
            if (_lexer.current() == lex_string)
            {
                // node name test
                nt_name = _lexer.contents();
                _lexer.next();
 
                // was it an axis name?
                if (_lexer.current() == lex_double_colon)
                {
                    // parse axis name
                    if (axis_specified)
                        return error("Two axis specifiers in one step");
 
                    axis = parse_axis_name(nt_name, axis_specified);
 
                    if (!axis_specified)
                        return error("Unknown axis");
 
                    // read actual node test
                    _lexer.next();
 
                    if (_lexer.current() == lex_multiply)
                    {
                        nt_type = nodetest_all;
                        nt_name = xpath_lexer_string();
                        _lexer.next();
                    }
                    else if (_lexer.current() == lex_string)
                    {
                        nt_name = _lexer.contents();
                        _lexer.next();
                    }
                    else
                    {
                        return error("Unrecognized node test");
                    }
                }
 
                if (nt_type == nodetest_none)
                {
                    // node type test or processing-instruction
                    if (_lexer.current() == lex_open_brace)
                    {
                        _lexer.next();
 
                        if (_lexer.current() == lex_close_brace)
                        {
                            _lexer.next();
 
                            nt_type = parse_node_test_type(nt_name);
 
                            if (nt_type == nodetest_none)
                                return error("Unrecognized node type");
 
                            nt_name = xpath_lexer_string();
                        }
                        else if (nt_name == PUGIXML_TEXT("processing-instruction"))
                        {
                            if (_lexer.current() != lex_quoted_string)
                                return error("Only literals are allowed as arguments to processing-instruction()");
 
                            nt_type = nodetest_pi;
                            nt_name = _lexer.contents();
                            _lexer.next();
 
                            if (_lexer.current() != lex_close_brace)
                                return error("Unmatched brace near processing-instruction()");
                            _lexer.next();
                        }
                        else
                        {
                            return error("Unmatched brace near node type test");
                        }
                    }
                    // QName or NCName:*
                    else
                    {
                        if (nt_name.end - nt_name.begin > 2 && nt_name.end[-2] == ':' && nt_name.end[-1] == '*') // NCName:*
                        {
                            nt_name.end--; // erase *
 
                            nt_type = nodetest_all_in_namespace;
                        }
                        else
                        {
                            nt_type = nodetest_name;
                        }
                    }
                }
            }
            else if (_lexer.current() == lex_multiply)
            {
                nt_type = nodetest_all;
                _lexer.next();
            }
            else
            {
                return error("Unrecognized node test");
            }
 
            const char_t* nt_name_copy = alloc_string(nt_name);
            if (!nt_name_copy) return 0;
 
            xpath_ast_node* n = alloc_node(ast_step, set, axis, nt_type, nt_name_copy);
            if (!n) return 0;
 
            size_t old_depth = _depth;
 
            xpath_ast_node* last = 0;
 
            while (_lexer.current() == lex_open_square_brace)
            {
                _lexer.next();
 
                if (++_depth > xpath_ast_depth_limit)
                    return error_rec();
 
                xpath_ast_node* expr = parse_expression();
                if (!expr) return 0;
 
                xpath_ast_node* pred = alloc_node(ast_predicate, 0, expr, predicate_default);
                if (!pred) return 0;
 
                if (_lexer.current() != lex_close_square_brace)
                    return error("Expected ']' to match an opening '['");
                _lexer.next();
 
                if (last) last->set_next(pred);
                else n->set_right(pred);
 
                last = pred;
            }
 
            _depth = old_depth;
 
            return n;
        }

Referenced by parse_relative_location_path().

Member Data Documentation

_alloc

xpath_allocator* xpath_parser::_alloc

Definition at line 11307 of file pugixml.cc.

Referenced by alloc_node(), alloc_string(), error_oom(), and xpath_parser().

_depth

size_t xpath_parser::_depth

Definition at line 11317 of file pugixml.cc.

Referenced by parse(), parse_expression(), parse_expression_rec(), parse_filter_expression(), parse_primary_expression(), parse_relative_location_path(), parse_step(), and xpath_parser().

_lexer

xpath_lexer xpath_parser::_lexer

Definition at line 11308 of file pugixml.cc.

Referenced by error(), parse(), parse_expression_rec(), parse_filter_expression(), parse_location_path(), parse_path_or_unary_expression(), parse_primary_expression(), parse_relative_location_path(), parse_step(), and xpath_parser().

_query

const char_t* xpath_parser::_query

Definition at line 11310 of file pugixml.cc.

Referenced by error(), and xpath_parser().

_result

xpath_parse_result* xpath_parser::_result

Definition at line 11313 of file pugixml.cc.

Referenced by error(), and xpath_parser().

_scratch

char_t xpath_parser::_scratch[32]

Definition at line 11315 of file pugixml.cc.

Referenced by parse_primary_expression().

_variables

xpath_variable_set* xpath_parser::_variables

Definition at line 11311 of file pugixml.cc.

Referenced by parse_primary_expression(), and xpath_parser().

---

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

• pugixml.cc