diff options
Diffstat (limited to 'src/pugixml.cpp')
| -rw-r--r-- | src/pugixml.cpp | 1183 |
1 files changed, 749 insertions, 434 deletions
diff --git a/src/pugixml.cpp b/src/pugixml.cpp index 415fb24..c57ddae 100644 --- a/src/pugixml.cpp +++ b/src/pugixml.cpp @@ -4711,46 +4711,208 @@ namespace pstd } } -namespace +// Allocator used for AST and evaluation stacks +namespace pugi { - using namespace pugi; + struct xpath_memory_block + { + xpath_memory_block* next; - char_t* duplicate_string(const char_t* string, size_t length) + char data[4096]; + }; + + class xpath_allocator { - char_t* result = static_cast<char_t*>(global_allocate((length + 1) * sizeof(char_t))); - if (!result) return 0; // $$ out of memory + xpath_memory_block* _root; + size_t _root_size; + + public: + static xpath_allocator* create() + { + void* memory = global_allocate(sizeof(xpath_allocator) + sizeof(xpath_memory_block)); + if (!memory) return 0; - memcpy(result, string, length * sizeof(char_t)); - result[length] = 0; + xpath_memory_block* root = reinterpret_cast<xpath_memory_block*>(static_cast<xpath_allocator*>(memory) + 1); + root->next = 0; - return result; - } + return new (memory) xpath_allocator(root); + } + + static void destroy(void* ptr) + { + if (!ptr) return; + + // free all allocated pages + xpath_allocator* alloc = static_cast<xpath_allocator*>(ptr); + + xpath_memory_block* cur = alloc->_root; + assert(cur); + + while (cur->next) + { + xpath_memory_block* next = cur->next; + + global_deallocate(cur); + + cur = next; + } + + // free allocator memory (with the first page) + global_deallocate(alloc); + } + + xpath_allocator(xpath_memory_block* root, size_t root_size = 0): _root(root), _root_size(root_size) + { + } + + void* allocate(size_t size) + { + const size_t block_capacity = sizeof(_root->data); + + // align size so that we're able to store pointers in subsequent blocks + size = (size + sizeof(void*) - 1) & ~(sizeof(void*) - 1); + + if (_root_size + size <= block_capacity) + { + void* buf = _root->data + _root_size; + _root_size += size; + return buf; + } + else + { + size_t block_data_size = (size > block_capacity) ? size : block_capacity; + size_t block_size = block_data_size + offsetof(xpath_memory_block, data); + + xpath_memory_block* block = static_cast<xpath_memory_block*>(global_allocate(block_size)); + if (!block) return 0; // $$ out of memory + + block->next = _root; + + _root = block; + _root_size = size; + + return block->data; + } + } + + void* reallocate(void* ptr, size_t old_size, size_t new_size) + { + // we can only reallocate the last object + assert(static_cast<char*>(ptr) + old_size == _root->data + _root_size); + + // adjust root size so that we have not allocated the object at all + _root_size -= old_size; + bool only_object = (_root_size == 0); + + // allocate a new version (this will obviously reuse the memory if possible) + void* result = allocate(new_size); + if (!result) return 0; // $$ out of memory + + // we have a new block + if (result != ptr) + { + // copy old data + assert(new_size > old_size); + memcpy(result, ptr, old_size); + + // free the previous page if it had no other objects + if (only_object) + { + assert(_root->data == result); + assert(_root->next); - char_t* duplicate_string(const char_t* string) + xpath_memory_block* next = _root->next->next; + + if (next) + { + // deallocate the whole page, unless it was the first one + global_deallocate(_root->next); + _root->next = next; + } + } + } + + return result; + } + + void revert(xpath_allocator& state) + { + // free all new pages + xpath_memory_block* cur = _root; + + while (cur != state._root) + { + xpath_memory_block* next = cur->next; + + global_deallocate(cur); + + cur = next; + } + + // restore state + _root = state._root; + _root_size = state._root_size; + } + }; + + struct xpath_allocator_capture { - return duplicate_string(string, strlength(string)); - } + xpath_allocator_capture(xpath_allocator* alloc): _target(alloc), _state(*alloc) + { + } + + ~xpath_allocator_capture() + { + _target->revert(_state); + } + + xpath_allocator* _target; + xpath_allocator _state; + }; + + struct xpath_stack + { + xpath_allocator* result; + xpath_allocator* temp; + }; +} + +// String class +namespace +{ + using namespace pugi; class xpath_string { const char_t* _buffer; bool _uses_heap; - public: - xpath_string(): _buffer(PUGIXML_TEXT("")), _uses_heap(false) + static char_t* duplicate_string(const char_t* string, size_t length, xpath_allocator* alloc) + { + char_t* result = static_cast<char_t*>(alloc->allocate((length + 1) * sizeof(char_t))); + if (!result) return 0; // $$ out of memory + + memcpy(result, string, length * sizeof(char_t)); + result[length] = 0; + + return result; + } + + static char_t* duplicate_string(const char_t* string, xpath_allocator* alloc) { + return duplicate_string(string, strlength(string), alloc); } - ~xpath_string() + public: + xpath_string(): _buffer(PUGIXML_TEXT("")), _uses_heap(false) { - if (_uses_heap) global_deallocate(const_cast<char_t*>(_buffer)); } - explicit xpath_string(const char_t* str) + explicit xpath_string(const char_t* str, xpath_allocator* alloc) { bool empty = (*str == 0); - _buffer = empty ? PUGIXML_TEXT("") : duplicate_string(str); + _buffer = empty ? PUGIXML_TEXT("") : duplicate_string(str, alloc); _uses_heap = !empty; } @@ -4758,37 +4920,17 @@ namespace { } - xpath_string(const char_t* begin, const char_t* end) + xpath_string(const char_t* begin, const char_t* end, xpath_allocator* alloc) { assert(begin <= end); bool empty = (begin == end); - _buffer = empty ? PUGIXML_TEXT("") : duplicate_string(begin, static_cast<size_t>(end - begin)); + _buffer = empty ? PUGIXML_TEXT("") : duplicate_string(begin, static_cast<size_t>(end - begin), alloc); _uses_heap = !empty; } - xpath_string(const xpath_string& o) - { - _buffer = o._uses_heap ? duplicate_string(o._buffer) : o._buffer; - _uses_heap = o._uses_heap; - } - - xpath_string& operator=(const xpath_string& o) - { - xpath_string temp(o); - swap(temp); - - return *this; - } - - void swap(xpath_string& o) - { - pstd::swap(_buffer, o._buffer); - pstd::swap(_uses_heap, o._uses_heap); - } - - void append(const xpath_string& o) + void append(const xpath_string& o, xpath_allocator* alloc) { // skip empty sources if (!*o._buffer) return; @@ -4806,8 +4948,9 @@ namespace size_t length = target_length + source_length; // allocate new buffer - char_t* result = static_cast<char_t*>(global_allocate((length + 1) * sizeof(char_t))); + char_t* result = static_cast<char_t*>(alloc->allocate((length + 1) * sizeof(char_t))); if (!result) return; // $$ out of memory + // $$ reallocate // append both strings in the new buffer memcpy(result, _buffer, target_length * sizeof(char_t)); @@ -4815,7 +4958,8 @@ namespace result[length] = 0; // finalize - xpath_string(result, true).swap(*this); + _buffer = result; + _uses_heap = true; } } @@ -4829,12 +4973,12 @@ namespace return strlength(_buffer); } - char_t* data() + char_t* data(xpath_allocator* alloc) { // make private heap copy if (!_uses_heap) { - _buffer = duplicate_string(_buffer); + _buffer = duplicate_string(_buffer, alloc); _uses_heap = true; } @@ -4908,7 +5052,7 @@ namespace return static_cast<unsigned int>(ch - 'A') < 26 ? (ch | ' ') : ch; } - xpath_string string_value(const xpath_node& na) + xpath_string string_value(const xpath_node& na, xpath_allocator* alloc) { if (na.attribute()) return xpath_string_const(na.attribute().value()); @@ -4934,7 +5078,7 @@ namespace while (cur && cur != n) { if (cur.type() == node_pcdata || cur.type() == node_cdata) - result.append(xpath_string_const(cur.value())); + result.append(xpath_string_const(cur.value()), alloc); if (cur.first_child()) cur = cur.first_child(); @@ -5185,7 +5329,7 @@ namespace } #endif - xpath_string convert_number_to_string(double value) + xpath_string convert_number_to_string(double value, xpath_allocator* alloc) { // try special number conversion const char_t* special = convert_number_to_string_special(value); @@ -5245,7 +5389,7 @@ namespace assert(s < result + sizeof(result) / sizeof(result[0])); *s = 0; - return xpath_string(result); + return xpath_string(result, alloc); } bool check_string_to_number_format(const char_t* string) @@ -5614,107 +5758,173 @@ namespace } } -namespace pugi +// Internal node set class +#include <algorithm> + +namespace { -#ifndef PUGIXML_NO_EXCEPTIONS - xpath_exception::xpath_exception(const xpath_parse_result& result): _result(result) - { - assert(result.error); - } - - const char* xpath_exception::what() const throw() + using namespace pugi; + + xpath_node_set::type_t xpath_sort(xpath_node* begin, xpath_node* end, xpath_node_set::type_t type, bool reverse) { - return _result.error; + xpath_node_set::type_t order = reverse ? xpath_node_set::type_sorted_reverse : xpath_node_set::type_sorted; + + if (type == xpath_node_set::type_unsorted) + { + pstd::sort(begin, end, document_order_comparator()); + + type = xpath_node_set::type_sorted; + } + + if (type != order) pstd::reverse(begin, end); + + return order; } - const xpath_parse_result& xpath_exception::result() const + xpath_node xpath_first(const xpath_node* begin, const xpath_node* end, xpath_node_set::type_t type) { - return _result; + if (begin == end) return xpath_node(); + + switch (type) + { + case xpath_node_set::type_sorted: + return *begin; + + case xpath_node_set::type_sorted_reverse: + return *(end - 1); + + case xpath_node_set::type_unsorted: + return *pstd::min_element(begin, end, document_order_comparator()); + + default: + assert(!"Invalid node set type"); + return xpath_node(); + } } -#endif - - class xpath_allocator + class xpath_node_set_raw { - struct memory_block - { - memory_block* next; - - char data[4096]; - }; - - memory_block* _root; - size_t _root_size; - + xpath_node_set::type_t _type; + + xpath_node* _begin; + xpath_node* _end; + xpath_node* _eos; + public: - static xpath_allocator* create() + xpath_node_set_raw(): _type(xpath_node_set::type_unsorted), _begin(0), _end(0), _eos(0) { - void* memory = global_allocate(sizeof(xpath_allocator) + sizeof(memory_block)); - if (!memory) return 0; + } - memory_block* root = reinterpret_cast<memory_block*>(static_cast<xpath_allocator*>(memory) + 1); - root->next = 0; + xpath_node* begin() const + { + return _begin; + } - return new (memory) xpath_allocator(root); + xpath_node* end() const + { + return _end; } - static void destroy(void* ptr) + bool empty() const { - if (!ptr) return; - - // free all allocated pages - xpath_allocator* alloc = static_cast<xpath_allocator*>(ptr); + return _begin == _end; + } - memory_block* cur = alloc->_root; - assert(cur); + size_t size() const + { + return static_cast<size_t>(_end - _begin); + } - while (cur->next) + xpath_node first() const + { + return xpath_first(_begin, _end, _type); + } + + void push_back(const xpath_node& node, xpath_allocator* alloc) + { + if (_end == _eos) { - memory_block* next = cur->next; + size_t capacity = static_cast<size_t>(_eos - _begin); - global_deallocate(cur); + // get new capacity (1.5x rule) + size_t new_capacity = capacity + capacity / 2 + 1; - cur = next; + // reallocate the old array or allocate a new one + xpath_node* data = 0; + + if (_begin) + { + data = static_cast<xpath_node*>(alloc->reallocate(_begin, capacity * sizeof(xpath_node), new_capacity * sizeof(xpath_node))); + if (!data) return; // $$ out of memory + } + else + { + data = static_cast<xpath_node*>(alloc->allocate(new_capacity * sizeof(xpath_node))); + if (!data) return; // $$ out of memory + + memcpy(data, _begin, capacity * sizeof(xpath_node)); + } + + + // finalize + _begin = data; + _end = data + capacity; + _eos = data + new_capacity; } - // free allocator memory (with the first page) - global_deallocate(alloc); + *_end++ = node; } - xpath_allocator(memory_block* root, size_t root_size = 0): _root(root), _root_size(root_size) + void sort() { + _type = xpath_sort(_begin, _end, _type, false); } - - void* allocate(size_t size) + + void truncate(xpath_node* pos) { - const size_t block_capacity = sizeof(_root->data); + assert(_begin <= pos && pos <= _end); - // align size so that we're able to store pointers in subsequent blocks - size = (size + sizeof(void*) - 1) & ~(sizeof(void*) - 1); + _end = pos; + } - if (_root_size + size <= block_capacity) - { - void* buf = _root->data + _root_size; - _root_size += size; - return buf; - } - else - { - size_t block_data_size = (size > block_capacity) ? size : block_capacity; - size_t block_size = block_data_size + offsetof(memory_block, data); + void remove_duplicates() + { + if (_type == xpath_node_set::type_unsorted) + pstd::sort(_begin, _end, duplicate_comparator()); + + _end = pstd::unique(_begin, _end); + } - memory_block* block = static_cast<memory_block*>(global_allocate(block_size)); - if (!block) return 0; - - block->next = _root; - - _root = block; - _root_size = size; - - return block->data; - } + xpath_node_set::type_t type() const + { + return _type; + } + + void set_type(xpath_node_set::type_t type) + { + _type = type; } }; +} +namespace pugi +{ +#ifndef PUGIXML_NO_EXCEPTIONS + xpath_exception::xpath_exception(const xpath_parse_result& result): _result(result) + { + assert(result.error); + } + + const char* xpath_exception::what() const throw() + { + return _result.error; + } + + const xpath_parse_result& xpath_exception::result() const + { + return _result; + } +#endif + xpath_node::xpath_node() { } @@ -5774,8 +5984,47 @@ namespace pugi } #endif - xpath_node_set::xpath_node_set(): _type(type_unsorted), _begin(&_storage), _end(&_storage), _eos(&_storage + 1) + void xpath_node_set::_assign(const_iterator begin, const_iterator end) + { + assert(begin <= end); + + size_t size = static_cast<size_t>(end - begin); + + if (size <= 1) + { + // deallocate old buffer + if (_begin != &_storage) global_deallocate(_begin); + + // use internal buffer + if (begin != end) _storage = *begin; + + _begin = &_storage; + _end = &_storage + size; + } + else + { + // make heap copy + xpath_node* storage = static_cast<xpath_node*>(global_allocate(size * sizeof(xpath_node))); + if (!storage) return; // $$ out of memory + + memcpy(storage, begin, size * sizeof(xpath_node)); + + // deallocate old buffer + if (_begin != &_storage) global_deallocate(_begin); + + // finalize + _begin = storage; + _end = storage + size; + } + } + + xpath_node_set::xpath_node_set(): _type(type_unsorted), _begin(&_storage), _end(&_storage) + { + } + + xpath_node_set::xpath_node_set(const_iterator begin, const_iterator end, type_t type): _type(type), _begin(&_storage), _end(&_storage) { + _assign(begin, end); } xpath_node_set::~xpath_node_set() @@ -5783,29 +6032,18 @@ namespace pugi if (_begin != &_storage) global_deallocate(_begin); } - xpath_node_set::xpath_node_set(const xpath_node_set& ns): _type(ns._type), _begin(&_storage), _end(&_storage), _eos(&_storage + 1) + xpath_node_set::xpath_node_set(const xpath_node_set& ns): _type(ns._type), _begin(&_storage), _end(&_storage) { - if (ns.size() == 1) - { - _storage = *ns._begin; - _end = _eos; - } - else - { - append(ns.begin(), ns.end()); - } + _assign(ns._begin, ns._end); } xpath_node_set& xpath_node_set::operator=(const xpath_node_set& ns) { if (this == &ns) return *this; - // clear & append _type = ns._type; - _end = _begin; - - append(ns.begin(), ns.end()); - + _assign(ns._begin, ns._end); + return *this; } @@ -5821,7 +6059,7 @@ namespace pugi bool xpath_node_set::empty() const { - return size() == 0; + return _begin == _end; } const xpath_node& xpath_node_set::operator[](size_t index) const @@ -5830,11 +6068,6 @@ namespace pugi return _begin[index]; } - xpath_node_set::iterator xpath_node_set::mut_begin() - { - return _begin; - } - xpath_node_set::const_iterator xpath_node_set::begin() const { return _begin; @@ -5847,88 +6080,12 @@ namespace pugi void xpath_node_set::sort(bool reverse) { - pstd::sort(_begin, _end, document_order_comparator()); - - if (reverse) pstd::reverse(_begin, _end); - - _type = reverse ? type_sorted_reverse : type_sorted; - } - - void xpath_node_set::push_back(const xpath_node& n) - { - if (_end == _eos) - append(&n, &n + 1); - else - { - *_end = n; - ++_end; - } - } - - void xpath_node_set::append(const_iterator begin, const_iterator end) - { - if (begin == end) return; - - size_t count = end - begin; - size_t size = _end - _begin; - size_t capacity = _eos - _begin; - - if (capacity < size + count) - { - if (capacity < 2) capacity = 2; - - while (capacity < size + count) capacity += capacity / 2; - - xpath_node* storage = static_cast<xpath_node*>(global_allocate(capacity * sizeof(xpath_node))); - if (!storage) return; // $$ out of memory - - memcpy(storage, _begin, size * sizeof(xpath_node)); - - if (_begin != &_storage) global_deallocate(_begin); - - _begin = storage; - _end = storage + size; - _eos = storage + capacity; - } - - memcpy(_end, begin, count * sizeof(xpath_node)); - _end += count; - } - - void xpath_node_set::truncate(iterator it) - { - _end = it; + _type = xpath_sort(_begin, _end, _type, reverse); } xpath_node xpath_node_set::first() const { - if (empty()) return xpath_node(); - - switch (_type) - { - case type_sorted: - return *_begin; - - case type_sorted_reverse: - return *(_end - 1); - - case type_unsorted: - return *pstd::min_element<iterator>(_begin, _end, document_order_comparator()); - - default: - assert(!"Invalid node set type"); - return xpath_node(); - } - } - - void xpath_node_set::remove_duplicates() - { - if (_type == type_unsorted) - { - pstd::sort(_begin, _end, duplicate_comparator()); - } - - truncate(pstd::unique(_begin, _end)); + return xpath_first(_begin, _end, _type); } struct xpath_context @@ -6425,28 +6582,39 @@ namespace pugi xpath_ast_node(const xpath_ast_node&); xpath_ast_node& operator=(const xpath_ast_node&); - template <class Comp> static bool compare_eq(xpath_ast_node* lhs, xpath_ast_node* rhs, const xpath_context& c, const Comp& comp) + template <class Comp> static bool compare_eq(xpath_ast_node* lhs, xpath_ast_node* rhs, const xpath_context& c, const xpath_stack& stack, const Comp& comp) { xpath_value_type lt = lhs->rettype(), rt = rhs->rettype(); if (lt != xpath_type_node_set && rt != xpath_type_node_set) { if (lt == xpath_type_boolean || rt == xpath_type_boolean) - return comp(lhs->eval_boolean(c), rhs->eval_boolean(c)); + return comp(lhs->eval_boolean(c, stack), rhs->eval_boolean(c, stack)); else if (lt == xpath_type_number || rt == xpath_type_number) - return comp(lhs->eval_number(c), rhs->eval_number(c)); + return comp(lhs->eval_number(c, stack), rhs->eval_number(c, stack)); else if (lt == xpath_type_string || rt == xpath_type_string) - return comp(lhs->eval_string(c), rhs->eval_string(c)); + { + xpath_allocator_capture cr(stack.result); + + xpath_string ls = lhs->eval_string(c, stack); + xpath_string rs = rhs->eval_string(c, stack); + + return comp(ls, rs); + } } else if (lt == xpath_type_node_set && rt == xpath_type_node_set) { - xpath_node_set ls = lhs->eval_node_set(c); - xpath_node_set rs = rhs->eval_node_set(c); + xpath_allocator_capture cr(stack.result); - for (xpath_node_set::const_iterator li = ls.begin(); li != ls.end(); ++li) - for (xpath_node_set::const_iterator ri = rs.begin(); ri != rs.end(); ++ri) + xpath_node_set_raw ls = lhs->eval_node_set(c, stack); + xpath_node_set_raw rs = rhs->eval_node_set(c, stack); + + for (const xpath_node* li = ls.begin(); li != ls.end(); ++li) + for (const xpath_node* ri = rs.begin(); ri != rs.end(); ++ri) { - if (comp(string_value(*li), string_value(*ri))) + xpath_allocator_capture cri(stack.result); + + if (comp(string_value(*li, stack.result), string_value(*ri, stack.result))) return true; } @@ -6461,15 +6629,19 @@ namespace pugi } if (lt == xpath_type_boolean) - return comp(lhs->eval_boolean(c), rhs->eval_boolean(c)); + return comp(lhs->eval_boolean(c, stack), rhs->eval_boolean(c, stack)); else if (lt == xpath_type_number) { - double l = lhs->eval_number(c); - xpath_node_set rs = rhs->eval_node_set(c); + xpath_allocator_capture cr(stack.result); - for (xpath_node_set::const_iterator ri = rs.begin(); ri != rs.end(); ++ri) + double l = lhs->eval_number(c, stack); + xpath_node_set_raw rs = rhs->eval_node_set(c, stack); + + for (const xpath_node* ri = rs.begin(); ri != rs.end(); ++ri) { - if (comp(l, convert_string_to_number(string_value(*ri).c_str()))) + xpath_allocator_capture cri(stack.result); + + if (comp(l, convert_string_to_number(string_value(*ri, stack.result).c_str()))) return true; } @@ -6477,12 +6649,16 @@ namespace pugi } else if (lt == xpath_type_string) { - xpath_string l = lhs->eval_string(c); - xpath_node_set rs = rhs->eval_node_set(c); + xpath_allocator_capture cr(stack.result); + + xpath_string l = lhs->eval_string(c, stack); + xpath_node_set_raw rs = rhs->eval_node_set(c, stack); - for (xpath_node_set::const_iterator ri = rs.begin(); ri != rs.end(); ++ri) + for (const xpath_node* ri = rs.begin(); ri != rs.end(); ++ri) { - if (comp(l, string_value(*ri))) + xpath_allocator_capture cri(stack.result); + + if (comp(l, string_value(*ri, stack.result))) return true; } @@ -6494,24 +6670,30 @@ namespace pugi return false; } - template <class Comp> static bool compare_rel(xpath_ast_node* lhs, xpath_ast_node* rhs, const xpath_context& c, const Comp& comp) + template <class Comp> static bool compare_rel(xpath_ast_node* lhs, xpath_ast_node* rhs, const xpath_context& c, const xpath_stack& stack, const Comp& comp) { xpath_value_type lt = lhs->rettype(), rt = rhs->rettype(); if (lt != xpath_type_node_set && rt != xpath_type_node_set) - return comp(lhs->eval_number(c), rhs->eval_number(c)); + return comp(lhs->eval_number(c, stack), rhs->eval_number(c, stack)); else if (lt == xpath_type_node_set && rt == xpath_type_node_set) { - xpath_node_set ls = lhs->eval_node_set(c); - xpath_node_set rs = rhs->eval_node_set(c); + xpath_allocator_capture cr(stack.result); + + xpath_node_set_raw ls = lhs->eval_node_set(c, stack); + xpath_node_set_raw rs = rhs->eval_node_set(c, stack); - for (xpath_node_set::const_iterator li = ls.begin(); li != ls.end(); ++li) + for (const xpath_node* li = ls.begin(); li != ls.end(); ++li) { - double l = convert_string_to_number(string_value(*li).c_str()); + xpath_allocator_capture cri(stack.result); - for (xpath_node_set::const_iterator ri = rs.begin(); ri != rs.end(); ++ri) + double l = convert_string_to_number(string_value(*li, stack.result).c_str()); + + for (const xpath_node* ri = rs.begin(); ri != rs.end(); ++ri) { - if (comp(l, convert_string_to_number(string_value(*ri).c_str()))) + xpath_allocator_capture crii(stack.result); + + if (comp(l, convert_string_to_number(string_value(*ri, stack.result).c_str()))) return true; } } @@ -6520,12 +6702,16 @@ namespace pugi } else if (lt != xpath_type_node_set && rt == xpath_type_node_set) { - double l = lhs->eval_number(c); - xpath_node_set rs = rhs->eval_node_set(c); + xpath_allocator_capture cr(stack.result); - for (xpath_node_set::const_iterator ri = rs.begin(); ri != rs.end(); ++ri) + double l = lhs->eval_number(c, stack); + xpath_node_set_raw rs = rhs->eval_node_set(c, stack); + + for (const xpath_node* ri = rs.begin(); ri != rs.end(); ++ri) { - if (comp(l, convert_string_to_number(string_value(*ri).c_str()))) + xpath_allocator_capture cri(stack.result); + + if (comp(l, convert_string_to_number(string_value(*ri, stack.result).c_str()))) return true; } @@ -6533,12 +6719,16 @@ namespace pugi } else if (lt == xpath_type_node_set && rt != xpath_type_node_set) { - xpath_node_set ls = lhs->eval_node_set(c); - double r = rhs->eval_number(c); + xpath_allocator_capture cr(stack.result); + + xpath_node_set_raw ls = lhs->eval_node_set(c, stack); + double r = rhs->eval_number(c, stack); - for (xpath_node_set::const_iterator li = ls.begin(); li != ls.end(); ++li) + for (const xpath_node* li = ls.begin(); li != ls.end(); ++li) { - if (comp(convert_string_to_number(string_value(*li).c_str()), r)) + xpath_allocator_capture cri(stack.result); + + if (comp(convert_string_to_number(string_value(*li, stack.result).c_str()), r)) return true; } @@ -6551,43 +6741,43 @@ namespace pugi } } - void apply_predicate(xpath_node_set& ns, size_t first, xpath_ast_node* expr) + void apply_predicate(xpath_node_set_raw& ns, size_t first, xpath_ast_node* expr, const xpath_stack& stack) { assert(ns.size() >= first); size_t i = 1; size_t size = ns.size() - first; - xpath_node_set::iterator last = ns.mut_begin() + first; + xpath_node* last = ns.begin() + first; // remove_if... or well, sort of - for (xpath_node_set::iterator it = last; it != ns.end(); ++it, ++i) + for (xpath_node* it = last; it != ns.end(); ++it, ++i) { xpath_context c(*it, i, size); if (expr->rettype() == xpath_type_number) { - if (expr->eval_number(c) == i) + if (expr->eval_number(c, stack) == i) *last++ = *it; } - else if (expr->eval_boolean(c)) + else if (expr->eval_boolean(c, stack)) *last++ = *it; } ns.truncate(last); } - void apply_predicates(xpath_node_set& ns, size_t first) + void apply_predicates(xpath_node_set_raw& ns, size_t first, const xpath_stack& stack) { if (ns.size() == first) return; for (xpath_ast_node* pred = _right; pred; pred = pred->_next) { - apply_predicate(ns, first, pred->_left); + apply_predicate(ns, first, pred->_left, stack); } } - void step_push(xpath_node_set& ns, const xml_attribute& a, const xml_node& parent) + void step_push(xpath_node_set_raw& ns, const xml_attribute& a, const xml_node& parent, xpath_allocator* alloc) { if (!a) return; @@ -6600,17 +6790,17 @@ namespace pugi switch (_test) { case nodetest_name: - if (strequal(name, _data.nodetest)) ns.push_back(xpath_node(a, parent)); + if (strequal(name, _data.nodetest)) ns.push_back(xpath_node(a, parent), alloc); break; case nodetest_type_node: case nodetest_all: - ns.push_back(xpath_node(a, parent)); + ns.push_back(xpath_node(a, parent), alloc); break; case nodetest_all_in_namespace: if (starts_with(name, _data.nodetest)) - ns.push_back(xpath_node(a, parent)); + ns.push_back(xpath_node(a, parent), alloc); break; default: @@ -6618,48 +6808,48 @@ namespace pugi } } - void step_push(xpath_node_set& ns, const xml_node& n) + void step_push(xpath_node_set_raw& ns, const xml_node& n, xpath_allocator* alloc) { if (!n) return; switch (_test) { case nodetest_name: - if (n.type() == node_element && strequal(n.name(), _data.nodetest)) ns.push_back(n); + if (n.type() == node_element && strequal(n.name(), _data.nodetest)) ns.push_back(n, alloc); break; case nodetest_type_node: - ns.push_back(n); + ns.push_back(n, alloc); break; case nodetest_type_comment: if (n.type() == node_comment) - ns.push_back(n); + ns.push_back(n, alloc); break; case nodetest_type_text: if (n.type() == node_pcdata || n.type() == node_cdata) - ns.push_back(n); + ns.push_back(n, alloc); break; case nodetest_type_pi: if (n.type() == node_pi) - ns.push_back(n); + ns.push_back(n, alloc); break; case nodetest_pi: if (n.type() == node_pi && strequal(n.name(), _data.nodetest)) - ns.push_back(n); + ns.push_back(n, alloc); break; case nodetest_all: if (n.type() == node_element) - ns.push_back(n); + ns.push_back(n, alloc); break; case nodetest_all_in_namespace: if (n.type() == node_element && starts_with(n.name(), _data.nodetest)) - ns.push_back(n); + ns.push_back(n, alloc); break; default: @@ -6667,7 +6857,7 @@ namespace pugi } } - template <class T> void step_fill(xpath_node_set& ns, const xml_node& n, T) + template <class T> void step_fill(xpath_node_set_raw& ns, const xml_node& n, xpath_allocator* alloc, T) { const axis_t axis = T::axis; @@ -6676,7 +6866,7 @@ namespace pugi case axis_attribute: { for (xml_attribute a = n.first_attribute(); a; a = a.next_attribute()) - step_push(ns, a, n); + step_push(ns, a, n, alloc); break; } @@ -6684,7 +6874,7 @@ namespace pugi case axis_child: { for (xml_node c = n.first_child(); c; c = c.next_sibling()) - step_push(ns, c); + step_push(ns, c, alloc); break; } @@ -6693,13 +6883,13 @@ namespace pugi case axis_descendant_or_self: { if (axis == axis_descendant_or_self) - step_push(ns, n); + step_push(ns, n, alloc); xml_node cur = n.first_child(); while (cur && cur != n) { - step_push(ns, cur); + step_push(ns, cur, alloc); if (cur.first_child()) cur = cur.first_child(); @@ -6720,7 +6910,7 @@ namespace pugi case axis_following_sibling: { for (xml_node c = n.next_sibling(); c; c = c.next_sibling()) - step_push(ns, c); + step_push(ns, c, alloc); break; } @@ -6728,7 +6918,7 @@ namespace pugi case axis_preceding_sibling: { for (xml_node c = n.previous_sibling(); c; c = c.previous_sibling()) - step_push(ns, c); + step_push(ns, c, alloc); break; } @@ -6743,7 +6933,7 @@ namespace pugi for (;;) { - step_push(ns, cur); + step_push(ns, cur, alloc); if (cur.first_child()) cur = cur.first_child(); @@ -6775,7 +6965,7 @@ namespace pugi else { // leaf node, can't be ancestor - step_push(ns, cur); + step_push(ns, cur, alloc); if (cur.previous_sibling()) cur = cur.previous_sibling(); @@ -6786,7 +6976,7 @@ namespace pugi cur = cur.parent(); if (!cur) break; - if (!node_is_ancestor(cur, n)) step_push(ns, cur); + if (!node_is_ancestor(cur, n)) step_push(ns, cur, alloc); } while (!cur.previous_sibling()); @@ -6804,13 +6994,13 @@ namespace pugi case axis_ancestor_or_self: { if (axis == axis_ancestor_or_self) - step_push(ns, n); + step_push(ns, n, alloc); xml_node cur = n.parent(); while (cur) { - step_push(ns, cur); + step_push(ns, cur, alloc); cur = cur.parent(); } @@ -6820,14 +7010,14 @@ namespace pugi case axis_self: { - step_push(ns, n); + step_push(ns, n, alloc); break; } case axis_parent: { - if (n.parent()) step_push(ns, n.parent()); + if (n.parent()) step_push(ns, n.parent(), alloc); break; } @@ -6837,7 +7027,7 @@ namespace pugi } } - template <class T> void step_fill(xpath_node_set& ns, const xml_attribute& a, const xml_node& p, T v) + template <class T> void step_fill(xpath_node_set_raw& ns, const xml_attribute& a, const xml_node& p, xpath_allocator* alloc, T v) { const axis_t axis = T::axis; @@ -6847,13 +7037,13 @@ namespace pugi case axis_ancestor_or_self: { if (axis == axis_ancestor_or_self && _test == nodetest_type_node) // reject attributes based on principal node type test - step_push(ns, a, p); + step_push(ns, a, p, alloc); xml_node cur = p; while (cur) { - step_push(ns, cur); + step_push(ns, cur, alloc); cur = cur.parent(); } @@ -6865,7 +7055,7 @@ namespace pugi case axis_self: { if (_test == nodetest_type_node) // reject attributes based on principal node type test - step_push(ns, a, p); + step_push(ns, a, p, alloc); break; } @@ -6888,7 +7078,7 @@ namespace pugi if (!cur) break; } - step_push(ns, cur); + step_push(ns, cur, alloc); } break; @@ -6896,7 +7086,7 @@ namespace pugi case axis_parent: { - step_push(ns, p); + step_push(ns, p, alloc); break; } @@ -6904,7 +7094,7 @@ namespace pugi case axis_preceding: { // preceding:: axis does not include attribute nodes and attribute ancestors (they are the same as parent's ancestors), so we can reuse node preceding - step_fill(ns, p, v); + step_fill(ns, p, alloc, v); break; } @@ -6913,44 +7103,44 @@ namespace pugi } } - template <class T> xpath_node_set step_do(const xpath_context& c, T v) + template <class T> xpath_node_set_raw step_do(const xpath_context& c, const xpath_stack& stack, T v) { const axis_t axis = T::axis; bool attributes = (axis == axis_ancestor || axis == axis_ancestor_or_self || axis == axis_descendant_or_self || axis == axis_following || axis == axis_parent || axis == axis_preceding || axis == axis_self); - xpath_node_set ns; - ns._type = (axis == axis_ancestor || axis == axis_ancestor_or_self || axis == axis_preceding || axis == axis_preceding_sibling) ? xpath_node_set::type_sorted_reverse : xpath_node_set::type_sorted; + xpath_node_set_raw ns; + ns.set_type((axis == axis_ancestor || axis == axis_ancestor_or_self || axis == axis_preceding || axis == axis_preceding_sibling) ? xpath_node_set::type_sorted_reverse : xpath_node_set::type_sorted); if (_left) { - xpath_node_set s = _left->eval_node_set(c); + xpath_node_set_raw s = _left->eval_node_set(c, stack); // self axis preserves the original order - if (axis == axis_self) ns._type = s._type; + if (axis == axis_self) ns.set_type(s.type()); - for (xpath_node_set::const_iterator it = s.begin(); it != s.end(); ++it) + for (const xpath_node* it = s.begin(); it != s.end(); ++it) { size_t size = ns.size(); // in general, all axes generate elements in a particular order, but there is no order guarantee if axis is applied to two nodes - if (axis != axis_self && size != 0) ns._type = xpath_node_set::type_unsorted; + if (axis != axis_self && size != 0) ns.set_type(xpath_node_set::type_unsorted); if (it->node()) - step_fill(ns, it->node(), v); + step_fill(ns, it->node(), stack.result, v); else if (attributes) - step_fill(ns, it->attribute(), it->parent(), v); + step_fill(ns, it->attribute(), it->parent(), stack.result, v); - apply_predicates(ns, size); + apply_predicates(ns, size, stack); } } else { if (c.n.node()) - step_fill(ns, c.n.node(), v); + step_fill(ns, c.n.node(), stack.result, v); else if (attributes) - step_fill(ns, c.n.attribute(), c.n.parent(), v); + step_fill(ns, c.n.attribute(), c.n.parent(), stack.result, v); - apply_predicates(ns, 0); + apply_predicates(ns, 0, stack); } // child, attribute and self axes always generate unique set of nodes @@ -7004,52 +7194,59 @@ namespace pugi _right = value; } - bool eval_boolean(const xpath_context& c) + bool eval_boolean(const xpath_context& c, const xpath_stack& stack) { switch (_type) { case ast_op_or: - if (_left->eval_boolean(c)) return true; - else return _right->eval_boolean(c); + return _left->eval_boolean(c, stack) || _right->eval_boolean(c, stack); case ast_op_and: - if (!_left->eval_boolean(c)) return false; - else return _right->eval_boolean(c); + return _left->eval_boolean(c, stack) && _right->eval_boolean(c, stack); case ast_op_equal: - return compare_eq(_left, _right, c, pstd::equal_to()); + return compare_eq(_left, _right, c, stack, pstd::equal_to()); case ast_op_not_equal: - return compare_eq(_left, _right, c, pstd::not_equal_to()); + return compare_eq(_left, _right, c, stack, pstd::not_equal_to()); case ast_op_less: - return compare_rel(_left, _right, c, pstd::less()); + return compare_rel(_left, _right, c, stack, pstd::less()); case ast_op_greater: - return compare_rel(_right, _left, c, pstd::less()); + return compare_rel(_right, _left, c, stack, pstd::less()); case ast_op_less_or_equal: - return compare_rel(_left, _right, c, pstd::less_equal()); + return compare_rel(_left, _right, c, stack, pstd::less_equal()); case ast_op_greater_or_equal: - return compare_rel(_right, _left, c, pstd::less_equal()); + return compare_rel(_right, _left, c, stack, pstd::less_equal()); case ast_func_starts_with: - return starts_with(_left->eval_string(c).c_str(), _right->eval_string(c).c_str()); + { + 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_string lr = _left->eval_string(c); - xpath_string rr = _right->eval_string(c); + 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); + return _left->eval_boolean(c, stack); case ast_func_not: - return !_left->eval_boolean(c); + return !_left->eval_boolean(c, stack); case ast_func_true: return true; @@ -7061,7 +7258,9 @@ namespace pugi { if (c.n.attribute()) return false; - xpath_string lang = _left->eval_string(c); + 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()) { @@ -7100,14 +7299,22 @@ namespace pugi switch (_rettype) { case xpath_type_number: - return convert_number_to_boolean(eval_number(c)); + return convert_number_to_boolean(eval_number(c, stack)); case xpath_type_string: - return !eval_string(c).empty(); + { + xpath_allocator_capture cr(stack.result); + + return !eval_string(c, stack).empty(); + } case xpath_type_node_set: - return !eval_node_set(c).empty(); - + { + xpath_allocator_capture cr(stack.result); + + return !eval_node_set(c, stack).empty(); + } + default: assert(!"Wrong expression for return type boolean"); return false; @@ -7116,27 +7323,27 @@ namespace pugi } } - double eval_number(const xpath_context& c) + double eval_number(const xpath_context& c, const xpath_stack& stack) { switch (_type) { case ast_op_add: - return _left->eval_number(c) + _right->eval_number(c); + return _left->eval_number(c, stack) + _right->eval_number(c, stack); case ast_op_subtract: - return _left->eval_number(c) - _right->eval_number(c); + return _left->eval_number(c, stack) - _right->eval_number(c, stack); case ast_op_multiply: - return _left->eval_number(c) * _right->eval_number(c); + return _left->eval_number(c, stack) * _right->eval_number(c, stack); case ast_op_divide: - return _left->eval_number(c) / _right->eval_number(c); + return _left->eval_number(c, stack) / _right->eval_number(c, stack); case ast_op_mod: - return fmod(_left->eval_number(c), _right->eval_number(c)); + return fmod(_left->eval_number(c, stack), _right->eval_number(c, stack)); case ast_op_negate: - return -_left->eval_number(c); + return -_left->eval_number(c, stack); case ast_number_constant: return _data.number; @@ -7148,48 +7355,66 @@ namespace pugi return (double)c.position; case ast_func_count: - return (double)_left->eval_node_set(c).size(); + { + xpath_allocator_capture cr(stack.result); + + return (double)_left->eval_node_set(c, stack).size(); + } case ast_func_string_length_0: - return (double)string_value(c.n).length(); + { + xpath_allocator_capture cr(stack.result); + + return (double)string_value(c.n, stack.result).length(); + } case ast_func_string_length_1: - return (double)_left->eval_string(c).length(); + { + xpath_allocator_capture cr(stack.result); + + return (double)_left->eval_string(c, stack).length(); + } case ast_func_number_0: - return convert_string_to_number(string_value(c.n).c_str()); + { + 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); + return _left->eval_number(c, stack); case ast_func_sum: { + xpath_allocator_capture cr(stack.result); + double r = 0; - xpath_node_set ns = _left->eval_node_set(c); + xpath_node_set_raw ns = _left->eval_node_set(c, stack); - for (xpath_node_set::const_iterator it = ns.begin(); it != ns.end(); ++it) - r += convert_string_to_number(string_value(*it).c_str()); + for (const xpath_node* it = ns.begin(); it != ns.end(); ++it) + r += convert_string_to_number(string_value(*it, stack.result).c_str()); return r; } case ast_func_floor: { - double r = _left->eval_number(c); + double r = _left->eval_number(c, stack); return r == r ? floor(r) : r; } case ast_func_ceiling: { - double r = _left->eval_number(c); + 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)); + return round_nearest_nzero(_left->eval_number(c, stack)); case ast_variable: { @@ -7206,13 +7431,21 @@ namespace pugi switch (_rettype) { case xpath_type_boolean: - return eval_boolean(c) ? 1 : 0; + return eval_boolean(c, stack) ? 1 : 0; case xpath_type_string: - return convert_string_to_number(eval_string(c).c_str()); + { + xpath_allocator_capture cr(stack.result); + + return convert_string_to_number(eval_string(c, stack).c_str()); + } case xpath_type_node_set: - return convert_string_to_number(eval_string(c).c_str()); + { + xpath_allocator_capture cr(stack.result); + + return convert_string_to_number(eval_string(c, stack).c_str()); + } default: assert(!"Wrong expression for return type number"); @@ -7223,10 +7456,12 @@ namespace pugi } } - xpath_string eval_string_concat(const xpath_context& c) + xpath_string eval_string_concat(const xpath_context& c, const xpath_stack& stack) { assert(_type == ast_func_concat); + xpath_allocator_capture ct(stack.temp); + // count the string number unsigned int count = 1; for (xpath_ast_node* nc = _right; nc; nc = nc->_next) count++; @@ -7238,17 +7473,17 @@ namespace pugi // allocate on-heap for large concats if (count > sizeof(static_buffer) / sizeof(static_buffer[0])) { - buffer = static_cast<xpath_string*>(global_allocate(count * sizeof(xpath_string))); + buffer = static_cast<xpath_string*>(stack.temp->allocate(count * sizeof(xpath_string))); if (!buffer) return xpath_string(); // $$ out of memory - - for (unsigned int i = 0; i < count; ++i) new (&buffer[i]) xpath_string(); } - // compute all strings - _left->eval_string(c).swap(buffer[0]); + // 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) n->eval_string(c).swap(buffer[pos]); + 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 @@ -7256,7 +7491,7 @@ namespace pugi for (unsigned int i = 0; i < count; ++i) length += buffer[i].length(); // create final string - char_t* result = static_cast<char_t*>(global_allocate((length + 1) * sizeof(char_t))); + char_t* result = static_cast<char_t*>(stack.result->allocate((length + 1) * sizeof(char_t))); if (result) { @@ -7269,21 +7504,13 @@ namespace pugi *ri = 0; } - // deallocate strings - if (buffer != static_buffer) - { - for (unsigned int i = 0; i < count; ++i) buffer[i].~xpath_string(); - - global_deallocate(buffer); - } - // return result if (!result) return xpath_string(); // $$ out of memory return xpath_string(result, true); } - xpath_string eval_string(const xpath_context& c) + xpath_string eval_string(const xpath_context& c, const xpath_stack& stack) { switch (_type) { @@ -7299,7 +7526,9 @@ namespace pugi case ast_func_local_name_1: { - xpath_node_set ns = _left->eval_node_set(c); + xpath_allocator_capture cr(stack.result); + + xpath_node_set_raw ns = _left->eval_node_set(c, stack); xpath_node na = ns.first(); return xpath_string_const(local_name(na)); @@ -7314,7 +7543,9 @@ namespace pugi case ast_func_name_1: { - xpath_node_set ns = _left->eval_node_set(c); + xpath_allocator_capture cr(stack.result); + + xpath_node_set_raw ns = _left->eval_node_set(c, stack); xpath_node na = ns.first(); return xpath_string_const(qualified_name(na)); @@ -7329,61 +7560,87 @@ namespace pugi case ast_func_namespace_uri_1: { - xpath_node_set ns = _left->eval_node_set(c); + xpath_allocator_capture cr(stack.result); + + xpath_node_set_raw ns = _left->eval_node_set(c, stack); xpath_node na = ns.first(); return xpath_string_const(namespace_uri(na)); } case ast_func_string_0: - return string_value(c.n); + return string_value(c.n, stack.result); case ast_func_string_1: - return _left->eval_string(c); + return _left->eval_string(c, stack); case ast_func_concat: - return eval_string_concat(c); + return eval_string_concat(c, stack); case ast_func_substring_before: { - xpath_string s = _left->eval_string(c); - xpath_string p = _right->eval_string(c); + 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(s.c_str(), pos) : xpath_string(); + return pos ? xpath_string(s.c_str(), pos, stack.result) : xpath_string(); } case ast_func_substring_after: { - xpath_string s = _left->eval_string(c); - xpath_string p = _right->eval_string(c); + 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(pos + p.length(), s.uses_heap()) : xpath_string(); + if (!pos) return xpath_string(); + + const char_t* result = pos + p.length(); + + return s.uses_heap() ? xpath_string(result, stack.result) : xpath_string_const(result); } case ast_func_substring_2: { - xpath_string s = _left->eval_string(c); - double first = round_nearest(_right->eval_number(c)); + 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 >= s.length() + 1) return xpath_string(); + else if (first >= s_length + 1) return xpath_string(); size_t pos = first < 1 ? 1 : (size_t)first; + assert(1 <= pos && pos <= s_length + 1); + + const char_t* rbegin = s.c_str() + (pos - 1); - return xpath_string(s.c_str() + (pos - 1), s.uses_heap()); + return s.uses_heap() ? xpath_string(rbegin, stack.result) : xpath_string_const(rbegin); } case ast_func_substring_3: { - xpath_string s = _left->eval_string(c); + 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)); - double last = first + round_nearest(_right->_next->eval_number(c)); + 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 >= s_length + 1) return xpath_string(); @@ -7394,38 +7651,43 @@ namespace pugi size_t end = last >= s_length + 1 ? s_length + 1 : (size_t)last; assert(1 <= pos && pos <= end && end <= s_length + 1); + const char_t* rbegin = s.c_str() + (pos - 1); if (end == s_length + 1) - return xpath_string(s.c_str() + (pos - 1), s.uses_heap()); + return s.uses_heap() ? xpath_string(rbegin, stack.result) : xpath_string_const(rbegin); else - return xpath_string(s.c_str() + (pos - 1), s.c_str() + (end - 1)); + return xpath_string(s.c_str() + (pos - 1), s.c_str() + (end - 1), stack.result); } case ast_func_normalize_space_0: { - xpath_string s = string_value(c.n); + xpath_string s = string_value(c.n, stack.result); - normalize_space(s.data()); + normalize_space(s.data(stack.result)); return s; } case ast_func_normalize_space_1: { - xpath_string s = _left->eval_string(c); + xpath_string s = _left->eval_string(c, stack); - normalize_space(s.data()); + normalize_space(s.data(stack.result)); return s; } case ast_func_translate: { - xpath_string s = _left->eval_string(c); - xpath_string from = _right->eval_string(c); - xpath_string to = _right->_next->eval_string(c); + 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); - translate(s.data(), from.c_str(), to.c_str()); + translate(s.data(stack.result), from.c_str(), to.c_str()); return s; } @@ -7445,15 +7707,19 @@ namespace pugi switch (_rettype) { case xpath_type_boolean: - return xpath_string_const(eval_boolean(c) ? PUGIXML_TEXT("true") : PUGIXML_TEXT("false")); + return xpath_string_const(eval_boolean(c, stack) ? PUGIXML_TEXT("true") : PUGIXML_TEXT("false")); case xpath_type_number: - return convert_number_to_string(eval_number(c)); + return convert_number_to_string(eval_number(c, stack), stack.result); case xpath_type_node_set: { - xpath_node_set ns = eval_node_set(c); - return ns.empty() ? xpath_string() : string_value(ns.first()); + 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); + return ns.empty() ? xpath_string() : string_value(ns.first(), stack.result); } default: @@ -7464,84 +7730,89 @@ namespace pugi } } - xpath_node_set eval_node_set(const xpath_context& c) + xpath_node_set_raw eval_node_set(const xpath_context& c, const xpath_stack& stack) { switch (_type) { case ast_op_union: { - xpath_node_set ls = _left->eval_node_set(c); - xpath_node_set rs = _right->eval_node_set(c); + xpath_allocator_capture cr(stack.temp); + + xpath_stack swapped_stack = {stack.temp, stack.result}; + + xpath_node_set_raw ls = _left->eval_node_set(c, swapped_stack); + xpath_node_set_raw rs = _right->eval_node_set(c, stack); // we can optimize merging two sorted sets, but this is a very rare operation, so don't bother - ls._type = xpath_node_set::type_unsorted; + rs.set_type(xpath_node_set::type_unsorted); - ls.append(rs.begin(), rs.end()); + for (const xpath_node* li = ls.begin(); li != ls.end(); ++li) + rs.push_back(*li, stack.result); - ls.remove_duplicates(); + rs.remove_duplicates(); - return ls; + return rs; } case ast_filter: case ast_filter_posinv: { - xpath_node_set set = _left->eval_node_set(c); + xpath_node_set_raw set = _left->eval_node_set(c, stack); // either expression is a number or it contains position() call; sort by document order if (_type == ast_filter) set.sort(); - apply_predicate(set, 0, _right); + apply_predicate(set, 0, _right, stack); return set; } case ast_func_id: - return xpath_node_set(); + return xpath_node_set_raw(); case ast_step: { switch (_axis) { case axis_ancestor: - return step_do(c, axis_to_type<axis_ancestor>()); + return step_do(c, stack, axis_to_type<axis_ancestor>()); case axis_ancestor_or_self: - return step_do(c, axis_to_type<axis_ancestor_or_self>()); + return step_do(c, stack, axis_to_type<axis_ancestor_or_self>()); case axis_attribute: - return step_do(c, axis_to_type<axis_attribute>()); + return step_do(c, stack, axis_to_type<axis_attribute>()); case axis_child: - return step_do(c, axis_to_type<axis_child>()); + return step_do(c, stack, axis_to_type<axis_child>()); case axis_descendant: - return step_do(c, axis_to_type<axis_descendant>()); + return step_do(c, stack, axis_to_type<axis_descendant>()); case axis_descendant_or_self: - return step_do(c, axis_to_type<axis_descendant_or_self>()); + return step_do(c, stack, axis_to_type<axis_descendant_or_self>()); case axis_following: - return step_do(c, axis_to_type<axis_following>()); + return step_do(c, stack, axis_to_type<axis_following>()); case axis_following_sibling: - return step_do(c, axis_to_type<axis_following_sibling>()); + return step_do(c, stack, axis_to_type<axis_following_sibling>()); case axis_namespace: // namespaced axis is not supported - return xpath_node_set(); + return xpath_node_set_raw(); case axis_parent: - return step_do(c, axis_to_type<axis_parent>()); + return step_do(c, stack, axis_to_type<axis_parent>()); case axis_preceding: - return step_do(c, axis_to_type<axis_preceding>()); + return step_do(c, stack, axis_to_type<axis_preceding>()); case axis_preceding_sibling: - return step_do(c, axis_to_type<axis_preceding_sibling>()); + return step_do(c, stack, axis_to_type<axis_preceding_sibling>()); case axis_self: - return step_do(c, axis_to_type<axis_self>()); + return step_do(c, stack, axis_to_type<axis_self>()); } } @@ -7549,11 +7820,12 @@ namespace pugi { assert(!_right); // root step can't have any predicates - xpath_node_set ns; - ns._type = xpath_node_set::type_sorted; + xpath_node_set_raw ns; - if (c.n.node()) ns.push_back(c.n.node().root()); - else if (c.n.attribute()) ns.push_back(c.n.parent().root()); + 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; } @@ -7563,14 +7835,25 @@ namespace pugi assert(_rettype == _data.variable->type()); if (_rettype == xpath_type_node_set) - return _data.variable->get_node_set(); + { + const xpath_node_set& s = _data.variable->get_node_set(); + + xpath_node_set_raw ns; + + ns.set_type(s.type()); + + for (xpath_node_set::const_iterator i = s.begin(); i != s.end(); ++i) + ns.push_back(*i, stack.result); + + return ns; + } // fallthrough to type conversion } default: assert(!"Wrong expression for return type node set"); - return xpath_node_set(); + return xpath_node_set_raw(); } } @@ -8532,9 +8815,13 @@ namespace pugi xpath_variable_string* var = static_cast<xpath_variable_string*>(this); // duplicate string - char_t* copy = duplicate_string(value); + size_t size = (strlength(value) + 1) * sizeof(char_t); + + char_t* copy = static_cast<char_t*>(global_allocate(size)); if (!copy) return false; + memcpy(copy, value, size); + // replace old string if (var->value) global_deallocate(var->value); var->value = copy; @@ -8689,7 +8976,12 @@ namespace pugi xpath_context c(n, 1, 1); - return _root->eval_boolean(c); + xpath_memory_block resultblock, tempblock; + xpath_allocator result(&resultblock), temp(&tempblock); + xpath_allocator_capture cr(&result), ct(&temp); + xpath_stack stack = {&result, &temp}; + + return _root->eval_boolean(c, stack); } double xpath_query::evaluate_number(const xpath_node& n) const @@ -8698,7 +8990,12 @@ namespace pugi xpath_context c(n, 1, 1); - return _root->eval_number(c); + xpath_memory_block resultblock, tempblock; + xpath_allocator result(&resultblock), temp(&tempblock); + xpath_allocator_capture cr(&result), ct(&temp); + xpath_stack stack = {&result, &temp}; + + return _root->eval_number(c, stack); } #ifndef PUGIXML_NO_STL @@ -8708,14 +9005,25 @@ namespace pugi xpath_context c(n, 1, 1); - return _root->eval_string(c).c_str(); + xpath_memory_block resultblock, tempblock; + xpath_allocator result(&resultblock), temp(&tempblock); + xpath_allocator_capture cr(&result), ct(&temp); + xpath_stack stack = {&result, &temp}; + + return _root->eval_string(c, stack).c_str(); } #endif size_t xpath_query::evaluate_string(char_t* buffer, size_t capacity, const xpath_node& n) const { xpath_context c(n, 1, 1); - xpath_string r = _root ? _root->eval_string(c) : xpath_string(); + + xpath_memory_block resultblock, tempblock; + xpath_allocator result(&resultblock), temp(&tempblock); + xpath_allocator_capture cr(&result), ct(&temp); + xpath_stack stack = {&result, &temp}; + + xpath_string r = _root ? _root->eval_string(c, stack) : xpath_string(); size_t size = r.length() + 1; @@ -8741,7 +9049,14 @@ namespace pugi xpath_context c(n, 1, 1); - return _root->eval_node_set(c); + xpath_memory_block resultblock, tempblock; + xpath_allocator result(&resultblock), temp(&tempblock); + xpath_allocator_capture cr(&result), ct(&temp); + xpath_stack stack = {&result, &temp}; + + xpath_node_set_raw r = _root->eval_node_set(c, stack); + + return xpath_node_set(r.begin(), r.end(), r.type()); } const xpath_parse_result& xpath_query::result() const |