api.h File Reference

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <stdbool.h>

Go to the source code of this file.

Classes
struct	TSPoint
struct	TSRange
struct	TSInput
struct	TSLogger
struct	TSInputEdit
struct	TSNode
struct	TSTreeCursor
struct	TSQueryCapture
struct	TSQueryMatch
struct	TSQueryPredicateStep

Macros
#define	TREE_SITTER_LANGUAGE_VERSION   14
#define	TREE_SITTER_MIN_COMPATIBLE_LANGUAGE_VERSION   13

Typedefs
typedef uint16_t	TSSymbol
typedef uint16_t	TSFieldId
typedef struct TSLanguage	TSLanguage
typedef struct TSParser	TSParser
typedef struct TSTree	TSTree
typedef struct TSQuery	TSQuery
typedef struct TSQueryCursor	TSQueryCursor

Enumerations
enum	TSInputEncoding { TSInputEncodingUTF8 , TSInputEncodingUTF16 }
enum	TSSymbolType { TSSymbolTypeRegular , TSSymbolTypeAnonymous , TSSymbolTypeAuxiliary }
enum	TSLogType { TSLogTypeParse , TSLogTypeLex }
enum	TSQuantifier {   TSQuantifierZero = 0 , TSQuantifierZeroOrOne , TSQuantifierZeroOrMore , TSQuantifierOne ,   TSQuantifierOneOrMore }
enum	TSQueryPredicateStepType { TSQueryPredicateStepTypeDone , TSQueryPredicateStepTypeCapture , TSQueryPredicateStepTypeString }
enum	TSQueryError {   TSQueryErrorNone = 0 , TSQueryErrorSyntax , TSQueryErrorNodeType , TSQueryErrorField ,   TSQueryErrorCapture , TSQueryErrorStructure , TSQueryErrorLanguage }

Functions
TSParser *	ts_parser_new (void)
void	ts_parser_delete (TSParser *parser)
bool	ts_parser_set_language (TSParser *self, const TSLanguage *language)
const TSLanguage *	ts_parser_language (const TSParser *self)
bool	ts_parser_set_included_ranges (TSParser *self, const TSRange *ranges, uint32_t length)
const TSRange *	ts_parser_included_ranges (const TSParser *self, uint32_t *length)
TSTree *	ts_parser_parse (TSParser *self, const TSTree *old_tree, TSInput input)
TSTree *	ts_parser_parse_string (TSParser *self, const TSTree *old_tree, const char *string, uint32_t length)
TSTree *	ts_parser_parse_string_encoding (TSParser *self, const TSTree *old_tree, const char *string, uint32_t length, TSInputEncoding encoding)
void	ts_parser_reset (TSParser *self)
void	ts_parser_set_timeout_micros (TSParser *self, uint64_t timeout)
uint64_t	ts_parser_timeout_micros (const TSParser *self)
void	ts_parser_set_cancellation_flag (TSParser *self, const size_t *flag)
const size_t *	ts_parser_cancellation_flag (const TSParser *self)
void	ts_parser_set_logger (TSParser *self, TSLogger logger)
TSLogger	ts_parser_logger (const TSParser *self)
void	ts_parser_print_dot_graphs (TSParser *self, int file)
TSTree *	ts_tree_copy (const TSTree *self)
void	ts_tree_delete (TSTree *self)
TSNode	ts_tree_root_node (const TSTree *self)
const TSLanguage *	ts_tree_language (const TSTree *)
void	ts_tree_edit (TSTree *self, const TSInputEdit *edit)
TSRange *	ts_tree_get_changed_ranges (const TSTree *old_tree, const TSTree *new_tree, uint32_t *length)
void	ts_tree_print_dot_graph (const TSTree *, FILE *)
const char *	ts_node_type (TSNode)
TSSymbol	ts_node_symbol (TSNode)
uint32_t	ts_node_start_byte (TSNode)
TSPoint	ts_node_start_point (TSNode)
uint32_t	ts_node_end_byte (TSNode)
TSPoint	ts_node_end_point (TSNode)
char *	ts_node_string (TSNode)
bool	ts_node_is_null (TSNode)
bool	ts_node_is_named (TSNode)
bool	ts_node_is_missing (TSNode)
bool	ts_node_is_extra (TSNode)
bool	ts_node_has_changes (TSNode)
bool	ts_node_has_error (TSNode)
TSNode	ts_node_parent (TSNode)
TSNode	ts_node_child (TSNode, uint32_t)
const char *	ts_node_field_name_for_child (TSNode, uint32_t)
uint32_t	ts_node_child_count (TSNode)
TSNode	ts_node_named_child (TSNode, uint32_t)
uint32_t	ts_node_named_child_count (TSNode)
TSNode	ts_node_child_by_field_name (TSNode self, const char *field_name, uint32_t field_name_length)
TSNode	ts_node_child_by_field_id (TSNode, TSFieldId)
TSNode	ts_node_next_sibling (TSNode)
TSNode	ts_node_prev_sibling (TSNode)
TSNode	ts_node_next_named_sibling (TSNode)
TSNode	ts_node_prev_named_sibling (TSNode)
TSNode	ts_node_first_child_for_byte (TSNode, uint32_t)
TSNode	ts_node_first_named_child_for_byte (TSNode, uint32_t)
TSNode	ts_node_descendant_for_byte_range (TSNode, uint32_t, uint32_t)
TSNode	ts_node_descendant_for_point_range (TSNode, TSPoint, TSPoint)
TSNode	ts_node_named_descendant_for_byte_range (TSNode, uint32_t, uint32_t)
TSNode	ts_node_named_descendant_for_point_range (TSNode, TSPoint, TSPoint)
void	ts_node_edit (TSNode *, const TSInputEdit *)
bool	ts_node_eq (TSNode, TSNode)
TSTreeCursor	ts_tree_cursor_new (TSNode)
void	ts_tree_cursor_delete (TSTreeCursor *)
void	ts_tree_cursor_reset (TSTreeCursor *, TSNode)
TSNode	ts_tree_cursor_current_node (const TSTreeCursor *)
const char *	ts_tree_cursor_current_field_name (const TSTreeCursor *)
TSFieldId	ts_tree_cursor_current_field_id (const TSTreeCursor *)
bool	ts_tree_cursor_goto_parent (TSTreeCursor *)
bool	ts_tree_cursor_goto_next_sibling (TSTreeCursor *)
bool	ts_tree_cursor_goto_first_child (TSTreeCursor *)
int64_t	ts_tree_cursor_goto_first_child_for_byte (TSTreeCursor *, uint32_t)
int64_t	ts_tree_cursor_goto_first_child_for_point (TSTreeCursor *, TSPoint)
TSTreeCursor	ts_tree_cursor_copy (const TSTreeCursor *)
TSQuery *	ts_query_new (const TSLanguage *language, const char *source, uint32_t source_len, uint32_t *error_offset, TSQueryError *error_type)
void	ts_query_delete (TSQuery *)
uint32_t	ts_query_pattern_count (const TSQuery *)
uint32_t	ts_query_capture_count (const TSQuery *)
uint32_t	ts_query_string_count (const TSQuery *)
uint32_t	ts_query_start_byte_for_pattern (const TSQuery *, uint32_t)
const TSQueryPredicateStep *	ts_query_predicates_for_pattern (const TSQuery *self, uint32_t pattern_index, uint32_t *length)
bool	ts_query_is_pattern_guaranteed_at_step (const TSQuery *self, uint32_t byte_offset)
const char *	ts_query_capture_name_for_id (const TSQuery *, uint32_t id, uint32_t *length)
TSQuantifier	ts_query_capture_quantifier_for_id (const TSQuery *, uint32_t pattern_id, uint32_t capture_id)
const char *	ts_query_string_value_for_id (const TSQuery *, uint32_t id, uint32_t *length)
void	ts_query_disable_capture (TSQuery *, const char *, uint32_t)
void	ts_query_disable_pattern (TSQuery *, uint32_t)
TSQueryCursor *	ts_query_cursor_new (void)
void	ts_query_cursor_delete (TSQueryCursor *)
void	ts_query_cursor_exec (TSQueryCursor *, const TSQuery *, TSNode)
bool	ts_query_cursor_did_exceed_match_limit (const TSQueryCursor *)
uint32_t	ts_query_cursor_match_limit (const TSQueryCursor *)
void	ts_query_cursor_set_match_limit (TSQueryCursor *, uint32_t)
void	ts_query_cursor_set_byte_range (TSQueryCursor *, uint32_t, uint32_t)
void	ts_query_cursor_set_point_range (TSQueryCursor *, TSPoint, TSPoint)
bool	ts_query_cursor_next_match (TSQueryCursor *, TSQueryMatch *match)
void	ts_query_cursor_remove_match (TSQueryCursor *, uint32_t id)
bool	ts_query_cursor_next_capture (TSQueryCursor *, TSQueryMatch *match, uint32_t *capture_index)
uint32_t	ts_language_symbol_count (const TSLanguage *)
const char *	ts_language_symbol_name (const TSLanguage *, TSSymbol)
TSSymbol	ts_language_symbol_for_name (const TSLanguage *self, const char *string, uint32_t length, bool is_named)
uint32_t	ts_language_field_count (const TSLanguage *)
const char *	ts_language_field_name_for_id (const TSLanguage *, TSFieldId)
TSFieldId	ts_language_field_id_for_name (const TSLanguage *, const char *, uint32_t)
TSSymbolType	ts_language_symbol_type (const TSLanguage *, TSSymbol)
uint32_t	ts_language_version (const TSLanguage *)
void	ts_set_allocator (void *(*new_malloc)(size_t), void *(*new_calloc)(size_t, size_t), void *(*new_realloc)(void *, size_t), void(*new_free)(void *))

Macro Definition Documentation

TREE_SITTER_LANGUAGE_VERSION

#define TREE_SITTER_LANGUAGE_VERSION   14

The latest ABI version that is supported by the current version of the library. When Languages are generated by the Tree-sitter CLI, they are assigned an ABI version number that corresponds to the current CLI version. The Tree-sitter library is generally backwards-compatible with languages generated using older CLI versions, but is not forwards-compatible.

Definition at line 24 of file api.h.

TREE_SITTER_MIN_COMPATIBLE_LANGUAGE_VERSION

#define TREE_SITTER_MIN_COMPATIBLE_LANGUAGE_VERSION   13

The earliest ABI version that is supported by the current version of the library.

Definition at line 30 of file api.h.

Typedef Documentation

TSFieldId

typedef uint16_t TSFieldId

Definition at line 37 of file api.h.

TSLanguage

typedef struct TSLanguage TSLanguage

Definition at line 37 of file api.h.

TSParser

typedef struct TSParser TSParser

Definition at line 37 of file api.h.

TSQuery

typedef struct TSQuery TSQuery

Definition at line 37 of file api.h.

TSQueryCursor

typedef struct TSQueryCursor TSQueryCursor

Definition at line 37 of file api.h.

TSSymbol

typedef uint16_t TSSymbol

Definition at line 36 of file api.h.

TSTree

typedef struct TSTree TSTree

Definition at line 37 of file api.h.

Enumeration Type Documentation

TSInputEncoding

enum TSInputEncoding

Enumerator
TSInputEncodingUTF8
TSInputEncodingUTF16

Definition at line 44 of file api.h.

             {
  TSInputEncodingUTF8,
  TSInputEncodingUTF16,
} TSInputEncoding;

TSLogType

enum TSLogType

Enumerator
TSLogTypeParse
TSLogTypeLex

Definition at line 73 of file api.h.

             {
  TSLogTypeParse,
  TSLogTypeLex,
} TSLogType;

TSQuantifier

enum TSQuantifier

Enumerator
TSQuantifierZero
TSQuantifierZeroOrOne
TSQuantifierZeroOrMore
TSQuantifierOne
TSQuantifierOneOrMore

Definition at line 109 of file api.h.

             {
  TSQuantifierZero = 0, // must match the array initialization value
  TSQuantifierZeroOrOne,
  TSQuantifierZeroOrMore,
  TSQuantifierOne,
  TSQuantifierOneOrMore,
} TSQuantifier;

TSQueryError

enum TSQueryError

Enumerator
TSQueryErrorNone
TSQueryErrorSyntax
TSQueryErrorNodeType
TSQueryErrorField
TSQueryErrorCapture
TSQueryErrorStructure
TSQueryErrorLanguage

Definition at line 135 of file api.h.

             {
  TSQueryErrorNone = 0,
  TSQueryErrorSyntax,
  TSQueryErrorNodeType,
  TSQueryErrorField,
  TSQueryErrorCapture,
  TSQueryErrorStructure,
  TSQueryErrorLanguage,
} TSQueryError;

TSQueryPredicateStepType

enum TSQueryPredicateStepType

Enumerator
TSQueryPredicateStepTypeDone
TSQueryPredicateStepTypeCapture
TSQueryPredicateStepTypeString

Definition at line 124 of file api.h.

             {
  TSQueryPredicateStepTypeDone,
  TSQueryPredicateStepTypeCapture,
  TSQueryPredicateStepTypeString,
} TSQueryPredicateStepType;

TSSymbolType

enum TSSymbolType

Enumerator
TSSymbolTypeRegular
TSSymbolTypeAnonymous
TSSymbolTypeAuxiliary

Definition at line 49 of file api.h.

             {
  TSSymbolTypeRegular,
  TSSymbolTypeAnonymous,
  TSSymbolTypeAuxiliary,
} TSSymbolType;

Function Documentation

ts_language_field_count()

uint32_t ts_language_field_count

(

const TSLanguage *

self

)

Get the number of distinct field names in the language.

Definition at line 14 of file language.c.

                                                         {
  return self->field_count;
}

Referenced by ts_language_field_id_for_name(), and ts_language_field_name_for_id().

ts_language_field_id_for_name()

TSFieldId ts_language_field_id_for_name	(	const TSLanguage *	self,
		const char *	name,
		uint32_t	name_length
	)

Get the numerical id for the given field name string.

Definition at line 119 of file language.c.

  {
  uint32_t count = ts_language_field_count(self);
  for (TSSymbol i = 1; i < count + 1; i++) {
    switch (strncmp(name, self->field_names[i], name_length)) {
      case 0:
        if (self->field_names[i][name_length] == 0) return i;
        break;
      case -1:
        return 0;
      default:
        break;
    }
  }
  return 0;
}

References count, i, and ts_language_field_count().

Referenced by ts_node_child_by_field_name(), and ts_query__parse_pattern().

ts_language_field_name_for_id()

const char* ts_language_field_name_for_id	(	const TSLanguage *	self,
		TSFieldId	id
	)

Get the field name string for the given numerical id.

Definition at line 107 of file language.c.

  {
  uint32_t count = ts_language_field_count(self);
  if (count && id <= count) {
    return self->field_names[id];
  } else {
    return NULL;
  }
}

References count, id, NULL, and ts_language_field_count().

Referenced by ts_query__analyze_patterns(), and ts_query_cursor__advance().

ts_language_symbol_count()

uint32_t ts_language_symbol_count

(

const TSLanguage *

self

)

Get the number of distinct node types in the language.

Definition at line 6 of file language.c.

                                                          {
  return self->symbol_count + self->alias_count;
}

Referenced by ts_language_symbol_for_name(), and ts_language_symbol_name().

ts_language_symbol_for_name()

TSSymbol ts_language_symbol_for_name	(	const TSLanguage *	self,
		const char *	string,
		uint32_t	length,
		bool	is_named
	)

Get the numerical id for the given node type string.

Definition at line 74 of file language.c.

  {
  if (!strncmp(string, "ERROR", length)) return ts_builtin_sym_error;
  uint32_t count = ts_language_symbol_count(self);
  for (TSSymbol i = 0; i < count; i++) {
    TSSymbolMetadata metadata = ts_language_symbol_metadata(self, i);
    if ((!metadata.visible && !metadata.supertype) || metadata.named != is_named) continue;
    const char *symbol_name = self->symbol_names[i];
    if (!strncmp(symbol_name, string, length) && !symbol_name[length]) {
      return self->public_symbol_map[i];
    }
  }
  return 0;
}

References count, i, length, TSSymbolMetadata::named, TSSymbolMetadata::supertype, ts_builtin_sym_error, ts_language_symbol_count(), ts_language_symbol_metadata(), and TSSymbolMetadata::visible.

Referenced by rz_core_cmd_new(), and ts_query__parse_pattern().

ts_language_symbol_name()

const char* ts_language_symbol_name	(	const TSLanguage *	self,
		TSSymbol	symbol
	)

Get a node type string for the given numerical id.

Definition at line 59 of file language.c.

  {
  if (symbol == ts_builtin_sym_error) {
    return "ERROR";
  } else if (symbol == ts_builtin_sym_error_repeat) {
    return "_ERROR";
  } else if (symbol < ts_language_symbol_count(self)) {
    return self->symbol_names[symbol];
  } else {
    return NULL;
  }
}

References NULL, ts_builtin_sym_error, ts_builtin_sym_error_repeat, and ts_language_symbol_count().

Referenced by ts_node_type(), ts_query__analyze_patterns(), ts_stack_print_dot_graph(), ts_subtree__print_dot_graph(), and ts_subtree__write_to_string().

ts_language_symbol_type()

TSSymbolType ts_language_symbol_type	(	const TSLanguage *	self,
		TSSymbol	symbol
	)

Check whether the given node type id belongs to named nodes, anonymous nodes, or a hidden nodes.

See also ts_node_is_named. Hidden nodes are never returned from the API.

Definition at line 93 of file language.c.

  {
  TSSymbolMetadata metadata = ts_language_symbol_metadata(self, symbol);
  if (metadata.named && metadata.visible) {
    return TSSymbolTypeRegular;
  } else if (metadata.visible) {
    return TSSymbolTypeAnonymous;
  } else {
    return TSSymbolTypeAuxiliary;
  }
}

References TSSymbolMetadata::named, ts_language_symbol_metadata(), TSSymbolTypeAnonymous, TSSymbolTypeAuxiliary, TSSymbolTypeRegular, and TSSymbolMetadata::visible.

Referenced by ts_language_type_is_named_wasm(), and ts_language_type_is_visible_wasm().

ts_language_version()

uint32_t ts_language_version

(

const TSLanguage *

self

)

Get the ABI version number for this language. This version number is used to ensure that languages were generated by a compatible version of Tree-sitter.

See also ts_parser_set_language.

Definition at line 10 of file language.c.

                                                     {
  return self->version;
}

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_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_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_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_parser_cancellation_flag()

const size_t* ts_parser_cancellation_flag

(

const TSParser *

self

)

Get the parser's current cancellation flag pointer.

Definition at line 1795 of file parser.c.

                                                                {
  return (const size_t *)self->cancellation_flag;
}

ts_parser_delete()

void ts_parser_delete

(

TSParser *

parser

)

Delete the parser, freeing all of the memory that it used.

Definition at line 1725 of file parser.c.

                                      {
  if (!self) return;
 
  ts_parser_set_language(self, NULL);
  ts_stack_delete(self->stack);
  if (self->reduce_actions.contents) {
    array_delete(&self->reduce_actions);
  }
  if (self->included_range_differences.contents) {
    array_delete(&self->included_range_differences);
  }
  if (self->old_tree.ptr) {
    ts_subtree_release(&self->tree_pool, self->old_tree);
    self->old_tree = NULL_SUBTREE;
  }
  ts_lexer_delete(&self->lexer);
  ts_parser__set_cached_token(self, 0, NULL_SUBTREE, NULL_SUBTREE);
  ts_subtree_pool_delete(&self->tree_pool);
  reusable_node_delete(&self->reusable_node);
  array_delete(&self->trailing_extras);
  array_delete(&self->trailing_extras2);
  array_delete(&self->scratch_trees);
  ts_free(self);
}

References array_delete, NULL, NULL_SUBTREE, reusable_node_delete(), ts_free, ts_lexer_delete(), ts_parser__set_cached_token(), ts_parser_set_language(), ts_stack_delete(), ts_subtree_pool_delete(), and ts_subtree_release().

Referenced by core_cmd_tsrzcmd(), guess_data_free(), guess_next_autocmplt_token(), rz_type_parse_string_declaration_single(), rz_type_parse_string_single(), and type_parse_string().

ts_parser_included_ranges()

const TSRange* ts_parser_included_ranges	(	const TSParser *	self,
		uint32_t *	length
	)

Get the ranges of text that the parser will include when parsing.

The returned pointer is owned by the parser. The caller should not free it or write to it. The length of the array will be written to the given length pointer.

Definition at line 1819 of file parser.c.

                                                                                {
  return ts_lexer_included_ranges(&self->lexer, count);
}

References count, and ts_lexer_included_ranges().

ts_parser_language()

const TSLanguage* ts_parser_language

(

const TSParser *

self

)

Get the parser's current language.

Definition at line 1750 of file parser.c.

                                                           {
  return self->language;
}

ts_parser_logger()

TSLogger ts_parser_logger

(

const TSParser *

self

)

Get the parser's current logger.

Definition at line 1775 of file parser.c.

                                                {
  return self->lexer.logger;
}

ts_parser_new()

TSParser* ts_parser_new

(

void

)

Create a new parser.

Definition at line 1704 of file parser.c.

                              {
  TSParser *self = ts_calloc(1, sizeof(TSParser));
  ts_lexer_init(&self->lexer);
  array_init(&self->reduce_actions);
  array_reserve(&self->reduce_actions, 4);
  self->tree_pool = ts_subtree_pool_new(32);
  self->stack = ts_stack_new(&self->tree_pool);
  self->finished_tree = NULL_SUBTREE;
  self->reusable_node = reusable_node_new();
  self->dot_graph_file = NULL;
  self->cancellation_flag = NULL;
  self->timeout_duration = 0;
  self->end_clock = clock_null();
  self->operation_count = 0;
  self->old_tree = NULL_SUBTREE;
  self->included_range_differences = (TSRangeArray) array_new();
  self->included_range_difference_index = 0;
  ts_parser__set_cached_token(self, 0, NULL_SUBTREE, NULL_SUBTREE);
  return self;
}

References array_init, array_new, array_reserve, clock_null(), NULL, NULL_SUBTREE, reusable_node_new(), ts_calloc, ts_lexer_init(), ts_parser__set_cached_token(), ts_stack_new(), and ts_subtree_pool_new().

Referenced by core_cmd_tsrzcmd(), guess_next_autocmplt_token(), rz_type_parse_string_declaration_single(), rz_type_parse_string_single(), ts_parser_new_wasm(), and type_parse_string().

ts_parser_parse()

TSTree* ts_parser_parse	(	TSParser *	self,
		const TSTree *	old_tree,
		TSInput	input
	)

Use the parser to parse some source code and create a syntax tree.

If you are parsing this document for the first time, pass NULL for the old_tree parameter. Otherwise, if you have already parsed an earlier version of this document and the document has since been edited, pass the previous syntax tree so that the unchanged parts of it can be reused. This will save time and memory. For this to work correctly, you must have already edited the old syntax tree using the ts_tree_edit function in a way that exactly matches the source code changes.

The TSInput parameter lets you specify how to read the text. It has the following three fields:

1. read: A function to retrieve a chunk of text at a given byte offset and (row, column) position. The function should return a pointer to the text and write its length to the bytes_read pointer. The parser does not take ownership of this buffer; it just borrows it until it has finished reading it. The function should write a zero value to the bytes_read pointer to indicate the end of the document.
2. payload: An arbitrary pointer that will be passed to each invocation of the read function.
3. encoding: An indication of how the text is encoded. Either TSInputEncodingUTF8 or TSInputEncodingUTF16.

This function returns a syntax tree on success, and NULL on failure. There are three possible reasons for failure:

1. The parser does not have a language assigned. Check for this using the ts_parser_language function.
2. Parsing was cancelled due to a timeout that was set by an earlier call to the ts_parser_set_timeout_micros function. You can resume parsing from where the parser left out by calling ts_parser_parse again with the same arguments. Or you can start parsing from scratch by first calling ts_parser_reset.
3. Parsing was cancelled using a cancellation flag that was set by an earlier call to ts_parser_set_cancellation_flag. You can resume parsing from where the parser left out by calling ts_parser_parse again with the same arguments.

Definition at line 1844 of file parser.c.

  {
  if (!self->language || !input.read) return NULL;
 
  ts_lexer_set_input(&self->lexer, input);
 
  array_clear(&self->included_range_differences);
  self->included_range_difference_index = 0;
 
  if (ts_parser_has_outstanding_parse(self)) {
    LOG("resume_parsing");
  } else if (old_tree) {
    ts_subtree_retain(old_tree->root);
    self->old_tree = old_tree->root;
    ts_range_array_get_changed_ranges(
      old_tree->included_ranges, old_tree->included_range_count,
      self->lexer.included_ranges, self->lexer.included_range_count,
      &self->included_range_differences
    );
    reusable_node_reset(&self->reusable_node, old_tree->root);
    LOG("parse_after_edit");
    LOG_TREE(self->old_tree);
    for (unsigned i = 0; i < self->included_range_differences.size; i++) {
      TSRange *range = &self->included_range_differences.contents[i];
      LOG("different_included_range %u - %u", range->start_byte, range->end_byte);
    }
  } else {
    reusable_node_clear(&self->reusable_node);
    LOG("new_parse");
  }
 
  self->operation_count = 0;
  if (self->timeout_duration) {
    self->end_clock = clock_after(clock_now(), self->timeout_duration);
  } else {
    self->end_clock = clock_null();
  }
 
  uint32_t position = 0, last_position = 0, version_count = 0;
  do {
    for (
      StackVersion version = 0;
      version_count = ts_stack_version_count(self->stack),
      version < version_count;
      version++
    ) {
      bool allow_node_reuse = version_count == 1;
      while (ts_stack_is_active(self->stack, version)) {
        LOG(
          "process version:%d, version_count:%u, state:%d, row:%u, col:%u",
          version,
          ts_stack_version_count(self->stack),
          ts_stack_state(self->stack, version),
          ts_stack_position(self->stack, version).extent.row,
          ts_stack_position(self->stack, version).extent.column
        );
 
        if (!ts_parser__advance(self, version, allow_node_reuse)) return NULL;
        LOG_STACK();
 
        position = ts_stack_position(self->stack, version).bytes;
        if (position > last_position || (version > 0 && position == last_position)) {
          last_position = position;
          break;
        }
      }
    }
 
    unsigned min_error_cost = ts_parser__condense_stack(self);
    if (self->finished_tree.ptr && ts_subtree_error_cost(self->finished_tree) < min_error_cost) {
      break;
    }
 
    while (self->included_range_difference_index < self->included_range_differences.size) {
      TSRange *range = &self->included_range_differences.contents[self->included_range_difference_index];
      if (range->end_byte <= position) {
        self->included_range_difference_index++;
      } else {
        break;
      }
    }
  } while (version_count != 0);
 
  ts_subtree_balance(self->finished_tree, &self->tree_pool, self->language);
  LOG("done");
  LOG_TREE(self->finished_tree);
 
  TSTree *result = ts_tree_new(
    self->finished_tree,
    self->language,
    self->lexer.included_ranges,
    self->lexer.included_range_count
  );
  self->finished_tree = NULL_SUBTREE;
  ts_parser_reset(self);
  return result;
}

References array_clear, Length::bytes, clock_after(), clock_now(), clock_null(), TSPoint::column, Length::extent, i, TSTree::included_range_count, TSTree::included_ranges, input(), LOG, LOG_STACK, LOG_TREE, NULL, NULL_SUBTREE, capstone::range, reusable_node_clear(), reusable_node_reset(), TSTree::root, TSPoint::row, ts_lexer_set_input(), ts_parser__advance(), ts_parser__condense_stack(), ts_parser_has_outstanding_parse(), ts_parser_reset(), ts_range_array_get_changed_ranges(), ts_stack_is_active(), ts_stack_position(), ts_stack_state(), ts_stack_version_count(), ts_subtree_balance(), ts_subtree_error_cost(), ts_subtree_retain(), and ts_tree_new().

Referenced by ts_parser_parse_string_encoding(), and ts_parser_parse_wasm().

ts_parser_parse_string()

TSTree* ts_parser_parse_string	(	TSParser *	self,
		const TSTree *	old_tree,
		const char *	string,
		uint32_t	length
	)

Use the parser to parse some source code stored in one contiguous buffer. The first two parameters are the same as in the ts_parser_parse function above. The second two parameters indicate the location of the buffer and its length in bytes.

Definition at line 1945 of file parser.c.

  {
  return ts_parser_parse_string_encoding(self, old_tree, string, length, TSInputEncodingUTF8);
}

References length, ts_parser_parse_string_encoding(), and TSInputEncodingUTF8.

Referenced by apply_edits(), core_cmd_tsrzcmd(), guess_next_autocmplt_token(), rz_type_parse_string_declaration_single(), rz_type_parse_string_single(), and type_parse_string().

ts_parser_parse_string_encoding()

TSTree* ts_parser_parse_string_encoding	(	TSParser *	self,
		const TSTree *	old_tree,
		const char *	string,
		uint32_t	length,
		TSInputEncoding	encoding
	)

Use the parser to parse some source code stored in one contiguous buffer with a given encoding. The first four parameters work the same as in the ts_parser_parse_string method above. The final parameter indicates whether the text is encoded as UTF8 or UTF16.

Definition at line 1954 of file parser.c.

  {
  TSStringInput input = {string, length};
  return ts_parser_parse(self, old_tree, (TSInput) {
    &input,
    ts_string_input_read,
    encoding,
  });
}

References cmd_descs_generate::encoding, input(), length, ts_parser_parse(), and ts_string_input_read().

Referenced by ts_parser_parse_string().

ts_parser_print_dot_graphs()

void ts_parser_print_dot_graphs	(	TSParser *	self,
		int	file
	)

Set the file descriptor to which the parser should write debugging graphs during parsing. The graphs are formatted in the DOT language. You may want to pipe these graphs directly to a dot(1) process in order to generate SVG output. You can turn off this logging by passing a negative number.

Definition at line 1783 of file parser.c.

                                                        {
  if (self->dot_graph_file) {
    fclose(self->dot_graph_file);
  }
 
  if (fd >= 0) {
    self->dot_graph_file = fdopen(fd, "a");
  } else {
    self->dot_graph_file = NULL;
  }
}

References fd, and NULL.

ts_parser_reset()

void ts_parser_reset

(

TSParser *

self

)

Instruct the parser to start the next parse from the beginning.

If the parser previously failed because of a timeout or a cancellation, then by default, it will resume where it left off on the next call to ts_parser_parse or other parsing functions. If you don't want to resume, and instead intend to use this parser to parse some other document, you must call ts_parser_reset first.

Definition at line 1823 of file parser.c.

                                     {
  if (self->language && self->language->external_scanner.deserialize) {
    self->language->external_scanner.deserialize(self->external_scanner_payload, NULL, 0);
  }
 
  if (self->old_tree.ptr) {
    ts_subtree_release(&self->tree_pool, self->old_tree);
    self->old_tree = NULL_SUBTREE;
  }
 
  reusable_node_clear(&self->reusable_node);
  ts_lexer_reset(&self->lexer, length_zero());
  ts_stack_clear(self->stack);
  ts_parser__set_cached_token(self, 0, NULL_SUBTREE, NULL_SUBTREE);
  if (self->finished_tree.ptr) {
    ts_subtree_release(&self->tree_pool, self->finished_tree);
    self->finished_tree = NULL_SUBTREE;
  }
  self->accept_count = 0;
}

References length_zero(), NULL, NULL_SUBTREE, reusable_node_clear(), ts_lexer_reset(), ts_parser__set_cached_token(), ts_stack_clear(), and ts_subtree_release().

Referenced by ts_parser_parse(), and ts_parser_set_language().

ts_parser_set_cancellation_flag()

void ts_parser_set_cancellation_flag	(	TSParser *	self,
		const size_t *	flag
	)

Set the parser's current cancellation flag pointer.

If a non-null pointer is assigned, then the parser will periodically read from this pointer during parsing. If it reads a non-zero value, it will halt early, returning NULL. See ts_parser_parse for more information.

Definition at line 1799 of file parser.c.

                                                                         {
  self->cancellation_flag = (const volatile size_t *)flag;
}

ts_parser_set_included_ranges()

bool ts_parser_set_included_ranges	(	TSParser *	self,
		const TSRange *	ranges,
		uint32_t	length
	)

Set the ranges of text that the parser should include when parsing.

By default, the parser will always include entire documents. This function allows you to parse only a portion of a document but still return a syntax tree whose ranges match up with the document as a whole. You can also pass multiple disjoint ranges.

The second and third parameters specify the location and length of an array of ranges. The parser does not take ownership of these ranges; it copies the data, so it doesn't matter how these ranges are allocated.

If length is zero, then the entire document will be parsed. Otherwise, the given ranges must be ordered from earliest to latest in the document, and they must not overlap. That is, the following must hold for all i < length - 1: ranges[i].end_byte <= ranges[i + 1].start_byte

If this requirement is not satisfied, the operation will fail, the ranges will not be assigned, and this function will return false. On success, this function returns true

Definition at line 1811 of file parser.c.

  {
  return ts_lexer_set_included_ranges(&self->lexer, ranges, count);
}

References count, and ts_lexer_set_included_ranges().

Referenced by ts_parser_parse_wasm().

ts_parser_set_language()

bool ts_parser_set_language	(	TSParser *	self,
		const TSLanguage *	language
	)

Set the language that the parser should use for parsing.

Returns a boolean indicating whether or not the language was successfully assigned. True means assignment succeeded. False means there was a version mismatch: the language was generated with an incompatible version of the Tree-sitter CLI. Check the language's version using ts_language_version and compare it to this library's TREE_SITTER_LANGUAGE_VERSION and TREE_SITTER_MIN_COMPATIBLE_LANGUAGE_VERSION constants.

Definition at line 1754 of file parser.c.

                                                                        {
  if (language) {
    if (language->version > TREE_SITTER_LANGUAGE_VERSION) return false;
    if (language->version < TREE_SITTER_MIN_COMPATIBLE_LANGUAGE_VERSION) return false;
  }
 
  if (self->external_scanner_payload && self->language->external_scanner.destroy) {
    self->language->external_scanner.destroy(self->external_scanner_payload);
  }
 
  if (language && language->external_scanner.create) {
    self->external_scanner_payload = language->external_scanner.create();
  } else {
    self->external_scanner_payload = NULL;
  }
 
  self->language = language;
  ts_parser_reset(self);
  return true;
}

References TSLanguage::create, TSLanguage::external_scanner, NULL, TREE_SITTER_LANGUAGE_VERSION, TREE_SITTER_MIN_COMPATIBLE_LANGUAGE_VERSION, ts_parser_reset(), and TSLanguage::version.

Referenced by core_cmd_tsrzcmd(), guess_next_autocmplt_token(), rz_type_parse_string_declaration_single(), rz_type_parse_string_single(), ts_parser_delete(), and type_parse_string().

ts_parser_set_logger()

void ts_parser_set_logger	(	TSParser *	self,
		TSLogger	logger
	)

Set the logger that a parser should use during parsing.

The parser does not take ownership over the logger payload. If a logger was previously assigned, the caller is responsible for releasing any memory owned by the previous logger.

Definition at line 1779 of file parser.c.

                                                           {
  self->lexer.logger = logger;
}

Referenced by ts_parser_enable_logger_wasm().

ts_parser_set_timeout_micros()

void ts_parser_set_timeout_micros	(	TSParser *	self,
		uint64_t	timeout
	)

Set the maximum duration in microseconds that parsing should be allowed to take before halting.

If parsing takes longer than this, it will halt early, returning NULL. See ts_parser_parse for more information.

Definition at line 1807 of file parser.c.

                                                                           {
  self->timeout_duration = duration_from_micros(timeout_micros);
}

References duration_from_micros().

ts_parser_timeout_micros()

uint64_t ts_parser_timeout_micros

(

const TSParser *

self

)

Get the duration in microseconds that parsing is allowed to take.

Definition at line 1803 of file parser.c.

                                                        {
  return duration_to_micros(self->timeout_duration);
}

References duration_to_micros().

ts_query_capture_count()

uint32_t ts_query_capture_count

(

const TSQuery *

self

)

Definition at line 2701 of file query.c.

                                                     {
  return self->captures.slices.size;
}

ts_query_capture_name_for_id()

const char* ts_query_capture_name_for_id	(	const TSQuery *	self,
		uint32_t	id,
		uint32_t *	length
	)

Get the name and length of one of the query's captures, or one of the query's string literals. Each capture and string is associated with a numeric id based on the order that it appeared in the query's source.

Definition at line 2709 of file query.c.

  {
  return symbol_table_name_for_id(&self->captures, index, length);
}

References length, and symbol_table_name_for_id().

ts_query_capture_quantifier_for_id()

TSQuantifier ts_query_capture_quantifier_for_id	(	const TSQuery *	self,
		uint32_t	pattern_id,
		uint32_t	capture_id
	)

Get the quantifier of the query's captures. Each capture is * associated with a numeric id based on the order that it appeared in the query's source.

Definition at line 2717 of file query.c.

  {
  CaptureQuantifiers *capture_quantifiers = array_get(&self->capture_quantifiers, pattern_index);
  return capture_quantifier_for_id(capture_quantifiers, capture_index);
}

References array_get, and capture_quantifier_for_id().

ts_query_cursor_delete()

void ts_query_cursor_delete

(

TSQueryCursor *

self

)

Delete a query cursor, freeing all of the memory that it used.

Definition at line 2839 of file query.c.

                                                 {
  array_delete(&self->states);
  array_delete(&self->finished_states);
  ts_tree_cursor_delete(&self->cursor);
  capture_list_pool_delete(&self->capture_list_pool);
  ts_free(self);
}

References array_delete, capture_list_pool_delete(), ts_free, and ts_tree_cursor_delete().

ts_query_cursor_did_exceed_match_limit()

bool ts_query_cursor_did_exceed_match_limit

(

const TSQueryCursor *

self

)

Manage the maximum number of in-progress matches allowed by this query cursor.

Query cursors have an optional maximum capacity for storing lists of in-progress captures. If this capacity is exceeded, then the earliest-starting match will silently be dropped to make room for further matches. This maximum capacity is optional — by default, query cursors allow any number of pending matches, dynamically allocating new space for them as needed as the query is executed.

Definition at line 2847 of file query.c.

                                                                       {
  return self->did_exceed_match_limit;
}

Referenced by ts_query_captures_wasm(), and ts_query_matches_wasm().

ts_query_cursor_exec()

void ts_query_cursor_exec	(	TSQueryCursor *	self,
		const TSQuery *	query,
		TSNode	node
	)

Start running a given query on a given node.

Definition at line 2859 of file query.c.

  {
  array_clear(&self->states);
  array_clear(&self->finished_states);
  ts_tree_cursor_reset(&self->cursor, node);
  capture_list_pool_reset(&self->capture_list_pool);
  self->next_state_id = 0;
  self->depth = 0;
  self->ascending = false;
  self->halted = false;
  self->query = query;
  self->did_exceed_match_limit = false;
}

References array_clear, capture_list_pool_reset(), and ts_tree_cursor_reset().

Referenced by ts_query_captures_wasm(), and ts_query_matches_wasm().

ts_query_cursor_match_limit()

uint32_t ts_query_cursor_match_limit

(

const TSQueryCursor *

self

)

Definition at line 2851 of file query.c.

                                                                {
  return self->capture_list_pool.max_capture_list_count;
}

ts_query_cursor_new()

TSQueryCursor* ts_query_cursor_new

(

void

)

Create a new cursor for executing a given query.

The cursor stores the state that is needed to iteratively search for matches. To use the query cursor, first call ts_query_cursor_exec to start running a given query on a given syntax node. Then, there are two options for consuming the results of the query:

1. Repeatedly call ts_query_cursor_next_match to iterate over all of the matches in the order that they were found. Each match contains the index of the pattern that matched, and an array of captures. Because multiple patterns can match the same set of nodes, one match may contain captures that appear before some of the captures from a previous match.
2. Repeatedly call ts_query_cursor_next_capture to iterate over all of the individual captures in the order that they appear. This is useful if don't care about which pattern matched, and just want a single ordered sequence of captures.

If you don't care about consuming all of the results, you can stop calling ts_query_cursor_next_match or ts_query_cursor_next_capture at any point. You can then start executing another query on another node by calling ts_query_cursor_exec again.

Definition at line 2820 of file query.c.

                                         {
  TSQueryCursor *self = ts_malloc(sizeof(TSQueryCursor));
  *self = (TSQueryCursor) {
    .did_exceed_match_limit = false,
    .ascending = false,
    .halted = false,
    .states = array_new(),
    .finished_states = array_new(),
    .capture_list_pool = capture_list_pool_new(),
    .start_byte = 0,
    .end_byte = UINT32_MAX,
    .start_point = {0, 0},
    .end_point = POINT_MAX,
  };
  array_reserve(&self->states, 8);
  array_reserve(&self->finished_states, 8);
  return self;
}

References array_new, array_reserve, capture_list_pool_new(), POINT_MAX, ts_malloc, and UINT32_MAX.

Referenced by ts_query_captures_wasm(), and ts_query_matches_wasm().

ts_query_cursor_next_capture()

bool ts_query_cursor_next_capture	(	TSQueryCursor *	self,
		TSQueryMatch *	match,
		uint32_t *	capture_index
	)

Advance to the next capture of the currently running query.

If there is a capture, write its match to *match and its index within the matche's capture list to *capture_index. Otherwise, return false.

Definition at line 3746 of file query.c.

  {
  // The goal here is to return captures in order, even though they may not
  // be discovered in order, because patterns can overlap. Search for matches
  // until there is a finished capture that is before any unfinished capture.
  for (;;) {
    // First, find the earliest capture in an unfinished match.
    uint32_t first_unfinished_capture_byte;
    uint32_t first_unfinished_pattern_index;
    uint32_t first_unfinished_state_index;
    bool first_unfinished_state_is_definite = false;
    ts_query_cursor__first_in_progress_capture(
      self,
      &first_unfinished_state_index,
      &first_unfinished_capture_byte,
      &first_unfinished_pattern_index,
      &first_unfinished_state_is_definite
    );
 
    // Then find the earliest capture in a finished match. It must occur
    // before the first capture in an *unfinished* match.
    QueryState *first_finished_state = NULL;
    uint32_t first_finished_capture_byte = first_unfinished_capture_byte;
    uint32_t first_finished_pattern_index = first_unfinished_pattern_index;
    for (unsigned i = 0; i < self->finished_states.size;) {
      QueryState *state = &self->finished_states.contents[i];
      const CaptureList *captures = capture_list_pool_get(
        &self->capture_list_pool,
        state->capture_list_id
      );
 
      // Remove states whose captures are all consumed.
      if (state->consumed_capture_count >= captures->size) {
        capture_list_pool_release(
          &self->capture_list_pool,
          state->capture_list_id
        );
        array_erase(&self->finished_states, i);
        continue;
      }
 
      // Skip captures that precede the cursor's start byte.
      TSNode node = captures->contents[state->consumed_capture_count].node;
      if (ts_node_end_byte(node) <= self->start_byte) {
        state->consumed_capture_count++;
        continue;
      }
 
      uint32_t node_start_byte = ts_node_start_byte(node);
      if (
        node_start_byte < first_finished_capture_byte ||
        (
          node_start_byte == first_finished_capture_byte &&
          state->pattern_index < first_finished_pattern_index
        )
      ) {
        first_finished_state = state;
        first_finished_capture_byte = node_start_byte;
        first_finished_pattern_index = state->pattern_index;
      }
      i++;
    }
 
    // If there is finished capture that is clearly before any unfinished
    // capture, then return its match, and its capture index. Internally
    // record the fact that the capture has been 'consumed'.
    QueryState *state;
    if (first_finished_state) {
      state = first_finished_state;
    } else if (first_unfinished_state_is_definite) {
      state = &self->states.contents[first_unfinished_state_index];
    } else {
      state = NULL;
    }
 
    if (state) {
      if (state->id == UINT32_MAX) state->id = self->next_state_id++;
      match->id = state->id;
      match->pattern_index = state->pattern_index;
      const CaptureList *captures = capture_list_pool_get(
        &self->capture_list_pool,
        state->capture_list_id
      );
      match->captures = captures->contents;
      match->capture_count = captures->size;
      *capture_index = state->consumed_capture_count;
      state->consumed_capture_count++;
      return true;
    }
 
    if (capture_list_pool_is_empty(&self->capture_list_pool)) {
      LOG(
        "  abandon state. index:%u, pattern:%u, offset:%u.\n",
        first_unfinished_state_index,
        first_unfinished_pattern_index,
        first_unfinished_capture_byte
      );
      capture_list_pool_release(
        &self->capture_list_pool,
        self->states.contents[first_unfinished_state_index].capture_list_id
      );
      array_erase(&self->states, first_unfinished_state_index);
    }
 
    // If there are no finished matches that are ready to be returned, then
    // continue finding more matches.
    if (
      !ts_query_cursor__advance(self, true) &&
      self->finished_states.size == 0
    ) return false;
  }
}

References array_erase, capture_list_pool_get(), capture_list_pool_is_empty(), capture_list_pool_release(), i, LOG, NULL, ts_node_end_byte(), ts_node_start_byte(), ts_query_cursor__advance(), ts_query_cursor__first_in_progress_capture(), and UINT32_MAX.

Referenced by ts_query_captures_wasm().

ts_query_cursor_next_match()

bool ts_query_cursor_next_match	(	TSQueryCursor *	self,
		TSQueryMatch *	match
	)

Advance to the next match of the currently running query.

If there is a match, write it to *match and return true. Otherwise, return false.

Definition at line 3690 of file query.c.

  {
  if (self->finished_states.size == 0) {
    if (!ts_query_cursor__advance(self, false)) {
      return false;
    }
  }
 
  QueryState *state = &self->finished_states.contents[0];
  if (state->id == UINT32_MAX) state->id = self->next_state_id++;
  match->id = state->id;
  match->pattern_index = state->pattern_index;
  const CaptureList *captures = capture_list_pool_get(
    &self->capture_list_pool,
    state->capture_list_id
  );
  match->captures = captures->contents;
  match->capture_count = captures->size;
  capture_list_pool_release(&self->capture_list_pool, state->capture_list_id);
  array_erase(&self->finished_states, 0);
  return true;
}

References array_erase, capture_list_pool_get(), capture_list_pool_release(), ts_query_cursor__advance(), and UINT32_MAX.

Referenced by ts_query_matches_wasm().

ts_query_cursor_remove_match()

void ts_query_cursor_remove_match	(	TSQueryCursor *	self,
		uint32_t	id
	)

Definition at line 3715 of file query.c.

  {
  for (unsigned i = 0; i < self->finished_states.size; i++) {
    const QueryState *state = &self->finished_states.contents[i];
    if (state->id == match_id) {
      capture_list_pool_release(
        &self->capture_list_pool,
        state->capture_list_id
      );
      array_erase(&self->finished_states, i);
      return;
    }
  }
 
  // Remove unfinished query states as well to prevent future
  // captures for a match being removed.
  for (unsigned i = 0; i < self->states.size; i++) {
    const QueryState *state = &self->states.contents[i];
    if (state->id == match_id) {
      capture_list_pool_release(
        &self->capture_list_pool,
        state->capture_list_id
      );
      array_erase(&self->states, i);
      return;
    }
  }
}

References array_erase, capture_list_pool_release(), and i.

ts_query_cursor_set_byte_range()

void ts_query_cursor_set_byte_range	(	TSQueryCursor *	self,
		uint32_t	start_byte,
		uint32_t	end_byte
	)

Set the range of bytes or (row, column) positions in which the query will be executed.

Definition at line 2876 of file query.c.

  {
  if (end_byte == 0) {
    end_byte = UINT32_MAX;
  }
  self->start_byte = start_byte;
  self->end_byte = end_byte;
}

References UINT32_MAX.

ts_query_cursor_set_match_limit()

void ts_query_cursor_set_match_limit	(	TSQueryCursor *	self,
		uint32_t	limit
	)

Definition at line 2855 of file query.c.

                                                                          {
  self->capture_list_pool.max_capture_list_count = limit;
}

References limit.

Referenced by ts_query_captures_wasm(), and ts_query_matches_wasm().

ts_query_cursor_set_point_range()

void ts_query_cursor_set_point_range	(	TSQueryCursor *	self,
		TSPoint	start_point,
		TSPoint	end_point
	)

Definition at line 2888 of file query.c.

  {
  if (end_point.row == 0 && end_point.column == 0) {
    end_point = POINT_MAX;
  }
  self->start_point = start_point;
  self->end_point = end_point;
}

References TSPoint::column, POINT_MAX, and TSPoint::row.

Referenced by ts_query_captures_wasm(), and ts_query_matches_wasm().

ts_query_delete()

void ts_query_delete

(

TSQuery *

self

)

Delete a query, freeing all of the memory that it used.

Definition at line 2677 of file query.c.

                                    {
  if (self) {
    array_delete(&self->steps);
    array_delete(&self->pattern_map);
    array_delete(&self->predicate_steps);
    array_delete(&self->patterns);
    array_delete(&self->step_offsets);
    array_delete(&self->string_buffer);
    array_delete(&self->negated_fields);
    symbol_table_delete(&self->captures);
    symbol_table_delete(&self->predicate_values);
    for (uint32_t index = 0; index < self->capture_quantifiers.size; index++) {
      CaptureQuantifiers *capture_quantifiers = array_get(&self->capture_quantifiers, index);
      capture_quantifiers_delete(capture_quantifiers);
    }
    array_delete(&self->capture_quantifiers);
    ts_free(self);
  }
}

References array_delete, array_get, capture_quantifiers_delete(), symbol_table_delete(), and ts_free.

Referenced by ts_query_new().

ts_query_disable_capture()

void ts_query_disable_capture	(	TSQuery *	self,
		const char *	name,
		uint32_t	length
	)

Disable a certain capture within a query.

This prevents the capture from being returned in matches, and also avoids any resource usage associated with recording the capture. Currently, there is no way to undo this.

Definition at line 2785 of file query.c.

  {
  // Remove capture information for any pattern step that previously
  // captured with the given name.
  int id = symbol_table_id_for_name(&self->captures, name, length);
  if (id != -1) {
    for (unsigned i = 0; i < self->steps.size; i++) {
      QueryStep *step = &self->steps.contents[i];
      query_step__remove_capture(step, id);
    }
  }
}

References i, length, query_step__remove_capture(), step(), and symbol_table_id_for_name().

ts_query_disable_pattern()

void ts_query_disable_pattern	(	TSQuery *	self,
		uint32_t	pattern_index
	)

Disable a certain pattern within a query.

This prevents the pattern from matching and removes most of the overhead associated with the pattern. Currently, there is no way to undo this.

Definition at line 2801 of file query.c.

  {
  // Remove the given pattern from the pattern map. Its steps will still
  // be in the `steps` array, but they will never be read.
  for (unsigned i = 0; i < self->pattern_map.size; i++) {
    PatternEntry *pattern = &self->pattern_map.contents[i];
    if (pattern->pattern_index == pattern_index) {
      array_erase(&self->pattern_map, i);
      i--;
    }
  }
}

References array_erase, i, and PatternEntry.

ts_query_is_pattern_guaranteed_at_step()

bool ts_query_is_pattern_guaranteed_at_step	(	const TSQuery *	self,
		uint32_t	byte_offset
	)

Definition at line 2754 of file query.c.

  {
  uint32_t step_index = UINT32_MAX;
  for (unsigned i = 0; i < self->step_offsets.size; i++) {
    StepOffset *step_offset = &self->step_offsets.contents[i];
    if (step_offset->byte_offset > byte_offset) break;
    step_index = step_offset->step_index;
  }
  if (step_index < self->steps.size) {
    return self->steps.contents[step_index].root_pattern_guaranteed;
  } else {
    return false;
  }
}

References StepOffset::byte_offset, i, StepOffset::step_index, and UINT32_MAX.

ts_query_new()

TSQuery* ts_query_new	(	const TSLanguage *	language,
		const char *	source,
		uint32_t	source_len,
		uint32_t *	error_offset,
		TSQueryError *	error_type
	)

Create a new query from a string containing one or more S-expression patterns. The query is associated with a particular language, and can only be run on syntax nodes parsed with that language.

If all of the given patterns are valid, this returns a TSQuery. If a pattern is invalid, this returns NULL, and provides two pieces of information about the problem:

1. The byte offset of the error is written to the error_offset parameter.
2. The type of error is written to the error_type parameter.

Definition at line 2546 of file query.c.

  {
  if (
    !language ||
    language->version > TREE_SITTER_LANGUAGE_VERSION ||
    language->version < TREE_SITTER_MIN_COMPATIBLE_LANGUAGE_VERSION
  ) {
    *error_type = TSQueryErrorLanguage;
    return NULL;
  }
 
  TSQuery *self = ts_malloc(sizeof(TSQuery));
  *self = (TSQuery) {
    .steps = array_new(),
    .pattern_map = array_new(),
    .captures = symbol_table_new(),
    .capture_quantifiers = array_new(),
    .predicate_values = symbol_table_new(),
    .predicate_steps = array_new(),
    .patterns = array_new(),
    .step_offsets = array_new(),
    .string_buffer = array_new(),
    .negated_fields = array_new(),
    .wildcard_root_pattern_count = 0,
    .language = language,
  };
 
  array_push(&self->negated_fields, 0);
 
  // Parse all of the S-expressions in the given string.
  Stream stream = stream_new(source, source_len);
  stream_skip_whitespace(&stream);
  while (stream.input < stream.end) {
    uint32_t pattern_index = self->patterns.size;
    uint32_t start_step_index = self->steps.size;
    uint32_t start_predicate_step_index = self->predicate_steps.size;
    array_push(&self->patterns, ((QueryPattern) {
      .steps = (Slice) {.offset = start_step_index},
      .predicate_steps = (Slice) {.offset = start_predicate_step_index},
      .start_byte = stream_offset(&stream),
    }));
    CaptureQuantifiers capture_quantifiers = capture_quantifiers_new();
    *error_type = ts_query__parse_pattern(self, &stream, 0, false, &capture_quantifiers);
    array_push(&self->steps, query_step__new(0, PATTERN_DONE_MARKER, false));
 
    QueryPattern *pattern = array_back(&self->patterns);
    pattern->steps.length = self->steps.size - start_step_index;
    pattern->predicate_steps.length = self->predicate_steps.size - start_predicate_step_index;
 
    // If any pattern could not be parsed, then report the error information
    // and terminate.
    if (*error_type) {
      if (*error_type == PARENT_DONE) *error_type = TSQueryErrorSyntax;
      *error_offset = stream_offset(&stream);
      capture_quantifiers_delete(&capture_quantifiers);
      ts_query_delete(self);
      return NULL;
    }
 
    // Maintain a list of capture quantifiers for each pattern
    array_push(&self->capture_quantifiers, capture_quantifiers);
 
    // Maintain a map that can look up patterns for a given root symbol.
    uint16_t wildcard_root_alternative_index = NONE;
    for (;;) {
      QueryStep *step = &self->steps.contents[start_step_index];
 
      // If a pattern has a wildcard at its root, but it has a non-wildcard child,
      // then optimize the matching process by skipping matching the wildcard.
      // Later, during the matching process, the query cursor will check that
      // there is a parent node, and capture it if necessary.
      if (step->symbol == WILDCARD_SYMBOL && step->depth == 0 && !step->field) {
        QueryStep *second_step = &self->steps.contents[start_step_index + 1];
        if (second_step->symbol != WILDCARD_SYMBOL && second_step->depth == 1) {
          wildcard_root_alternative_index = step->alternative_index;
          start_step_index += 1;
          step = second_step;
        }
      }
 
      // Determine whether the pattern has a single root node. This affects
      // decisions about whether or not to start matching the pattern when
      // a query cursor has a range restriction.
      bool is_rooted = true;
      uint32_t start_depth = step->depth;
      for (uint32_t step_index = start_step_index + 1; step_index < self->steps.size; step_index++) {
        QueryStep *step = &self->steps.contents[step_index];
        if (step->depth == start_depth) {
          is_rooted = false;
          break;
        }
      }
 
      ts_query__pattern_map_insert(self, step->symbol, (PatternEntry) {
        .step_index = start_step_index,
        .pattern_index = pattern_index,
        .is_rooted = is_rooted
      });
      if (step->symbol == WILDCARD_SYMBOL) {
        self->wildcard_root_pattern_count++;
      }
 
      // If there are alternatives or options at the root of the pattern,
      // then add multiple entries to the pattern map.
      if (step->alternative_index != NONE) {
        start_step_index = step->alternative_index;
        step->alternative_index = NONE;
      } else if (wildcard_root_alternative_index != NONE) {
        start_step_index = wildcard_root_alternative_index;
        wildcard_root_alternative_index = NONE;
      } else {
        break;
      }
    }
  }
 
  if (!ts_query__analyze_patterns(self, error_offset)) {
    *error_type = TSQueryErrorStructure;
    ts_query_delete(self);
    return NULL;
  }
 
  array_delete(&self->string_buffer);
  return self;
}

References array_back, array_new, array_push, capture_quantifiers_delete(), capture_quantifiers_new(), QueryStep::depth, Slice::length, NONE, NULL, PARENT_DONE, PATTERN_DONE_MARKER, PatternEntry, QueryPattern::predicate_steps, query_step__new(), source, step(), QueryPattern::steps, stream_new(), stream_offset(), stream_skip_whitespace(), QueryStep::symbol, symbol_table_new(), TREE_SITTER_LANGUAGE_VERSION, TREE_SITTER_MIN_COMPATIBLE_LANGUAGE_VERSION, ts_malloc, ts_query__parse_pattern(), ts_query__pattern_map_insert(), ts_query_delete(), TSQueryErrorLanguage, TSQueryErrorSyntax, TSLanguage::version, and WILDCARD_SYMBOL.

ts_query_pattern_count()

uint32_t ts_query_pattern_count

(

const TSQuery *

self

)

Get the number of patterns, captures, or string literals in the query.

Definition at line 2697 of file query.c.

                                                     {
  return self->patterns.size;
}

ts_query_predicates_for_pattern()

const TSQueryPredicateStep* ts_query_predicates_for_pattern	(	const TSQuery *	self,
		uint32_t	pattern_index,
		uint32_t *	length
	)

Get all of the predicates for the given pattern in the query.

The predicates are represented as a single array of steps. There are three types of steps in this array, which correspond to the three legal values for the type field:

• TSQueryPredicateStepTypeCapture - Steps with this type represent names of captures. Their value_id can be used with the ts_query_capture_name_for_id function to obtain the name of the capture.
• TSQueryPredicateStepTypeString - Steps with this type represent literal strings. Their value_id can be used with the ts_query_string_value_for_id function to obtain their string value.
• TSQueryPredicateStepTypeDone - Steps with this type are sentinels that represent the end of an individual predicate. If a pattern has two predicates, then there will be two steps with this type in the array.

Definition at line 2734 of file query.c.

  {
  Slice slice = self->patterns.contents[pattern_index].predicate_steps;
  *step_count = slice.length;
  if (self->predicate_steps.contents == NULL) {
    return NULL;
  }
  return &self->predicate_steps.contents[slice.offset];
}

References Slice::length, NULL, and Slice::offset.

ts_query_start_byte_for_pattern()

uint32_t ts_query_start_byte_for_pattern	(	const TSQuery *	self,
		uint32_t	pattern_index
	)

Get the byte offset where the given pattern starts in the query's source.

This can be useful when combining queries by concatenating their source code strings.

Definition at line 2747 of file query.c.

  {
  return self->patterns.contents[pattern_index].start_byte;
}

ts_query_string_count()

uint32_t ts_query_string_count

(

const TSQuery *

self

)

Definition at line 2705 of file query.c.

                                                    {
  return self->predicate_values.slices.size;
}

ts_query_string_value_for_id()

const char* ts_query_string_value_for_id	(	const TSQuery *	self,
		uint32_t	id,
		uint32_t *	length
	)

Definition at line 2726 of file query.c.

  {
  return symbol_table_name_for_id(&self->predicate_values, index, length);
}

References length, and symbol_table_name_for_id().

ts_set_allocator()

void ts_set_allocator	(	void *(*)(size_t)	new_malloc,
		void *(*)(size_t, size_t)	new_calloc,
		void *(*)(void *, size_t)	new_realloc,
		void(*)(void *)	new_free
	)

Set the allocation functions used by the library.

By default, Tree-sitter uses the standard libc allocation functions, but aborts the process when an allocation fails. This function lets you supply alternative allocation functions at runtime.

If you pass NULL for any parameter, Tree-sitter will switch back to its default implementation of that function.

If you call this function after the library has already been used, then you must ensure that either:

1. All the existing objects have been freed.
2. The new allocator shares its state with the old one, so it is capable of freeing memory that was allocated by the old allocator.

Definition at line 37 of file alloc.c.

  {
  ts_current_malloc = new_malloc ? new_malloc : ts_malloc_default;
  ts_current_calloc = new_calloc ? new_calloc : ts_calloc_default;
  ts_current_realloc = new_realloc ? new_realloc : ts_realloc_default;
  ts_current_free = new_free ? new_free : free;
}

References free(), ts_calloc_default(), ts_current_calloc, ts_current_free, ts_current_malloc, ts_current_realloc, ts_malloc_default(), and ts_realloc_default().

ts_tree_copy()

TSTree* ts_tree_copy

(

const TSTree *

self

)

Create a shallow copy of the syntax tree. This is very fast.

You need to copy a syntax tree in order to use it on more than one thread at a time, as syntax trees are not thread safe.

Definition at line 21 of file tree.c.

                                         {
  ts_subtree_retain(self->root);
  return ts_tree_new(self->root, self->language, self->included_ranges, self->included_range_count);
}

References ts_subtree_retain(), and ts_tree_new().

ts_tree_cursor_copy()

TSTreeCursor ts_tree_cursor_copy

(

const TSTreeCursor *

_cursor

)

Definition at line 479 of file tree_cursor.c.

                                                              {
  const TreeCursor *cursor = (const TreeCursor *)_cursor;
  TSTreeCursor res = {NULL, NULL, {0, 0}};
  TreeCursor *copy = (TreeCursor *)&res;
  copy->tree = cursor->tree;
  array_init(&copy->stack);
  array_push_all(&copy->stack, &cursor->stack);
  return res;
}

References array_init, array_push_all, NULL, and TreeCursor::tree.

ts_tree_cursor_current_field_id()

TSFieldId ts_tree_cursor_current_field_id

(

const TSTreeCursor *

_self

)

Get the field id of the tree cursor's current node.

This returns zero if the current node doesn't have a field. See also ts_node_child_by_field_id, ts_language_field_id_for_name.

Definition at line 431 of file tree_cursor.c.

                                                                     {
  const TreeCursor *self = (const TreeCursor *)_self;
 
  // Walk up the tree, visiting the current node and its invisible ancestors.
  for (unsigned i = self->stack.size - 1; i > 0; i--) {
    TreeCursorEntry *entry = &self->stack.contents[i];
    TreeCursorEntry *parent_entry = &self->stack.contents[i - 1];
 
    // Stop walking up when another visible node is found.
    if (i != self->stack.size - 1) {
      if (ts_subtree_visible(*entry->subtree)) break;
      if (
        !ts_subtree_extra(*entry->subtree) &&
        ts_language_alias_at(
          self->tree->language,
          parent_entry->subtree->ptr->production_id,
          entry->structural_child_index
        )
      ) break;
    }
 
    if (ts_subtree_extra(*entry->subtree)) break;
 
    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
    );
    for (const TSFieldMapEntry *i = field_map; i < field_map_end; i++) {
      if (!i->inherited && i->child_index == entry->structural_child_index) {
        return i->field_id;
      }
    }
  }
  return 0;
}

References i, SubtreeHeapData::production_id, Subtree::ptr, TreeCursorEntry::subtree, ts_language_alias_at(), ts_language_field_map(), ts_subtree_extra(), and ts_subtree_visible().

Referenced by ts_tree_cursor_current_field_id_wasm(), and ts_tree_cursor_current_field_name().

ts_tree_cursor_current_field_name()

const char* ts_tree_cursor_current_field_name

(

const TSTreeCursor *

_self

)

Get the field name of the tree cursor's current node.

This returns NULL if the current node doesn't have a field. See also ts_node_child_by_field_name.

Definition at line 469 of file tree_cursor.c.

                                                                         {
  TSFieldId id = ts_tree_cursor_current_field_id(_self);
  if (id) {
    const TreeCursor *self = (const TreeCursor *)_self;
    return self->tree->language->field_names[id];
  } else {
    return NULL;
  }
}

References id, NULL, TSTreeCursor::tree, and ts_tree_cursor_current_field_id().

ts_tree_cursor_current_node()

TSNode ts_tree_cursor_current_node

(

const TSTreeCursor *

_self

)

Get the tree cursor's current node.

Definition at line 262 of file tree_cursor.c.

                                                              {
  const TreeCursor *self = (const TreeCursor *)_self;
  TreeCursorEntry *last_entry = array_back(&self->stack);
  TSSymbol alias_symbol = 0;
  if (self->stack.size > 1 && !ts_subtree_extra(*last_entry->subtree)) {
    TreeCursorEntry *parent_entry = &self->stack.contents[self->stack.size - 2];
    alias_symbol = ts_language_alias_at(
      self->tree->language,
      parent_entry->subtree->ptr->production_id,
      last_entry->structural_child_index
    );
  }
  return ts_node_new(
    self->tree,
    last_entry->subtree,
    last_entry->position,
    alias_symbol
  );
}

References array_back, TreeCursorEntry::position, SubtreeHeapData::production_id, Subtree::ptr, TreeCursorEntry::structural_child_index, TreeCursorEntry::subtree, ts_language_alias_at(), ts_node_new(), and ts_subtree_extra().

Referenced by ts_node_children_wasm(), ts_node_descendants_of_type_wasm(), ts_node_named_children_wasm(), ts_query_cursor__advance(), ts_tree_cursor_current_node_id_wasm(), ts_tree_cursor_current_node_is_missing_wasm(), ts_tree_cursor_current_node_is_named_wasm(), ts_tree_cursor_current_node_type_id_wasm(), ts_tree_cursor_current_node_wasm(), ts_tree_cursor_end_index_wasm(), ts_tree_cursor_end_position_wasm(), ts_tree_cursor_start_index_wasm(), and ts_tree_cursor_start_position_wasm().

ts_tree_cursor_delete()

void ts_tree_cursor_delete

(

TSTreeCursor *

_self

)

Delete a tree cursor, freeing all of the memory that it used.

Definition at line 94 of file tree_cursor.c.

                                                {
  TreeCursor *self = (TreeCursor *)_self;
  array_delete(&self->stack);
}

References array_delete.

Referenced by ts_query_cursor_delete(), and ts_tree_cursor_delete_wasm().

ts_tree_cursor_goto_first_child()

bool ts_tree_cursor_goto_first_child

(

TSTreeCursor *

_self

)

Move the cursor to the first child of its current node.

This returns true if the cursor successfully moved, and returns false if there were no children.

Definition at line 101 of file tree_cursor.c.

                                                          {
  TreeCursor *self = (TreeCursor *)_self;
 
  bool did_descend;
  do {
    did_descend = false;
 
    bool visible;
    TreeCursorEntry entry;
    CursorChildIterator iterator = ts_tree_cursor_iterate_children(self);
    while (ts_tree_cursor_child_iterator_next(&iterator, &entry, &visible)) {
      if (visible) {
        array_push(&self->stack, entry);
        return true;
      }
 
      if (ts_subtree_visible_child_count(*entry.subtree) > 0) {
        array_push(&self->stack, entry);
        did_descend = true;
        break;
      }
    }
  } while (did_descend);
 
  return false;
}

References array_push, ts_subtree_visible_child_count(), ts_tree_cursor_child_iterator_next(), and ts_tree_cursor_iterate_children().

Referenced by ts_node_children_wasm(), ts_node_descendants_of_type_wasm(), ts_node_named_children_wasm(), ts_query_cursor__advance(), ts_tree_cursor_goto_first_child_wasm(), and ts_tree_cursor_goto_next_sibling().

ts_tree_cursor_goto_first_child_for_byte()

int64_t ts_tree_cursor_goto_first_child_for_byte	(	TSTreeCursor *	_self,
		uint32_t	goal_byte
	)

Move the cursor to the first child of its current node that extends beyond the given byte offset or point.

This returns the index of the child node if one was found, and returns -1 if no such child was found.

Definition at line 128 of file tree_cursor.c.

                                                                                          {
  TreeCursor *self = (TreeCursor *)_self;
  uint32_t initial_size = self->stack.size;
  uint32_t visible_child_index = 0;
 
  bool did_descend;
  do {
    did_descend = false;
 
    bool visible;
    TreeCursorEntry entry;
    CursorChildIterator iterator = ts_tree_cursor_iterate_children(self);
    while (ts_tree_cursor_child_iterator_next(&iterator, &entry, &visible)) {
      uint32_t end_byte = entry.position.bytes + ts_subtree_size(*entry.subtree).bytes;
      bool at_goal = end_byte >= goal_byte;
      uint32_t visible_child_count = ts_subtree_visible_child_count(*entry.subtree);
 
      if (at_goal) {
        if (visible) {
          array_push(&self->stack, entry);
          return visible_child_index;
        }
 
        if (visible_child_count > 0) {
          array_push(&self->stack, entry);
          did_descend = true;
          break;
        }
      } else if (visible) {
        visible_child_index++;
      } else {
        visible_child_index += visible_child_count;
      }
    }
  } while (did_descend);
 
  self->stack.size = initial_size;
  return -1;
}

References array_push, Length::bytes, ts_subtree_size(), ts_subtree_visible_child_count(), ts_tree_cursor_child_iterator_next(), and ts_tree_cursor_iterate_children().

ts_tree_cursor_goto_first_child_for_point()

int64_t ts_tree_cursor_goto_first_child_for_point	(	TSTreeCursor *	_self,
		TSPoint	goal_point
	)

Definition at line 168 of file tree_cursor.c.

                                                                                           {
  TreeCursor *self = (TreeCursor *)_self;
  uint32_t initial_size = self->stack.size;
  uint32_t visible_child_index = 0;
 
  bool did_descend;
  do {
    did_descend = false;
 
    bool visible;
    TreeCursorEntry entry;
    CursorChildIterator iterator = ts_tree_cursor_iterate_children(self);
    while (ts_tree_cursor_child_iterator_next(&iterator, &entry, &visible)) {
      TSPoint end_point = point_add(entry.position.extent, ts_subtree_size(*entry.subtree).extent);
      bool at_goal = point_gte(end_point, goal_point);
      uint32_t visible_child_count = ts_subtree_visible_child_count(*entry.subtree);
      if (at_goal) {
        if (visible) {
          array_push(&self->stack, entry);
          return visible_child_index;
        }
        if (visible_child_count > 0) {
          array_push(&self->stack, entry);
          did_descend = true;
          break;
        }
      } else if (visible) {
        visible_child_index++;
      } else {
        visible_child_index += visible_child_count;
      }
    }
  } while (did_descend);
 
  self->stack.size = initial_size;
  return -1;
}

References array_push, Length::extent, point_add(), point_gte(), ts_subtree_size(), ts_subtree_visible_child_count(), ts_tree_cursor_child_iterator_next(), and ts_tree_cursor_iterate_children().

ts_tree_cursor_goto_next_sibling()

bool ts_tree_cursor_goto_next_sibling

(

TSTreeCursor *

_self

)

Move the cursor to the next sibling of its current node.

This returns true if the cursor successfully moved, and returns false if there was no next sibling node.

Definition at line 206 of file tree_cursor.c.

                                                           {
  TreeCursor *self = (TreeCursor *)_self;
  uint32_t initial_size = self->stack.size;
 
  while (self->stack.size > 1) {
    TreeCursorEntry entry = array_pop(&self->stack);
    CursorChildIterator iterator = ts_tree_cursor_iterate_children(self);
    iterator.child_index = entry.child_index;
    iterator.structural_child_index = entry.structural_child_index;
    iterator.position = entry.position;
 
    bool visible = false;
    ts_tree_cursor_child_iterator_next(&iterator, &entry, &visible);
    if (visible && self->stack.size + 1 < initial_size) break;
 
    while (ts_tree_cursor_child_iterator_next(&iterator, &entry, &visible)) {
      if (visible) {
        array_push(&self->stack, entry);
        return true;
      }
 
      if (ts_subtree_visible_child_count(*entry.subtree)) {
        array_push(&self->stack, entry);
        ts_tree_cursor_goto_first_child(_self);
        return true;
      }
    }
  }
 
  self->stack.size = initial_size;
  return false;
}

References array_pop, array_push, ts_subtree_visible_child_count(), ts_tree_cursor_child_iterator_next(), ts_tree_cursor_goto_first_child(), and ts_tree_cursor_iterate_children().

Referenced by ts_node_children_wasm(), ts_node_descendants_of_type_wasm(), ts_node_named_children_wasm(), ts_query_cursor__advance(), and ts_tree_cursor_goto_next_sibling_wasm().

ts_tree_cursor_goto_parent()

bool ts_tree_cursor_goto_parent

(

TSTreeCursor *

_self

)

Move the cursor to the parent of its current node.

This returns true if the cursor successfully moved, and returns false if there was no parent node (the cursor was already on the root node).

Definition at line 239 of file tree_cursor.c.

                                                     {
  TreeCursor *self = (TreeCursor *)_self;
  for (unsigned i = self->stack.size - 2; i + 1 > 0; i--) {
    TreeCursorEntry *entry = &self->stack.contents[i];
    if (ts_subtree_visible(*entry->subtree)) {
      self->stack.size = i + 1;
      return true;
    }
    if (i > 0 && !ts_subtree_extra(*entry->subtree)) {
      TreeCursorEntry *parent_entry = &self->stack.contents[i - 1];
      if (ts_language_alias_at(
        self->tree->language,
        parent_entry->subtree->ptr->production_id,
        entry->structural_child_index
      )) {
        self->stack.size = i + 1;
        return true;
      }
    }
  }
  return false;
}

References i, SubtreeHeapData::production_id, Subtree::ptr, entry::size, TreeCursorEntry::subtree, ts_language_alias_at(), ts_subtree_extra(), and ts_subtree_visible().

Referenced by ts_node_descendants_of_type_wasm(), ts_query_cursor__advance(), and ts_tree_cursor_goto_parent_wasm().

ts_tree_cursor_new()

TSTreeCursor ts_tree_cursor_new

(

TSNode

node

)

Create a new tree cursor starting from the given node.

A tree cursor allows you to walk a syntax tree more efficiently than is possible using the TSNode functions. It is a mutable object that is always on a certain syntax node, and can be moved imperatively to different nodes.

Definition at line 70 of file tree_cursor.c.

                                             {
  TSTreeCursor self = {NULL, NULL, {0, 0}};
  ts_tree_cursor_init((TreeCursor *)&self, node);
  return self;
}

References NULL, and ts_tree_cursor_init().

Referenced by ts_tree_cursor_new_wasm().

ts_tree_cursor_reset()

void ts_tree_cursor_reset	(	TSTreeCursor *	_self,
		TSNode	node
	)

Re-initialize a tree cursor to start at a different node.

Definition at line 76 of file tree_cursor.c.

                                                            {
  ts_tree_cursor_init((TreeCursor *)_self, node);
}

References ts_tree_cursor_init().

Referenced by ts_node_children_wasm(), ts_node_descendants_of_type_wasm(), ts_node_named_children_wasm(), ts_query_cursor_exec(), and ts_tree_cursor_reset_wasm().

ts_tree_delete()

void ts_tree_delete

(

TSTree *

self

)

Delete the syntax tree, freeing all of the memory that it used.

Definition at line 26 of file tree.c.

                                  {
  if (!self) return;
 
  SubtreePool pool = ts_subtree_pool_new(0);
  ts_subtree_release(&pool, self->root);
  ts_subtree_pool_delete(&pool);
  ts_free(self->included_ranges);
  ts_free(self);
}

References ts_free, ts_subtree_pool_delete(), ts_subtree_pool_new(), and ts_subtree_release().

Referenced by core_cmd_tsrzcmd(), guess_data_free(), guess_next_autocmplt_token(), rz_type_parse_string_declaration_single(), rz_type_parse_string_single(), substitute_args_do(), substitute_args_fini(), and type_parse_string().

ts_tree_edit()

void ts_tree_edit	(	TSTree *	self,
		const TSInputEdit *	edit
	)

Edit the syntax tree to keep it in sync with source code that has been edited.

You must describe the edit both in terms of byte offsets and in terms of (row, column) coordinates.

Definition at line 44 of file tree.c.

                                                         {
  for (unsigned i = 0; i < self->included_range_count; i++) {
    TSRange *range = &self->included_ranges[i];
    if (range->end_byte >= edit->old_end_byte) {
      if (range->end_byte != UINT32_MAX) {
        range->end_byte = edit->new_end_byte + (range->end_byte - edit->old_end_byte);
        range->end_point = point_add(
          edit->new_end_point,
          point_sub(range->end_point, edit->old_end_point)
        );
        if (range->end_byte < edit->new_end_byte) {
          range->end_byte = UINT32_MAX;
          range->end_point = POINT_MAX;
        }
      }
      if (range->start_byte >= edit->old_end_byte) {
        range->start_byte = edit->new_end_byte + (range->start_byte - edit->old_end_byte);
        range->start_point = point_add(
          edit->new_end_point,
          point_sub(range->start_point, edit->old_end_point)
        );
        if (range->start_byte < edit->new_end_byte) {
          range->start_byte = UINT32_MAX;
          range->start_point = POINT_MAX;
        }
      }
    }
  }
 
  SubtreePool pool = ts_subtree_pool_new(0);
  self->root = ts_subtree_edit(self->root, edit, &pool);
  ts_subtree_pool_delete(&pool);
}

References i, TSInputEdit::new_end_byte, TSInputEdit::new_end_point, TSInputEdit::old_end_byte, TSInputEdit::old_end_point, point_add(), POINT_MAX, point_sub(), capstone::range, ts_subtree_edit(), ts_subtree_pool_delete(), ts_subtree_pool_new(), and UINT32_MAX.

Referenced by ts_tree_edit_wasm().

ts_tree_get_changed_ranges()

TSRange* ts_tree_get_changed_ranges	(	const TSTree *	old_tree,
		const TSTree *	new_tree,
		uint32_t *	length
	)

Compare an old edited syntax tree to a new syntax tree representing the same document, returning an array of ranges whose syntactic structure has changed.

For this to work correctly, the old syntax tree must have been edited such that its ranges match up to the new tree. Generally, you'll want to call this function right after calling one of the ts_parser_parse functions. You need to pass the old tree that was passed to parse, as well as the new tree that was returned from that function.

The returned array is allocated using malloc and the caller is responsible for freeing it using free. The length of the array will be written to the given length pointer.

Definition at line 78 of file tree.c.

                                                                                              {
  TreeCursor cursor1 = {NULL, array_new()};
  TreeCursor cursor2 = {NULL, array_new()};
  ts_tree_cursor_init(&cursor1, ts_tree_root_node(self));
  ts_tree_cursor_init(&cursor2, ts_tree_root_node(other));
 
  TSRangeArray included_range_differences = array_new();
  ts_range_array_get_changed_ranges(
    self->included_ranges, self->included_range_count,
    other->included_ranges, other->included_range_count,
    &included_range_differences
  );
 
  TSRange *result;
  *count = ts_subtree_get_changed_ranges(
    &self->root, &other->root, &cursor1, &cursor2,
    self->language, &included_range_differences, &result
  );
 
  array_delete(&included_range_differences);
  array_delete(&cursor1.stack);
  array_delete(&cursor2.stack);
  return result;
}

References array_delete, array_new, count, TSTree::included_range_count, TSTree::included_ranges, NULL, TSTree::root, ts_range_array_get_changed_ranges(), ts_subtree_get_changed_ranges(), ts_tree_cursor_init(), and ts_tree_root_node().

Referenced by ts_tree_get_changed_ranges_wasm().

ts_tree_language()

const TSLanguage* ts_tree_language

(

const TSTree *

self

)

Get the language that was used to parse the syntax tree.

Definition at line 40 of file tree.c.

                                                       {
  return self->language;
}

ts_tree_print_dot_graph()

void ts_tree_print_dot_graph	(	const TSTree *	self,
		FILE *	file
	)

Write a DOT graph describing the syntax tree to the given file.

Definition at line 103 of file tree.c.

                                                             {
  ts_subtree_print_dot_graph(self->root, self->language, file);
}

References ts_subtree_print_dot_graph().

ts_tree_root_node()

TSNode ts_tree_root_node

(

const TSTree *

self

)

Get the root node of the syntax tree.

Definition at line 36 of file tree.c.

                                             {
  return ts_node_new(self, &self->root, ts_subtree_padding(self->root), 0);
}

References ts_node_new(), and ts_subtree_padding().

Referenced by core_cmd_tsrzcmd(), guess_next_autocmplt_token(), rz_type_parse_string_declaration_single(), rz_type_parse_string_single(), substitute_args_do(), ts_node_parent(), ts_tree_get_changed_ranges(), ts_tree_root_node_wasm(), and type_parse_string().