subtree.h File Reference

#include <limits.h>
#include <stdbool.h>
#include <stdio.h>
#include "./length.h"
#include "./array.h"
#include "./error_costs.h"
#include "./host.h"
#include "tree_sitter/api.h"
#include "tree_sitter/parser.h"

Go to the source code of this file.

Classes
struct	ExternalScannerState
struct	SubtreeInlineData
struct	SubtreeHeapData
union	Subtree
union	MutableSubtree
struct	SubtreePool

Macros
#define	TS_TREE_STATE_NONE   USHRT_MAX
#define	NULL_SUBTREE   ((Subtree) {.ptr = NULL})
#define	SUBTREE_BITS
#define	SUBTREE_SIZE
#define	SUBTREE_GET(self, name)   (self.data.is_inline ? self.data.name : self.ptr->name)
#define	ts_subtree_children(self)    ((self).data.is_inline ? NULL : (Subtree *)((self).ptr) - (self).ptr->child_count)

Typedefs
typedef struct SubtreeInlineData	SubtreeInlineData

Functions
typedef	Array (Subtree) SubtreeArray
typedef	Array (MutableSubtree) MutableSubtreeArray
void	ts_external_scanner_state_init (ExternalScannerState *, const char *, unsigned)
const char *	ts_external_scanner_state_data (const ExternalScannerState *)
void	ts_subtree_array_copy (SubtreeArray, SubtreeArray *)
void	ts_subtree_array_clear (SubtreePool *, SubtreeArray *)
void	ts_subtree_array_delete (SubtreePool *, SubtreeArray *)
void	ts_subtree_array_remove_trailing_extras (SubtreeArray *, SubtreeArray *)
void	ts_subtree_array_reverse (SubtreeArray *)
SubtreePool	ts_subtree_pool_new (uint32_t capacity)
void	ts_subtree_pool_delete (SubtreePool *)
Subtree	ts_subtree_new_leaf (SubtreePool *, TSSymbol, Length, Length, uint32_t, TSStateId, bool, bool, bool, const TSLanguage *)
Subtree	ts_subtree_new_error (SubtreePool *, int32_t, Length, Length, uint32_t, TSStateId, const TSLanguage *)
MutableSubtree	ts_subtree_new_node (TSSymbol, SubtreeArray *, unsigned, const TSLanguage *)
Subtree	ts_subtree_new_error_node (SubtreeArray *, bool, const TSLanguage *)
Subtree	ts_subtree_new_missing_leaf (SubtreePool *, TSSymbol, Length, uint32_t, const TSLanguage *)
MutableSubtree	ts_subtree_make_mut (SubtreePool *, Subtree)
void	ts_subtree_retain (Subtree)
void	ts_subtree_release (SubtreePool *, Subtree)
int	ts_subtree_compare (Subtree, Subtree)
void	ts_subtree_set_symbol (MutableSubtree *, TSSymbol, const TSLanguage *)
void	ts_subtree_summarize (MutableSubtree, const Subtree *, uint32_t, const TSLanguage *)
void	ts_subtree_summarize_children (MutableSubtree, const TSLanguage *)
void	ts_subtree_balance (Subtree, SubtreePool *, const TSLanguage *)
Subtree	ts_subtree_edit (Subtree, const TSInputEdit *edit, SubtreePool *)
char *	ts_subtree_string (Subtree, const TSLanguage *, bool include_all)
void	ts_subtree_print_dot_graph (Subtree, const TSLanguage *, FILE *)
Subtree	ts_subtree_last_external_token (Subtree)
bool	ts_subtree_external_scanner_state_eq (Subtree, Subtree)
static TSSymbol	ts_subtree_symbol (Subtree self)
static bool	ts_subtree_visible (Subtree self)
static bool	ts_subtree_named (Subtree self)
static bool	ts_subtree_extra (Subtree self)
static bool	ts_subtree_has_changes (Subtree self)
static bool	ts_subtree_missing (Subtree self)
static bool	ts_subtree_is_keyword (Subtree self)
static TSStateId	ts_subtree_parse_state (Subtree self)
static uint32_t	ts_subtree_lookahead_bytes (Subtree self)
static size_t	ts_subtree_alloc_size (uint32_t child_count)
static void	ts_subtree_set_extra (MutableSubtree *self, bool is_extra)
static TSSymbol	ts_subtree_leaf_symbol (Subtree self)
static TSStateId	ts_subtree_leaf_parse_state (Subtree self)
static Length	ts_subtree_padding (Subtree self)
static Length	ts_subtree_size (Subtree self)
static Length	ts_subtree_total_size (Subtree self)
static uint32_t	ts_subtree_total_bytes (Subtree self)
static uint32_t	ts_subtree_child_count (Subtree self)
static uint32_t	ts_subtree_repeat_depth (Subtree self)
static uint32_t	ts_subtree_node_count (Subtree self)
static uint32_t	ts_subtree_visible_child_count (Subtree self)
static uint32_t	ts_subtree_error_cost (Subtree self)
static int32_t	ts_subtree_dynamic_precedence (Subtree self)
static uint16_t	ts_subtree_production_id (Subtree self)
static bool	ts_subtree_fragile_left (Subtree self)
static bool	ts_subtree_fragile_right (Subtree self)
static bool	ts_subtree_has_external_tokens (Subtree self)
static bool	ts_subtree_depends_on_column (Subtree self)
static bool	ts_subtree_is_fragile (Subtree self)
static bool	ts_subtree_is_error (Subtree self)
static bool	ts_subtree_is_eof (Subtree self)
static Subtree	ts_subtree_from_mut (MutableSubtree self)
static MutableSubtree	ts_subtree_to_mut_unsafe (Subtree self)

Macro Definition Documentation

NULL_SUBTREE

#define NULL_SUBTREE   ((Subtree) {.ptr = NULL})

Definition at line 19 of file subtree.h.

SUBTREE_BITS

#define SUBTREE_BITS

Value:

  bool visible : 1;     \
  bool named : 1;       \
  bool extra : 1;       \
  bool has_changes : 1; \
  bool is_missing : 1;  \
  bool is_keyword : 1;

Definition at line 52 of file subtree.h.

SUBTREE_GET

#define SUBTREE_GET	(		self,
			name
	)		(self.data.is_inline ? self.data.name : self.ptr->name)

Definition at line 211 of file subtree.h.

SUBTREE_SIZE

#define SUBTREE_SIZE

Value:

  uint8_t padding_columns;     \
  uint8_t padding_rows : 4;    \
  uint8_t lookahead_bytes : 4; \
  uint8_t padding_bytes;       \
  uint8_t size_bytes;

Definition at line 60 of file subtree.h.

ts_subtree_children

#define ts_subtree_children

(

self

)

((self).data.is_inline ? NULL : (Subtree *)((self).ptr) - (self).ptr->child_count)

Definition at line 233 of file subtree.h.

TS_TREE_STATE_NONE

#define TS_TREE_STATE_NONE   USHRT_MAX

Definition at line 18 of file subtree.h.

Typedef Documentation

SubtreeInlineData

typedef struct SubtreeInlineData SubtreeInlineData

Definition at line 1 of file subtree.h.

Function Documentation

Array() [1/2]

typedef Array

(

MutableSubtree

)

Array() [2/2]

typedef Array

(

Subtree

)

ts_external_scanner_state_data()

const char* ts_external_scanner_state_data

(

const ExternalScannerState *

self

)

Definition at line 53 of file subtree.c.

                                                                             {
  if (self->length > sizeof(self->short_data)) {
    return self->long_data;
  } else {
    return self->short_data;
  }
}

Referenced by ts_external_scanner_state_eq(), ts_parser__restore_external_scanner(), and ts_stack_print_dot_graph().

ts_external_scanner_state_init()

void ts_external_scanner_state_init	(	ExternalScannerState *	self,
		const char *	data,
		unsigned	length
	)

Definition at line 28 of file subtree.c.

                                                                                                   {
  self->length = length;
  if (length > sizeof(self->short_data)) {
    self->long_data = ts_malloc(length);
    memcpy(self->long_data, data, length);
  } else {
    memcpy(self->short_data, data, length);
  }
}

References length, memcpy(), and ts_malloc.

Referenced by ts_parser__lex().

ts_subtree_alloc_size()

static size_t ts_subtree_alloc_size ( uint32_t  child_count )

inlinestatic

Definition at line 227 of file subtree.h.

                                                                 {
  return child_count * sizeof(Subtree) + sizeof(SubtreeHeapData);
}

Referenced by stack__iter(), ts_subtree_clone(), and ts_subtree_new_node().

ts_subtree_array_clear()

void ts_subtree_array_clear	(	SubtreePool *	pool,
		SubtreeArray *	self
	)

Definition at line 83 of file subtree.c.

                                                                   {
  for (uint32_t i = 0; i < self->size; i++) {
    ts_subtree_release(pool, self->contents[i]);
  }
  array_clear(self);
}

References array_clear, i, and ts_subtree_release().

Referenced by ts_parser__reduce(), and ts_subtree_array_delete().

ts_subtree_array_copy()

void ts_subtree_array_copy	(	SubtreeArray	self,
		SubtreeArray *	dest
	)

Definition at line 70 of file subtree.c.

                                                                  {
  dest->size = self.size;
  dest->capacity = self.capacity;
  dest->contents = self.contents;
  if (self.capacity > 0) {
    dest->contents = ts_calloc(self.capacity, sizeof(Subtree));
    memcpy(dest->contents, self.contents, self.size * sizeof(Subtree));
    for (uint32_t i = 0; i < self.size; i++) {
      ts_subtree_retain(dest->contents[i]);
    }
  }
}

References dest, i, memcpy(), ts_calloc, and ts_subtree_retain().

Referenced by stack__iter().

ts_subtree_array_delete()

void ts_subtree_array_delete	(	SubtreePool *	pool,
		SubtreeArray *	self
	)

Definition at line 90 of file subtree.c.

                                                                    {
  ts_subtree_array_clear(pool, self);
  array_delete(self);
}

References array_delete, and ts_subtree_array_clear().

Referenced by stack__iter(), ts_parser__recover(), ts_parser__recover_to_state(), and ts_parser__reduce().

ts_subtree_array_remove_trailing_extras()

void ts_subtree_array_remove_trailing_extras	(	SubtreeArray *	self,
		SubtreeArray *	destination
	)

Definition at line 95 of file subtree.c.

  {
  array_clear(destination);
  while (self->size > 0) {
    Subtree last = self->contents[self->size - 1];
    if (ts_subtree_extra(last)) {
      self->size--;
      array_push(destination, last);
    } else {
      break;
    }
  }
  ts_subtree_array_reverse(destination);
}

References array_clear, array_push, ts_subtree_array_reverse(), and ts_subtree_extra().

Referenced by ts_parser__recover_to_state(), and ts_parser__reduce().

ts_subtree_array_reverse()

void ts_subtree_array_reverse

(

SubtreeArray *

self

)

Definition at line 112 of file subtree.c.

                                                  {
  for (uint32_t i = 0, limit = self->size / 2; i < limit; i++) {
    size_t reverse_index = self->size - 1 - i;
    Subtree swap = self->contents[i];
    self->contents[i] = self->contents[reverse_index];
    self->contents[reverse_index] = swap;
  }
}

References i, limit, and swap.

Referenced by stack__iter(), and ts_subtree_array_remove_trailing_extras().

ts_subtree_balance()

void ts_subtree_balance	(	Subtree	self,
		SubtreePool *	pool,
		const TSLanguage *	language
	)

Definition at line 338 of file subtree.c.

                                                                                     {
  array_clear(&pool->tree_stack);
 
  if (ts_subtree_child_count(self) > 0 && self.ptr->ref_count == 1) {
    array_push(&pool->tree_stack, ts_subtree_to_mut_unsafe(self));
  }
 
  while (pool->tree_stack.size > 0) {
    MutableSubtree tree = array_pop(&pool->tree_stack);
 
    if (tree.ptr->repeat_depth > 0) {
      Subtree child1 = ts_subtree_children(tree)[0];
      Subtree child2 = ts_subtree_children(tree)[tree.ptr->child_count - 1];
      long repeat_delta = (long)ts_subtree_repeat_depth(child1) - (long)ts_subtree_repeat_depth(child2);
      if (repeat_delta > 0) {
        unsigned n = repeat_delta;
        for (unsigned i = n / 2; i > 0; i /= 2) {
          ts_subtree__compress(tree, i, language, &pool->tree_stack);
          n -= i;
        }
      }
    }
 
    for (uint32_t i = 0; i < tree.ptr->child_count; i++) {
      Subtree child = ts_subtree_children(tree)[i];
      if (ts_subtree_child_count(child) > 0 && child.ptr->ref_count == 1) {
        array_push(&pool->tree_stack, ts_subtree_to_mut_unsafe(child));
      }
    }
  }
}

References array_clear, array_pop, array_push, SubtreeHeapData::child_count, i, long, n, Subtree::ptr, MutableSubtree::ptr, SubtreeHeapData::ref_count, SubtreeHeapData::repeat_depth, SubtreePool::tree_stack, ts_subtree__compress(), ts_subtree_child_count(), ts_subtree_children, ts_subtree_repeat_depth(), and ts_subtree_to_mut_unsafe().

Referenced by ts_parser_parse().

ts_subtree_child_count()

static uint32_t ts_subtree_child_count ( Subtree  self )

inlinestatic

Definition at line 282 of file subtree.h.

                                                            {
  return self.data.is_inline ? 0 : self.ptr->child_count;
}

Referenced by iterator_advance(), iterator_descend(), reusable_node_advance(), reusable_node_descend(), stack__subtree_is_equivalent(), ts_node__relevant_child_count(), ts_node_child_count(), ts_node_iterate_children(), ts_node_named_child_count(), ts_parser__accept(), ts_parser__advance(), ts_parser__breakdown_lookahead(), ts_parser__breakdown_top_of_stack(), ts_parser__handle_error(), ts_parser__recover_to_state(), ts_parser__shift(), ts_subtree__print_dot_graph(), ts_subtree__write_to_string(), ts_subtree_balance(), ts_subtree_compare(), ts_subtree_edit(), ts_subtree_has_trailing_empty_descendant(), ts_subtree_production_id(), ts_subtree_summarize_children(), ts_subtree_visible_child_count(), and ts_tree_cursor_iterate_children().

ts_subtree_compare()

int ts_subtree_compare	(	Subtree	left,
		Subtree	right
	)

Definition at line 615 of file subtree.c.

                                                    {
  if (ts_subtree_symbol(left) < ts_subtree_symbol(right)) return -1;
  if (ts_subtree_symbol(right) < ts_subtree_symbol(left)) return 1;
  if (ts_subtree_child_count(left) < ts_subtree_child_count(right)) return -1;
  if (ts_subtree_child_count(right) < ts_subtree_child_count(left)) return 1;
  for (uint32_t i = 0, n = ts_subtree_child_count(left); i < n; i++) {
    Subtree left_child = ts_subtree_children(left)[i];
    Subtree right_child = ts_subtree_children(right)[i];
    switch (ts_subtree_compare(left_child, right_child)) {
      case -1: return -1;
      case 1: return 1;
      default: break;
    }
  }
  return 0;
}

References i, n, ts_subtree_child_count(), ts_subtree_children, and ts_subtree_symbol().

Referenced by ts_parser__select_tree().

ts_subtree_depends_on_column()

static bool ts_subtree_depends_on_column ( Subtree  self )

inlinestatic

Definition at line 334 of file subtree.h.

                                                              {
  return self.data.is_inline ? false : self.ptr->depends_on_column;
}

References false.

Referenced by ts_subtree__print_dot_graph(), ts_subtree_edit(), and ts_subtree_summarize_children().

ts_subtree_dynamic_precedence()

static int32_t ts_subtree_dynamic_precedence ( Subtree  self )

inlinestatic

Definition at line 310 of file subtree.h.

                                                                  {
  return (self.data.is_inline || self.ptr->child_count == 0) ? 0 : self.ptr->dynamic_precedence;
}

Referenced by stack_node_add_link(), stack_node_new(), ts_parser__select_tree(), ts_stack_print_dot_graph(), and ts_subtree_summarize_children().

ts_subtree_edit()

Subtree ts_subtree_edit	(	Subtree	self,
		const TSInputEdit *	edit,
		SubtreePool *	pool
	)

Definition at line 640 of file subtree.c.

                                                                                  {
  typedef struct {
    Subtree *tree;
    Edit edit;
  } StackEntry;
 
  Array(StackEntry) stack = array_new();
  array_push(&stack, ((StackEntry) {
    .tree = &self,
    .edit = (Edit) {
      .start = {edit->start_byte, edit->start_point},
      .old_end = {edit->old_end_byte, edit->old_end_point},
      .new_end = {edit->new_end_byte, edit->new_end_point},
    },
  }));
 
  while (stack.size) {
    StackEntry entry = array_pop(&stack);
    Edit edit = entry.edit;
    bool is_noop = edit.old_end.bytes == edit.start.bytes && edit.new_end.bytes == edit.start.bytes;
    bool is_pure_insertion = edit.old_end.bytes == edit.start.bytes;
    bool invalidate_first_row = ts_subtree_depends_on_column(*entry.tree);
 
    Length size = ts_subtree_size(*entry.tree);
    Length padding = ts_subtree_padding(*entry.tree);
    uint32_t lookahead_bytes = ts_subtree_lookahead_bytes(*entry.tree);
    uint32_t end_byte = padding.bytes + size.bytes + lookahead_bytes;
    if (edit.start.bytes > end_byte || (is_noop && edit.start.bytes == end_byte)) continue;
 
    // If the edit is entirely within the space before this subtree, then shift this
    // subtree over according to the edit without changing its size.
    if (edit.old_end.bytes <= padding.bytes) {
      padding = length_add(edit.new_end, length_sub(padding, edit.old_end));
    }
 
    // If the edit starts in the space before this subtree and extends into this subtree,
    // shrink the subtree's content to compensate for the change in the space before it.
    else if (edit.start.bytes < padding.bytes) {
      size = length_sub(size, length_sub(edit.old_end, padding));
      padding = edit.new_end;
    }
 
    // If the edit is a pure insertion right at the start of the subtree,
    // shift the subtree over according to the insertion.
    else if (edit.start.bytes == padding.bytes && is_pure_insertion) {
      padding = edit.new_end;
    }
 
    // If the edit is within this subtree, resize the subtree to reflect the edit.
    else {
      uint32_t total_bytes = padding.bytes + size.bytes;
      if (edit.start.bytes < total_bytes ||
         (edit.start.bytes == total_bytes && is_pure_insertion)) {
        size = length_add(
          length_sub(edit.new_end, padding),
          length_sub(size, length_sub(edit.old_end, padding))
        );
      }
    }
 
    MutableSubtree result = ts_subtree_make_mut(pool, *entry.tree);
 
    if (result.data.is_inline) {
      if (ts_subtree_can_inline(padding, size, lookahead_bytes)) {
        result.data.padding_bytes = padding.bytes;
        result.data.padding_rows = padding.extent.row;
        result.data.padding_columns = padding.extent.column;
        result.data.size_bytes = size.bytes;
      } else {
        SubtreeHeapData *data = ts_subtree_pool_allocate(pool);
        data->ref_count = 1;
        data->padding = padding;
        data->size = size;
        data->lookahead_bytes = lookahead_bytes;
        data->error_cost = 0;
        data->child_count = 0;
        data->symbol = result.data.symbol;
        data->parse_state = result.data.parse_state;
        data->visible = result.data.visible;
        data->named = result.data.named;
        data->extra = result.data.extra;
        data->fragile_left = false;
        data->fragile_right = false;
        data->has_changes = false;
        data->has_external_tokens = false;
        data->depends_on_column = false;
        data->is_missing = result.data.is_missing;
        data->is_keyword = result.data.is_keyword;
        result.ptr = data;
      }
    } else {
      result.ptr->padding = padding;
      result.ptr->size = size;
    }
 
    ts_subtree_set_has_changes(&result);
    *entry.tree = ts_subtree_from_mut(result);
 
    Length child_left, child_right = length_zero();
    for (uint32_t i = 0, n = ts_subtree_child_count(*entry.tree); i < n; i++) {
      Subtree *child = &ts_subtree_children(*entry.tree)[i];
      Length child_size = ts_subtree_total_size(*child);
      child_left = child_right;
      child_right = length_add(child_left, child_size);
 
      // If this child ends before the edit, it is not affected.
      if (child_right.bytes + ts_subtree_lookahead_bytes(*child) < edit.start.bytes) continue;
 
      // Keep editing child nodes until a node is reached that starts after the edit.
      // Also, if this node's validity depends on its column position, then continue
      // invaliditing child nodes until reaching a line break.
      if ((
        (child_left.bytes > edit.old_end.bytes) ||
        (child_left.bytes == edit.old_end.bytes && child_size.bytes > 0 && i > 0)
      ) && (
        !invalidate_first_row ||
        child_left.extent.row > entry.tree->ptr->padding.extent.row
      )) {
        break;
      }
 
      // Transform edit into the child's coordinate space.
      Edit child_edit = {
        .start = length_sub(edit.start, child_left),
        .old_end = length_sub(edit.old_end, child_left),
        .new_end = length_sub(edit.new_end, child_left),
      };
 
      // Clamp child_edit to the child's bounds.
      if (edit.start.bytes < child_left.bytes) child_edit.start = length_zero();
      if (edit.old_end.bytes < child_left.bytes) child_edit.old_end = length_zero();
      if (edit.new_end.bytes < child_left.bytes) child_edit.new_end = length_zero();
      if (edit.old_end.bytes > child_right.bytes) child_edit.old_end = child_size;
 
      // Interpret all inserted text as applying to the *first* child that touches the edit.
      // Subsequent children are only never have any text inserted into them; they are only
      // shrunk to compensate for the edit.
      if (
        child_right.bytes > edit.start.bytes ||
        (child_right.bytes == edit.start.bytes && is_pure_insertion)
      ) {
        edit.new_end = edit.start;
      }
 
      // Children that occur before the edit are not reshaped by the edit.
      else {
        child_edit.old_end = child_edit.start;
        child_edit.new_end = child_edit.start;
      }
 
      // Queue processing of this child's subtree.
      array_push(&stack, ((StackEntry) {
        .tree = child,
        .edit = child_edit,
      }));
    }
  }
 
  array_delete(&stack);
  return self;
}

References Array, array_delete, array_new, array_pop, array_push, Length::bytes, SubtreeHeapData::child_count, TSPoint::column, MutableSubtree::data, SubtreeHeapData::depends_on_column, SubtreeHeapData::error_cost, Length::extent, SubtreeHeapData::extra, SubtreeHeapData::fragile_left, SubtreeHeapData::fragile_right, SubtreeHeapData::has_changes, SubtreeHeapData::has_external_tokens, i, SubtreeInlineData::is_inline, SubtreeHeapData::is_keyword, SubtreeHeapData::is_missing, length_add(), length_sub(), length_zero(), SubtreeHeapData::lookahead_bytes, n, SubtreeHeapData::named, Edit::new_end, TSInputEdit::new_end_byte, TSInputEdit::new_end_point, Edit::old_end, TSInputEdit::old_end_byte, TSInputEdit::old_end_point, SubtreeHeapData::padding, SubtreeInlineData::parse_state, SubtreeHeapData::parse_state, MutableSubtree::ptr, SubtreeHeapData::ref_count, TSPoint::row, SubtreeHeapData::size, Edit::start, TSInputEdit::start_byte, TSInputEdit::start_point, SubtreeInlineData::symbol, SubtreeHeapData::symbol, ts_subtree_can_inline(), ts_subtree_child_count(), ts_subtree_children, ts_subtree_depends_on_column(), ts_subtree_from_mut(), ts_subtree_lookahead_bytes(), ts_subtree_make_mut(), ts_subtree_padding(), ts_subtree_pool_allocate(), ts_subtree_set_has_changes(), ts_subtree_size(), ts_subtree_total_size(), and SubtreeHeapData::visible.

Referenced by ts_tree_edit().

ts_subtree_error_cost()

static uint32_t ts_subtree_error_cost ( Subtree  self )

inlinestatic

Definition at line 302 of file subtree.h.

                                                           {
  if (ts_subtree_missing(self)) {
    return ERROR_COST_PER_MISSING_TREE + ERROR_COST_PER_RECOVERY;
  } else {
    return self.data.is_inline ? 0 : self.ptr->error_cost;
  }
}

References ERROR_COST_PER_MISSING_TREE, ERROR_COST_PER_RECOVERY, and ts_subtree_missing().

Referenced by stack__subtree_is_equivalent(), stack_node_new(), ts_node_has_error(), ts_parser__better_version_exists(), ts_parser__select_tree(), ts_parser_parse(), ts_stack_has_advanced_since_error(), ts_stack_print_dot_graph(), ts_subtree__print_dot_graph(), and ts_subtree_summarize_children().

ts_subtree_external_scanner_state_eq()

bool ts_subtree_external_scanner_state_eq	(	Subtree	self,
		Subtree	other
	)

Definition at line 1027 of file subtree.c.

                                                                       {
  const ExternalScannerState *state1 = &empty_state;
  const ExternalScannerState *state2 = &empty_state;
  if (self.ptr && ts_subtree_has_external_tokens(self) && !self.ptr->child_count) {
    state1 = &self.ptr->external_scanner_state;
  }
  if (other.ptr && ts_subtree_has_external_tokens(other) && !other.ptr->child_count) {
    state2 = &other.ptr->external_scanner_state;
  }
  return ts_external_scanner_state_eq(state1, state2);
}

References SubtreeHeapData::child_count, empty_state, SubtreeHeapData::external_scanner_state, Subtree::ptr, ts_external_scanner_state_eq(), and ts_subtree_has_external_tokens().

Referenced by stack__subtree_is_equivalent(), ts_parser__get_cached_token(), ts_parser__reuse_node(), and ts_stack_can_merge().

ts_subtree_extra()

static bool ts_subtree_extra ( Subtree  self )

inlinestatic

Definition at line 216 of file subtree.h.

{ return SUBTREE_GET(self, extra); }

References SUBTREE_GET.

Referenced by iterator_advance(), iterator_descend(), stack__iter(), stack__subtree_is_equivalent(), ts_node_child_by_field_id(), ts_node_child_iterator_next(), ts_node_is_extra(), ts_parser__accept(), ts_parser__breakdown_top_of_stack(), ts_parser__shift(), ts_stack_print_dot_graph(), ts_subtree__print_dot_graph(), ts_subtree__write_to_string(), ts_subtree_array_remove_trailing_extras(), ts_subtree_summarize_children(), ts_tree_cursor_child_iterator_next(), ts_tree_cursor_current_field_id(), ts_tree_cursor_current_node(), ts_tree_cursor_current_status(), and ts_tree_cursor_goto_parent().

ts_subtree_fragile_left()

static bool ts_subtree_fragile_left ( Subtree  self )

inlinestatic

Definition at line 322 of file subtree.h.

                                                         {
  return self.data.is_inline ? false : self.ptr->fragile_left;
}

References false.

Referenced by ts_subtree_summarize_children().

ts_subtree_fragile_right()

static bool ts_subtree_fragile_right ( Subtree  self )

inlinestatic

Definition at line 326 of file subtree.h.

                                                          {
  return self.data.is_inline ? false : self.ptr->fragile_right;
}

References false.

Referenced by ts_subtree_summarize_children().

ts_subtree_from_mut()

static Subtree ts_subtree_from_mut ( MutableSubtree  self )

inlinestatic

Definition at line 350 of file subtree.h.

                                                               {
  Subtree result;
  result.data = self.data;
  return result;
}

References Subtree::data.

Referenced by ts_parser__accept(), ts_parser__advance(), ts_parser__recover(), ts_parser__reduce(), ts_parser__select_children(), ts_parser__shift(), ts_subtree__compress(), ts_subtree_edit(), and ts_subtree_new_error_node().

ts_subtree_has_changes()

static bool ts_subtree_has_changes ( Subtree  self )

inlinestatic

Definition at line 217 of file subtree.h.

{ return SUBTREE_GET(self, has_changes); }

References SUBTREE_GET.

Referenced by iterator_compare(), ts_node_has_changes(), ts_parser__reuse_node(), and ts_subtree__print_dot_graph().

ts_subtree_has_external_tokens()

static bool ts_subtree_has_external_tokens ( Subtree  self )

inlinestatic

Definition at line 330 of file subtree.h.

                                                                {
  return self.data.is_inline ? false : self.ptr->has_external_tokens;
}

References false.

Referenced by reusable_node_advance(), ts_parser__recover(), ts_parser__shift(), ts_subtree_external_scanner_state_eq(), ts_subtree_last_external_token(), and ts_subtree_summarize_children().

ts_subtree_is_eof()

static bool ts_subtree_is_eof ( Subtree  self )

inlinestatic

Definition at line 346 of file subtree.h.

                                                   {
  return ts_subtree_symbol(self) == ts_builtin_sym_end;
}

References ts_builtin_sym_end, and ts_subtree_symbol().

Referenced by ts_parser__accept(), ts_parser__recover(), and ts_parser__reuse_node().

ts_subtree_is_error()

static bool ts_subtree_is_error ( Subtree  self )

inlinestatic

Definition at line 342 of file subtree.h.

                                                     {
  return ts_subtree_symbol(self) == ts_builtin_sym_error;
}

References ts_builtin_sym_error, and ts_subtree_symbol().

Referenced by pop_error_callback(), ts_parser__breakdown_top_of_stack(), ts_parser__recover(), ts_parser__reuse_node(), ts_stack_pop_error(), ts_subtree__print_dot_graph(), ts_subtree__write_to_string(), and ts_subtree_summarize_children().

ts_subtree_is_fragile()

static bool ts_subtree_is_fragile ( Subtree  self )

inlinestatic

Definition at line 338 of file subtree.h.

                                                       {
  return self.data.is_inline ? false : (self.ptr->fragile_left || self.ptr->fragile_right);
}

References false.

Referenced by ts_parser__reuse_node().

ts_subtree_is_keyword()

static bool ts_subtree_is_keyword ( Subtree  self )

inlinestatic

Definition at line 219 of file subtree.h.

{ return SUBTREE_GET(self, is_keyword); }

References SUBTREE_GET.

Referenced by ts_parser__advance(), and ts_parser__can_reuse_first_leaf().

ts_subtree_last_external_token()

Subtree ts_subtree_last_external_token

(

Subtree

tree

)

Definition at line 802 of file subtree.c.

                                                     {
  if (!ts_subtree_has_external_tokens(tree)) return NULL_SUBTREE;
  while (tree.ptr->child_count > 0) {
    for (uint32_t i = tree.ptr->child_count - 1; i + 1 > 0; i--) {
      Subtree child = ts_subtree_children(tree)[i];
      if (ts_subtree_has_external_tokens(child)) {
        tree = child;
        break;
      }
    }
  }
  return tree;
}

References SubtreeHeapData::child_count, i, NULL_SUBTREE, Subtree::ptr, ts_subtree_children, and ts_subtree_has_external_tokens().

Referenced by reusable_node_advance(), ts_parser__recover(), and ts_parser__shift().

ts_subtree_leaf_parse_state()

static TSStateId ts_subtree_leaf_parse_state ( Subtree  self )

inlinestatic

Definition at line 250 of file subtree.h.

                                                                  {
  if (self.data.is_inline) return self.data.parse_state;
  if (self.ptr->child_count == 0) return self.ptr->parse_state;
  return self.ptr->first_leaf.parse_state;
}

Referenced by ts_parser__can_reuse_first_leaf(), and ts_subtree_summarize_children().

ts_subtree_leaf_symbol()

static TSSymbol ts_subtree_leaf_symbol ( Subtree  self )

inlinestatic

Definition at line 244 of file subtree.h.

                                                            {
  if (self.data.is_inline) return self.data.symbol;
  if (self.ptr->child_count == 0) return self.ptr->symbol;
  return self.ptr->first_leaf.symbol;
}

Referenced by ts_parser__advance(), ts_parser__can_reuse_first_leaf(), ts_parser__handle_error(), ts_parser__reuse_node(), and ts_subtree_summarize_children().

ts_subtree_lookahead_bytes()

static uint32_t ts_subtree_lookahead_bytes ( Subtree  self )

inlinestatic

Definition at line 221 of file subtree.h.

{ return SUBTREE_GET(self, lookahead_bytes); }

References SUBTREE_GET.

Referenced by ts_parser__handle_error(), ts_subtree__print_dot_graph(), ts_subtree_edit(), and ts_subtree_summarize_children().

ts_subtree_make_mut()

MutableSubtree ts_subtree_make_mut	(	SubtreePool *	pool,
		Subtree	self
	)

Definition at line 284 of file subtree.c.

                                                                    {
  if (self.data.is_inline) return (MutableSubtree) {self.data};
  if (self.ptr->ref_count == 1) return ts_subtree_to_mut_unsafe(self);
  MutableSubtree result = ts_subtree_clone(self);
  ts_subtree_release(pool, self);
  return result;
}

References MutableSubtree::data, ts_subtree_clone(), ts_subtree_release(), and ts_subtree_to_mut_unsafe().

Referenced by ts_parser__advance(), ts_parser__recover(), ts_parser__shift(), and ts_subtree_edit().

ts_subtree_missing()

static bool ts_subtree_missing ( Subtree  self )

inlinestatic

Definition at line 218 of file subtree.h.

{ return SUBTREE_GET(self, is_missing); }

References SUBTREE_GET.

Referenced by ts_node_is_missing(), ts_parser__reuse_node(), ts_subtree__write_to_string(), and ts_subtree_error_cost().

ts_subtree_named()

static bool ts_subtree_named ( Subtree  self )

inlinestatic

Definition at line 215 of file subtree.h.

{ return SUBTREE_GET(self, named); }

References SUBTREE_GET.

Referenced by ts_node__is_relevant(), ts_node_is_named(), ts_stack_print_dot_graph(), ts_subtree__write_to_string(), and ts_subtree_summarize_children().

ts_subtree_new_error()

Subtree ts_subtree_new_error	(	SubtreePool *	pool,
		int32_t	lookahead_char,
		Length	padding,
		Length	size,
		uint32_t	bytes_scanned,
		TSStateId	parse_state,
		const TSLanguage *	language
	)

Definition at line 244 of file subtree.c.

  {
  Subtree result = ts_subtree_new_leaf(
    pool, ts_builtin_sym_error, padding, size, bytes_scanned,
    parse_state, false, false, false, language
  );
  SubtreeHeapData *data = (SubtreeHeapData *)result.ptr;
  data->fragile_left = true;
  data->fragile_right = true;
  data->lookahead_char = lookahead_char;
  return result;
}

References SubtreeHeapData::fragile_left, SubtreeHeapData::fragile_right, SubtreeHeapData::lookahead_char, Subtree::ptr, ts_builtin_sym_error, and ts_subtree_new_leaf().

Referenced by ts_parser__lex().

ts_subtree_new_error_node()

Subtree ts_subtree_new_error_node	(	SubtreeArray *	children,
		bool	extra,
		const TSLanguage *	language
	)

Definition at line 542 of file subtree.c.

  {
  MutableSubtree result = ts_subtree_new_node(
    ts_builtin_sym_error, children, 0, language
  );
  result.ptr->extra = extra;
  return ts_subtree_from_mut(result);
}

References SubtreeHeapData::extra, MutableSubtree::ptr, ts_builtin_sym_error, ts_subtree_from_mut(), and ts_subtree_new_node().

Referenced by ts_parser__recover(), and ts_parser__recover_to_state().

ts_subtree_new_leaf()

Subtree ts_subtree_new_leaf	(	SubtreePool *	pool,
		TSSymbol	symbol,
		Length	padding,
		Length	size,
		uint32_t	lookahead_bytes,
		TSStateId	parse_state,
		bool	has_external_tokens,
		bool	depends_on_column,
		bool	is_keyword,
		const TSLanguage *	language
	)

Definition at line 167 of file subtree.c.

  {
  TSSymbolMetadata metadata = ts_language_symbol_metadata(language, symbol);
  bool extra = symbol == ts_builtin_sym_end;
 
  bool is_inline = (
    symbol <= UINT8_MAX &&
    !has_external_tokens &&
    ts_subtree_can_inline(padding, size, lookahead_bytes)
  );
 
  if (is_inline) {
    return (Subtree) {{
      .parse_state = parse_state,
      .symbol = symbol,
      .padding_bytes = padding.bytes,
      .padding_rows = padding.extent.row,
      .padding_columns = padding.extent.column,
      .size_bytes = size.bytes,
      .lookahead_bytes = lookahead_bytes,
      .visible = metadata.visible,
      .named = metadata.named,
      .extra = extra,
      .has_changes = false,
      .is_missing = false,
      .is_keyword = is_keyword,
      .is_inline = true,
    }};
  } else {
    SubtreeHeapData *data = ts_subtree_pool_allocate(pool);
    *data = (SubtreeHeapData) {
      .ref_count = 1,
      .padding = padding,
      .size = size,
      .lookahead_bytes = lookahead_bytes,
      .error_cost = 0,
      .child_count = 0,
      .symbol = symbol,
      .parse_state = parse_state,
      .visible = metadata.visible,
      .named = metadata.named,
      .extra = extra,
      .fragile_left = false,
      .fragile_right = false,
      .has_changes = false,
      .has_external_tokens = has_external_tokens,
      .depends_on_column = depends_on_column,
      .is_missing = false,
      .is_keyword = is_keyword,
      {{.first_leaf = {.symbol = 0, .parse_state = 0}}}
    };
    return (Subtree) {.ptr = data};
  }
}

References Length::bytes, TSPoint::column, Length::extent, TSSymbolMetadata::named, SubtreeHeapData::ref_count, TSPoint::row, ts_builtin_sym_end, ts_language_symbol_metadata(), ts_subtree_can_inline(), ts_subtree_pool_allocate(), UINT8_MAX, and TSSymbolMetadata::visible.

Referenced by ts_parser__lex(), ts_subtree_new_error(), and ts_subtree_new_missing_leaf().

ts_subtree_new_missing_leaf()

Subtree ts_subtree_new_missing_leaf	(	SubtreePool *	pool,
		TSSymbol	symbol,
		Length	padding,
		uint32_t	lookahead_bytes,
		const TSLanguage *	language
	)

Definition at line 558 of file subtree.c.

  {
  Subtree result = ts_subtree_new_leaf(
    pool, symbol, padding, length_zero(), lookahead_bytes,
    0, false, false, false, language
  );
  if (result.data.is_inline) {
    result.data.is_missing = true;
  } else {
    ((SubtreeHeapData *)result.ptr)->is_missing = true;
  }
  return result;
}

References Subtree::data, SubtreeInlineData::is_inline, length_zero(), Subtree::ptr, and ts_subtree_new_leaf().

Referenced by ts_parser__handle_error().

ts_subtree_new_node()

MutableSubtree ts_subtree_new_node	(	TSSymbol	symbol,
		SubtreeArray *	children,
		unsigned	production_id,
		const TSLanguage *	language
	)

Definition at line 500 of file subtree.c.

  {
  TSSymbolMetadata metadata = ts_language_symbol_metadata(language, symbol);
  bool fragile = symbol == ts_builtin_sym_error || symbol == ts_builtin_sym_error_repeat;
 
  // Allocate the node's data at the end of the array of children.
  size_t new_byte_size = ts_subtree_alloc_size(children->size);
  if (children->capacity * sizeof(Subtree) < new_byte_size) {
    children->contents = ts_realloc(children->contents, new_byte_size);
    children->capacity = new_byte_size / sizeof(Subtree);
  }
  SubtreeHeapData *data = (SubtreeHeapData *)&children->contents[children->size];
 
  *data = (SubtreeHeapData) {
    .ref_count = 1,
    .symbol = symbol,
    .child_count = children->size,
    .visible = metadata.visible,
    .named = metadata.named,
    .has_changes = false,
    .fragile_left = fragile,
    .fragile_right = fragile,
    .is_keyword = false,
    {{
      .node_count = 0,
      .production_id = production_id,
      .first_leaf = {.symbol = 0, .parse_state = 0},
    }}
  };
  MutableSubtree result = {.ptr = data};
  ts_subtree_summarize_children(result, language);
  return result;
}

References TSSymbolMetadata::named, MutableSubtree::ptr, SubtreeHeapData::ref_count, ts_builtin_sym_error, ts_builtin_sym_error_repeat, ts_language_symbol_metadata(), ts_realloc, ts_subtree_alloc_size(), ts_subtree_summarize_children(), and TSSymbolMetadata::visible.

Referenced by ts_parser__accept(), ts_parser__recover(), ts_parser__reduce(), ts_parser__select_children(), and ts_subtree_new_error_node().

ts_subtree_node_count()

static uint32_t ts_subtree_node_count ( Subtree  self )

inlinestatic

Definition at line 290 of file subtree.h.

                                                           {
  return (self.data.is_inline || self.ptr->child_count == 0) ? 1 : self.ptr->node_count;
}

Referenced by stack_node_add_link(), stack_node_new(), and ts_subtree_summarize_children().

ts_subtree_padding()

static Length ts_subtree_padding ( Subtree  self )

inlinestatic

Definition at line 256 of file subtree.h.

                                                      {
  if (self.data.is_inline) {
    Length result = {self.data.padding_bytes, {self.data.padding_rows, self.data.padding_columns}};
    return result;
  } else {
    return self.ptr->padding;
  }
}

Referenced by iterator_advance(), iterator_descend(), iterator_end_position(), iterator_start_position(), stack__subtree_is_equivalent(), ts_node_child_iterator_next(), ts_subtree_edit(), ts_subtree_summarize_children(), ts_subtree_total_size(), ts_tree_cursor_child_iterator_next(), and ts_tree_root_node().

ts_subtree_parse_state()

static TSStateId ts_subtree_parse_state ( Subtree  self )

inlinestatic

Definition at line 220 of file subtree.h.

{ return SUBTREE_GET(self, parse_state); }

References SUBTREE_GET.

Referenced by iterator_compare(), ts_parser__breakdown_lookahead(), ts_parser__can_reuse_first_leaf(), and ts_subtree__print_dot_graph().

ts_subtree_pool_delete()

void ts_subtree_pool_delete

(

SubtreePool *

self

)

Definition at line 129 of file subtree.c.

                                               {
  if (self->free_trees.contents) {
    for (unsigned i = 0; i < self->free_trees.size; i++) {
      ts_free(self->free_trees.contents[i].ptr);
    }
    array_delete(&self->free_trees);
  }
  if (self->tree_stack.contents) array_delete(&self->tree_stack);
}

References array_delete, i, and ts_free.

Referenced by ts_parser_delete(), ts_tree_delete(), and ts_tree_edit().

ts_subtree_pool_new()

SubtreePool ts_subtree_pool_new

(

uint32_t

capacity

)

Definition at line 123 of file subtree.c.

                                                   {
  SubtreePool self = {array_new(), array_new()};
  array_reserve(&self.free_trees, capacity);
  return self;
}

References array_new, and array_reserve.

Referenced by ts_parser_new(), ts_tree_delete(), and ts_tree_edit().

ts_subtree_print_dot_graph()

void ts_subtree_print_dot_graph	(	Subtree	self,
		const TSLanguage *	language,
		FILE *	f
	)

Definition at line 1020 of file subtree.c.

                                                                                   {
  fprintf(f, "digraph tree {\n");
  fprintf(f, "edge [arrowhead=none]\n");
  ts_subtree__print_dot_graph(&self, 0, language, 0, f);
  fprintf(f, "}\n");
}

References f, and ts_subtree__print_dot_graph().

Referenced by ts_tree_print_dot_graph().

ts_subtree_production_id()

static uint16_t ts_subtree_production_id ( Subtree  self )

inlinestatic

Definition at line 314 of file subtree.h.

                                                              {
  if (ts_subtree_child_count(self) > 0) {
    return self.ptr->production_id;
  } else {
    return 0;
  }
}

References ts_subtree_child_count().

Referenced by ts_subtree__print_dot_graph().

ts_subtree_release()

void ts_subtree_release	(	SubtreePool *	pool,
		Subtree	self
	)

Definition at line 584 of file subtree.c.

                                                         {
  if (self.data.is_inline) return;
  array_clear(&pool->tree_stack);
 
  assert(self.ptr->ref_count > 0);
  if (atomic_dec((volatile uint32_t *)&self.ptr->ref_count) == 0) {
    array_push(&pool->tree_stack, ts_subtree_to_mut_unsafe(self));
  }
 
  while (pool->tree_stack.size > 0) {
    MutableSubtree tree = array_pop(&pool->tree_stack);
    if (tree.ptr->child_count > 0) {
      Subtree *children = ts_subtree_children(tree);
      for (uint32_t i = 0; i < tree.ptr->child_count; i++) {
        Subtree child = children[i];
        if (child.data.is_inline) continue;
        assert(child.ptr->ref_count > 0);
        if (atomic_dec((volatile uint32_t *)&child.ptr->ref_count) == 0) {
          array_push(&pool->tree_stack, ts_subtree_to_mut_unsafe(child));
        }
      }
      ts_free(children);
    } else {
      if (tree.ptr->has_external_tokens) {
        ts_external_scanner_state_delete(&tree.ptr->external_scanner_state);
      }
      ts_subtree_pool_free(pool, tree.ptr);
    }
  }
}

References array_clear, array_pop, array_push, assert(), atomic_dec(), SubtreeHeapData::child_count, Subtree::data, SubtreeHeapData::external_scanner_state, SubtreeHeapData::has_external_tokens, i, SubtreeInlineData::is_inline, Subtree::ptr, MutableSubtree::ptr, SubtreeHeapData::ref_count, SubtreePool::tree_stack, ts_external_scanner_state_delete(), ts_free, ts_subtree_children, ts_subtree_pool_free(), and ts_subtree_to_mut_unsafe().

Referenced by stack_head_delete(), stack_node_add_link(), stack_node_release(), ts_parser__accept(), ts_parser__advance(), ts_parser__breakdown_lookahead(), ts_parser__breakdown_top_of_stack(), ts_parser__recover(), ts_parser__reduce(), ts_parser__set_cached_token(), ts_parser_delete(), ts_parser_reset(), ts_stack_set_last_external_token(), ts_subtree_array_clear(), ts_subtree_make_mut(), and ts_tree_delete().

ts_subtree_repeat_depth()

static uint32_t ts_subtree_repeat_depth ( Subtree  self )

inlinestatic

Definition at line 286 of file subtree.h.

                                                             {
  return self.data.is_inline ? 0 : self.ptr->repeat_depth;
}

Referenced by ts_subtree__print_dot_graph(), ts_subtree_balance(), and ts_subtree_summarize_children().

ts_subtree_retain()

void ts_subtree_retain

(

Subtree

self

)

Definition at line 577 of file subtree.c.

                                     {
  if (self.data.is_inline) return;
  assert(self.ptr->ref_count > 0);
  atomic_inc((volatile uint32_t *)&self.ptr->ref_count);
  assert(self.ptr->ref_count != 0);
}

References assert(), and atomic_inc().

Referenced by stack__iter(), stack_node_add_link(), ts_parser__accept(), ts_parser__breakdown_lookahead(), ts_parser__breakdown_top_of_stack(), ts_parser__get_cached_token(), ts_parser__recover_to_state(), ts_parser__reuse_node(), ts_parser__set_cached_token(), ts_parser_parse(), ts_stack__add_version(), ts_stack_copy_version(), ts_stack_set_last_external_token(), ts_subtree_array_copy(), ts_subtree_clone(), and ts_tree_copy().

ts_subtree_set_extra()

static void ts_subtree_set_extra ( MutableSubtree *  self, bool  is_extra  )

inlinestatic

Definition at line 236 of file subtree.h.

                                                                             {
  if (self->data.is_inline) {
    self->data.extra = is_extra;
  } else {
    self->ptr->extra = is_extra;
  }
}

Referenced by ts_parser__recover(), and ts_parser__shift().

ts_subtree_set_symbol()

void ts_subtree_set_symbol	(	MutableSubtree *	self,
		TSSymbol	symbol,
		const TSLanguage *	language
	)

Definition at line 226 of file subtree.c.

  {
  TSSymbolMetadata metadata = ts_language_symbol_metadata(language, symbol);
  if (self->data.is_inline) {
    assert(symbol < UINT8_MAX);
    self->data.symbol = symbol;
    self->data.named = metadata.named;
    self->data.visible = metadata.visible;
  } else {
    self->ptr->symbol = symbol;
    self->ptr->named = metadata.named;
    self->ptr->visible = metadata.visible;
  }
}

References assert(), TSSymbolMetadata::named, ts_language_symbol_metadata(), UINT8_MAX, and TSSymbolMetadata::visible.

Referenced by ts_parser__advance().

ts_subtree_size()

static Length ts_subtree_size ( Subtree  self )

inlinestatic

Definition at line 265 of file subtree.h.

                                                   {
  if (self.data.is_inline) {
    Length result = {self.data.size_bytes, {0, self.data.size_bytes}};
    return result;
  } else {
    return self.ptr->size;
  }
}

Referenced by iterator_compare(), iterator_descend(), iterator_end_position(), stack__subtree_is_equivalent(), ts_node_child_iterator_next(), ts_node_end_byte(), ts_node_end_point(), ts_parser__can_reuse_first_leaf(), ts_subtree_edit(), ts_subtree_summarize_children(), ts_subtree_total_size(), ts_tree_cursor_child_iterator_next(), ts_tree_cursor_goto_first_child_for_byte(), and ts_tree_cursor_goto_first_child_for_point().

ts_subtree_string()

char* ts_subtree_string	(	Subtree	self,
		const TSLanguage *	language,
		bool	include_all
	)

Definition at line 947 of file subtree.c.

  {
  char scratch_string[1];
  size_t size = ts_subtree__write_to_string(
    self, scratch_string, 1,
    language, include_all,
    0, false, ROOT_FIELD
  ) + 1;
  char *result = ts_malloc(size * sizeof(char));
  ts_subtree__write_to_string(
    self, result, size,
    language, include_all,
    0, false, ROOT_FIELD
  );
  return result;
}

References ROOT_FIELD, ts_malloc, and ts_subtree__write_to_string().

Referenced by ts_node_string().

ts_subtree_summarize()

void ts_subtree_summarize	(	MutableSubtree	,
		const Subtree *	,
		uint32_t	,
		const TSLanguage *
	)

ts_subtree_summarize_children()

void ts_subtree_summarize_children	(	MutableSubtree	self,
		const TSLanguage *	language
	)

Definition at line 371 of file subtree.c.

  {
  assert(!self.data.is_inline);
 
  self.ptr->named_child_count = 0;
  self.ptr->visible_child_count = 0;
  self.ptr->error_cost = 0;
  self.ptr->repeat_depth = 0;
  self.ptr->node_count = 1;
  self.ptr->has_external_tokens = false;
  self.ptr->depends_on_column = false;
  self.ptr->dynamic_precedence = 0;
 
  uint32_t structural_index = 0;
  const TSSymbol *alias_sequence = ts_language_alias_sequence(language, self.ptr->production_id);
  uint32_t lookahead_end_byte = 0;
 
  const Subtree *children = ts_subtree_children(self);
  for (uint32_t i = 0; i < self.ptr->child_count; i++) {
    Subtree child = children[i];
 
    if (
      self.ptr->size.extent.row == 0 &&
      ts_subtree_depends_on_column(child)
    ) {
      self.ptr->depends_on_column = true;
    }
 
    if (i == 0) {
      self.ptr->padding = ts_subtree_padding(child);
      self.ptr->size = ts_subtree_size(child);
    } else {
      self.ptr->size = length_add(self.ptr->size, ts_subtree_total_size(child));
    }
 
    uint32_t child_lookahead_end_byte =
      self.ptr->padding.bytes +
      self.ptr->size.bytes +
      ts_subtree_lookahead_bytes(child);
    if (child_lookahead_end_byte > lookahead_end_byte) {
      lookahead_end_byte = child_lookahead_end_byte;
    }
 
    if (ts_subtree_symbol(child) != ts_builtin_sym_error_repeat) {
      self.ptr->error_cost += ts_subtree_error_cost(child);
    }
 
    uint32_t grandchild_count = ts_subtree_child_count(child);
    if (
      self.ptr->symbol == ts_builtin_sym_error ||
      self.ptr->symbol == ts_builtin_sym_error_repeat
    ) {
      if (!ts_subtree_extra(child) && !(ts_subtree_is_error(child) && grandchild_count == 0)) {
        if (ts_subtree_visible(child)) {
          self.ptr->error_cost += ERROR_COST_PER_SKIPPED_TREE;
        } else if (grandchild_count > 0) {
          self.ptr->error_cost += ERROR_COST_PER_SKIPPED_TREE * child.ptr->visible_child_count;
        }
      }
    }
 
    self.ptr->dynamic_precedence += ts_subtree_dynamic_precedence(child);
    self.ptr->node_count += ts_subtree_node_count(child);
 
    if (alias_sequence && alias_sequence[structural_index] != 0 && !ts_subtree_extra(child)) {
      self.ptr->visible_child_count++;
      if (ts_language_symbol_metadata(language, alias_sequence[structural_index]).named) {
        self.ptr->named_child_count++;
      }
    } else if (ts_subtree_visible(child)) {
      self.ptr->visible_child_count++;
      if (ts_subtree_named(child)) self.ptr->named_child_count++;
    } else if (grandchild_count > 0) {
      self.ptr->visible_child_count += child.ptr->visible_child_count;
      self.ptr->named_child_count += child.ptr->named_child_count;
    }
 
    if (ts_subtree_has_external_tokens(child)) self.ptr->has_external_tokens = true;
 
    if (ts_subtree_is_error(child)) {
      self.ptr->fragile_left = self.ptr->fragile_right = true;
      self.ptr->parse_state = TS_TREE_STATE_NONE;
    }
 
    if (!ts_subtree_extra(child)) structural_index++;
  }
 
  self.ptr->lookahead_bytes = lookahead_end_byte - self.ptr->size.bytes - self.ptr->padding.bytes;
 
  if (
    self.ptr->symbol == ts_builtin_sym_error ||
    self.ptr->symbol == ts_builtin_sym_error_repeat
  ) {
    self.ptr->error_cost +=
      ERROR_COST_PER_RECOVERY +
      ERROR_COST_PER_SKIPPED_CHAR * self.ptr->size.bytes +
      ERROR_COST_PER_SKIPPED_LINE * self.ptr->size.extent.row;
  }
 
  if (self.ptr->child_count > 0) {
    Subtree first_child = children[0];
    Subtree last_child = children[self.ptr->child_count - 1];
 
    self.ptr->first_leaf.symbol = ts_subtree_leaf_symbol(first_child);
    self.ptr->first_leaf.parse_state = ts_subtree_leaf_parse_state(first_child);
 
    if (ts_subtree_fragile_left(first_child)) self.ptr->fragile_left = true;
    if (ts_subtree_fragile_right(last_child)) self.ptr->fragile_right = true;
 
    if (
      self.ptr->child_count >= 2 &&
      !self.ptr->visible &&
      !self.ptr->named &&
      ts_subtree_symbol(first_child) == self.ptr->symbol
    ) {
      if (ts_subtree_repeat_depth(first_child) > ts_subtree_repeat_depth(last_child)) {
        self.ptr->repeat_depth = ts_subtree_repeat_depth(first_child) + 1;
      } else {
        self.ptr->repeat_depth = ts_subtree_repeat_depth(last_child) + 1;
      }
    }
  }
}

References assert(), SubtreeHeapData::depends_on_column, ERROR_COST_PER_RECOVERY, ERROR_COST_PER_SKIPPED_CHAR, ERROR_COST_PER_SKIPPED_LINE, ERROR_COST_PER_SKIPPED_TREE, SubtreeHeapData::first_leaf, i, length_add(), SubtreeHeapData::named_child_count, Subtree::ptr, ts_builtin_sym_error, ts_builtin_sym_error_repeat, ts_language_alias_sequence(), ts_language_symbol_metadata(), ts_subtree_child_count(), ts_subtree_children, ts_subtree_depends_on_column(), ts_subtree_dynamic_precedence(), ts_subtree_error_cost(), ts_subtree_extra(), ts_subtree_fragile_left(), ts_subtree_fragile_right(), ts_subtree_has_external_tokens(), ts_subtree_is_error(), ts_subtree_leaf_parse_state(), ts_subtree_leaf_symbol(), ts_subtree_lookahead_bytes(), ts_subtree_named(), ts_subtree_node_count(), ts_subtree_padding(), ts_subtree_repeat_depth(), ts_subtree_size(), ts_subtree_symbol(), ts_subtree_total_size(), ts_subtree_visible(), TS_TREE_STATE_NONE, and SubtreeHeapData::visible_child_count.

Referenced by ts_subtree__compress(), and ts_subtree_new_node().

ts_subtree_symbol()

static TSSymbol ts_subtree_symbol ( Subtree  self )

inlinestatic

Definition at line 213 of file subtree.h.

{ return SUBTREE_GET(self, symbol); }

References SUBTREE_GET.

Referenced by iterator_compare(), stack__subtree_is_equivalent(), ts_node_symbol(), ts_node_type(), ts_parser__accept(), ts_parser__advance(), ts_parser__breakdown_top_of_stack(), ts_parser__get_cached_token(), ts_parser__lex(), ts_parser__recover(), ts_parser__select_children(), ts_stack_print_dot_graph(), ts_subtree__print_dot_graph(), ts_subtree__write_to_string(), ts_subtree_compare(), ts_subtree_is_eof(), ts_subtree_is_error(), and ts_subtree_summarize_children().

ts_subtree_to_mut_unsafe()

static MutableSubtree ts_subtree_to_mut_unsafe ( Subtree  self )

inlinestatic

Definition at line 356 of file subtree.h.

                                                                    {
  MutableSubtree result;
  result.data = self.data;
  return result;
}

References MutableSubtree::data.

Referenced by ts_subtree__compress(), ts_subtree_balance(), ts_subtree_make_mut(), and ts_subtree_release().

ts_subtree_total_bytes()

static uint32_t ts_subtree_total_bytes ( Subtree  self )

inlinestatic

Definition at line 278 of file subtree.h.

                                                            {
  return ts_subtree_total_size(self).bytes;
}

References Length::bytes, and ts_subtree_total_size().

Referenced by reusable_node_advance(), ts_node__prev_sibling(), ts_parser__handle_error(), ts_parser__recover(), ts_parser__reuse_node(), ts_stack_has_advanced_since_error(), ts_subtree__print_dot_graph(), and ts_subtree_has_trailing_empty_descendant().

ts_subtree_total_size()

static Length ts_subtree_total_size ( Subtree  self )

inlinestatic

Definition at line 274 of file subtree.h.

                                                         {
  return length_add(ts_subtree_padding(self), ts_subtree_size(self));
}

References length_add(), ts_subtree_padding(), and ts_subtree_size().

Referenced by iterator_advance(), stack_node_new(), ts_parser__lex(), ts_parser__recover(), ts_subtree_edit(), ts_subtree_get_changed_ranges(), ts_subtree_summarize_children(), and ts_subtree_total_bytes().

ts_subtree_visible()

static bool ts_subtree_visible ( Subtree  self )

inlinestatic

Definition at line 214 of file subtree.h.

{ return SUBTREE_GET(self, visible); }

References SUBTREE_GET.

Referenced by iterator_get_visible_state(), iterator_tree_is_visible(), ts_node__is_relevant(), ts_stack_print_dot_graph(), ts_subtree__write_to_string(), ts_subtree_summarize_children(), ts_tree_cursor_child_iterator_next(), ts_tree_cursor_current_field_id(), ts_tree_cursor_goto_parent(), and ts_tree_cursor_parent_node().

ts_subtree_visible_child_count()

static uint32_t ts_subtree_visible_child_count ( Subtree  self )

inlinestatic

Definition at line 294 of file subtree.h.

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

References ts_subtree_child_count().

Referenced by ts_tree_cursor_current_status(), ts_tree_cursor_goto_first_child(), ts_tree_cursor_goto_first_child_for_byte(), ts_tree_cursor_goto_first_child_for_point(), and ts_tree_cursor_goto_next_sibling().