Node* TreeWalker::previousNode()
{
RefPtr<Node> node = m_current;
while (node != root()) {
while (Node* previousSibling = node->previousSibling()) {
node = previousSibling;
short acceptNodeResult = acceptNode(node.get());
if (acceptNodeResult == NodeFilter::FILTER_REJECT)
continue;
while (Node* lastChild = node->lastChild()) {
node = lastChild;
acceptNodeResult = acceptNode(node.get());
if (acceptNodeResult == NodeFilter::FILTER_REJECT)
break;
}
if (acceptNodeResult == NodeFilter::FILTER_ACCEPT) {
m_current = node.release();
return m_current.get();
}
}
if (node == root())
return nullptr;
ContainerNode* parent = node->parentNode();
if (!parent)
return nullptr;
node = parent;
short acceptNodeResult = acceptNode(node.get());
if (acceptNodeResult == NodeFilter::FILTER_ACCEPT)
return setCurrent(WTFMove(node));
}
return nullptr;
}
Node* TreeWalker::nextNode(ExceptionState& exceptionState)
{
RefPtrWillBeRawPtr<Node> node = m_current;
Children:
while (Node* firstChild = node->firstChild()) {
node = firstChild;
unsigned acceptNodeResult = acceptNode(node.get(), exceptionState);
if (exceptionState.hadException())
return 0;
if (acceptNodeResult == NodeFilter::FILTER_ACCEPT)
return setCurrent(node.release());
if (acceptNodeResult == NodeFilter::FILTER_REJECT)
break;
}
while (Node* nextSibling = NodeTraversal::nextSkippingChildren(*node, root())) {
node = nextSibling;
unsigned acceptNodeResult = acceptNode(node.get(), exceptionState);
if (exceptionState.hadException())
return 0;
if (acceptNodeResult == NodeFilter::FILTER_ACCEPT)
return setCurrent(node.release());
if (acceptNodeResult == NodeFilter::FILTER_SKIP)
goto Children;
}
return 0;
}
Node* TreeWalker::nextNode(ScriptState* state)
{
RefPtr<Node> node = m_current;
Children:
while (Node* firstChild = node->firstChild()) {
node = firstChild;
short acceptNodeResult = acceptNode(state, node.get());
if (state && state->hadException())
return 0;
if (acceptNodeResult == NodeFilter::FILTER_ACCEPT)
return setCurrent(node.release());
if (acceptNodeResult == NodeFilter::FILTER_REJECT)
break;
}
while (Node* nextSibling = node->traverseNextSibling(root())) {
node = nextSibling;
short acceptNodeResult = acceptNode(state, node.get());
if (state && state->hadException())
return 0;
if (acceptNodeResult == NodeFilter::FILTER_ACCEPT)
return setCurrent(node.release());
if (acceptNodeResult == NodeFilter::FILTER_SKIP)
goto Children;
}
return 0;
}
Node* TreeWalker::nextNode(JSValue*& exception)
{
exception = 0;
RefPtr<Node> node = m_current;
Children:
while (Node* firstChild = node->firstChild()) {
node = firstChild;
short acceptNodeResult = acceptNode(node.get(), exception);
if (exception)
return 0;
if (acceptNodeResult == NodeFilter::FILTER_ACCEPT)
return setCurrent(node.release());
if (acceptNodeResult == NodeFilter::FILTER_REJECT)
break;
}
while (Node* nextSibling = node->traverseNextSibling(root())) {
node = nextSibling;
short acceptNodeResult = acceptNode(node.get(), exception);
if (exception)
return 0;
if (acceptNodeResult == NodeFilter::FILTER_ACCEPT)
return setCurrent(node.release());
if (acceptNodeResult == NodeFilter::FILTER_SKIP)
goto Children;
}
return 0;
}
DOMNode* DOMTreeWalkerImpl::getPreviousSibling (DOMNode* node) {
if (!node || node == fRoot) return 0;
DOMNode* newNode = node->getPreviousSibling();
if (!newNode) {
newNode = node->getParentNode();
if (!newNode || node == fRoot) return 0;
short parentAccept = acceptNode(newNode);
if (parentAccept == DOMNodeFilter::FILTER_SKIP) {
return getPreviousSibling(newNode);
}
return 0;
}
short accept = acceptNode(newNode);
if (accept == DOMNodeFilter::FILTER_ACCEPT)
return newNode;
else
if (accept == DOMNodeFilter::FILTER_SKIP) {
DOMNode* fChild = getLastChild(newNode);
if (!fChild && !newNode->hasChildNodes()) {
return getPreviousSibling(newNode);
}
return fChild;
}
return getPreviousSibling(newNode);
}
template<TreeWalker::SiblingTraversalType type> Node* TreeWalker::traverseSiblings()
{
RefPtr<Node> node = m_current;
if (node == root())
return nullptr;
auto isNext = type == SiblingTraversalType::Next;
while (true) {
for (RefPtr<Node> sibling = isNext ? node->nextSibling() : node->previousSibling(); sibling; ) {
short acceptNodeResult = acceptNode(sibling.get());
if (acceptNodeResult == NodeFilter::FILTER_ACCEPT) {
m_current = WTFMove(sibling);
return m_current.get();
}
node = sibling;
sibling = isNext ? sibling->firstChild() : sibling->lastChild();
if (acceptNodeResult == NodeFilter::FILTER_REJECT || !sibling)
sibling = isNext ? node->nextSibling() : node->previousSibling();
}
node = node->parentNode();
if (!node || node == root())
return nullptr;
short acceptNodeResult = acceptNode(node.get());
if (acceptNodeResult == NodeFilter::FILTER_ACCEPT)
return nullptr;
}
}
Node* TreeWalker::firstChild(ExceptionState& exceptionState)
{
for (RefPtrWillBeRawPtr<Node> node = m_current->firstChild(); node; ) {
unsigned acceptNodeResult = acceptNode(node.get(), exceptionState);
if (exceptionState.hadException())
return 0;
switch (acceptNodeResult) {
case NodeFilter::FILTER_ACCEPT:
m_current = node.release();
return m_current.get();
case NodeFilter::FILTER_SKIP:
if (node->hasChildren()) {
node = node->firstChild();
continue;
}
break;
case NodeFilter::FILTER_REJECT:
break;
}
do {
if (node->nextSibling()) {
node = node->nextSibling();
break;
}
ContainerNode* parent = node->parentNode();
if (!parent || parent == root() || parent == m_current)
return 0;
node = parent;
} while (node);
}
return 0;
}
PassRefPtr<Node> NodeIterator::nextNode(ScriptState* state, ExceptionCode& ec)
{
if (m_detached) {
ec = INVALID_STATE_ERR;
return 0;
}
RefPtr<Node> result;
m_candidateNode = m_referenceNode;
while (m_candidateNode.moveToNext(root())) {
// NodeIterators treat the DOM tree as a flat list of nodes.
// In other words, FILTER_REJECT does not pass over descendants
// of the rejected node. Hence, FILTER_REJECT is the same as FILTER_SKIP.
RefPtr<Node> provisionalResult = m_candidateNode.node;
bool nodeWasAccepted = acceptNode(state, provisionalResult.get()) == NodeFilter::FILTER_ACCEPT;
if (state && state->hadException())
break;
if (nodeWasAccepted) {
m_referenceNode = m_candidateNode;
result = provisionalResult.release();
break;
}
}
m_candidateNode.clear();
return result.release();
}
Node* TreeWalker::lastChild()
{
for (RefPtr<Node> node = m_current->lastChild(); node; ) {
short acceptNodeResult = acceptNode(node.get());
switch (acceptNodeResult) {
case NodeFilter::FILTER_ACCEPT:
m_current = node.release();
return m_current.get();
case NodeFilter::FILTER_SKIP:
if (node->lastChild()) {
node = node->lastChild();
continue;
}
break;
case NodeFilter::FILTER_REJECT:
break;
}
do {
if (node->previousSibling()) {
node = node->previousSibling();
break;
}
ContainerNode* parent = node->parentNode();
if (!parent || parent == root() || parent == m_current)
return nullptr;
node = parent;
} while (node);
}
return nullptr;
}
bool TreeWalkerImpl::ancestorRejected(const NodeImpl *node) const
{
for (NodeImpl *a = node->parentNode(); a && a != root(); a = a->parentNode())
if (acceptNode(a) == NodeFilter::FILTER_REJECT)
return true;
return false;
}
Node* TreeWalker::firstChild(ScriptState* state)
{
for (RefPtr<Node> node = m_current->firstChild(); node; ) {
short acceptNodeResult = acceptNode(state, node.get());
if (state && state->hadException())
return 0;
switch (acceptNodeResult) {
case NodeFilter::FILTER_ACCEPT:
m_current = node.release();
return m_current.get();
case NodeFilter::FILTER_SKIP:
if (node->firstChild()) {
node = node->firstChild();
continue;
}
break;
case NodeFilter::FILTER_REJECT:
break;
}
do {
if (node->nextSibling()) {
node = node->nextSibling();
break;
}
ContainerNode* parent = node->parentNode();
if (!parent || parent == root() || parent == m_current)
return 0;
node = parent;
} while (node);
}
return 0;
}
Node* TreeWalker::firstChild(JSValue*& exception)
{
exception = 0;
for (RefPtr<Node> node = m_current->firstChild(); node; ) {
short acceptNodeResult = acceptNode(node.get(), exception);
if (exception)
return 0;
switch (acceptNodeResult) {
case NodeFilter::FILTER_ACCEPT:
m_current = node.release();
return m_current.get();
case NodeFilter::FILTER_SKIP:
if (node->firstChild()) {
node = node->firstChild();
continue;
}
break;
case NodeFilter::FILTER_REJECT:
break;
}
do {
if (node->nextSibling()) {
node = node->nextSibling();
break;
}
Node* parent = node->parentNode();
if (!parent || parent == root() || parent == m_current)
return 0;
node = parent;
} while (node);
}
return 0;
}
NodeImpl *NodeIteratorImpl::previousNode(int &exceptioncode)
{
NodeImpl *node = referenceNode() ? referenceNode() : root();
if (pointerBeforeReferenceNode() || acceptNode(node) != NodeFilter::FILTER_ACCEPT)
node = findPreviousNode(node);
if (node)
setReferenceNode(node);
setPointerBeforeReferenceNode();
return node;
}
NodeImpl *NodeIteratorImpl::findPreviousNode(NodeImpl *node) const
{
while ((node = node->traversePreviousNode())) {
// NodeIterators treat the DOM tree as a flat list of nodes.
// In other words, FILTER_REJECT does not pass over descendants
// of the rejected node. Hence, FILTER_REJECT is the same as FILTER_SKIP.
if (acceptNode(node) == NodeFilter::FILTER_ACCEPT)
break;
}
return node;
}
NodeImpl *TreeWalkerImpl::parentNode()
{
NodeImpl *result = 0;
for (NodeImpl *node = currentNode()->parentNode(); node && node != root(); node = node->parentNode()) {
if (acceptNode(node) == NodeFilter::FILTER_ACCEPT) {
setCurrentNode(node);
result = node;
break;
}
}
return result;
}
NodeImpl *TreeWalkerImpl::nextSibling()
{
NodeImpl *result = 0;
for (NodeImpl *node = currentNode()->nextSibling(); node; node = node->nextSibling()) {
if (acceptNode(node) == NodeFilter::FILTER_ACCEPT) {
setCurrentNode(node);
result = node;
break;
}
}
return result;
}
NodeImpl *TreeWalkerImpl::nextNode()
{
NodeImpl *result = 0;
for (NodeImpl *node = currentNode()->traverseNextNode(); node; node = node->traverseNextNode()) {
if (acceptNode(node) == NodeFilter::FILTER_ACCEPT && !ancestorRejected(node)) {
setCurrentNode(node);
result = node;
break;
}
}
return result;
}
Node* TreeWalker::parentNode()
{
RefPtr<Node> node = m_current;
while (node != root()) {
node = node->parentNode();
if (!node)
return nullptr;
short acceptNodeResult = acceptNode(node.get());
if (acceptNodeResult == NodeFilter::FILTER_ACCEPT)
return setCurrent(WTFMove(node));
}
return nullptr;
}
Node* TreeWalker::previousNode(JSValue*& exception)
{
exception = 0;
RefPtr<Node> node = m_current;
while (node != root()) {
while (Node* previousSibling = node->previousSibling()) {
node = previousSibling;
short acceptNodeResult = acceptNode(node.get(), exception);
if (exception)
return 0;
if (acceptNodeResult == NodeFilter::FILTER_REJECT)
continue;
while (Node* lastChild = node->lastChild()) {
node = lastChild;
acceptNodeResult = acceptNode(node.get(), exception);
if (exception)
return 0;
if (acceptNodeResult == NodeFilter::FILTER_ACCEPT)
continue;
}
if (acceptNodeResult == NodeFilter::FILTER_ACCEPT) {
m_current = node.release();
return m_current.get();
}
}
if (node == root())
return 0;
Node* parent = node->parentNode();
if (!parent)
return 0;
node = parent;
short acceptNodeResult = acceptNode(node.get(), exception);
if (exception)
return 0;
if (acceptNodeResult == NodeFilter::FILTER_ACCEPT)
return setCurrent(node.release());
}
return 0;
}
Node* TreeWalker::nextNode()
{
RefPtr<Node> node = m_current;
Children:
while (Node* firstChild = node->firstChild()) {
node = firstChild;
short acceptNodeResult = acceptNode(node.get());
if (acceptNodeResult == NodeFilter::FILTER_ACCEPT)
return setCurrent(WTFMove(node));
if (acceptNodeResult == NodeFilter::FILTER_REJECT)
break;
}
while (Node* nextSibling = NodeTraversal::nextSkippingChildren(*node, root())) {
node = nextSibling;
short acceptNodeResult = acceptNode(node.get());
if (acceptNodeResult == NodeFilter::FILTER_ACCEPT)
return setCurrent(WTFMove(node));
if (acceptNodeResult == NodeFilter::FILTER_SKIP)
goto Children;
}
return nullptr;
}
Node* TreeWalker::previousNode(ExceptionState& exceptionState)
{
RefPtrWillBeRawPtr<Node> node = m_current;
while (node != root()) {
while (Node* previousSibling = node->previousSibling()) {
node = previousSibling;
unsigned acceptNodeResult = acceptNode(node.get(), exceptionState);
if (exceptionState.hadException())
return 0;
if (acceptNodeResult == NodeFilter::FILTER_REJECT)
continue;
while (Node* lastChild = node->lastChild()) {
node = lastChild;
acceptNodeResult = acceptNode(node.get(), exceptionState);
if (exceptionState.hadException())
return 0;
if (acceptNodeResult == NodeFilter::FILTER_REJECT)
break;
}
if (acceptNodeResult == NodeFilter::FILTER_ACCEPT) {
m_current = node.release();
return m_current.get();
}
}
if (node == root())
return 0;
ContainerNode* parent = node->parentNode();
if (!parent)
return 0;
node = parent;
unsigned acceptNodeResult = acceptNode(node.get(), exceptionState);
if (exceptionState.hadException())
return 0;
if (acceptNodeResult == NodeFilter::FILTER_ACCEPT)
return setCurrent(node.release());
}
return 0;
}
Node* TreeWalker::previousNode(ScriptState* state)
{
RefPtr<Node> node = m_current;
while (node != root()) {
while (Node* previousSibling = node->previousSibling()) {
node = previousSibling;
short acceptNodeResult = acceptNode(state, node.get());
if (state && state->hadException())
return 0;
if (acceptNodeResult == NodeFilter::FILTER_REJECT)
continue;
while (Node* lastChild = node->lastChild()) {
node = lastChild;
acceptNodeResult = acceptNode(state, node.get());
if (state && state->hadException())
return 0;
if (acceptNodeResult == NodeFilter::FILTER_REJECT)
break;
}
if (acceptNodeResult == NodeFilter::FILTER_ACCEPT) {
m_current = node.release();
return m_current.get();
}
}
if (node == root())
return 0;
ContainerNode* parent = node->parentNode();
if (!parent)
return 0;
node = parent;
short acceptNodeResult = acceptNode(state, node.get());
if (state && state->hadException())
return 0;
if (acceptNodeResult == NodeFilter::FILTER_ACCEPT)
return setCurrent(node.release());
}
return 0;
}
DOM_Node TreeWalkerImpl::getNextSibling (DOM_Node node) {
DOM_Node result;
if (node.isNull() || node == fRoot) return result;
DOM_Node newNode = node.getNextSibling();
if (newNode.isNull()) {
newNode = node.getParentNode();
if (newNode.isNull() || node == fRoot) return result;
short parentAccept = acceptNode(newNode);
if (parentAccept == DOM_NodeFilter::FILTER_SKIP) {
return getNextSibling(newNode);
}
return result;
}
short accept = acceptNode(newNode);
if (accept == DOM_NodeFilter::FILTER_ACCEPT)
return newNode;
else
if (accept == DOM_NodeFilter::FILTER_SKIP) {
DOM_Node fChild = getFirstChild(newNode);
if (fChild.isNull()) {
return getNextSibling(newNode);
}
return fChild;
}
return getNextSibling(newNode);
}
Node* TreeWalker::nextSibling(ExceptionState& exceptionState)
{
RefPtrWillBeRawPtr<Node> node = m_current;
if (node == root())
return 0;
while (1) {
for (RefPtrWillBeRawPtr<Node> sibling = node->nextSibling(); sibling; ) {
unsigned acceptNodeResult = acceptNode(sibling.get(), exceptionState);
if (exceptionState.hadException())
return 0;
switch (acceptNodeResult) {
case NodeFilter::FILTER_ACCEPT:
m_current = sibling.release();
return m_current.get();
case NodeFilter::FILTER_SKIP:
if (sibling->hasChildren()) {
sibling = sibling->firstChild();
node = sibling;
continue;
}
break;
case NodeFilter::FILTER_REJECT:
break;
}
sibling = sibling->nextSibling();
}
node = node->parentNode();
if (!node || node == root())
return 0;
unsigned acceptNodeResult = acceptNode(node.get(), exceptionState);
if (exceptionState.hadException())
return 0;
if (acceptNodeResult == NodeFilter::FILTER_ACCEPT)
return 0;
}
}
Node* TreeWalker::nextSibling(JSValue*& exception)
{
exception = 0;
RefPtr<Node> node = m_current;
if (node == root())
return 0;
while (1) {
for (RefPtr<Node> sibling = node->nextSibling(); sibling; ) {
short acceptNodeResult = acceptNode(sibling.get(), exception);
if (exception)
return 0;
switch (acceptNodeResult) {
case NodeFilter::FILTER_ACCEPT:
m_current = sibling.release();
return m_current.get();
case NodeFilter::FILTER_SKIP:
if (sibling->firstChild()) {
sibling = sibling->firstChild();
continue;
}
break;
case NodeFilter::FILTER_REJECT:
break;
}
sibling = sibling->nextSibling();
}
node = node->parentNode();
if (!node || node == root())
return 0;
short acceptNodeResult = acceptNode(node.get(), exception);
if (exception)
return 0;
if (acceptNodeResult == NodeFilter::FILTER_ACCEPT)
return 0;
}
}
Node* TreeWalker::parentNode(ScriptState* state)
{
RefPtr<Node> node = m_current;
while (node != root()) {
node = node->parentNode();
if (!node)
return 0;
short acceptNodeResult = acceptNode(state, node.get());
if (state && state->hadException())
return 0;
if (acceptNodeResult == NodeFilter::FILTER_ACCEPT)
return setCurrent(node.release());
}
return 0;
}
Node* TreeWalker::parentNode(ExceptionState& exceptionState)
{
RefPtrWillBeRawPtr<Node> node = m_current;
while (node != root()) {
node = node->parentNode();
if (!node)
return 0;
unsigned acceptNodeResult = acceptNode(node.get(), exceptionState);
if (exceptionState.hadException())
return 0;
if (acceptNodeResult == NodeFilter::FILTER_ACCEPT)
return setCurrent(node.release());
}
return 0;
}
NodeImpl *NodeIteratorImpl::nextNode(int &exceptioncode)
{
if (detached()) {
exceptioncode = DOMException::INVALID_STATE_ERR;
return 0;
}
NodeImpl *node = referenceNode() ? referenceNode() : root();
if (!pointerBeforeReferenceNode() || acceptNode(node) != NodeFilter::FILTER_ACCEPT)
node = findNextNode(node);
if (node)
setReferenceNode(node);
setPointerBeforeReferenceNode(false);
return node;
}
DOMNode* DOMTreeWalkerImpl::getParentNode (DOMNode* node) {
if (!node || node == fRoot) return 0;
DOMNode* newNode = node->getParentNode();
if (!newNode) return 0;
short accept = acceptNode(newNode);
if (accept == DOMNodeFilter::FILTER_ACCEPT)
return newNode;
return getParentNode(newNode);
}
Node* TreeWalker::nextSibling(ScriptState* state)
{
RefPtr<Node> node = m_current;
if (node == root())
return 0;
while (1) {
for (RefPtr<Node> sibling = node->nextSibling(); sibling; ) {
short acceptNodeResult = acceptNode(state, sibling.get());
if (state && state->hadException())
return 0;
switch (acceptNodeResult) {
case NodeFilter::FILTER_ACCEPT:
m_current = sibling.release();
return m_current.get();
case NodeFilter::FILTER_SKIP:
if (sibling->firstChild()) {
sibling = sibling->firstChild();
node = sibling;
continue;
}
break;
case NodeFilter::FILTER_REJECT:
break;
}
sibling = sibling->nextSibling();
}
node = node->parentNode();
if (!node || node == root())
return 0;
short acceptNodeResult = acceptNode(state, node.get());
if (state && state->hadException())
return 0;
if (acceptNodeResult == NodeFilter::FILTER_ACCEPT)
return 0;
}
}
