#include "config.h"
#include "XPathPath.h"
#include "Document.h"
#include "XPathPredicate.h"
#include "XPathStep.h"
namespace WebCore {
namespace XPath {
Filter::Filter(std::unique_ptr<Expression> expression, Vector<std::unique_ptr<Expression>> predicates)
: m_expression(WTFMove(expression)), m_predicates(WTFMove(predicates))
{
setIsContextNodeSensitive(m_expression->isContextNodeSensitive());
setIsContextPositionSensitive(m_expression->isContextPositionSensitive());
setIsContextSizeSensitive(m_expression->isContextSizeSensitive());
}
Value Filter::evaluate() const
{
Value result = m_expression->evaluate();
NodeSet& nodes = result.modifiableNodeSet();
nodes.sort();
EvaluationContext& evaluationContext = Expression::evaluationContext();
for (auto& predicate : m_predicates) {
NodeSet newNodes;
evaluationContext.size = nodes.size();
evaluationContext.position = 0;
for (auto& node : nodes) {
evaluationContext.node = node;
++evaluationContext.position;
if (evaluatePredicate(*predicate))
newNodes.append(node.copyRef());
}
nodes = WTFMove(newNodes);
}
return result;
}
LocationPath::LocationPath()
: m_isAbsolute(false)
{
setIsContextNodeSensitive(true);
}
Value LocationPath::evaluate() const
{
EvaluationContext& evaluationContext = Expression::evaluationContext();
EvaluationContext backupContext = evaluationContext;
Node* context = evaluationContext.node.get();
if (m_isAbsolute && !context->isDocumentNode())
context = &context->rootNode();
NodeSet nodes;
nodes.append(context);
evaluate(nodes);
evaluationContext = backupContext;
return Value(WTFMove(nodes));
}
void LocationPath::evaluate(NodeSet& nodes) const
{
bool resultIsSorted = nodes.isSorted();
for (auto& step : m_steps) {
NodeSet newNodes;
HashSet<Node*> newNodesSet;
bool needToCheckForDuplicateNodes = !nodes.subtreesAreDisjoint() || (step->axis() != Step::ChildAxis && step->axis() != Step::SelfAxis
&& step->axis() != Step::DescendantAxis && step->axis() != Step::DescendantOrSelfAxis && step->axis() != Step::AttributeAxis);
if (needToCheckForDuplicateNodes)
resultIsSorted = false;
if (nodes.subtreesAreDisjoint() && (step->axis() == Step::ChildAxis || step->axis() == Step::SelfAxis))
newNodes.markSubtreesDisjoint(true);
for (auto& node : nodes) {
NodeSet matches;
step->evaluate(*node, matches);
if (!matches.isSorted())
resultIsSorted = false;
for (auto& match : matches) {
if (!needToCheckForDuplicateNodes || newNodesSet.add(match.get()).isNewEntry)
newNodes.append(match.copyRef());
}
}
nodes = WTFMove(newNodes);
}
nodes.markSorted(resultIsSorted);
}
void LocationPath::appendStep(std::unique_ptr<Step> step)
{
unsigned stepCount = m_steps.size();
if (stepCount) {
bool dropSecondStep;
optimizeStepPair(*m_steps[stepCount - 1], *step, dropSecondStep);
if (dropSecondStep)
return;
}
step->optimize();
m_steps.append(WTFMove(step));
}
void LocationPath::prependStep(std::unique_ptr<Step> step)
{
if (m_steps.size()) {
bool dropSecondStep;
optimizeStepPair(*step, *m_steps[0], dropSecondStep);
if (dropSecondStep) {
m_steps[0] = WTFMove(step);
return;
}
}
step->optimize();
m_steps.insert(0, WTFMove(step));
}
Path::Path(std::unique_ptr<Expression> filter, std::unique_ptr<LocationPath> path)
: m_filter(WTFMove(filter))
, m_path(WTFMove(path))
{
setIsContextNodeSensitive(m_filter->isContextNodeSensitive());
setIsContextPositionSensitive(m_filter->isContextPositionSensitive());
setIsContextSizeSensitive(m_filter->isContextSizeSensitive());
}
Value Path::evaluate() const
{
Value result = m_filter->evaluate();
NodeSet& nodes = result.modifiableNodeSet();
m_path->evaluate(nodes);
return result;
}
}
}