tree_cursor.h File Reference

#include "./subtree.h"

Go to the source code of this file.

Classes
struct	TreeCursorEntry
struct	TreeCursor

Functions
void	ts_tree_cursor_init (TreeCursor *, TSNode)
void	ts_tree_cursor_current_status (const TSTreeCursor *, TSFieldId *, bool *, bool *, bool *, TSSymbol *, unsigned *)
TSNode	ts_tree_cursor_parent_node (const TSTreeCursor *)

Function Documentation

ts_tree_cursor_current_status()

void ts_tree_cursor_current_status	(	const TSTreeCursor *	_self,
		TSFieldId *	field_id,
		bool *	has_later_siblings,
		bool *	has_later_named_siblings,
		bool *	can_have_later_siblings_with_this_field,
		TSSymbol *	supertypes,
		unsigned *	supertype_count
	)

Definition at line 284 of file tree_cursor.c.

  {
  const TreeCursor *self = (const TreeCursor *)_self;
  unsigned max_supertypes = *supertype_count;
  *field_id = 0;
  *supertype_count = 0;
  *has_later_siblings = false;
  *has_later_named_siblings = false;
  *can_have_later_siblings_with_this_field = false;
 
  // Walk up the tree, visiting the current node and its invisible ancestors,
  // because fields can refer to nodes through invisible *wrapper* nodes,
  for (unsigned i = self->stack.size - 1; i > 0; i--) {
    TreeCursorEntry *entry = &self->stack.contents[i];
    TreeCursorEntry *parent_entry = &self->stack.contents[i - 1];
 
    const TSSymbol *alias_sequence = ts_language_alias_sequence(
      self->tree->language,
      parent_entry->subtree->ptr->production_id
    );
 
    #define subtree_symbol(subtree, structural_child_index) \
      ((                                                    \
        !ts_subtree_extra(subtree) &&                       \
        alias_sequence &&                                   \
        alias_sequence[structural_child_index]              \
      ) ?                                                   \
        alias_sequence[structural_child_index] :            \
        ts_subtree_symbol(subtree))
 
    // Stop walking up when a visible ancestor is found.
    TSSymbol entry_symbol = subtree_symbol(
      *entry->subtree,
      entry->structural_child_index
    );
    TSSymbolMetadata entry_metadata = ts_language_symbol_metadata(
      self->tree->language,
      entry_symbol
    );
    if (i != self->stack.size - 1 && entry_metadata.visible) break;
 
    // Record any supertypes
    if (entry_metadata.supertype && *supertype_count < max_supertypes) {
      supertypes[*supertype_count] = entry_symbol;
      (*supertype_count)++;
    }
 
    // Determine if the current node has later siblings.
    if (!*has_later_siblings) {
      unsigned sibling_count = parent_entry->subtree->ptr->child_count;
      unsigned structural_child_index = entry->structural_child_index;
      if (!ts_subtree_extra(*entry->subtree)) structural_child_index++;
      for (unsigned j = entry->child_index + 1; j < sibling_count; j++) {
        Subtree sibling = ts_subtree_children(*parent_entry->subtree)[j];
        TSSymbolMetadata sibling_metadata = ts_language_symbol_metadata(
          self->tree->language,
          subtree_symbol(sibling, structural_child_index)
        );
        if (sibling_metadata.visible) {
          *has_later_siblings = true;
          if (*has_later_named_siblings) break;
          if (sibling_metadata.named) {
            *has_later_named_siblings = true;
            break;
          }
        } else if (ts_subtree_visible_child_count(sibling) > 0) {
          *has_later_siblings = true;
          if (*has_later_named_siblings) break;
          if (sibling.ptr->named_child_count > 0) {
            *has_later_named_siblings = true;
            break;
          }
        }
        if (!ts_subtree_extra(sibling)) structural_child_index++;
      }
    }
 
    #undef subtree_symbol
 
    if (!ts_subtree_extra(*entry->subtree)) {
      const TSFieldMapEntry *field_map, *field_map_end;
      ts_language_field_map(
        self->tree->language,
        parent_entry->subtree->ptr->production_id,
        &field_map, &field_map_end
      );
 
      // Look for a field name associated with the current node.
      if (!*field_id) {
        for (const TSFieldMapEntry *i = field_map; i < field_map_end; i++) {
          if (!i->inherited && i->child_index == entry->structural_child_index) {
            *field_id = i->field_id;
            break;
          }
        }
      }
 
      // Determine if the current node can have later siblings with the same field name.
      if (*field_id) {
        for (const TSFieldMapEntry *i = field_map; i < field_map_end; i++) {
          if (
            i->field_id == *field_id &&
            i->child_index > entry->structural_child_index
          ) {
            *can_have_later_siblings_with_this_field = true;
            break;
          }
        }
      }
    }
  }
}

References SubtreeHeapData::child_count, field_id, i, TSSymbolMetadata::named, SubtreeHeapData::named_child_count, SubtreeHeapData::production_id, Subtree::ptr, TreeCursorEntry::subtree, subtree_symbol, TSSymbolMetadata::supertype, ts_language_alias_sequence(), ts_language_field_map(), ts_language_symbol_metadata(), ts_subtree_children, ts_subtree_extra(), ts_subtree_visible_child_count(), and TSSymbolMetadata::visible.

Referenced by ts_query_cursor__advance().

ts_tree_cursor_init()

void ts_tree_cursor_init	(	TreeCursor *	self,
		TSNode	node
	)

Definition at line 80 of file tree_cursor.c.

                                                        {
  self->tree = node.tree;
  array_clear(&self->stack);
  array_push(&self->stack, ((TreeCursorEntry) {
    .subtree = (const Subtree *)node.id,
    .position = {
      ts_node_start_byte(node),
      ts_node_start_point(node)
    },
    .child_index = 0,
    .structural_child_index = 0,
  }));
}

References array_clear, array_push, and TSNode::tree.

Referenced by ts_tree_cursor_new(), ts_tree_cursor_reset(), and ts_tree_get_changed_ranges().

ts_tree_cursor_parent_node()

TSNode ts_tree_cursor_parent_node

(

const TSTreeCursor *

_self

)

Definition at line 404 of file tree_cursor.c.

                                                             {
  const TreeCursor *self = (const TreeCursor *)_self;
  for (int i = (int)self->stack.size - 2; i >= 0; i--) {
    TreeCursorEntry *entry = &self->stack.contents[i];
    bool is_visible = true;
    TSSymbol alias_symbol = 0;
    if (i > 0) {
      TreeCursorEntry *parent_entry = &self->stack.contents[i - 1];
      alias_symbol = ts_language_alias_at(
        self->tree->language,
        parent_entry->subtree->ptr->production_id,
        entry->structural_child_index
      );
      is_visible = (alias_symbol != 0) || ts_subtree_visible(*entry->subtree);
    }
    if (is_visible) {
      return ts_node_new(
        self->tree,
        entry->subtree,
        entry->position,
        alias_symbol
      );
    }
  }
  return ts_node_new(NULL, NULL, length_zero(), 0);
}

References i, length_zero(), NULL, SubtreeHeapData::production_id, Subtree::ptr, TreeCursorEntry::subtree, ts_language_alias_at(), ts_node_new(), and ts_subtree_visible().

Referenced by ts_query_cursor__advance().