Everything is working again except for predicates.
This commit is contained in:
John Wiegley
parent
b6ab7deb63
commit
bf2c8c0f48
6 changed files with 149 additions and 159 deletions
22
src/main.cc
22
src/main.cc
|
|
@ -145,15 +145,27 @@ static int read_and_report(ledger::report_t& report, int argc, char * argv[],
|
|||
xml::xpath_t expr(*arg);
|
||||
xml::document_t temp(xml::LEDGER_NODE);
|
||||
|
||||
xml::xpath_t::document_scope_t doc_scope(report, temp);
|
||||
xml::xpath_t::context_scope_t doc_scope(report, temp);
|
||||
|
||||
IF_INFO() {
|
||||
std::cout << "Value expression tree:" << std::endl;
|
||||
expr.dump(std::cout);
|
||||
std::cout << std::endl;
|
||||
|
||||
std::cout << "Value expression parsed was:" << std::endl;
|
||||
expr.print(std::cout, doc_scope);
|
||||
std::cout << std::endl << std::endl;
|
||||
|
||||
expr.compile(doc_scope);
|
||||
|
||||
std::cout << "Value expression after compiling:" << std::endl;
|
||||
expr.dump(std::cout);
|
||||
std::cout << std::endl;
|
||||
|
||||
std::cout << "Value expression is now:" << std::endl;
|
||||
expr.print(std::cout, doc_scope);
|
||||
std::cout << std::endl << std::endl;
|
||||
|
||||
std::cout << "Result of calculation: ";
|
||||
}
|
||||
|
||||
|
|
@ -248,7 +260,7 @@ static int read_and_report(ledger::report_t& report, int argc, char * argv[],
|
|||
|
||||
// Are we handling the expr commands? Do so now.
|
||||
|
||||
xml::xpath_t::document_scope_t doc_scope(report, xml_document);
|
||||
xml::xpath_t::context_scope_t doc_scope(report, xml_document);
|
||||
|
||||
if (verb == "expr") {
|
||||
xml::xpath_t expr(*arg);
|
||||
|
|
@ -268,14 +280,13 @@ static int read_and_report(ledger::report_t& report, int argc, char * argv[],
|
|||
return 0;
|
||||
}
|
||||
else if (verb == "xpath") {
|
||||
std::cout << "XPath parsed:" << std::endl;
|
||||
std::cout << "XPath parsed:";
|
||||
|
||||
xml::xpath_t xpath(*arg);
|
||||
xpath.print(*out, doc_scope);
|
||||
*out << std::endl;
|
||||
|
||||
#if 0
|
||||
foreach (const value_t& value, xpath.find_all(xml_document, report)) {
|
||||
foreach (const value_t& value, xpath.find_all(doc_scope)) {
|
||||
if (value.is_xml_node()) {
|
||||
value.as_xml_node()->print(std::cout);
|
||||
} else {
|
||||
|
|
@ -283,7 +294,6 @@ static int read_and_report(ledger::report_t& report, int argc, char * argv[],
|
|||
}
|
||||
std::cout << std::endl;
|
||||
}
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -284,7 +284,7 @@ void trace_ctor_func(void * ptr, const char * cls_name, const char * args,
|
|||
std::strcat(name, args);
|
||||
std::strcat(name, ")");
|
||||
|
||||
DEBUG("verify.memory", "TRACE_CTOR " << ptr << " " << name);
|
||||
DEBUG("memory.debug", "TRACE_CTOR " << ptr << " " << name);
|
||||
|
||||
live_objects->insert
|
||||
(live_objects_map::value_type(ptr, allocation_pair(cls_name, cls_size)));
|
||||
|
|
@ -303,7 +303,7 @@ void trace_dtor_func(void * ptr, const char * cls_name, std::size_t cls_size)
|
|||
|
||||
if (! live_objects) return;
|
||||
|
||||
DEBUG("ledger.trace.debug", "TRACE_DTOR " << ptr << " " << cls_name);
|
||||
DEBUG("memory.debug", "TRACE_DTOR " << ptr << " " << cls_name);
|
||||
|
||||
live_objects_map::iterator i = live_objects->find(ptr);
|
||||
VERIFY(i != live_objects->end());
|
||||
|
|
|
|||
|
|
@ -1371,6 +1371,7 @@ value_t value_t::strip_annotations(const bool keep_price,
|
|||
const bool keep_tag) const
|
||||
{
|
||||
switch (type()) {
|
||||
case VOID:
|
||||
case BOOLEAN:
|
||||
case INTEGER:
|
||||
case DATETIME:
|
||||
|
|
@ -1551,6 +1552,9 @@ void value_t::print(std::ostream& out, const int first_width,
|
|||
std::ostream& operator<<(std::ostream& out, const value_t& val)
|
||||
{
|
||||
switch (val.type()) {
|
||||
case value_t::VOID:
|
||||
out << "VOID";
|
||||
break;
|
||||
case value_t::BOOLEAN:
|
||||
out << (val.as_boolean() ? "true" : "false");
|
||||
break;
|
||||
|
|
|
|||
24
src/value.h
24
src/value.h
|
|
@ -216,12 +216,12 @@ public:
|
|||
TRACE_CTOR(value_t, "const sequence_t&");
|
||||
set_sequence(val);
|
||||
}
|
||||
value_t(xml::node_t * xml_node) {
|
||||
value_t(xml::node_t * item) {
|
||||
TRACE_CTOR(value_t, "xml::node_t *");
|
||||
set_xml_node(xml_node);
|
||||
set_xml_node(item);
|
||||
}
|
||||
template <typename T>
|
||||
value_t(T * item) {
|
||||
explicit value_t(T * item) {
|
||||
TRACE_CTOR(value_t, "T *");
|
||||
set_pointer(item);
|
||||
}
|
||||
|
|
@ -230,9 +230,8 @@ public:
|
|||
}
|
||||
|
||||
value_t& operator=(const value_t& val) {
|
||||
if (this == &val || storage == val.storage)
|
||||
return *this;
|
||||
storage = val.storage;
|
||||
if (! (this == &val || storage == val.storage))
|
||||
storage = val.storage;
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
|
@ -537,11 +536,14 @@ public:
|
|||
if (! is_sequence())
|
||||
in_place_cast(SEQUENCE);
|
||||
|
||||
if (! val.is_sequence())
|
||||
as_sequence_lval().push_back(val);
|
||||
else
|
||||
std::copy(val.as_sequence().begin(), val.as_sequence().end(),
|
||||
as_sequence_lval().end());
|
||||
value_t::sequence_t& seq(as_sequence_lval());
|
||||
if (! val.is_sequence()) {
|
||||
if (! val.is_null())
|
||||
seq.push_back(val);
|
||||
} else {
|
||||
const value_t::sequence_t& val_seq(val.as_sequence());
|
||||
std::copy(val_seq.begin(), val_seq.end(), back_inserter(seq));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
141
src/xpath.cc
141
src/xpath.cc
|
|
@ -414,7 +414,6 @@ void xpath_t::symbol_scope_t::define(const string& name, ptr_op_t def)
|
|||
if (! result.second) {
|
||||
symbol_map::iterator i = symbols.find(name);
|
||||
assert(i != symbols.end());
|
||||
(*i).second->release();
|
||||
symbols.erase(i);
|
||||
|
||||
std::pair<symbol_map::iterator, bool> result2
|
||||
|
|
@ -423,7 +422,6 @@ void xpath_t::symbol_scope_t::define(const string& name, ptr_op_t def)
|
|||
throw_(compile_error,
|
||||
"Redefinition of '" << name << "' in same scope");
|
||||
}
|
||||
def->acquire();
|
||||
}
|
||||
|
||||
void xpath_t::scope_t::define(const string& name, const value_t& val) {
|
||||
|
|
@ -432,21 +430,21 @@ void xpath_t::scope_t::define(const string& name, const value_t& val) {
|
|||
|
||||
value_t xpath_fn_last(xpath_t::call_scope_t& scope)
|
||||
{
|
||||
xpath_t::context_scope_t& context(FIND_SCOPE(xpath_t::context_scope_t, scope));
|
||||
xpath_t::context_scope_t& context(CONTEXT_SCOPE(scope));
|
||||
|
||||
return context.size();
|
||||
}
|
||||
|
||||
value_t xpath_fn_position(xpath_t::call_scope_t& scope)
|
||||
{
|
||||
xpath_t::context_scope_t& context(FIND_SCOPE(xpath_t::context_scope_t, scope));
|
||||
xpath_t::context_scope_t& context(CONTEXT_SCOPE(scope));
|
||||
|
||||
return context.index();
|
||||
}
|
||||
|
||||
value_t xpath_fn_text(xpath_t::call_scope_t& scope)
|
||||
{
|
||||
xpath_t::context_scope_t& context(FIND_SCOPE(xpath_t::context_scope_t, scope));
|
||||
xpath_t::context_scope_t& context(CONTEXT_SCOPE(scope));
|
||||
|
||||
return value_t(context.xml_node().to_value().to_string(), true);
|
||||
}
|
||||
|
|
@ -971,6 +969,9 @@ xpath_t::ptr_op_t xpath_t::op_t::compile(scope_t& scope)
|
|||
break;
|
||||
}
|
||||
|
||||
if (kind < TERMINALS)
|
||||
return this;
|
||||
|
||||
ptr_op_t lhs(left()->compile(scope));
|
||||
ptr_op_t rhs(right() ? right()->compile(scope) : ptr_op_t());
|
||||
|
||||
|
|
@ -987,16 +988,46 @@ xpath_t::ptr_op_t xpath_t::op_t::compile(scope_t& scope)
|
|||
|
||||
value_t xpath_t::op_t::current_value(scope_t& scope)
|
||||
{
|
||||
xpath_t::context_scope_t& context(FIND_SCOPE(xpath_t::context_scope_t, scope));
|
||||
xpath_t::context_scope_t& context(CONTEXT_SCOPE(scope));
|
||||
return context.value();
|
||||
}
|
||||
|
||||
node_t& xpath_t::op_t::current_xml_node(scope_t& scope)
|
||||
{
|
||||
xpath_t::context_scope_t& context(FIND_SCOPE(xpath_t::context_scope_t, scope));
|
||||
xpath_t::context_scope_t& context(CONTEXT_SCOPE(scope));
|
||||
return context.xml_node();
|
||||
}
|
||||
|
||||
namespace {
|
||||
value_t search_nodes(value_t nodes, xpath_t::ptr_op_t find_op,
|
||||
xpath_t::scope_t& scope, bool recurse)
|
||||
{
|
||||
value_t node_sequence = nodes.to_sequence();
|
||||
value_t result;
|
||||
|
||||
foreach (value_t& node_value, node_sequence.as_sequence_lval()) {
|
||||
if (! node_value.is_xml_node())
|
||||
throw_(xpath_t::calc_error,
|
||||
"Application of / operator to non-node value '"
|
||||
<< node_value << "'");
|
||||
|
||||
node_t& node(*node_value.as_xml_node());
|
||||
xpath_t::context_scope_t node_scope(scope, node, node_sequence);
|
||||
|
||||
result.push_back(find_op->calc(node_scope));
|
||||
|
||||
if (recurse && node.is_parent_node()) {
|
||||
value_t children;
|
||||
foreach (node_t * child, node.as_parent_node())
|
||||
children.push_back(child);
|
||||
|
||||
result.push_back(search_nodes(children, find_op, scope, recurse));
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
}
|
||||
|
||||
value_t xpath_t::op_t::calc(scope_t& scope)
|
||||
{
|
||||
switch (kind) {
|
||||
|
|
@ -1021,7 +1052,8 @@ value_t xpath_t::op_t::calc(scope_t& scope)
|
|||
case O_CALL: {
|
||||
call_scope_t call_args(scope);
|
||||
|
||||
call_args.set_args(right()->calc(scope));
|
||||
if (right())
|
||||
call_args.set_args(right()->calc(scope));
|
||||
|
||||
ptr_op_t func = left();
|
||||
string name;
|
||||
|
|
@ -1045,36 +1077,13 @@ value_t xpath_t::op_t::calc(scope_t& scope)
|
|||
if (as_long() >= 0 && as_long() < args.size())
|
||||
return args[as_long()];
|
||||
else
|
||||
throw_(compile_error, "Reference to a non-existing argument");
|
||||
throw_(calc_error, "Reference to a non-existing argument");
|
||||
break;
|
||||
}
|
||||
|
||||
case O_FIND:
|
||||
case O_RFIND: {
|
||||
value_t result;
|
||||
|
||||
if (value_t items = left()->calc(scope)) {
|
||||
value_t sequence = items.to_sequence();
|
||||
foreach (value_t& item, sequence.as_sequence_lval()) {
|
||||
if (item.is_xml_node()) {
|
||||
node_t& node(*item.as_xml_node());
|
||||
node_scope_t node_scope(scope, node);
|
||||
|
||||
result.push_back(right()->calc(node_scope));
|
||||
#if 0
|
||||
// jww (2007-05-17): How do I get it to recurse down? I'll
|
||||
// have to use a recursive helper function.
|
||||
if (kind == O_RFIND && node.is_parent_node())
|
||||
foreach (node_t * child, node.as_parent_node())
|
||||
walk_elements(element->right(), scope, *child, NULL, func);
|
||||
#endif
|
||||
} else {
|
||||
throw_(compile_error, "Application of / operator to non-node value");
|
||||
}
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
case O_RFIND:
|
||||
return search_nodes(left()->calc(scope), right(), scope, kind == O_RFIND);
|
||||
|
||||
case NODE_ID:
|
||||
switch (as_name()) {
|
||||
|
|
@ -1094,7 +1103,7 @@ value_t xpath_t::op_t::calc(scope_t& scope)
|
|||
case document_t::ALL: {
|
||||
node_t& current_node(current_xml_node(scope));
|
||||
if (! current_node.is_parent_node())
|
||||
throw_(compile_error, "Referencing child nodes from a non-parent value");
|
||||
throw_(calc_error, "Referencing child nodes from a non-parent value");
|
||||
|
||||
value_t result;
|
||||
foreach (node_t * child, current_node.as_parent_node())
|
||||
|
|
@ -1109,20 +1118,14 @@ value_t xpath_t::op_t::calc(scope_t& scope)
|
|||
|
||||
case NODE_NAME: {
|
||||
node_t& current_node(current_xml_node(scope));
|
||||
|
||||
if (current_node.is_parent_node()) {
|
||||
bool have_name_id = kind == NODE_ID;
|
||||
|
||||
value_t result;
|
||||
|
||||
foreach (node_t * child, current_node.as_parent_node()) {
|
||||
if (( have_name_id && as_name() == child->name_id()) ||
|
||||
(! have_name_id && as_string() == child->name()))
|
||||
result.push_back(child);
|
||||
#if 0
|
||||
else if (recurse)
|
||||
/* ... */;
|
||||
#endif
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
|
@ -1130,30 +1133,36 @@ value_t xpath_t::op_t::calc(scope_t& scope)
|
|||
}
|
||||
|
||||
case O_PRED: {
|
||||
#if 0
|
||||
predicate_scope_t predicate_scope(scope, right());
|
||||
return left()->calc(predicate_scope);
|
||||
#endif
|
||||
break;
|
||||
value_t values = left()->calc(scope).to_sequence();
|
||||
value_t result;
|
||||
|
||||
std::size_t index = 0;
|
||||
foreach (const value_t& value, values.as_sequence()) {
|
||||
xpath_t::context_scope_t value_scope(scope, value);
|
||||
|
||||
value_t predval = right()->calc(value_scope);
|
||||
if ((predval.is_long() &&
|
||||
predval.as_long() == (long)index + 1) ||
|
||||
predval.to_boolean())
|
||||
result.push_back(value);
|
||||
|
||||
index++;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
case ATTR_ID:
|
||||
case ATTR_NAME: {
|
||||
context_scope_t& context(scope.find_scope<context_scope_t>());
|
||||
|
||||
if (context.type() != scope_t::NODE_SCOPE)
|
||||
throw_(calc_error, "Looking up attribute in a non-node context");
|
||||
|
||||
node_scope_t& node_scope(downcast<node_scope_t>(context));
|
||||
node_t& current_node(current_xml_node(scope));
|
||||
|
||||
if (optional<const string&> value =
|
||||
kind == ATTR_ID ? node_scope.xml_node().get_attr(as_long()) :
|
||||
node_scope.xml_node().get_attr(as_string()))
|
||||
kind == ATTR_ID ? current_node.get_attr(as_long()) :
|
||||
current_node.get_attr(as_string()))
|
||||
return value_t(*value, true);
|
||||
else
|
||||
throw_(calc_error, "Attribute '"
|
||||
<< (kind == ATTR_ID ?
|
||||
*node_scope.xml_node().document().lookup_name(as_long()) :
|
||||
*current_node.document().lookup_name(as_long()) :
|
||||
as_string().c_str())
|
||||
<< "' was not found");
|
||||
break;
|
||||
|
|
@ -1243,6 +1252,8 @@ bool xpath_t::op_t::print(std::ostream& out, print_context_t& context) const
|
|||
out << "0";
|
||||
break;
|
||||
case value_t::INTEGER:
|
||||
out << value;
|
||||
break;
|
||||
case value_t::AMOUNT:
|
||||
if (! context.relaxed)
|
||||
out << '{';
|
||||
|
|
@ -1278,16 +1289,9 @@ bool xpath_t::op_t::print(std::ostream& out, print_context_t& context) const
|
|||
out << '@';
|
||||
// fall through...
|
||||
case NODE_ID: {
|
||||
context_scope_t& context_scope(context.scope.find_scope<context_scope_t>());
|
||||
|
||||
if (context_scope.type() != scope_t::NODE_SCOPE)
|
||||
throw_(calc_error, "Looking up node name in a non-node context");
|
||||
|
||||
node_scope_t& node_scope(downcast<node_scope_t>(context_scope));
|
||||
|
||||
optional<const char *> name =
|
||||
node_scope.xml_node().document().lookup_name(as_name());
|
||||
if (name)
|
||||
context_scope_t& node_scope(CONTEXT_SCOPE(context.scope));
|
||||
if (optional<const char *> name =
|
||||
node_scope.xml_node().document().lookup_name(as_name()))
|
||||
out << *name;
|
||||
else
|
||||
out << '#' << as_name();
|
||||
|
|
@ -1308,7 +1312,7 @@ bool xpath_t::op_t::print(std::ostream& out, print_context_t& context) const
|
|||
break;
|
||||
|
||||
case FUNCTION:
|
||||
out << as_function();
|
||||
out << '<FUNCTION>';
|
||||
break;
|
||||
|
||||
case ARG_INDEX:
|
||||
|
|
@ -1544,7 +1548,7 @@ void xpath_t::op_t::dump(std::ostream& out, const int depth) const
|
|||
break;
|
||||
|
||||
case FUNCTION:
|
||||
out << "FUNCTION - " << as_function();
|
||||
out << "FUNCTION";
|
||||
break;
|
||||
|
||||
case O_CALL: out << "O_CALL"; break;
|
||||
|
|
@ -1603,8 +1607,7 @@ value_t xml_command(xml::xpath_t::call_scope_t& args)
|
|||
value_t ostream = args.resolve("ostream");
|
||||
std::ostream& outs(ostream.as_ref_lval<std::ostream>());
|
||||
|
||||
xml::xpath_t::node_scope_t& node_context
|
||||
(FIND_SCOPE(xml::xpath_t::node_scope_t, args));
|
||||
xml::xpath_t::context_scope_t& node_context(CONTEXT_SCOPE(args));
|
||||
node_context.xml_node().print(outs);
|
||||
|
||||
return true;
|
||||
|
|
|
|||
113
src/xpath.h
113
src/xpath.h
|
|
@ -69,8 +69,9 @@ public:
|
|||
SYMBOL_SCOPE,
|
||||
CALL_SCOPE,
|
||||
CONTEXT_SCOPE,
|
||||
NODE_SCOPE,
|
||||
#if 0
|
||||
PREDICATE_SCOPE
|
||||
#endif
|
||||
} type_;
|
||||
|
||||
explicit scope_t(type_t _type) : type_(_type) {
|
||||
|
|
@ -213,11 +214,30 @@ public:
|
|||
explicit context_scope_t(scope_t& _parent,
|
||||
const value_t& _element,
|
||||
const optional<value_t>& _sequence = none)
|
||||
: child_scope_t(_parent, CONTEXT_SCOPE),
|
||||
element(_element), sequence(_sequence)
|
||||
: child_scope_t(_parent, CONTEXT_SCOPE)
|
||||
{
|
||||
TRACE_CTOR(xpath_t::context_scope_t,
|
||||
"scope_t&, const value_t&, const optional<value_t>&");
|
||||
set_context(_element, _sequence);
|
||||
}
|
||||
explicit context_scope_t(scope_t& _parent,
|
||||
node_t& _element,
|
||||
const optional<value_t>& _sequence = none)
|
||||
: child_scope_t(_parent, CONTEXT_SCOPE)
|
||||
{
|
||||
TRACE_CTOR(xpath_t::context_scope_t,
|
||||
"scope_t&, const value_t&, const optional<value_t>&");
|
||||
set_context(value_t(&_element), _sequence);
|
||||
}
|
||||
virtual ~context_scope_t() {
|
||||
TRACE_DTOR(xpath_t::context_scope_t);
|
||||
}
|
||||
|
||||
void set_context(const value_t& _element,
|
||||
const optional<value_t>& _sequence) {
|
||||
element = _element;
|
||||
sequence = _sequence;
|
||||
|
||||
assert(! element.is_sequence());
|
||||
|
||||
if (DO_VERIFY() && sequence) {
|
||||
|
|
@ -230,9 +250,6 @@ public:
|
|||
}
|
||||
}
|
||||
}
|
||||
virtual ~context_scope_t() {
|
||||
TRACE_DTOR(xpath_t::context_scope_t);
|
||||
}
|
||||
|
||||
const std::size_t index() const {
|
||||
if (! sequence) {
|
||||
|
|
@ -262,21 +279,7 @@ public:
|
|||
}
|
||||
};
|
||||
|
||||
class node_scope_t : public context_scope_t
|
||||
{
|
||||
public:
|
||||
node_scope_t(scope_t& _parent, node_t& _node)
|
||||
: context_scope_t(_parent, &_node) {
|
||||
TRACE_CTOR(xpath_t::node_scope_t, "scope_t&, node_t&");
|
||||
type_ = NODE_SCOPE;
|
||||
}
|
||||
virtual ~node_scope_t() {
|
||||
TRACE_DTOR(xpath_t::node_scope_t);
|
||||
}
|
||||
};
|
||||
|
||||
typedef node_scope_t document_scope_t;
|
||||
|
||||
#if 0
|
||||
class predicate_scope_t : public child_scope_t
|
||||
{
|
||||
public:
|
||||
|
|
@ -305,6 +308,7 @@ public:
|
|||
return predicate->calc(context_scope).to_boolean();
|
||||
}
|
||||
};
|
||||
#endif
|
||||
|
||||
#define XPATH_PARSE_NORMAL 0x00
|
||||
#define XPATH_PARSE_PARTIAL 0x01
|
||||
|
|
@ -402,41 +406,27 @@ private:
|
|||
};
|
||||
|
||||
public:
|
||||
#if 0
|
||||
class path_iterator_t
|
||||
{
|
||||
typedef NodeType * pointer;
|
||||
typedef NodeType& reference;
|
||||
typedef node_t * pointer;
|
||||
typedef node_t& reference;
|
||||
|
||||
path_t path;
|
||||
node_t& start;
|
||||
xpath_t& path_expr;
|
||||
scope_t& scope;
|
||||
|
||||
mutable value_t::sequence_t sequence;
|
||||
mutable bool searched;
|
||||
|
||||
struct node_appender_t {
|
||||
value_t::sequence_t& sequence;
|
||||
node_appender_t(value_t::sequence_t& _sequence)
|
||||
: sequence(_sequence) {}
|
||||
void operator()(const value_t& node) {
|
||||
sequence.push_back(node);
|
||||
}
|
||||
};
|
||||
|
||||
public:
|
||||
typedef value_t::sequence_t::iterator iterator;
|
||||
typedef value_t::sequence_t::const_iterator const_iterator;
|
||||
|
||||
path_iterator_t(const xpath_t& path_expr,
|
||||
node_t& _start, scope_t& _scope)
|
||||
: path(path_expr), start(_start), scope(_scope),
|
||||
searched(false) {
|
||||
}
|
||||
path_iterator_t(xpath_t& _path_expr, scope_t& _scope)
|
||||
: path_expr(_path_expr), scope(_scope), searched(false) {}
|
||||
|
||||
iterator begin() {
|
||||
if (! searched) {
|
||||
path.visit(start, scope, node_appender_t(sequence));
|
||||
sequence = path_expr.calc(scope).to_sequence();
|
||||
searched = true;
|
||||
}
|
||||
return sequence.begin();
|
||||
|
|
@ -448,7 +438,6 @@ public:
|
|||
iterator end() { return sequence.end(); }
|
||||
const_iterator end() const { return sequence.end(); }
|
||||
};
|
||||
#endif
|
||||
|
||||
struct op_t : public noncopyable
|
||||
{
|
||||
|
|
@ -857,24 +846,9 @@ public:
|
|||
return xpath_t(_expr).calc(scope);
|
||||
}
|
||||
|
||||
#if 0
|
||||
path_iterator_t<node_t>
|
||||
find_all(node_t& start, scope_t& scope) {
|
||||
return path_iterator_t<node_t>(*this, start, scope);
|
||||
path_iterator_t find_all(scope_t& scope) {
|
||||
return path_iterator_t(*this, scope);
|
||||
}
|
||||
path_iterator_t<const node_t>
|
||||
find_all(const node_t& start, scope_t& scope) {
|
||||
return path_iterator_t<const node_t>(*this, start, scope);
|
||||
}
|
||||
|
||||
void visit(node_t& start, scope_t& scope, const path_t::visitor_t& func) {
|
||||
path_t(*this).visit(start, scope, func);
|
||||
}
|
||||
void visit(const node_t& start, scope_t& scope, const
|
||||
path_t::visitor_t& func) {
|
||||
path_t(*this).visit(start, scope, func);
|
||||
}
|
||||
#endif
|
||||
|
||||
void print(std::ostream& out, scope_t& scope) const {
|
||||
op_t::print_context_t context(scope);
|
||||
|
|
@ -890,10 +864,8 @@ public:
|
|||
inline xpath_t::ptr_op_t
|
||||
xpath_t::op_t::new_node(kind_t _kind, ptr_op_t _left, ptr_op_t _right) {
|
||||
ptr_op_t node(new op_t(_kind));
|
||||
if (_left)
|
||||
node->set_left(_left);
|
||||
if (_right)
|
||||
node->set_right(_right);
|
||||
node->set_left(_left);
|
||||
node->set_right(_right);
|
||||
return node;
|
||||
}
|
||||
|
||||
|
|
@ -935,17 +907,16 @@ xpath_t::scope_t::find_scope<xpath_t::context_scope_t>(bool skip_this) {
|
|||
return downcast<context_scope_t>(*scope);
|
||||
}
|
||||
|
||||
template<>
|
||||
inline xpath_t::node_scope_t&
|
||||
xpath_t::scope_t::find_scope<xpath_t::node_scope_t>(bool skip_this) {
|
||||
optional<scope_t&> scope = find_scope(NODE_SCOPE, skip_this);
|
||||
assert(scope);
|
||||
return downcast<node_scope_t>(*scope);
|
||||
}
|
||||
|
||||
#define FIND_SCOPE(scope_type, scope_ref) \
|
||||
downcast<xml::xpath_t::scope_t>(scope_ref).find_scope<scope_type>()
|
||||
|
||||
#define CALL_SCOPE(scope_ref) \
|
||||
FIND_SCOPE(xml::xpath_t::call_scope_t, scope_ref)
|
||||
#define SYMBOL_SCOPE(scope_ref) \
|
||||
FIND_SCOPE(xml::xpath_t::symbol_scope_t, scope_ref)
|
||||
#define CONTEXT_SCOPE(scope_ref) \
|
||||
FIND_SCOPE(xml::xpath_t::context_scope_t, scope_ref)
|
||||
|
||||
} // namespace xml
|
||||
|
||||
value_t xml_command(xml::xpath_t::call_scope_t& args);
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue