dymokomi/luce-browser-engine
Source of release 0.6.0
0.6.0 / src / web / dom / node_iterator.lucb
#==============================================================================================
#
# node_iterator - DOM::NodeIterator: a traversal over a root's subtree in tree order
#
# DESCRIPTION:
# Port of LibWeb/DOM/NodeIterator.cpp (lines 1-258) and the inline functions of
# NodeIterator.h: creation (registered with the document so node removal can adjust its
# pointers), traverse, "filter" (which calls the NodeFilter's acceptNode) and the
# pre-removing steps.
#
#==============================================================================================
# mark: Construction ============================================================================
## Ported from NodeIterator.cpp:18 Web::DOM::NodeIterator::NodeIterator.
pub func dom_node_iterator_construct(this: DomNodeIterator*, realm: Realm*, root: DomNode*):
bind_platform_object_construct_realm(this.bind_platform_object(), realm)
this.m_root = root
this.m_reference = DomNodeIteratorNodePointer(node = root, is_before_node = true)
dom_document_register_node_iterator(dom_node_document(root), this)
## Ported from NodeIterator.cpp:28 Web::DOM::NodeIterator::initialize (override).
pub func dom_node_iterator_initialize_impl(base: JsCell*, realm: Realm*):
web_set_prototype_for_interface(base, realm, BindInterfaceName.node_iterator)
# Base::initialize(realm): PlatformObject inherits JS::Object's.
js_cell_initialize_impl(base, realm)
## Ported from NodeIterator.cpp:34 Web::DOM::NodeIterator::finalize (override).
pub func dom_node_iterator_finalize_impl(base: gc.Cell*):
let this = (DomNodeIterator*)base
# Base::finalize(): PlatformObject inherits GC::Cell's, which does nothing.
dom_document_unregister_node_iterator(dom_node_document(this.m_root), this)
## Ported from NodeIterator.cpp:40 Web::DOM::NodeIterator::visit_edges (override).
pub func dom_node_iterator_visit_edges_impl(base: gc.Cell*, visitor: gc.CellVisitor*):
let this = (DomNodeIterator*)base
bind_platform_object_visit_edges_impl(base, visitor)
gc.cell_visitor_visit_t(visitor, this.m_filter)
gc.cell_visitor_visit_t_2(visitor, this.m_root)
gc.cell_visitor_visit_t_2(visitor, this.m_reference.node)
if let traversal_pointer = this.m_traversal_pointer:
gc.cell_visitor_visit_t_2(visitor, traversal_pointer.node)
## Ported from NodeIterator.cpp:52 Web::DOM::NodeIterator::create.
# https://dom.spec.whatwg.org/#dom-document-createnodeiterator
pub func dom_node_iterator_create(realm: Realm*, root: DomNode*, what_to_show: u32, filter: DomNodeFilter*?) -> DomNodeIterator*:
# 1. Let iterator be a new NodeIterator object.
# 2. Set iterator’s root and iterator’s reference to root.
# 3. Set iterator’s pointer before reference to true.
let iterator = realm_create_dom_node_iterator(realm, realm, root)
# 4. Set iterator’s whatToShow to whatToShow.
iterator.m_what_to_show = what_to_show
# 5. Set iterator’s filter to filter.
iterator.m_filter = filter
# 6. Return iterator.
return iterator
## Ported from NodeIterator.cpp:70 Web::DOM::NodeIterator::detach.
# https://dom.spec.whatwg.org/#dom-nodeiterator-detach
pub func dom_node_iterator_detach(this: DomNodeIterator*):
# The detach() method steps are to do nothing.
# Its functionality (disabling a NodeIterator object) was removed, but the method itself is preserved for compatibility.
return
# mark: Traversal ===============================================================================
## The traversal pointer during a traversal (C++'s `m_traversal_pointer->`).
func dom_node_iterator_traversal_pointer(this: DomNodeIterator*) -> DomNodeIteratorNodePointer*:
let pointer = ak.optional_base_ptr(&this.m_traversal_pointer)
return pointer else trap("VERIFY: traversal pointer")
## Ported from NodeIterator.cpp:77 Web::DOM::NodeIterator::traverse.
# https://dom.spec.whatwg.org/#concept-nodeiterator-traverse
func dom_node_iterator_traverse(this: DomNodeIterator*, direction: DomNodeIteratorDirection) -> DomNode*?!:
# 1. Let node be iterator’s reference.
# 2. Let beforeNode be iterator’s pointer before reference.
this.m_traversal_pointer = this.m_reference
var candidate: DomNode*? = none
# 3. While true:
while true:
# 4. Branch on direction:
if direction == DomNodeIteratorDirection.next:
# next
# If beforeNode is false, then set node to the first node following node in iterator’s iterator collection.
# If there is no such node, then return null.
let pointer = dom_node_iterator_traversal_pointer(this)
if not pointer.is_before_node:
let next_node = tree_node_next_in_pre_order_t(pointer.node, this.m_root) else return none
pointer.node = next_node
else:
# If beforeNode is true, then set it to false.
pointer.is_before_node = false
else:
# previous
# If beforeNode is true, then set node to the first node preceding node in iterator’s iterator collection.
# If there is no such node, then return null.
let pointer = dom_node_iterator_traversal_pointer(this)
if pointer.is_before_node:
if pointer.node == this.m_root:
return none
let previous_node = tree_node_previous_in_pre_order(pointer.node) else return none
pointer.node = previous_node
else:
# If beforeNode is false, then set it to true.
pointer.is_before_node = true
# NOTE: If the NodeFilter deletes the iterator's current traversal pointer,
# we will automatically retarget it. However, in that case, we're expected
# to return the node passed to the filter, not the adjusted traversal pointer's
# node after the filter returns!
candidate = dom_node_iterator_traversal_pointer(this).node
# 2. Let result be the result of filtering node within iterator.
let result = try dom_node_iterator_filter_dom_node(this, dom_node_iterator_traversal_pointer(this).node)
# 3. If result is FILTER_ACCEPT, then break.
if result == DomNodeFilterResult.filter_accept:
break
# 4. Set iterator’s reference to node.
# 5. Set iterator’s pointer before reference to beforeNode.
this.m_reference = this.m_traversal_pointer else trap("VERIFY: traversal pointer")
this.m_traversal_pointer = none
# 6. Return node.
return candidate
## Ported from NodeIterator.cpp:141 Web::DOM::NodeIterator::filter.
# https://dom.spec.whatwg.org/#concept-traversal-filter
pub func dom_node_iterator_filter(this: DomNodeIterator*) -> DomNodeFilter*?:
return this.m_filter
## Ported from NodeIterator.cpp:147 Web::DOM::NodeIterator::filter.
# https://dom.spec.whatwg.org/#concept-node-filter
func dom_node_iterator_filter_dom_node(this: DomNodeIterator*, node: DomNode*) -> DomNodeFilterResult!:
# 1. If traverser’s active flag is set, then throw an "InvalidStateError" DOMException.
if this.m_active:
try idl_throw(.idl_dom_exception(idl_invalid_state_error_create(bind_platform_object_realm(this.bind_platform_object()), ak.utf16_string_from_str("NodeIterator is already active"))))
# 2. Let n be node’s nodeType attribute value − 1.
let n = (u32)dom_node_node_type(node) - 1
# 3. If the nth bit (where 0 is the least significant bit) of traverser’s whatToShow is not set, then return FILTER_SKIP.
if (this.m_what_to_show & ((u32)1 << n)) == 0:
return DomNodeFilterResult.filter_skip
# 4. If traverser’s filter is null, then return FILTER_ACCEPT.
let filter = this.m_filter else return DomNodeFilterResult.filter_accept
# 5. Set traverser’s active flag.
this.m_active = true
# 6. Let result be the return value of call a user object’s operation with traverser’s filter, "acceptNode", and « node ».
# If this throws an exception, then unset traverser’s active flag and rethrow the exception.
let arguments: JsValue[1] = [js_value_from_object((JsObject*)node)]
let result = idl_call_user_object_operation(dom_node_filter_callback(filter), ak.utf16_fly_string_from_utf8_string_view(ak.sv("acceptNode")), none, arguments)
if js_completion_is_abrupt(&result):
this.m_active = false
try idl_throw(.js_completion(result))
# 7. Unset traverser’s active flag.
this.m_active = false
# 8. Return result.
let result_value = try dom_js_value_to_i32(js_cell_vm(this.js_cell()), js_completion_value(&result))
return (DomNodeFilterResult)(u8)result_value
## Ported from NodeIterator.cpp:184 Web::DOM::NodeIterator::next_node.
# https://dom.spec.whatwg.org/#dom-nodeiterator-nextnode
pub func dom_node_iterator_next_node(this: DomNodeIterator*) -> DomNode*?!:
return try dom_node_iterator_traverse(this, DomNodeIteratorDirection.next)
## Ported from NodeIterator.cpp:190 Web::DOM::NodeIterator::previous_node.
# https://dom.spec.whatwg.org/#dom-nodeiterator-previousnode
pub func dom_node_iterator_previous_node(this: DomNodeIterator*) -> DomNode*?!:
return try dom_node_iterator_traverse(this, DomNodeIteratorDirection.previous)
# mark: Node removal ============================================================================
## Ported from NodeIterator.cpp:195 Web::DOM::NodeIterator::run_pre_removing_steps_with_node_pointer.
func dom_node_iterator_run_pre_removing_steps_with_node_pointer(this: DomNodeIterator*, to_be_removed_node: DomNode*, pointer: DomNodeIteratorNodePointer*):
# NOTE: This function tries to match the behavior of other engines, but not the DOM specification
# as it's a known issue that the spec doesn't match how major browsers behave.
# Spec bug: https://github.com/whatwg/dom/issues/907
let root = this.m_root
if not tree_node_is_descendant_of(to_be_removed_node, root):
return
if not tree_node_is_inclusive_ancestor_of(to_be_removed_node, pointer.node):
return
if pointer.is_before_node:
if let first_following = tree_node_next_in_pre_order_t(to_be_removed_node, root):
var node: DomNode*? = first_following
while let current = node:
if not tree_node_is_descendant_of(current, to_be_removed_node):
break
node = tree_node_next_in_pre_order_t(current, root)
if let found = node:
pointer.node = found
return
if let first_preceding = tree_node_previous_in_pre_order(to_be_removed_node):
var node: DomNode*? = first_preceding
if tree_node_is_ancestor_of(to_be_removed_node, pointer.node):
while let current = node:
if not tree_node_is_descendant_of(current, to_be_removed_node):
break
node = tree_node_previous_in_pre_order(current)
if let found = node:
*pointer = DomNodeIteratorNodePointer(node = found, is_before_node = false)
return
if let first_preceding = tree_node_previous_in_pre_order(to_be_removed_node):
var node: DomNode*? = first_preceding
if tree_node_is_ancestor_of(to_be_removed_node, pointer.node):
while let current = node:
if not tree_node_is_descendant_of(current, to_be_removed_node):
break
node = tree_node_previous_in_pre_order(current)
if let found = node:
pointer.node = found
return
var node = tree_node_next_in_pre_order_t(to_be_removed_node, root)
if tree_node_is_ancestor_of(to_be_removed_node, pointer.node):
while let current = node:
if not tree_node_is_descendant_of(current, to_be_removed_node):
break
node = tree_node_previous_in_pre_order(current)
if let found = node:
pointer.node = found
## Ported from NodeIterator.cpp:249 Web::DOM::NodeIterator::run_pre_removing_steps.
# https://dom.spec.whatwg.org/#nodeiterator-pre-removing-steps
pub func dom_node_iterator_run_pre_removing_steps(this: DomNodeIterator*, to_be_removed_node: DomNode*):
# NOTE: If we're in the middle of traversal, we have to adjust the traversal pointer in response to node removal.
if this.m_traversal_pointer != none:
dom_node_iterator_run_pre_removing_steps_with_node_pointer(this, to_be_removed_node, dom_node_iterator_traversal_pointer(this))
dom_node_iterator_run_pre_removing_steps_with_node_pointer(this, to_be_removed_node, &this.m_reference)
# mark: NodeIterator.h ==========================================================================
## Ported from NodeIterator.h:26 Web::DOM::NodeIterator::root.
pub func dom_node_iterator_root(this: DomNodeIterator*) -> DomNode*:
return this.m_root
## Ported from NodeIterator.h:27 Web::DOM::NodeIterator::reference_node.
pub func dom_node_iterator_reference_node(this: DomNodeIterator*) -> DomNode*:
return this.m_reference.node
## Ported from NodeIterator.h:28 Web::DOM::NodeIterator::pointer_before_reference_node.
pub func dom_node_iterator_pointer_before_reference_node(this: DomNodeIterator*) -> bool:
return this.m_reference.is_before_node
## Ported from NodeIterator.h:29 Web::DOM::NodeIterator::what_to_show.
pub func dom_node_iterator_what_to_show(this: DomNodeIterator*) -> u32:
return this.m_what_to_show