xpath_ast_node Class Reference

Public Member Functions
	xpath_ast_node (ast_type_t type, xpath_value_type rettype_, const char_t *value)
	xpath_ast_node (ast_type_t type, xpath_value_type rettype_, double value)
	xpath_ast_node (ast_type_t type, xpath_value_type rettype_, xpath_variable *value)
	xpath_ast_node (ast_type_t type, xpath_value_type rettype_, xpath_ast_node *left=0, xpath_ast_node *right=0)
	xpath_ast_node (ast_type_t type, xpath_ast_node *left, axis_t axis, nodetest_t test, const char_t *contents)
	xpath_ast_node (ast_type_t type, xpath_ast_node *left, xpath_ast_node *right, predicate_t test)
void	set_next (xpath_ast_node *value)
void	set_right (xpath_ast_node *value)
bool	eval_boolean (const xpath_context &c, const xpath_stack &stack)
double	eval_number (const xpath_context &c, const xpath_stack &stack)
xpath_string	eval_string_concat (const xpath_context &c, const xpath_stack &stack)
xpath_string	eval_string (const xpath_context &c, const xpath_stack &stack)
xpath_node_set_raw	eval_node_set (const xpath_context &c, const xpath_stack &stack, nodeset_eval_t eval)
void	optimize (xpath_allocator *alloc)
void	optimize_self (xpath_allocator *alloc)
bool	is_posinv_expr () const
bool	is_posinv_step () const
xpath_value_type	rettype () const

Detailed Description

Definition at line 9670 of file pugixml.cc.

Constructor & Destructor Documentation

xpath_ast_node() [1/6]

xpath_ast_node::xpath_ast_node ( ast_type_t type, xpath_value_type rettype_, const char_t * value )

inline

Definition at line 10421 of file pugixml.cc.

                                                                                       :
            _type(static_cast<char>(type)), _rettype(static_cast<char>(rettype_)), _axis(0), _test(0), _left(0), _right(0), _next(0)
        {
            assert(type == ast_string_constant);
            _data.string = value;
        }

xpath_ast_node() [2/6]

xpath_ast_node::xpath_ast_node ( ast_type_t type, xpath_value_type rettype_, double value )

inline

Definition at line 10428 of file pugixml.cc.

                                                                                :
            _type(static_cast<char>(type)), _rettype(static_cast<char>(rettype_)), _axis(0), _test(0), _left(0), _right(0), _next(0)
        {
            assert(type == ast_number_constant);
            _data.number = value;
        }

xpath_ast_node() [3/6]

xpath_ast_node::xpath_ast_node ( ast_type_t type, xpath_value_type rettype_, xpath_variable * value )

inline

Definition at line 10435 of file pugixml.cc.

                                                                                         :
            _type(static_cast<char>(type)), _rettype(static_cast<char>(rettype_)), _axis(0), _test(0), _left(0), _right(0), _next(0)
        {
            assert(type == ast_variable);
            _data.variable = value;
        }

xpath_ast_node() [4/6]

xpath_ast_node::xpath_ast_node ( ast_type_t type, xpath_value_type rettype_, xpath_ast_node * left = 0, xpath_ast_node * right = 0 )

inline

Definition at line 10442 of file pugixml.cc.

                                                                                                                   :
            _type(static_cast<char>(type)), _rettype(static_cast<char>(rettype_)), _axis(0), _test(0), _left(left), _right(right), _next(0)
        {
        }

xpath_ast_node() [5/6]

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

inline

Definition at line 10447 of file pugixml.cc.

                                                                                                                   :
            _type(static_cast<char>(type)), _rettype(xpath_type_node_set), _axis(static_cast<char>(axis)), _test(static_cast<char>(test)), _left(left), _right(0), _next(0)
        {
            assert(type == ast_step);
            _data.nodetest = contents;
        }

xpath_ast_node() [6/6]

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

inline

Definition at line 10454 of file pugixml.cc.

                                                                                                      :
            _type(static_cast<char>(type)), _rettype(xpath_type_node_set), _axis(0), _test(static_cast<char>(test)), _left(left), _right(right), _next(0)
        {
            assert(type == ast_filter || type == ast_predicate);
        }

Member Function Documentation

eval_boolean()

bool xpath_ast_node::eval_boolean ( const xpath_context & c, const xpath_stack & stack )

inline

Definition at line 10470 of file pugixml.cc.

        {
            switch (_type)
            {
            case ast_op_or:
                return _left->eval_boolean(c, stack) || _right->eval_boolean(c, stack);
 
            case ast_op_and:
                return _left->eval_boolean(c, stack) && _right->eval_boolean(c, stack);
 
            case ast_op_equal:
                return compare_eq(_left, _right, c, stack, equal_to());
 
            case ast_op_not_equal:
                return compare_eq(_left, _right, c, stack, not_equal_to());
 
            case ast_op_less:
                return compare_rel(_left, _right, c, stack, less());
 
            case ast_op_greater:
                return compare_rel(_right, _left, c, stack, less());
 
            case ast_op_less_or_equal:
                return compare_rel(_left, _right, c, stack, less_equal());
 
            case ast_op_greater_or_equal:
                return compare_rel(_right, _left, c, stack, less_equal());
 
            case ast_func_starts_with:
            {
                xpath_allocator_capture cr(stack.result);
 
                xpath_string lr = _left->eval_string(c, stack);
                xpath_string rr = _right->eval_string(c, stack);
 
                return starts_with(lr.c_str(), rr.c_str());
            }
 
            case ast_func_contains:
            {
                xpath_allocator_capture cr(stack.result);
 
                xpath_string lr = _left->eval_string(c, stack);
                xpath_string rr = _right->eval_string(c, stack);
 
                return find_substring(lr.c_str(), rr.c_str()) != 0;
            }
 
            case ast_func_boolean:
                return _left->eval_boolean(c, stack);
 
            case ast_func_not:
                return !_left->eval_boolean(c, stack);
 
            case ast_func_true:
                return true;
 
            case ast_func_false:
                return false;
 
            case ast_func_lang:
            {
                if (c.n.attribute()) return false;
 
                xpath_allocator_capture cr(stack.result);
 
                xpath_string lang = _left->eval_string(c, stack);
 
                for (xml_node n = c.n.node(); n; n = n.parent())
                {
                    xml_attribute a = n.attribute(PUGIXML_TEXT("xml:lang"));
 
                    if (a)
                    {
                        const char_t* value = a.value();
 
                        // strnicmp / strncasecmp is not portable
                        for (const char_t* lit = lang.c_str(); *lit; ++lit)
                        {
                            if (tolower_ascii(*lit) != tolower_ascii(*value)) return false;
                            ++value;
                        }
 
                        return *value == 0 || *value == '-';
                    }
                }
 
                return false;
            }
 
            case ast_opt_compare_attribute:
            {
                const char_t* value = (_right->_type == ast_string_constant) ? _right->_data.string : _right->_data.variable->get_string();
 
                xml_attribute attr = c.n.node().attribute(_left->_data.nodetest);
 
                return attr && strequal(attr.value(), value) && is_xpath_attribute(attr.name());
            }
 
            case ast_variable:
            {
                assert(_rettype == _data.variable->type());
 
                if (_rettype == xpath_type_boolean)
                    return _data.variable->get_boolean();
 
                // variable needs to be converted to the correct type, this is handled by the fallthrough block below
                break;
            }
 
            default:
                ;
            }
 
            // none of the ast types that return the value directly matched, we need to perform type conversion
            switch (_rettype)
            {
            case xpath_type_number:
                return convert_number_to_boolean(eval_number(c, stack));
 
            case xpath_type_string:
            {
                xpath_allocator_capture cr(stack.result);
 
                return !eval_string(c, stack).empty();
            }
 
            case xpath_type_node_set:
            {
                xpath_allocator_capture cr(stack.result);
 
                return !eval_node_set(c, stack, nodeset_eval_any).empty();
            }
 
            default:
                assert(false && "Wrong expression for return type boolean"); // unreachable
                return false;
            }
        }

Referenced by eval_number(), and eval_string().

eval_node_set()

xpath_node_set_raw xpath_ast_node::eval_node_set ( const xpath_context & c, const xpath_stack & stack, nodeset_eval_t eval )

inline

Definition at line 11033 of file pugixml.cc.

        {
            switch (_type)
            {
            case ast_op_union:
            {
                xpath_allocator_capture cr(stack.temp);
 
                xpath_stack swapped_stack = {stack.temp, stack.result};
 
                xpath_node_set_raw ls = _left->eval_node_set(c, stack, eval);
                xpath_node_set_raw rs = _right->eval_node_set(c, swapped_stack, eval);
 
                // we can optimize merging two sorted sets, but this is a very rare operation, so don't bother
                ls.set_type(xpath_node_set::type_unsorted);
 
                ls.append(rs.begin(), rs.end(), stack.result);
                ls.remove_duplicates(stack.temp);
 
                return ls;
            }
 
            case ast_filter:
            {
                xpath_node_set_raw set = _left->eval_node_set(c, stack, _test == predicate_constant_one ? nodeset_eval_first : nodeset_eval_all);
 
                // either expression is a number or it contains position() call; sort by document order
                if (_test != predicate_posinv) set.sort_do();
 
                bool once = eval_once(set.type(), eval);
 
                apply_predicate(set, 0, stack, once);
 
                return set;
            }
 
            case ast_func_id:
                return xpath_node_set_raw();
 
            case ast_step:
            {
                switch (_axis)
                {
                case axis_ancestor:
                    return step_do(c, stack, eval, axis_to_type<axis_ancestor>());
 
                case axis_ancestor_or_self:
                    return step_do(c, stack, eval, axis_to_type<axis_ancestor_or_self>());
 
                case axis_attribute:
                    return step_do(c, stack, eval, axis_to_type<axis_attribute>());
 
                case axis_child:
                    return step_do(c, stack, eval, axis_to_type<axis_child>());
 
                case axis_descendant:
                    return step_do(c, stack, eval, axis_to_type<axis_descendant>());
 
                case axis_descendant_or_self:
                    return step_do(c, stack, eval, axis_to_type<axis_descendant_or_self>());
 
                case axis_following:
                    return step_do(c, stack, eval, axis_to_type<axis_following>());
 
                case axis_following_sibling:
                    return step_do(c, stack, eval, axis_to_type<axis_following_sibling>());
 
                case axis_namespace:
                    // namespaced axis is not supported
                    return xpath_node_set_raw();
 
                case axis_parent:
                    return step_do(c, stack, eval, axis_to_type<axis_parent>());
 
                case axis_preceding:
                    return step_do(c, stack, eval, axis_to_type<axis_preceding>());
 
                case axis_preceding_sibling:
                    return step_do(c, stack, eval, axis_to_type<axis_preceding_sibling>());
 
                case axis_self:
                    return step_do(c, stack, eval, axis_to_type<axis_self>());
 
                default:
                    assert(false && "Unknown axis"); // unreachable
                    return xpath_node_set_raw();
                }
            }
 
            case ast_step_root:
            {
                assert(!_right); // root step can't have any predicates
 
                xpath_node_set_raw ns;
 
                ns.set_type(xpath_node_set::type_sorted);
 
                if (c.n.node()) ns.push_back(c.n.node().root(), stack.result);
                else if (c.n.attribute()) ns.push_back(c.n.parent().root(), stack.result);
 
                return ns;
            }
 
            case ast_variable:
            {
                assert(_rettype == _data.variable->type());
 
                if (_rettype == xpath_type_node_set)
                {
                    const xpath_node_set& s = _data.variable->get_node_set();
 
                    xpath_node_set_raw ns;
 
                    ns.set_type(s.type());
                    ns.append(s.begin(), s.end(), stack.result);
 
                    return ns;
                }
 
                // variable needs to be converted to the correct type, this is handled by the fallthrough block below
                break;
            }
 
            default:
                ;
            }
 
            // none of the ast types that return the value directly matched, but conversions to node set are invalid
            assert(false && "Wrong expression for return type node set"); // unreachable
            return xpath_node_set_raw();
        }

Referenced by eval_boolean(), and eval_string().

eval_number()

double xpath_ast_node::eval_number ( const xpath_context & c, const xpath_stack & stack )

inline

Definition at line 10610 of file pugixml.cc.

        {
            switch (_type)
            {
            case ast_op_add:
                return _left->eval_number(c, stack) + _right->eval_number(c, stack);
 
            case ast_op_subtract:
                return _left->eval_number(c, stack) - _right->eval_number(c, stack);
 
            case ast_op_multiply:
                return _left->eval_number(c, stack) * _right->eval_number(c, stack);
 
            case ast_op_divide:
                return _left->eval_number(c, stack) / _right->eval_number(c, stack);
 
            case ast_op_mod:
                return fmod(_left->eval_number(c, stack), _right->eval_number(c, stack));
 
            case ast_op_negate:
                return -_left->eval_number(c, stack);
 
            case ast_number_constant:
                return _data.number;
 
            case ast_func_last:
                return static_cast<double>(c.size);
 
            case ast_func_position:
                return static_cast<double>(c.position);
 
            case ast_func_count:
            {
                xpath_allocator_capture cr(stack.result);
 
                return static_cast<double>(_left->eval_node_set(c, stack, nodeset_eval_all).size());
            }
 
            case ast_func_string_length_0:
            {
                xpath_allocator_capture cr(stack.result);
 
                return static_cast<double>(string_value(c.n, stack.result).length());
            }
 
            case ast_func_string_length_1:
            {
                xpath_allocator_capture cr(stack.result);
 
                return static_cast<double>(_left->eval_string(c, stack).length());
            }
 
            case ast_func_number_0:
            {
                xpath_allocator_capture cr(stack.result);
 
                return convert_string_to_number(string_value(c.n, stack.result).c_str());
            }
 
            case ast_func_number_1:
                return _left->eval_number(c, stack);
 
            case ast_func_sum:
            {
                xpath_allocator_capture cr(stack.result);
 
                double r = 0;
 
                xpath_node_set_raw ns = _left->eval_node_set(c, stack, nodeset_eval_all);
 
                for (const xpath_node* it = ns.begin(); it != ns.end(); ++it)
                {
                    xpath_allocator_capture cri(stack.result);
 
                    r += convert_string_to_number(string_value(*it, stack.result).c_str());
                }
 
                return r;
            }
 
            case ast_func_floor:
            {
                double r = _left->eval_number(c, stack);
 
                return r == r ? floor(r) : r;
            }
 
            case ast_func_ceiling:
            {
                double r = _left->eval_number(c, stack);
 
                return r == r ? ceil(r) : r;
            }
 
            case ast_func_round:
                return round_nearest_nzero(_left->eval_number(c, stack));
 
            case ast_variable:
            {
                assert(_rettype == _data.variable->type());
 
                if (_rettype == xpath_type_number)
                    return _data.variable->get_number();
 
                // variable needs to be converted to the correct type, this is handled by the fallthrough block below
                break;
            }
 
            default:
                ;
            }
 
            // none of the ast types that return the value directly matched, we need to perform type conversion
            switch (_rettype)
            {
            case xpath_type_boolean:
                return eval_boolean(c, stack) ? 1 : 0;
 
            case xpath_type_string:
            {
                xpath_allocator_capture cr(stack.result);
 
                return convert_string_to_number(eval_string(c, stack).c_str());
            }
 
            case xpath_type_node_set:
            {
                xpath_allocator_capture cr(stack.result);
 
                return convert_string_to_number(eval_string(c, stack).c_str());
            }
 
            default:
                assert(false && "Wrong expression for return type number"); // unreachable
                return 0;
            }
        }

Referenced by eval_boolean(), and eval_string().

eval_string()

xpath_string xpath_ast_node::eval_string ( const xpath_context & c, const xpath_stack & stack )

inline

Definition at line 10790 of file pugixml.cc.

        {
            switch (_type)
            {
            case ast_string_constant:
                return xpath_string::from_const(_data.string);
 
            case ast_func_local_name_0:
            {
                xpath_node na = c.n;
 
                return xpath_string::from_const(local_name(na));
            }
 
            case ast_func_local_name_1:
            {
                xpath_allocator_capture cr(stack.result);
 
                xpath_node_set_raw ns = _left->eval_node_set(c, stack, nodeset_eval_first);
                xpath_node na = ns.first();
 
                return xpath_string::from_const(local_name(na));
            }
 
            case ast_func_name_0:
            {
                xpath_node na = c.n;
 
                return xpath_string::from_const(qualified_name(na));
            }
 
            case ast_func_name_1:
            {
                xpath_allocator_capture cr(stack.result);
 
                xpath_node_set_raw ns = _left->eval_node_set(c, stack, nodeset_eval_first);
                xpath_node na = ns.first();
 
                return xpath_string::from_const(qualified_name(na));
            }
 
            case ast_func_namespace_uri_0:
            {
                xpath_node na = c.n;
 
                return xpath_string::from_const(namespace_uri(na));
            }
 
            case ast_func_namespace_uri_1:
            {
                xpath_allocator_capture cr(stack.result);
 
                xpath_node_set_raw ns = _left->eval_node_set(c, stack, nodeset_eval_first);
                xpath_node na = ns.first();
 
                return xpath_string::from_const(namespace_uri(na));
            }
 
            case ast_func_string_0:
                return string_value(c.n, stack.result);
 
            case ast_func_string_1:
                return _left->eval_string(c, stack);
 
            case ast_func_concat:
                return eval_string_concat(c, stack);
 
            case ast_func_substring_before:
            {
                xpath_allocator_capture cr(stack.temp);
 
                xpath_stack swapped_stack = {stack.temp, stack.result};
 
                xpath_string s = _left->eval_string(c, swapped_stack);
                xpath_string p = _right->eval_string(c, swapped_stack);
 
                const char_t* pos = find_substring(s.c_str(), p.c_str());
 
                return pos ? xpath_string::from_heap(s.c_str(), pos, stack.result) : xpath_string();
            }
 
            case ast_func_substring_after:
            {
                xpath_allocator_capture cr(stack.temp);
 
                xpath_stack swapped_stack = {stack.temp, stack.result};
 
                xpath_string s = _left->eval_string(c, swapped_stack);
                xpath_string p = _right->eval_string(c, swapped_stack);
 
                const char_t* pos = find_substring(s.c_str(), p.c_str());
                if (!pos) return xpath_string();
 
                const char_t* rbegin = pos + p.length();
                const char_t* rend = s.c_str() + s.length();
 
                return s.uses_heap() ? xpath_string::from_heap(rbegin, rend, stack.result) : xpath_string::from_const(rbegin);
            }
 
            case ast_func_substring_2:
            {
                xpath_allocator_capture cr(stack.temp);
 
                xpath_stack swapped_stack = {stack.temp, stack.result};
 
                xpath_string s = _left->eval_string(c, swapped_stack);
                size_t s_length = s.length();
 
                double first = round_nearest(_right->eval_number(c, stack));
 
                if (is_nan(first)) return xpath_string(); // NaN
                else if (first >= static_cast<double>(s_length + 1)) return xpath_string();
 
                size_t pos = first < 1 ? 1 : static_cast<size_t>(first);
                assert(1 <= pos && pos <= s_length + 1);
 
                const char_t* rbegin = s.c_str() + (pos - 1);
                const char_t* rend = s.c_str() + s.length();
 
                return s.uses_heap() ? xpath_string::from_heap(rbegin, rend, stack.result) : xpath_string::from_const(rbegin);
            }
 
            case ast_func_substring_3:
            {
                xpath_allocator_capture cr(stack.temp);
 
                xpath_stack swapped_stack = {stack.temp, stack.result};
 
                xpath_string s = _left->eval_string(c, swapped_stack);
                size_t s_length = s.length();
 
                double first = round_nearest(_right->eval_number(c, stack));
                double last = first + round_nearest(_right->_next->eval_number(c, stack));
 
                if (is_nan(first) || is_nan(last)) return xpath_string();
                else if (first >= static_cast<double>(s_length + 1)) return xpath_string();
                else if (first >= last) return xpath_string();
                else if (last < 1) return xpath_string();
 
                size_t pos = first < 1 ? 1 : static_cast<size_t>(first);
                size_t end = last >= static_cast<double>(s_length + 1) ? s_length + 1 : static_cast<size_t>(last);
 
                assert(1 <= pos && pos <= end && end <= s_length + 1);
                const char_t* rbegin = s.c_str() + (pos - 1);
                const char_t* rend = s.c_str() + (end - 1);
 
                return (end == s_length + 1 && !s.uses_heap()) ? xpath_string::from_const(rbegin) : xpath_string::from_heap(rbegin, rend, stack.result);
            }
 
            case ast_func_normalize_space_0:
            {
                xpath_string s = string_value(c.n, stack.result);
 
                char_t* begin = s.data(stack.result);
                if (!begin) return xpath_string();
 
                char_t* end = normalize_space(begin);
 
                return xpath_string::from_heap_preallocated(begin, end);
            }
 
            case ast_func_normalize_space_1:
            {
                xpath_string s = _left->eval_string(c, stack);
 
                char_t* begin = s.data(stack.result);
                if (!begin) return xpath_string();
 
                char_t* end = normalize_space(begin);
 
                return xpath_string::from_heap_preallocated(begin, end);
            }
 
            case ast_func_translate:
            {
                xpath_allocator_capture cr(stack.temp);
 
                xpath_stack swapped_stack = {stack.temp, stack.result};
 
                xpath_string s = _left->eval_string(c, stack);
                xpath_string from = _right->eval_string(c, swapped_stack);
                xpath_string to = _right->_next->eval_string(c, swapped_stack);
 
                char_t* begin = s.data(stack.result);
                if (!begin) return xpath_string();
 
                char_t* end = translate(begin, from.c_str(), to.c_str(), to.length());
 
                return xpath_string::from_heap_preallocated(begin, end);
            }
 
            case ast_opt_translate_table:
            {
                xpath_string s = _left->eval_string(c, stack);
 
                char_t* begin = s.data(stack.result);
                if (!begin) return xpath_string();
 
                char_t* end = translate_table(begin, _data.table);
 
                return xpath_string::from_heap_preallocated(begin, end);
            }
 
            case ast_variable:
            {
                assert(_rettype == _data.variable->type());
 
                if (_rettype == xpath_type_string)
                    return xpath_string::from_const(_data.variable->get_string());
 
                // variable needs to be converted to the correct type, this is handled by the fallthrough block below
                break;
            }
 
            default:
                ;
            }
 
            // none of the ast types that return the value directly matched, we need to perform type conversion
            switch (_rettype)
            {
            case xpath_type_boolean:
                return xpath_string::from_const(eval_boolean(c, stack) ? PUGIXML_TEXT("true") : PUGIXML_TEXT("false"));
 
            case xpath_type_number:
                return convert_number_to_string(eval_number(c, stack), stack.result);
 
            case xpath_type_node_set:
            {
                xpath_allocator_capture cr(stack.temp);
 
                xpath_stack swapped_stack = {stack.temp, stack.result};
 
                xpath_node_set_raw ns = eval_node_set(c, swapped_stack, nodeset_eval_first);
                return ns.empty() ? xpath_string() : string_value(ns.first(), stack.result);
            }
 
            default:
                assert(false && "Wrong expression for return type string"); // unreachable
                return xpath_string();
            }
        }

Referenced by eval_boolean(), and eval_number().

eval_string_concat()

xpath_string xpath_ast_node::eval_string_concat ( const xpath_context & c, const xpath_stack & stack )

inline

Definition at line 10748 of file pugixml.cc.

        {
            assert(_type == ast_func_concat);
 
            xpath_allocator_capture ct(stack.temp);
 
            // count the string number
            size_t count = 1;
            for (xpath_ast_node* nc = _right; nc; nc = nc->_next) count++;
 
            // allocate a buffer for temporary string objects
            xpath_string* buffer = static_cast<xpath_string*>(stack.temp->allocate(count * sizeof(xpath_string)));
            if (!buffer) return xpath_string();
 
            // evaluate all strings to temporary stack
            xpath_stack swapped_stack = {stack.temp, stack.result};
 
            buffer[0] = _left->eval_string(c, swapped_stack);
 
            size_t pos = 1;
            for (xpath_ast_node* n = _right; n; n = n->_next, ++pos) buffer[pos] = n->eval_string(c, swapped_stack);
            assert(pos == count);
 
            // get total length
            size_t length = 0;
            for (size_t i = 0; i < count; ++i) length += buffer[i].length();
 
            // create final string
            char_t* result = static_cast<char_t*>(stack.result->allocate((length + 1) * sizeof(char_t)));
            if (!result) return xpath_string();
 
            char_t* ri = result;
 
            for (size_t j = 0; j < count; ++j)
                for (const char_t* bi = buffer[j].c_str(); *bi; ++bi)
                    *ri++ = *bi;
 
            *ri = 0;
 
            return xpath_string::from_heap_preallocated(result, ri);
        }

Referenced by eval_string().

is_posinv_expr()

bool xpath_ast_node::is_posinv_expr ( ) const

inline

Definition at line 11245 of file pugixml.cc.

        {
            switch (_type)
            {
            case ast_func_position:
            case ast_func_last:
                return false;
 
            case ast_string_constant:
            case ast_number_constant:
            case ast_variable:
                return true;
 
            case ast_step:
            case ast_step_root:
                return true;
 
            case ast_predicate:
            case ast_filter:
                return true;
 
            default:
                if (_left && !_left->is_posinv_expr()) return false;
 
                for (xpath_ast_node* n = _right; n; n = n->_next)
                    if (!n->is_posinv_expr()) return false;
 
                return true;
            }
        }

is_posinv_step()

bool xpath_ast_node::is_posinv_step ( ) const

inline

Definition at line 11276 of file pugixml.cc.

        {
            assert(_type == ast_step);
 
            for (xpath_ast_node* n = _right; n; n = n->_next)
            {
                assert(n->_type == ast_predicate);
 
                if (n->_test != predicate_posinv)
                    return false;
            }
 
            return true;
        }

Referenced by optimize_self().

optimize()

void xpath_ast_node::optimize ( xpath_allocator * alloc )

inline

Definition at line 11165 of file pugixml.cc.

        {
            if (_left)
                _left->optimize(alloc);
 
            if (_right)
                _right->optimize(alloc);
 
            if (_next)
                _next->optimize(alloc);
 
            // coverity[var_deref_model]
            optimize_self(alloc);
        }

optimize_self()

void xpath_ast_node::optimize_self ( xpath_allocator * alloc )

inline

Definition at line 11180 of file pugixml.cc.

        {
            // Rewrite [position()=expr] with [expr]
            // Note that this step has to go before classification to recognize [position()=1]
            if ((_type == ast_filter || _type == ast_predicate) &&
                _right && // workaround for clang static analyzer (_right is never null for ast_filter/ast_predicate)
                _right->_type == ast_op_equal && _right->_left->_type == ast_func_position && _right->_right->_rettype == xpath_type_number)
            {
                _right = _right->_right;
            }
 
            // Classify filter/predicate ops to perform various optimizations during evaluation
            if ((_type == ast_filter || _type == ast_predicate) && _right) // workaround for clang static analyzer (_right is never null for ast_filter/ast_predicate)
            {
                assert(_test == predicate_default);
 
                if (_right->_type == ast_number_constant && _right->_data.number == 1.0)
                    _test = predicate_constant_one;
                else if (_right->_rettype == xpath_type_number && (_right->_type == ast_number_constant || _right->_type == ast_variable || _right->_type == ast_func_last))
                    _test = predicate_constant;
                else if (_right->_rettype != xpath_type_number && _right->is_posinv_expr())
                    _test = predicate_posinv;
            }
 
            // Rewrite descendant-or-self::node()/child::foo with descendant::foo
            // The former is a full form of //foo, the latter is much faster since it executes the node test immediately
            // Do a similar kind of rewrite for self/descendant/descendant-or-self axes
            // Note that we only rewrite positionally invariant steps (//foo[1] != /descendant::foo[1])
            if (_type == ast_step && (_axis == axis_child || _axis == axis_self || _axis == axis_descendant || _axis == axis_descendant_or_self) &&
                _left && _left->_type == ast_step && _left->_axis == axis_descendant_or_self && _left->_test == nodetest_type_node && !_left->_right &&
                is_posinv_step())
            {
                if (_axis == axis_child || _axis == axis_descendant)
                    _axis = axis_descendant;
                else
                    _axis = axis_descendant_or_self;
 
                _left = _left->_left;
            }
 
            // Use optimized lookup table implementation for translate() with constant arguments
            if (_type == ast_func_translate &&
                _right && // workaround for clang static analyzer (_right is never null for ast_func_translate)
                _right->_type == ast_string_constant && _right->_next->_type == ast_string_constant)
            {
                unsigned char* table = translate_table_generate(alloc, _right->_data.string, _right->_next->_data.string);
 
                if (table)
                {
                    _type = ast_opt_translate_table;
                    _data.table = table;
                }
            }
 
            // Use optimized path for @attr = 'value' or @attr = $value
            if (_type == ast_op_equal &&
                _left && _right && // workaround for clang static analyzer and Coverity (_left and _right are never null for ast_op_equal)
                // coverity[mixed_enums]
                _left->_type == ast_step && _left->_axis == axis_attribute && _left->_test == nodetest_name && !_left->_left && !_left->_right &&
                (_right->_type == ast_string_constant || (_right->_type == ast_variable && _right->_rettype == xpath_type_string)))
            {
                _type = ast_opt_compare_attribute;
            }
        }

Referenced by optimize().

rettype()

xpath_value_type xpath_ast_node::rettype ( ) const

inline

Definition at line 11291 of file pugixml.cc.

        {
            return static_cast<xpath_value_type>(_rettype);
        }

Referenced by evaluate_node_set_prepare(), xpath_parser::parse_expression_rec(), and xpath_parser::parse_step().

set_next()

void xpath_ast_node::set_next ( xpath_ast_node * value )

inline

Definition at line 10460 of file pugixml.cc.

        {
            _next = value;
        }

Referenced by xpath_parser::parse_primary_expression(), and xpath_parser::parse_step().

set_right()

void xpath_ast_node::set_right ( xpath_ast_node * value )

inline

Definition at line 10465 of file pugixml.cc.

        {
            _right = value;
        }

Member Data Documentation

nodetest

const char_t* xpath_ast_node::nodetest

Definition at line 9697 of file pugixml.cc.

number

double xpath_ast_node::number

Definition at line 9693 of file pugixml.cc.

string

const char_t* xpath_ast_node::string

Definition at line 9691 of file pugixml.cc.

table

const unsigned char* xpath_ast_node::table

Definition at line 9699 of file pugixml.cc.

Referenced by optimize_self().

variable

xpath_variable* xpath_ast_node::variable

Definition at line 9695 of file pugixml.cc.

---

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

• pugixml.cc