node.c File Reference

#include <stdbool.h>
#include "./subtree.h"
#include "./tree.h"
#include "./language.h"

Go to the source code of this file.

Classes
struct	NodeChildIterator

Functions
TSNode	ts_node_new (const TSTree *tree, const Subtree *subtree, Length position, TSSymbol alias)
static TSNode	ts_node__null (void)
uint32_t	ts_node_start_byte (TSNode self)
TSPoint	ts_node_start_point (TSNode self)
static uint32_t	ts_node__alias (const TSNode *self)
static Subtree	ts_node__subtree (TSNode self)
static NodeChildIterator	ts_node_iterate_children (const TSNode *node)
static bool	ts_node_child_iterator_done (NodeChildIterator *self)
static bool	ts_node_child_iterator_next (NodeChildIterator *self, TSNode *result)
static bool	ts_node__is_relevant (TSNode self, bool include_anonymous)
static uint32_t	ts_node__relevant_child_count (TSNode self, bool include_anonymous)
static TSNode	ts_node__child (TSNode self, uint32_t child_index, bool include_anonymous)
static bool	ts_subtree_has_trailing_empty_descendant (Subtree self, Subtree other)
static TSNode	ts_node__prev_sibling (TSNode self, bool include_anonymous)
static TSNode	ts_node__next_sibling (TSNode self, bool include_anonymous)
static TSNode	ts_node__first_child_for_byte (TSNode self, uint32_t goal, bool include_anonymous)
static TSNode	ts_node__descendant_for_byte_range (TSNode self, uint32_t range_start, uint32_t range_end, bool include_anonymous)
static TSNode	ts_node__descendant_for_point_range (TSNode self, TSPoint range_start, TSPoint range_end, bool include_anonymous)
uint32_t	ts_node_end_byte (TSNode self)
TSPoint	ts_node_end_point (TSNode self)
TSSymbol	ts_node_symbol (TSNode self)
const char *	ts_node_type (TSNode self)
char *	ts_node_string (TSNode self)
bool	ts_node_eq (TSNode self, TSNode other)
bool	ts_node_is_null (TSNode self)
bool	ts_node_is_extra (TSNode self)
bool	ts_node_is_named (TSNode self)
bool	ts_node_is_missing (TSNode self)
bool	ts_node_has_changes (TSNode self)
bool	ts_node_has_error (TSNode self)
TSNode	ts_node_parent (TSNode self)
TSNode	ts_node_child (TSNode self, uint32_t child_index)
TSNode	ts_node_named_child (TSNode self, uint32_t child_index)
TSNode	ts_node_child_by_field_id (TSNode self, TSFieldId field_id)
const char *	ts_node_field_name_for_child (TSNode self, uint32_t child_index)
TSNode	ts_node_child_by_field_name (TSNode self, const char *name, uint32_t name_length)
uint32_t	ts_node_child_count (TSNode self)
uint32_t	ts_node_named_child_count (TSNode self)
TSNode	ts_node_next_sibling (TSNode self)
TSNode	ts_node_next_named_sibling (TSNode self)
TSNode	ts_node_prev_sibling (TSNode self)
TSNode	ts_node_prev_named_sibling (TSNode self)
TSNode	ts_node_first_child_for_byte (TSNode self, uint32_t byte)
TSNode	ts_node_first_named_child_for_byte (TSNode self, uint32_t byte)
TSNode	ts_node_descendant_for_byte_range (TSNode self, uint32_t start, uint32_t end)
TSNode	ts_node_named_descendant_for_byte_range (TSNode self, uint32_t start, uint32_t end)
TSNode	ts_node_descendant_for_point_range (TSNode self, TSPoint start, TSPoint end)
TSNode	ts_node_named_descendant_for_point_range (TSNode self, TSPoint start, TSPoint end)
void	ts_node_edit (TSNode *self, const TSInputEdit *edit)

Function Documentation

ts_node__alias()

static uint32_t ts_node__alias ( const TSNode *  self )

inlinestatic

Definition at line 44 of file node.c.

                                                          {
  return self->context[3];
}

Referenced by ts_node__is_relevant(), ts_node_is_named(), ts_node_symbol(), and ts_node_type().

ts_node__child()

static TSNode ts_node__child ( TSNode  self, uint32_t  child_index, bool  include_anonymous  )

inlinestatic

Definition at line 136 of file node.c.

  {
  TSNode result = self;
  bool did_descend = true;
 
  while (did_descend) {
    did_descend = false;
 
    TSNode child;
    uint32_t index = 0;
    NodeChildIterator iterator = ts_node_iterate_children(&result);
    while (ts_node_child_iterator_next(&iterator, &child)) {
      if (ts_node__is_relevant(child, include_anonymous)) {
        if (index == child_index) {
          return child;
        }
        index++;
      } else {
        uint32_t grandchild_index = child_index - index;
        uint32_t grandchild_count = ts_node__relevant_child_count(child, include_anonymous);
        if (grandchild_index < grandchild_count) {
          did_descend = true;
          result = child;
          child_index = grandchild_index;
          break;
        }
        index += grandchild_count;
      }
    }
  }
 
  return ts_node__null();
}

References ts_node__is_relevant(), ts_node__null(), ts_node__relevant_child_count(), ts_node_child_iterator_next(), and ts_node_iterate_children().

Referenced by ts_node_child(), and ts_node_named_child().

ts_node__descendant_for_byte_range()

static TSNode ts_node__descendant_for_byte_range ( TSNode  self, uint32_t  range_start, uint32_t  range_end, bool  include_anonymous  )

inlinestatic

Definition at line 326 of file node.c.

  {
  TSNode node = self;
  TSNode last_visible_node = self;
 
  bool did_descend = true;
  while (did_descend) {
    did_descend = false;
 
    TSNode child;
    NodeChildIterator iterator = ts_node_iterate_children(&node);
    while (ts_node_child_iterator_next(&iterator, &child)) {
      uint32_t node_end = iterator.position.bytes;
 
      // The end of this node must extend far enough forward to touch
      // the end of the range and exceed the start of the range.
      if (node_end < range_end) continue;
      if (node_end <= range_start) continue;
 
      // The start of this node must extend far enough backward to
      // touch the start of the range.
      if (range_start < ts_node_start_byte(child)) break;
 
      node = child;
      if (ts_node__is_relevant(node, include_anonymous)) {
        last_visible_node = node;
      }
      did_descend = true;
      break;
    }
  }
 
  return last_visible_node;
}

References ts_node__is_relevant(), ts_node_child_iterator_next(), ts_node_iterate_children(), and ts_node_start_byte().

Referenced by ts_node_descendant_for_byte_range(), and ts_node_named_descendant_for_byte_range().

ts_node__descendant_for_point_range()

static TSNode ts_node__descendant_for_point_range ( TSNode  self, TSPoint  range_start, TSPoint  range_end, bool  include_anonymous  )

inlinestatic

Definition at line 365 of file node.c.

  {
  TSNode node = self;
  TSNode last_visible_node = self;
 
  bool did_descend = true;
  while (did_descend) {
    did_descend = false;
 
    TSNode child;
    NodeChildIterator iterator = ts_node_iterate_children(&node);
    while (ts_node_child_iterator_next(&iterator, &child)) {
      TSPoint node_end = iterator.position.extent;
 
      // The end of this node must extend far enough forward to touch
      // the end of the range and exceed the start of the range.
      if (point_lt(node_end, range_end)) continue;
      if (point_lte(node_end, range_start)) continue;
 
      // The start of this node must extend far enough backward to
      // touch the start of the range.
      if (point_lt(range_start, ts_node_start_point(child))) break;
 
      node = child;
      if (ts_node__is_relevant(node, include_anonymous)) {
        last_visible_node = node;
      }
      did_descend = true;
      break;
    }
  }
 
  return last_visible_node;
}

References point_lt(), point_lte(), ts_node__is_relevant(), ts_node_child_iterator_next(), ts_node_iterate_children(), and ts_node_start_point().

Referenced by ts_node_descendant_for_point_range(), and ts_node_named_descendant_for_point_range().

ts_node__first_child_for_byte()

static TSNode ts_node__first_child_for_byte ( TSNode  self, uint32_t  goal, bool  include_anonymous  )

inlinestatic

Definition at line 297 of file node.c.

  {
  TSNode node = self;
  bool did_descend = true;
 
  while (did_descend) {
    did_descend = false;
 
    TSNode child;
    NodeChildIterator iterator = ts_node_iterate_children(&node);
    while (ts_node_child_iterator_next(&iterator, &child)) {
      if (ts_node_end_byte(child) > goal) {
        if (ts_node__is_relevant(child, include_anonymous)) {
          return child;
        } else if (ts_node_child_count(child) > 0) {
          did_descend = true;
          node = child;
          break;
        }
      }
    }
  }
 
  return ts_node__null();
}

References ts_node__is_relevant(), ts_node__null(), ts_node_child_count(), ts_node_child_iterator_next(), ts_node_end_byte(), and ts_node_iterate_children().

Referenced by ts_node_first_child_for_byte(), and ts_node_first_named_child_for_byte().

ts_node__is_relevant()

static bool ts_node__is_relevant ( TSNode  self, bool  include_anonymous  )

inlinestatic

Definition at line 106 of file node.c.

                                                                             {
  Subtree tree = ts_node__subtree(self);
  if (include_anonymous) {
    return ts_subtree_visible(tree) || ts_node__alias(&self);
  } else {
    TSSymbol alias = ts_node__alias(&self);
    if (alias) {
      return ts_language_symbol_metadata(self.tree->language, alias).named;
    } else {
      return ts_subtree_visible(tree) && ts_subtree_named(tree);
    }
  }
}

References TSSymbolMetadata::named, ts_language_symbol_metadata(), ts_node__alias(), ts_node__subtree(), ts_subtree_named(), and ts_subtree_visible().

Referenced by ts_node__child(), ts_node__descendant_for_byte_range(), ts_node__descendant_for_point_range(), ts_node__first_child_for_byte(), ts_node__next_sibling(), ts_node__prev_sibling(), ts_node_child_by_field_id(), and ts_node_parent().

ts_node__next_sibling()

static TSNode ts_node__next_sibling ( TSNode  self, bool  include_anonymous  )

inlinestatic

Definition at line 246 of file node.c.

                                                                                {
  uint32_t target_end_byte = ts_node_end_byte(self);
 
  TSNode node = ts_node_parent(self);
  TSNode later_node = ts_node__null();
  bool later_node_is_relevant = false;
 
  while (!ts_node_is_null(node)) {
    TSNode later_child = ts_node__null();
    bool later_child_is_relevant = false;
    TSNode child_containing_target = ts_node__null();
 
    TSNode child;
    NodeChildIterator iterator = ts_node_iterate_children(&node);
    while (ts_node_child_iterator_next(&iterator, &child)) {
      if (iterator.position.bytes < target_end_byte) continue;
      if (ts_node_start_byte(child) <= ts_node_start_byte(self)) {
        if (ts_node__subtree(child).ptr != ts_node__subtree(self).ptr) {
          child_containing_target = child;
        }
      } else if (ts_node__is_relevant(child, include_anonymous)) {
        later_child = child;
        later_child_is_relevant = true;
        break;
      } else if (ts_node__relevant_child_count(child, include_anonymous) > 0) {
        later_child = child;
        later_child_is_relevant = false;
        break;
      }
    }
 
    if (!ts_node_is_null(child_containing_target)) {
      if (!ts_node_is_null(later_child)) {
        later_node = later_child;
        later_node_is_relevant = later_child_is_relevant;
      }
      node = child_containing_target;
    } else if (later_child_is_relevant) {
      return later_child;
    } else if (!ts_node_is_null(later_child)) {
      node = later_child;
    } else if (later_node_is_relevant) {
      return later_node;
    } else {
      node = later_node;
    }
  }
 
  return ts_node__null();
}

References ts_node__is_relevant(), ts_node__null(), ts_node__relevant_child_count(), ts_node__subtree(), ts_node_child_iterator_next(), ts_node_end_byte(), ts_node_is_null(), ts_node_iterate_children(), ts_node_parent(), and ts_node_start_byte().

Referenced by ts_node_next_named_sibling(), and ts_node_next_sibling().

ts_node__null()

static TSNode ts_node__null ( void  )

inlinestatic

Definition at line 30 of file node.c.

                                         {
  return ts_node_new(NULL, NULL, length_zero(), 0);
}

References length_zero(), NULL, and ts_node_new().

Referenced by ts_node__child(), ts_node__first_child_for_byte(), ts_node__next_sibling(), ts_node__prev_sibling(), ts_node_child_by_field_id(), and ts_node_parent().

ts_node__prev_sibling()

static TSNode ts_node__prev_sibling ( TSNode  self, bool  include_anonymous  )

inlinestatic

Definition at line 187 of file node.c.

                                                                                {
  Subtree self_subtree = ts_node__subtree(self);
  bool self_is_empty = ts_subtree_total_bytes(self_subtree) == 0;
  uint32_t target_end_byte = ts_node_end_byte(self);
 
  TSNode node = ts_node_parent(self);
  TSNode earlier_node = ts_node__null();
  bool earlier_node_is_relevant = false;
 
  while (!ts_node_is_null(node)) {
    TSNode earlier_child = ts_node__null();
    bool earlier_child_is_relevant = false;
    bool found_child_containing_target = false;
 
    TSNode child;
    NodeChildIterator iterator = ts_node_iterate_children(&node);
    while (ts_node_child_iterator_next(&iterator, &child)) {
      if (child.id == self.id) break;
      if (iterator.position.bytes > target_end_byte) {
        found_child_containing_target = true;
        break;
      }
 
      if (iterator.position.bytes == target_end_byte &&
          (!self_is_empty ||
           ts_subtree_has_trailing_empty_descendant(ts_node__subtree(child), self_subtree))) {
        found_child_containing_target = true;
        break;
      }
 
      if (ts_node__is_relevant(child, include_anonymous)) {
        earlier_child = child;
        earlier_child_is_relevant = true;
      } else if (ts_node__relevant_child_count(child, include_anonymous) > 0) {
        earlier_child = child;
        earlier_child_is_relevant = false;
      }
    }
 
    if (found_child_containing_target) {
      if (!ts_node_is_null(earlier_child)) {
        earlier_node = earlier_child;
        earlier_node_is_relevant = earlier_child_is_relevant;
      }
      node = child;
    } else if (earlier_child_is_relevant) {
      return earlier_child;
    } else if (!ts_node_is_null(earlier_child)) {
      node = earlier_child;
    } else if (earlier_node_is_relevant) {
      return earlier_node;
    } else {
      node = earlier_node;
    }
  }
 
  return ts_node__null();
}

References TSNode::id, ts_node__is_relevant(), ts_node__null(), ts_node__relevant_child_count(), ts_node__subtree(), ts_node_child_iterator_next(), ts_node_end_byte(), ts_node_is_null(), ts_node_iterate_children(), ts_node_parent(), ts_subtree_has_trailing_empty_descendant(), and ts_subtree_total_bytes().

Referenced by ts_node_prev_named_sibling(), and ts_node_prev_sibling().

ts_node__relevant_child_count()

static uint32_t ts_node__relevant_child_count ( TSNode  self, bool  include_anonymous  )

inlinestatic

Definition at line 120 of file node.c.

  {
  Subtree tree = ts_node__subtree(self);
  if (ts_subtree_child_count(tree) > 0) {
    if (include_anonymous) {
      return tree.ptr->visible_child_count;
    } else {
      return tree.ptr->named_child_count;
    }
  } else {
    return 0;
  }
}

References SubtreeHeapData::named_child_count, Subtree::ptr, ts_node__subtree(), ts_subtree_child_count(), and SubtreeHeapData::visible_child_count.

Referenced by ts_node__child(), ts_node__next_sibling(), and ts_node__prev_sibling().

ts_node__subtree()

static Subtree ts_node__subtree ( TSNode  self )

inlinestatic

Definition at line 48 of file node.c.

                                                    {
  return *(const Subtree *)self.id;
}

Referenced by ts_node__is_relevant(), ts_node__next_sibling(), ts_node__prev_sibling(), ts_node__relevant_child_count(), ts_node_child_by_field_id(), ts_node_child_count(), ts_node_end_byte(), ts_node_end_point(), ts_node_field_name_for_child(), ts_node_has_changes(), ts_node_has_error(), ts_node_is_extra(), ts_node_is_missing(), ts_node_is_named(), ts_node_iterate_children(), ts_node_named_child_count(), ts_node_string(), ts_node_symbol(), and ts_node_type().

ts_node_child()

TSNode ts_node_child	(	TSNode	self,
		uint32_t	child_index
	)

Get the node's child at the given index, where zero represents the first child.

Definition at line 492 of file node.c.

                                                        {
  return ts_node__child(self, child_index, true);
}

References ts_node__child().

Referenced by DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), handle_cmd_substitution_arg(), ts_node_child_by_field_id(), and ts_node_child_wasm().

ts_node_child_by_field_id()

TSNode ts_node_child_by_field_id	(	TSNode	self,
		TSFieldId	field_id
	)

Get the node's child with the given numerical field id.

You can convert a field name to an id using the ts_language_field_id_for_name function.

Definition at line 500 of file node.c.

                                                                  {
recur:
  if (!field_id || ts_node_child_count(self) == 0) return ts_node__null();
 
  const TSFieldMapEntry *field_map, *field_map_end;
  ts_language_field_map(
    self.tree->language,
    ts_node__subtree(self).ptr->production_id,
    &field_map,
    &field_map_end
  );
  if (field_map == field_map_end) return ts_node__null();
 
  // The field mappings are sorted by their field id. Scan all
  // the mappings to find the ones for the given field id.
  while (field_map->field_id < field_id) {
    field_map++;
    if (field_map == field_map_end) return ts_node__null();
  }
  while (field_map_end[-1].field_id > field_id) {
    field_map_end--;
    if (field_map == field_map_end) return ts_node__null();
  }
 
  TSNode child;
  NodeChildIterator iterator = ts_node_iterate_children(&self);
  while (ts_node_child_iterator_next(&iterator, &child)) {
    if (!ts_subtree_extra(ts_node__subtree(child))) {
      uint32_t index = iterator.structural_child_index - 1;
      if (index < field_map->child_index) continue;
 
      // Hidden nodes' fields are "inherited" by their visible parent.
      if (field_map->inherited) {
 
        // If this is the *last* possible child node for this field,
        // then perform a tail call to avoid recursion.
        if (field_map + 1 == field_map_end) {
          self = child;
          goto recur;
        }
 
        // Otherwise, descend into this child, but if it doesn't contain
        // the field, continue searching subsequent children.
        else {
          TSNode result = ts_node_child_by_field_id(child, field_id);
          if (result.id) return result;
          field_map++;
          if (field_map == field_map_end) return ts_node__null();
        }
      }
 
      else if (ts_node__is_relevant(child, true)) {
        return child;
      }
 
      // If the field refers to a hidden node with visible children,
      // return the first visible child.
      else if (ts_node_child_count(child) > 0 ) {
        return ts_node_child(child, 0);
      }
 
      // Otherwise, continue searching subsequent children.
      else {
        field_map++;
        if (field_map == field_map_end) return ts_node__null();
      }
    }
  }
 
  return ts_node__null();
}

References field_id, TSFieldMapEntry::field_id, TSNode::id, TSFieldMapEntry::inherited, ts_language_field_map(), ts_node__is_relevant(), ts_node__null(), ts_node__subtree(), ts_node_child(), ts_node_child_by_field_id(), ts_node_child_count(), ts_node_child_iterator_next(), ts_node_iterate_children(), and ts_subtree_extra().

Referenced by ts_node_child_by_field_id(), ts_node_child_by_field_id_wasm(), ts_node_child_by_field_name(), and ts_query_cursor__advance().

ts_node_child_by_field_name()

TSNode ts_node_child_by_field_name	(	TSNode	self,
		const char *	field_name,
		uint32_t	field_name_length
	)

Get the node's child with the given field name.

Definition at line 589 of file node.c.

  {
  TSFieldId field_id = ts_language_field_id_for_name(
    self.tree->language,
    name,
    name_length
  );
  return ts_node_child_by_field_id(self, field_id);
}

References field_id, ts_language_field_id_for_name(), and ts_node_child_by_field_id().

Referenced by DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), parse_declaration_node(), parse_enum_node(), parse_parameter_declaration_node(), parse_struct_node(), parse_type_abstract_declarator_node(), parse_type_declarator_node(), parse_type_descriptor_single(), parse_typedef_node(), and parse_union_node().

ts_node_child_count()

uint32_t ts_node_child_count

(

TSNode

self

)

Get the node's number of children.

Definition at line 602 of file node.c.

                                          {
  Subtree tree = ts_node__subtree(self);
  if (ts_subtree_child_count(tree) > 0) {
    return tree.ptr->visible_child_count;
  } else {
    return 0;
  }
}

References Subtree::ptr, ts_node__subtree(), ts_subtree_child_count(), and SubtreeHeapData::visible_child_count.

Referenced by ts_node__first_child_for_byte(), ts_node_child_by_field_id(), ts_node_child_count_wasm(), and ts_node_children_wasm().

ts_node_child_iterator_done()

static bool ts_node_child_iterator_done ( NodeChildIterator *  self )

inlinestatic

Definition at line 73 of file node.c.

                                                                        {
  return self->child_index == self->parent.ptr->child_count;
}

Referenced by ts_node_child_iterator_next().

ts_node_child_iterator_next()

static bool ts_node_child_iterator_next ( NodeChildIterator *  self, TSNode *  result  )

inlinestatic

Definition at line 77 of file node.c.

  {
  if (!self->parent.ptr || ts_node_child_iterator_done(self)) return false;
  const Subtree *child = &ts_subtree_children(self->parent)[self->child_index];
  TSSymbol alias_symbol = 0;
  if (!ts_subtree_extra(*child)) {
    if (self->alias_sequence) {
      alias_symbol = self->alias_sequence[self->structural_child_index];
    }
    self->structural_child_index++;
  }
  if (self->child_index > 0) {
    self->position = length_add(self->position, ts_subtree_padding(*child));
  }
  *result = ts_node_new(
    self->tree,
    child,
    self->position,
    alias_symbol
  );
  self->position = length_add(self->position, ts_subtree_size(*child));
  self->child_index++;
  return true;
}

References length_add(), ts_node_child_iterator_done(), ts_node_new(), ts_subtree_children, ts_subtree_extra(), ts_subtree_padding(), and ts_subtree_size().

Referenced by ts_node__child(), ts_node__descendant_for_byte_range(), ts_node__descendant_for_point_range(), ts_node__first_child_for_byte(), ts_node__next_sibling(), ts_node__prev_sibling(), ts_node_child_by_field_id(), and ts_node_parent().

ts_node_descendant_for_byte_range()

TSNode ts_node_descendant_for_byte_range	(	TSNode	self,
		uint32_t	start,
		uint32_t	end
	)

Get the smallest node within this node that spans the given range of bytes or (row, column) positions.

Definition at line 644 of file node.c.

  {
  return ts_node__descendant_for_byte_range(self, start, end, true);
}

References test_evm::end, start, and ts_node__descendant_for_byte_range().

Referenced by ts_node_descendant_for_index_wasm().

ts_node_descendant_for_point_range()

TSNode ts_node_descendant_for_point_range	(	TSNode	self,
		TSPoint	start,
		TSPoint	end
	)

Definition at line 660 of file node.c.

  {
  return ts_node__descendant_for_point_range(self, start, end, true);
}

References test_evm::end, start, and ts_node__descendant_for_point_range().

Referenced by ts_node_descendant_for_position_wasm().

ts_node_edit()

void ts_node_edit	(	TSNode *	self,
		const TSInputEdit *	edit
	)

Edit the node to keep it in-sync with source code that has been edited.

This function is only rarely needed. When you edit a syntax tree with the ts_tree_edit function, all of the nodes that you retrieve from the tree afterward will already reflect the edit. You only need to use ts_node_edit when you have a TSNode instance that you want to keep and continue to use after an edit.

Definition at line 676 of file node.c.

                                                         {
  uint32_t start_byte = ts_node_start_byte(*self);
  TSPoint start_point = ts_node_start_point(*self);
 
  if (start_byte >= edit->old_end_byte) {
    start_byte = edit->new_end_byte + (start_byte - edit->old_end_byte);
    start_point = point_add(edit->new_end_point, point_sub(start_point, edit->old_end_point));
  } else if (start_byte > edit->start_byte) {
    start_byte = edit->new_end_byte;
    start_point = edit->new_end_point;
  }
 
  self->context[0] = start_byte;
  self->context[1] = start_point.row;
  self->context[2] = start_point.column;
}

References TSPoint::column, TSInputEdit::new_end_byte, TSInputEdit::new_end_point, TSInputEdit::old_end_byte, TSInputEdit::old_end_point, point_add(), point_sub(), TSPoint::row, TSInputEdit::start_byte, ts_node_start_byte(), and ts_node_start_point().

ts_node_end_byte()

uint32_t ts_node_end_byte

(

TSNode

self

)

Get the node's end byte.

Definition at line 406 of file node.c.

                                       {
  return ts_node_start_byte(self) + ts_subtree_size(ts_node__subtree(self)).bytes;
}

References Length::bytes, ts_node__subtree(), ts_node_start_byte(), and ts_subtree_size().

Referenced by create_cmd_edit(), DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), find_autocmplt_type(), find_autocmplt_type_at_stmt(), find_autocmplt_type_at_stmt_op(), find_autocmplt_type_quoted_arg(), get_cd_from_cmdid(), ts_node__first_child_for_byte(), ts_node__next_sibling(), ts_node__prev_sibling(), ts_node_end_index_wasm(), ts_node_parent(), ts_query_cursor__advance(), ts_query_cursor__compare_nodes(), ts_query_cursor__first_in_progress_capture(), ts_query_cursor_next_capture(), and ts_tree_cursor_end_index_wasm().

ts_node_end_point()

TSPoint ts_node_end_point

(

TSNode

self

)

Get the node's end position in terms of rows and columns.

Definition at line 410 of file node.c.

                                       {
  return point_add(ts_node_start_point(self), ts_subtree_size(ts_node__subtree(self)).extent);
}

References point_add(), ts_node__subtree(), ts_node_start_point(), and ts_subtree_size().

Referenced by create_cmd_edit(), ts_node_descendants_of_type_wasm(), ts_node_end_point_wasm(), ts_query_cursor__advance(), ts_query_cursor__first_in_progress_capture(), and ts_tree_cursor_end_position_wasm().

ts_node_eq()

bool ts_node_eq	(	TSNode	self,
		TSNode	other
	)

Check if two nodes are identical.

Definition at line 430 of file node.c.

                                           {
  return self.tree == other.tree && self.id == other.id;
}

References TSNode::id, and TSNode::tree.

ts_node_field_name_for_child()

const char* ts_node_field_name_for_child	(	TSNode	self,
		uint32_t	child_index
	)

Get the field name for node's child at the given index, where zero represents the first child. Returns NULL, if no field is found.

Definition at line 572 of file node.c.

                                                                            {
  const TSFieldMapEntry *field_map_start = NULL, *field_map_end = NULL;
  ts_language_field_map(
    self.tree->language,
    ts_node__subtree(self).ptr->production_id,
    &field_map_start,
    &field_map_end
  );
 
  for (const TSFieldMapEntry *i = field_map_start; i < field_map_end; i++) {
    if (i->child_index == child_index) {
      return self.tree->language->field_names[i->field_id];
    }
  }
  return NULL;
}

References i, NULL, ts_language_field_map(), and ts_node__subtree().

ts_node_first_child_for_byte()

TSNode ts_node_first_child_for_byte	(	TSNode	self,
		uint32_t	byte
	)

Get the node's first child that extends beyond the given byte offset.

Definition at line 636 of file node.c.

                                                                {
  return ts_node__first_child_for_byte(self, byte, true);
}

References ts_node__first_child_for_byte().

ts_node_first_named_child_for_byte()

TSNode ts_node_first_named_child_for_byte	(	TSNode	self,
		uint32_t	byte
	)

Get the node's first named child that extends beyond the given byte offset.

Definition at line 640 of file node.c.

                                                                      {
  return ts_node__first_child_for_byte(self, byte, false);
}

References ts_node__first_child_for_byte().

ts_node_has_changes()

bool ts_node_has_changes

(

TSNode

self

)

Check if a syntax node has been edited.

Definition at line 453 of file node.c.

                                      {
  return ts_subtree_has_changes(ts_node__subtree(self));
}

References ts_node__subtree(), and ts_subtree_has_changes().

Referenced by ts_node_has_changes_wasm().

ts_node_has_error()

bool ts_node_has_error

(

TSNode

self

)

Check if the node is a syntax error or contains any syntax errors.

Definition at line 457 of file node.c.

                                    {
  return ts_subtree_error_cost(ts_node__subtree(self)) > 0;
}

References ts_node__subtree(), and ts_subtree_error_cost().

Referenced by core_cmd_tsrzcmd(), find_autocmplt_type_quoted_arg(), substitute_args_do(), and ts_node_has_error_wasm().

ts_node_is_extra()

bool ts_node_is_extra

(

TSNode

self

)

Check if the node is extra. Extra nodes represent things like comments, which are not required the grammar, but can appear anywhere.

Definition at line 438 of file node.c.

                                   {
  return ts_subtree_extra(ts_node__subtree(self));
}

References ts_node__subtree(), and ts_subtree_extra().

ts_node_is_missing()

bool ts_node_is_missing

(

TSNode

self

)

Check if the node is missing. Missing nodes are inserted by the parser in order to recover from certain kinds of syntax errors.

Definition at line 449 of file node.c.

                                     {
  return ts_subtree_missing(ts_node__subtree(self));
}

References ts_node__subtree(), and ts_subtree_missing().

Referenced by ts_node_is_missing_wasm(), and ts_tree_cursor_current_node_is_missing_wasm().

ts_node_is_named()

bool ts_node_is_named

(

TSNode

self

)

Check if the node is named. Named nodes correspond to named rules in the grammar, whereas anonymous nodes correspond to string literals in the grammar.

Definition at line 442 of file node.c.

                                   {
  TSSymbol alias = ts_node__alias(&self);
  return alias
    ? ts_language_symbol_metadata(self.tree->language, alias).named
    : ts_subtree_named(ts_node__subtree(self));
}

References TSSymbolMetadata::named, ts_language_symbol_metadata(), ts_node__alias(), ts_node__subtree(), and ts_subtree_named().

Referenced by parse_declaration_node(), parse_enum_node(), parse_parameter_declaration_node(), parse_parameter_list(), parse_primitive_type(), parse_sized_primitive_type(), parse_sole_type_name(), parse_struct_node(), parse_type_abstract_declarator_node(), parse_type_declarator_node(), parse_type_descriptor_single(), parse_type_node_single(), parse_type_nodes_save(), parse_typedef_node(), parse_union_node(), ts_node_is_named_wasm(), ts_node_named_children_wasm(), ts_query_cursor__advance(), and ts_tree_cursor_current_node_is_named_wasm().

ts_node_is_null()

bool ts_node_is_null

(

TSNode

self

)

Check if the node is null. Functions like ts_node_child and ts_node_next_sibling will return a null node to indicate that no such node was found.

Definition at line 434 of file node.c.

                                  {
  return self.id == 0;
}

Referenced by DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), find_autocmplt_type_arg_identifier(), find_autocmplt_type_at_stmt_op(), get_arg_number(), get_arg_parent(), get_cd_from_arg(), guess_next_autocmplt_token(), handle_cmd_substitution_arg(), is_arg_identifier_in_tmp_stmt(), node_malformed_error(), parse_args(), parse_declaration_node(), parse_enum_node(), parse_parameter_declaration_node(), parse_parameter_list(), parse_primitive_type(), parse_sized_primitive_type(), parse_sole_type_name(), parse_struct_node(), parse_type_abstract_declarator_node(), parse_type_declarator_node(), parse_type_descriptor_single(), parse_type_node_single(), parse_type_nodes_save(), parse_typedef_node(), parse_union_node(), ts_node__next_sibling(), ts_node__prev_sibling(), and ts_query_cursor__advance().

ts_node_iterate_children()

static NodeChildIterator ts_node_iterate_children ( const TSNode *  node )

inlinestatic

Definition at line 54 of file node.c.

                                                                             {
  Subtree subtree = ts_node__subtree(*node);
  if (ts_subtree_child_count(subtree) == 0) {
    return (NodeChildIterator) {NULL_SUBTREE, node->tree, length_zero(), 0, 0, NULL};
  }
  const TSSymbol *alias_sequence = ts_language_alias_sequence(
    node->tree->language,
    subtree.ptr->production_id
  );
  return (NodeChildIterator) {
    .tree = node->tree,
    .parent = subtree,
    .position = {ts_node_start_byte(*node), ts_node_start_point(*node)},
    .child_index = 0,
    .structural_child_index = 0,
    .alias_sequence = alias_sequence,
  };
}

References TSTree::language, length_zero(), NULL, NULL_SUBTREE, SubtreeHeapData::production_id, Subtree::ptr, TSNode::tree, ts_language_alias_sequence(), ts_node__subtree(), ts_node_start_byte(), ts_node_start_point(), and ts_subtree_child_count().

Referenced by ts_node__child(), ts_node__descendant_for_byte_range(), ts_node__descendant_for_point_range(), ts_node__first_child_for_byte(), ts_node__next_sibling(), ts_node__prev_sibling(), ts_node_child_by_field_id(), and ts_node_parent().

ts_node_named_child()

TSNode ts_node_named_child	(	TSNode	self,
		uint32_t	child_index
	)

Get the node's named child at the given index.

See also ts_node_is_named.

Definition at line 496 of file node.c.

                                                              {
  return ts_node__child(self, child_index, false);
}

References ts_node__child().

Referenced by DEFINE_HANDLE_TS_FCN(), DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), do_handle_ts_unescape_arg(), do_iter_sections(), get_cd_from_arg(), handle_substitution_args(), iter_dbt_commands(), iter_offsets_common(), parse_args(), parse_declaration_node(), parse_enum_node(), parse_parameter_declaration_node(), parse_parameter_list(), parse_struct_node(), parse_type_abstract_declarator_node(), parse_type_declarator_node(), parse_type_descriptor_single(), parse_typedef_node(), parse_union_node(), rz_type_parse_string_declaration_single(), rz_type_parse_string_single(), substitute_args_do(), ts_node_handle_arg_prargs(), ts_node_named_child_wasm(), and type_parse_string().

ts_node_named_child_count()

uint32_t ts_node_named_child_count

(

TSNode

self

)

Get the node's number of named children.

See also ts_node_is_named.

Definition at line 611 of file node.c.

                                                {
  Subtree tree = ts_node__subtree(self);
  if (ts_subtree_child_count(tree) > 0) {
    return tree.ptr->named_child_count;
  } else {
    return 0;
  }
}

References SubtreeHeapData::named_child_count, Subtree::ptr, ts_node__subtree(), and ts_subtree_child_count().

Referenced by DEFINE_HANDLE_TS_FCN(), DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), do_handle_ts_unescape_arg(), find_autocmplt_type(), handle_substitution_args(), iter_offsets_common(), parse_args(), parse_declaration_node(), parse_enum_node(), parse_parameter_list(), parse_struct_node(), parse_type_abstract_declarator_node(), parse_type_declarator_node(), parse_type_descriptor_single(), parse_typedef_node(), parse_union_node(), rz_type_parse_string_declaration_single(), rz_type_parse_string_single(), ts_node_named_child_count_wasm(), ts_node_named_children_wasm(), and type_parse_string().

ts_node_named_descendant_for_byte_range()

TSNode ts_node_named_descendant_for_byte_range	(	TSNode	self,
		uint32_t	start,
		uint32_t	end
	)

Get the smallest named node within this node that spans the given range of bytes or (row, column) positions.

Definition at line 652 of file node.c.

  {
  return ts_node__descendant_for_byte_range(self, start, end, false);
}

References test_evm::end, start, and ts_node__descendant_for_byte_range().

Referenced by guess_next_autocmplt_token(), and ts_node_named_descendant_for_index_wasm().

ts_node_named_descendant_for_point_range()

TSNode ts_node_named_descendant_for_point_range	(	TSNode	self,
		TSPoint	start,
		TSPoint	end
	)

Definition at line 668 of file node.c.

  {
  return ts_node__descendant_for_point_range(self, start, end, false);
}

References test_evm::end, start, and ts_node__descendant_for_point_range().

Referenced by ts_node_named_descendant_for_position_wasm().

ts_node_new()

TSNode ts_node_new	(	const TSTree *	tree,
		const Subtree *	subtree,
		Length	position,
		TSSymbol	alias
	)

Definition at line 17 of file node.c.

  {
  return (TSNode) {
    {position.bytes, position.extent.row, position.extent.column, alias},
    subtree,
    tree,
  };
}

References Length::bytes, TSPoint::column, Length::extent, and TSPoint::row.

Referenced by ts_node__null(), ts_node_child_iterator_next(), ts_tree_cursor_current_node(), ts_tree_cursor_parent_node(), and ts_tree_root_node().

ts_node_next_named_sibling()

TSNode ts_node_next_named_sibling

(

TSNode

self

)

Get the node's next / previous named sibling.

Definition at line 624 of file node.c.

                                               {
  return ts_node__next_sibling(self, false);
}

References ts_node__next_sibling().

Referenced by parse_struct_node(), parse_union_node(), and ts_node_next_named_sibling_wasm().

ts_node_next_sibling()

TSNode ts_node_next_sibling

(

TSNode

self

)

Get the node's next / previous sibling.

Definition at line 620 of file node.c.

                                         {
  return ts_node__next_sibling(self, true);
}

References ts_node__next_sibling().

Referenced by ts_node_next_sibling_wasm().

ts_node_parent()

TSNode ts_node_parent

(

TSNode

self

)

Get the node's immediate parent.

Definition at line 461 of file node.c.

                                   {
  TSNode node = ts_tree_root_node(self.tree);
  uint32_t end_byte = ts_node_end_byte(self);
  if (node.id == self.id) return ts_node__null();
 
  TSNode last_visible_node = node;
  bool did_descend = true;
  while (did_descend) {
    did_descend = false;
 
    TSNode child;
    NodeChildIterator iterator = ts_node_iterate_children(&node);
    while (ts_node_child_iterator_next(&iterator, &child)) {
      if (
        ts_node_start_byte(child) > ts_node_start_byte(self) ||
        child.id == self.id
      ) break;
      if (iterator.position.bytes >= end_byte) {
        node = child;
        if (ts_node__is_relevant(child, true)) {
          last_visible_node = node;
        }
        did_descend = true;
        break;
      }
    }
  }
 
  return last_visible_node;
}

References TSNode::id, ts_node__is_relevant(), ts_node__null(), ts_node_child_iterator_next(), ts_node_end_byte(), ts_node_iterate_children(), ts_node_start_byte(), and ts_tree_root_node().

Referenced by get_arg_number(), get_arg_parent(), get_cd_from_arg(), handle_cmd_substitution_arg(), ts_node__next_sibling(), ts_node__prev_sibling(), and ts_node_parent_wasm().

ts_node_prev_named_sibling()

TSNode ts_node_prev_named_sibling

(

TSNode

self

)

Definition at line 632 of file node.c.

                                               {
  return ts_node__prev_sibling(self, false);
}

References ts_node__prev_sibling().

Referenced by ts_node_prev_named_sibling_wasm().

ts_node_prev_sibling()

TSNode ts_node_prev_sibling

(

TSNode

self

)

Definition at line 628 of file node.c.

                                         {
  return ts_node__prev_sibling(self, true);
}

References ts_node__prev_sibling().

Referenced by get_arg_number(), and ts_node_prev_sibling_wasm().

ts_node_start_byte()

uint32_t ts_node_start_byte

(

TSNode

self

)

Get the node's start byte.

Definition at line 36 of file node.c.

                                         {
  return self.context[0];
}

Referenced by create_cmd_edit(), DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), find_autocmplt_type(), find_autocmplt_type_at_stmt(), find_autocmplt_type_at_stmt_op(), find_autocmplt_type_newcmd_or_arg(), find_autocmplt_type_quoted_arg(), get_cd_from_cmdid(), ts_node__descendant_for_byte_range(), ts_node__next_sibling(), ts_node_edit(), ts_node_end_byte(), ts_node_iterate_children(), ts_node_parent(), ts_node_start_index_wasm(), ts_node_sub_parent_string(), ts_query_cursor__advance(), ts_query_cursor__compare_nodes(), ts_query_cursor__first_in_progress_capture(), ts_query_cursor_next_capture(), and ts_tree_cursor_start_index_wasm().

ts_node_start_point()

TSPoint ts_node_start_point

(

TSNode

self

)

Get the node's start position in terms of rows and columns.

Definition at line 40 of file node.c.

                                         {
  return (TSPoint) {self.context[1], self.context[2]};
}

Referenced by create_cmd_edit(), ts_node__descendant_for_point_range(), ts_node_descendants_of_type_wasm(), ts_node_edit(), ts_node_end_point(), ts_node_iterate_children(), ts_node_start_point_wasm(), ts_query_cursor__advance(), and ts_tree_cursor_start_position_wasm().

ts_node_string()

char* ts_node_string

(

TSNode

self

)

Get an S-expression representing the node as a string.

This string is allocated with malloc and the caller is responsible for freeing it using free.

Definition at line 426 of file node.c.

                                  {
  return ts_subtree_string(ts_node__subtree(self), self.tree->language, false);
}

References ts_node__subtree(), and ts_subtree_string().

Referenced by core_cmd_tsrzcmd(), node_malformed_error(), parse_enum_node(), parse_struct_node(), parse_typedef_node(), parse_union_node(), rz_type_parse_string_declaration_single(), rz_type_parse_string_single(), ts_node_to_string_wasm(), and type_parse_string().

ts_node_symbol()

TSSymbol ts_node_symbol

(

TSNode

self

)

Get the node's type as a numerical id.

Definition at line 414 of file node.c.

                                     {
  TSSymbol symbol = ts_node__alias(&self);
  if (!symbol) symbol = ts_subtree_symbol(ts_node__subtree(self));
  return ts_language_public_symbol(self.tree->language, symbol);
}

References ts_language_public_symbol(), ts_node__alias(), ts_node__subtree(), and ts_subtree_symbol().

Referenced by handle_ts_stmt(), ts_node_descendants_of_type_wasm(), ts_node_symbol_wasm(), ts_query_cursor__advance(), and ts_tree_cursor_current_node_type_id_wasm().

ts_node_type()

const char* ts_node_type

(

TSNode

self

)

Get the node's type as a null-terminated string.

Definition at line 420 of file node.c.

                                      {
  TSSymbol symbol = ts_node__alias(&self);
  if (!symbol) symbol = ts_subtree_symbol(ts_node__subtree(self));
  return ts_language_symbol_name(self.tree->language, symbol);
}

References ts_language_symbol_name(), ts_node__alias(), ts_node__subtree(), and ts_subtree_symbol().

Referenced by find_autocmplt_type(), find_autocmplt_type_arg_identifier(), find_autocmplt_type_at_stmt(), find_autocmplt_type_at_stmt_op(), find_autocmplt_type_newcmd_or_arg(), find_autocmplt_type_quoted_arg(), get_arg_number(), get_arg_parent(), get_cd_from_arg(), handle_ts_stmt(), is_arg_identifier_in_tmp_stmt(), parse_declaration_node(), parse_enum_node(), parse_parameter_declaration_node(), parse_parameter_list(), parse_primitive_type(), parse_sized_primitive_type(), parse_sole_type_name(), parse_struct_node(), parse_type_abstract_declarator_node(), parse_type_declarator_node(), parse_type_descriptor_single(), parse_type_node_single(), parse_type_nodes_save(), parse_typedef_node(), parse_union_node(), rz_type_parse_string_declaration_single(), rz_type_parse_string_single(), ts_query_cursor__advance(), ts_query_cursor__capture(), and type_parse_string().

ts_subtree_has_trailing_empty_descendant()

static bool ts_subtree_has_trailing_empty_descendant ( Subtree  self, Subtree  other  )

static

Definition at line 173 of file node.c.

  {
  for (unsigned i = ts_subtree_child_count(self) - 1; i + 1 > 0; i--) {
    Subtree child = ts_subtree_children(self)[i];
    if (ts_subtree_total_bytes(child) > 0) break;
    if (child.ptr == other.ptr || ts_subtree_has_trailing_empty_descendant(child, other)) {
      return true;
    }
  }
  return false;
}

References i, Subtree::ptr, ts_subtree_child_count(), ts_subtree_children, and ts_subtree_total_bytes().

Referenced by ts_node__prev_sibling().