tree.c File Reference

#include "tree_sitter/api.h"
#include "./array.h"
#include "./get_changed_ranges.h"
#include "./subtree.h"
#include "./tree_cursor.h"
#include "./tree.h"

Go to the source code of this file.

Functions
TSTree *	ts_tree_new (Subtree root, const TSLanguage *language, const TSRange *included_ranges, unsigned included_range_count)
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 *self)
void	ts_tree_edit (TSTree *self, const TSInputEdit *edit)
TSRange *	ts_tree_get_changed_ranges (const TSTree *self, const TSTree *other, uint32_t *count)
void	ts_tree_print_dot_graph (const TSTree *self, FILE *file)

Function Documentation

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

TSTree* ts_tree_new	(	Subtree	root,
		const TSLanguage *	language,
		const TSRange *	included_ranges,
		unsigned	included_range_count
	)

Definition at line 8 of file tree.c.

  {
  TSTree *result = ts_malloc(sizeof(TSTree));
  result->root = root;
  result->language = language;
  result->included_ranges = ts_calloc(included_range_count, sizeof(TSRange));
  memcpy(result->included_ranges, included_ranges, included_range_count * sizeof(TSRange));
  result->included_range_count = included_range_count;
  return result;
}

References TSTree::included_range_count, TSTree::included_ranges, TSTree::language, memcpy(), TSTree::root, root, ts_calloc, and ts_malloc.

Referenced by ts_parser_parse(), and ts_tree_copy().

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().