binding.c File Reference

#include <emscripten.h>
#include <tree_sitter/api.h>
#include <stdio.h>
#include "array.h"
#include "point.h"

Go to the source code of this file.

Functions
void *	ts_init ()
static uint32_t	code_unit_to_byte (uint32_t unit)
static uint32_t	byte_to_code_unit (uint32_t byte)
static void	marshal_node (const void **buffer, TSNode node)
static TSNode	unmarshal_node (const TSTree *tree)
static void	marshal_cursor (const TSTreeCursor *cursor)
static TSTreeCursor	unmarshal_cursor (const void **buffer, const TSTree *tree)
static void	marshal_point (TSPoint point)
static TSPoint	unmarshal_point (const void **address)
static void	marshal_range (TSRange *range)
static void	unmarshal_range (TSRange *range)
static TSInputEdit	unmarshal_edit ()
void	tree_sitter_parse_callback (char *input_buffer, uint32_t index, uint32_t row, uint32_t column, uint32_t *length_read)
void	tree_sitter_log_callback (bool is_lex_message, const char *message)
static const char *	call_parse_callback (void *payload, uint32_t byte, TSPoint position, uint32_t *bytes_read)
static void	call_log_callback (void *payload, TSLogType log_type, const char *message)
void	ts_parser_new_wasm ()
void	ts_parser_enable_logger_wasm (TSParser *self, bool should_log)
TSTree *	ts_parser_parse_wasm (TSParser *self, char *input_buffer, const TSTree *old_tree, TSRange *ranges, uint32_t range_count)
int	ts_language_type_is_named_wasm (const TSLanguage *self, TSSymbol typeId)
int	ts_language_type_is_visible_wasm (const TSLanguage *self, TSSymbol typeId)
void	ts_tree_root_node_wasm (const TSTree *tree)
void	ts_tree_edit_wasm (TSTree *tree)
void	ts_tree_get_changed_ranges_wasm (TSTree *tree, TSTree *other)
void	ts_tree_cursor_new_wasm (const TSTree *tree)
void	ts_tree_cursor_delete_wasm (const TSTree *tree)
void	ts_tree_cursor_reset_wasm (const TSTree *tree)
bool	ts_tree_cursor_goto_first_child_wasm (const TSTree *tree)
bool	ts_tree_cursor_goto_next_sibling_wasm (const TSTree *tree)
bool	ts_tree_cursor_goto_parent_wasm (const TSTree *tree)
uint16_t	ts_tree_cursor_current_node_type_id_wasm (const TSTree *tree)
bool	ts_tree_cursor_current_node_is_named_wasm (const TSTree *tree)
bool	ts_tree_cursor_current_node_is_missing_wasm (const TSTree *tree)
const uint32_t	ts_tree_cursor_current_node_id_wasm (const TSTree *tree)
void	ts_tree_cursor_start_position_wasm (const TSTree *tree)
void	ts_tree_cursor_end_position_wasm (const TSTree *tree)
uint32_t	ts_tree_cursor_start_index_wasm (const TSTree *tree)
uint32_t	ts_tree_cursor_end_index_wasm (const TSTree *tree)
uint32_t	ts_tree_cursor_current_field_id_wasm (const TSTree *tree)
void	ts_tree_cursor_current_node_wasm (const TSTree *tree)
uint16_t	ts_node_symbol_wasm (const TSTree *tree)
uint32_t	ts_node_child_count_wasm (const TSTree *tree)
uint32_t	ts_node_named_child_count_wasm (const TSTree *tree)
void	ts_node_child_wasm (const TSTree *tree, uint32_t index)
void	ts_node_named_child_wasm (const TSTree *tree, uint32_t index)
void	ts_node_child_by_field_id_wasm (const TSTree *tree, uint32_t field_id)
void	ts_node_next_sibling_wasm (const TSTree *tree)
void	ts_node_prev_sibling_wasm (const TSTree *tree)
void	ts_node_next_named_sibling_wasm (const TSTree *tree)
void	ts_node_prev_named_sibling_wasm (const TSTree *tree)
void	ts_node_parent_wasm (const TSTree *tree)
void	ts_node_descendant_for_index_wasm (const TSTree *tree)
void	ts_node_named_descendant_for_index_wasm (const TSTree *tree)
void	ts_node_descendant_for_position_wasm (const TSTree *tree)
void	ts_node_named_descendant_for_position_wasm (const TSTree *tree)
void	ts_node_start_point_wasm (const TSTree *tree)
void	ts_node_end_point_wasm (const TSTree *tree)
uint32_t	ts_node_start_index_wasm (const TSTree *tree)
uint32_t	ts_node_end_index_wasm (const TSTree *tree)
char *	ts_node_to_string_wasm (const TSTree *tree)
void	ts_node_children_wasm (const TSTree *tree)
void	ts_node_named_children_wasm (const TSTree *tree)
bool	symbols_contain (const uint32_t *set, uint32_t length, uint32_t value)
void	ts_node_descendants_of_type_wasm (const TSTree *tree, const uint32_t *symbols, uint32_t symbol_count, uint32_t start_row, uint32_t start_column, uint32_t end_row, uint32_t end_column)
int	ts_node_is_named_wasm (const TSTree *tree)
int	ts_node_has_changes_wasm (const TSTree *tree)
int	ts_node_has_error_wasm (const TSTree *tree)
int	ts_node_is_missing_wasm (const TSTree *tree)
void	ts_query_matches_wasm (const TSQuery *self, const TSTree *tree, uint32_t start_row, uint32_t start_column, uint32_t end_row, uint32_t end_column, uint32_t match_limit)
void	ts_query_captures_wasm (const TSQuery *self, const TSTree *tree, uint32_t start_row, uint32_t start_column, uint32_t end_row, uint32_t end_column, uint32_t match_limit)

Variables
static const uint32_t	INPUT_BUFFER_SIZE = 10 * 1024
const void *	TRANSFER_BUFFER [12]
static TSTreeCursor	scratch_cursor = {0}
static TSQueryCursor *	scratch_query_cursor = NULL

Function Documentation

byte_to_code_unit()

static uint32_t byte_to_code_unit ( uint32_t  byte )

static

Definition at line 29 of file binding.c.

                                                 {
  return byte >> 1;
}

Referenced by call_parse_callback(), marshal_node(), marshal_point(), marshal_range(), ts_node_end_index_wasm(), ts_node_start_index_wasm(), ts_tree_cursor_end_index_wasm(), and ts_tree_cursor_start_index_wasm().

call_log_callback()

static void call_log_callback ( void *  payload, TSLogType  log_type, const char *  message  )

static

Definition at line 143 of file binding.c.

  {
  tree_sitter_log_callback(log_type == TSLogTypeLex, message);
}

References message, tree_sitter_log_callback(), and TSLogTypeLex.

Referenced by ts_parser_enable_logger_wasm().

call_parse_callback()

static const char* call_parse_callback ( void *  payload, uint32_t  byte, TSPoint  position, uint32_t *  bytes_read  )

static

Definition at line 122 of file binding.c.

  {
  char *buffer = (char *)payload;
  tree_sitter_parse_callback(
    buffer,
    byte_to_code_unit(byte),
    position.row,
    byte_to_code_unit(position.column),
    bytes_read
  );
  *bytes_read = code_unit_to_byte(*bytes_read);
  if (*bytes_read >= INPUT_BUFFER_SIZE) {
    *bytes_read = INPUT_BUFFER_SIZE - 2;
  }
  return buffer;
}

References byte_to_code_unit(), code_unit_to_byte(), TSPoint::column, INPUT_BUFFER_SIZE, TSPoint::row, and tree_sitter_parse_callback().

Referenced by ts_parser_parse_wasm().

code_unit_to_byte()

static uint32_t code_unit_to_byte ( uint32_t  unit )

static

Definition at line 25 of file binding.c.

                                                 {
  return unit << 1;
}

Referenced by call_parse_callback(), ts_node_descendant_for_index_wasm(), ts_node_descendants_of_type_wasm(), ts_node_named_descendant_for_index_wasm(), ts_query_captures_wasm(), ts_query_matches_wasm(), unmarshal_edit(), unmarshal_node(), unmarshal_point(), and unmarshal_range().

marshal_cursor()

static void marshal_cursor ( const TSTreeCursor *  cursor )

inlinestatic

Definition at line 52 of file binding.c.

                                                              {
  TRANSFER_BUFFER[0] = (const void *)cursor->id;
  TRANSFER_BUFFER[1] = (const void *)cursor->context[0];
  TRANSFER_BUFFER[2] = (const void *)cursor->context[1];
}

References TSTreeCursor::context, TSTreeCursor::id, and TRANSFER_BUFFER.

Referenced by ts_tree_cursor_goto_first_child_wasm(), ts_tree_cursor_goto_next_sibling_wasm(), ts_tree_cursor_goto_parent_wasm(), ts_tree_cursor_new_wasm(), and ts_tree_cursor_reset_wasm().

marshal_node()

static void marshal_node ( const void **  buffer, TSNode  node  )

inlinestatic

Definition at line 33 of file binding.c.

                                                                  {
  buffer[0] = (const void *)node.id;
  buffer[1] = (const void *)byte_to_code_unit(node.context[0]);
  buffer[2] = (const void *)node.context[1];
  buffer[3] = (const void *)byte_to_code_unit(node.context[2]);
  buffer[4] = (const void *)node.context[3];
}

References byte_to_code_unit(), TSNode::context, and TSNode::id.

Referenced by ts_node_child_by_field_id_wasm(), ts_node_child_wasm(), ts_node_children_wasm(), ts_node_descendant_for_index_wasm(), ts_node_descendant_for_position_wasm(), ts_node_descendants_of_type_wasm(), ts_node_named_child_wasm(), ts_node_named_children_wasm(), ts_node_named_descendant_for_index_wasm(), ts_node_named_descendant_for_position_wasm(), ts_node_next_named_sibling_wasm(), ts_node_next_sibling_wasm(), ts_node_parent_wasm(), ts_node_prev_named_sibling_wasm(), ts_node_prev_sibling_wasm(), ts_query_captures_wasm(), ts_query_matches_wasm(), ts_tree_cursor_current_node_wasm(), and ts_tree_root_node_wasm().

marshal_point()

static void marshal_point ( TSPoint  point )

static

Definition at line 67 of file binding.c.

                                         {
  TRANSFER_BUFFER[0] = (const void *)point.row;
  TRANSFER_BUFFER[1] = (const void *)byte_to_code_unit(point.column);
}

References byte_to_code_unit(), and TRANSFER_BUFFER.

Referenced by ts_node_end_point_wasm(), ts_node_start_point_wasm(), ts_tree_cursor_end_position_wasm(), and ts_tree_cursor_start_position_wasm().

marshal_range()

static void marshal_range ( TSRange *  range )

static

Definition at line 79 of file binding.c.

                                          {
  range->start_byte = byte_to_code_unit(range->start_byte);
  range->end_byte = byte_to_code_unit(range->end_byte);
  range->start_point.column = byte_to_code_unit(range->start_point.column);
  range->end_point.column = byte_to_code_unit(range->end_point.column);
}

References byte_to_code_unit(), and capstone::range.

Referenced by ts_tree_get_changed_ranges_wasm().

symbols_contain()

bool symbols_contain	(	const uint32_t *	set,
		uint32_t	length,
		uint32_t	value
	)

Definition at line 490 of file binding.c.

                                                                           {
  for (unsigned i = 0; i < length; i++) {
    if (set[i] == value) return true;
    if (set[i] > value) break;
  }
  return false;
}

References i, length, and value.

Referenced by ts_node_descendants_of_type_wasm().

tree_sitter_log_callback()

void tree_sitter_log_callback	(	bool	is_lex_message,
		const char *	message
	)

Referenced by call_log_callback().

tree_sitter_parse_callback()

void tree_sitter_parse_callback	(	char *	input_buffer,
		uint32_t	index,
		uint32_t	row,
		uint32_t	column,
		uint32_t *	length_read
	)

Referenced by call_parse_callback().

ts_init()

void* ts_init

(

)

Definition at line 19 of file binding.c.

                {
  TRANSFER_BUFFER[0] = (const void *)TREE_SITTER_LANGUAGE_VERSION;
  TRANSFER_BUFFER[1] = (const void *)TREE_SITTER_MIN_COMPATIBLE_LANGUAGE_VERSION;
  return TRANSFER_BUFFER;
}

References TRANSFER_BUFFER, TREE_SITTER_LANGUAGE_VERSION, and TREE_SITTER_MIN_COMPATIBLE_LANGUAGE_VERSION.

ts_language_type_is_named_wasm()

int ts_language_type_is_named_wasm	(	const TSLanguage *	self,
		TSSymbol	typeId
	)

Definition at line 191 of file binding.c.

                                                                            {
  const TSSymbolType symbolType = ts_language_symbol_type(self, typeId);
  return symbolType == TSSymbolTypeRegular;
}

References ts_language_symbol_type(), and TSSymbolTypeRegular.

ts_language_type_is_visible_wasm()

int ts_language_type_is_visible_wasm	(	const TSLanguage *	self,
		TSSymbol	typeId
	)

Definition at line 196 of file binding.c.

                                                                              {
  const TSSymbolType symbolType = ts_language_symbol_type(self, typeId);
  return symbolType <= TSSymbolTypeAnonymous;
}

References ts_language_symbol_type(), and TSSymbolTypeAnonymous.

ts_node_child_by_field_id_wasm()

void ts_node_child_by_field_id_wasm	(	const TSTree *	tree,
		uint32_t	field_id
	)

Definition at line 357 of file binding.c.

                                                                           {
  TSNode node = unmarshal_node(tree);
  marshal_node(TRANSFER_BUFFER, ts_node_child_by_field_id(node, field_id));
}

References field_id, marshal_node(), TRANSFER_BUFFER, ts_node_child_by_field_id(), and unmarshal_node().

ts_node_child_count_wasm()

uint32_t ts_node_child_count_wasm

(

const TSTree *

tree

)

Definition at line 337 of file binding.c.

                                                      {
  TSNode node = unmarshal_node(tree);
  return ts_node_child_count(node);
}

References ts_node_child_count(), and unmarshal_node().

ts_node_child_wasm()

void ts_node_child_wasm	(	const TSTree *	tree,
		uint32_t	index
	)

Definition at line 347 of file binding.c.

                                                            {
  TSNode node = unmarshal_node(tree);
  marshal_node(TRANSFER_BUFFER, ts_node_child(node, index));
}

References marshal_node(), TRANSFER_BUFFER, ts_node_child(), and unmarshal_node().

ts_node_children_wasm()

void ts_node_children_wasm

(

const TSTree *

tree

)

Definition at line 444 of file binding.c.

                                               {
  TSNode node = unmarshal_node(tree);
  uint32_t count = ts_node_child_count(node);
  const void **result = NULL;
  if (count > 0) {
    result = calloc(sizeof(void *), 5 * count);
    const void **address = result;
    ts_tree_cursor_reset(&scratch_cursor, node);
    ts_tree_cursor_goto_first_child(&scratch_cursor);
    marshal_node(address, ts_tree_cursor_current_node(&scratch_cursor));
    for (uint32_t i = 1; i < count; i++) {
      address += 5;
      ts_tree_cursor_goto_next_sibling(&scratch_cursor);
      TSNode child = ts_tree_cursor_current_node(&scratch_cursor);
      marshal_node(address, child);
    }
  }
  TRANSFER_BUFFER[0] = (const void *)count;
  TRANSFER_BUFFER[1] = result;
}

References calloc(), count, i, marshal_node(), NULL, scratch_cursor, TRANSFER_BUFFER, ts_node_child_count(), ts_tree_cursor_current_node(), ts_tree_cursor_goto_first_child(), ts_tree_cursor_goto_next_sibling(), ts_tree_cursor_reset(), and unmarshal_node().

ts_node_descendant_for_index_wasm()

void ts_node_descendant_for_index_wasm

(

const TSTree *

tree

)

Definition at line 387 of file binding.c.

                                                           {
  TSNode node = unmarshal_node(tree);
  const void **address = TRANSFER_BUFFER + 5;
  uint32_t start = code_unit_to_byte((uint32_t)address[0]);
  uint32_t end = code_unit_to_byte((uint32_t)address[1]);
  marshal_node(TRANSFER_BUFFER, ts_node_descendant_for_byte_range(node, start, end));
}

References code_unit_to_byte(), test_evm::end, marshal_node(), start, TRANSFER_BUFFER, ts_node_descendant_for_byte_range(), and unmarshal_node().

ts_node_descendant_for_position_wasm()

void ts_node_descendant_for_position_wasm

(

const TSTree *

tree

)

Definition at line 403 of file binding.c.

                                                              {
  TSNode node = unmarshal_node(tree);
  const void **address = TRANSFER_BUFFER + 5;
  TSPoint start = unmarshal_point(address); address += 2;
  TSPoint end = unmarshal_point(address);
  marshal_node(TRANSFER_BUFFER, ts_node_descendant_for_point_range(node, start, end));
}

References test_evm::end, marshal_node(), start, TRANSFER_BUFFER, ts_node_descendant_for_point_range(), unmarshal_node(), and unmarshal_point().

ts_node_descendants_of_type_wasm()

void ts_node_descendants_of_type_wasm	(	const TSTree *	tree,
		const uint32_t *	symbols,
		uint32_t	symbol_count,
		uint32_t	start_row,
		uint32_t	start_column,
		uint32_t	end_row,
		uint32_t	end_column
	)

Definition at line 498 of file binding.c.

  {
  TSNode node = unmarshal_node(tree);
  TSPoint start_point = {start_row, code_unit_to_byte(start_column)};
  TSPoint end_point = {end_row, code_unit_to_byte(end_column)};
  if (end_point.row == 0 && end_point.column == 0) {
    end_point = (TSPoint) {UINT32_MAX, UINT32_MAX};
  }
 
  Array(const void *) result = array_new();
 
  // Walk the tree depth first looking for matching nodes.
  ts_tree_cursor_reset(&scratch_cursor, node);
  bool already_visited_children = false;
  while (true) {
    TSNode descendant = ts_tree_cursor_current_node(&scratch_cursor);
 
    if (!already_visited_children) {
      // If this node is before the selected range, then avoid
      // descending into it.
      if (point_lte(ts_node_end_point(descendant), start_point)) {
        if (ts_tree_cursor_goto_next_sibling(&scratch_cursor)) {
          already_visited_children = false;
        } else {
          if (!ts_tree_cursor_goto_parent(&scratch_cursor)) break;
          already_visited_children = true;
        }
        continue;
      }
 
      // If this node is after the selected range, then stop walking.
      if (point_lte(end_point, ts_node_start_point(descendant))) break;
 
      // Add the node to the result if its type matches one of the given
      // node types.
      if (symbols_contain(symbols, symbol_count, ts_node_symbol(descendant))) {
        array_grow_by(&result, 5);
        marshal_node(result.contents + result.size - 5, descendant);
      }
 
      // Continue walking.
      if (ts_tree_cursor_goto_first_child(&scratch_cursor)) {
        already_visited_children = false;
      } else if (ts_tree_cursor_goto_next_sibling(&scratch_cursor)) {
        already_visited_children = false;
      } else {
        if (!ts_tree_cursor_goto_parent(&scratch_cursor)) break;
        already_visited_children = true;
      }
    } else {
      if (ts_tree_cursor_goto_next_sibling(&scratch_cursor)) {
        already_visited_children = false;
      } else {
        if (!ts_tree_cursor_goto_parent(&scratch_cursor)) break;
      }
    }
  }
 
  TRANSFER_BUFFER[0] = (const void *)(result.size / 5);
  TRANSFER_BUFFER[1] = result.contents;
}

References Array, array_grow_by, array_new, code_unit_to_byte(), TSPoint::column, marshal_node(), point_lte(), TSPoint::row, scratch_cursor, symbols(), symbols_contain(), TRANSFER_BUFFER, ts_node_end_point(), ts_node_start_point(), ts_node_symbol(), ts_tree_cursor_current_node(), ts_tree_cursor_goto_first_child(), ts_tree_cursor_goto_next_sibling(), ts_tree_cursor_goto_parent(), ts_tree_cursor_reset(), UINT32_MAX, and unmarshal_node().

ts_node_end_index_wasm()

uint32_t ts_node_end_index_wasm

(

const TSTree *

tree

)

Definition at line 434 of file binding.c.

                                                    {
  TSNode node = unmarshal_node(tree);
  return byte_to_code_unit(ts_node_end_byte(node));
}

References byte_to_code_unit(), ts_node_end_byte(), and unmarshal_node().

ts_node_end_point_wasm()

void ts_node_end_point_wasm

(

const TSTree *

tree

)

Definition at line 424 of file binding.c.

                                                {
  TSNode node = unmarshal_node(tree);
  marshal_point(ts_node_end_point(node));
}

References marshal_point(), ts_node_end_point(), and unmarshal_node().

ts_node_has_changes_wasm()

int ts_node_has_changes_wasm

(

const TSTree *

tree

)

Definition at line 572 of file binding.c.

                                                 {
  TSNode node = unmarshal_node(tree);
  return ts_node_has_changes(node);
}

References ts_node_has_changes(), and unmarshal_node().

ts_node_has_error_wasm()

int ts_node_has_error_wasm

(

const TSTree *

tree

)

Definition at line 577 of file binding.c.

                                               {
  TSNode node = unmarshal_node(tree);
  return ts_node_has_error(node);
}

References ts_node_has_error(), and unmarshal_node().

ts_node_is_missing_wasm()

int ts_node_is_missing_wasm

(

const TSTree *

tree

)

Definition at line 582 of file binding.c.

                                                {
  TSNode node = unmarshal_node(tree);
  return ts_node_is_missing(node);
}

References ts_node_is_missing(), and unmarshal_node().

ts_node_is_named_wasm()

int ts_node_is_named_wasm

(

const TSTree *

tree

)

Definition at line 567 of file binding.c.

                                              {
  TSNode node = unmarshal_node(tree);
  return ts_node_is_named(node);
}

References ts_node_is_named(), and unmarshal_node().

ts_node_named_child_count_wasm()

uint32_t ts_node_named_child_count_wasm

(

const TSTree *

tree

)

Definition at line 342 of file binding.c.

                                                            {
  TSNode node = unmarshal_node(tree);
  return ts_node_named_child_count(node);
}

References ts_node_named_child_count(), and unmarshal_node().

ts_node_named_child_wasm()

void ts_node_named_child_wasm	(	const TSTree *	tree,
		uint32_t	index
	)

Definition at line 352 of file binding.c.

                                                                  {
  TSNode node = unmarshal_node(tree);
  marshal_node(TRANSFER_BUFFER, ts_node_named_child(node, index));
}

References marshal_node(), TRANSFER_BUFFER, ts_node_named_child(), and unmarshal_node().

ts_node_named_children_wasm()

void ts_node_named_children_wasm

(

const TSTree *

tree

)

Definition at line 465 of file binding.c.

                                                     {
  TSNode node = unmarshal_node(tree);
  uint32_t count = ts_node_named_child_count(node);
  const void **result = NULL;
  if (count > 0) {
    result = calloc(sizeof(void *), 5 * count);
    const void **address = result;
    ts_tree_cursor_reset(&scratch_cursor, node);
    ts_tree_cursor_goto_first_child(&scratch_cursor);
    uint32_t i = 0;
    for (;;) {
      TSNode child = ts_tree_cursor_current_node(&scratch_cursor);
      if (ts_node_is_named(child)) {
        marshal_node(address, child);
        address += 5;
        i++;
        if (i == count) break;
      }
      if (!ts_tree_cursor_goto_next_sibling(&scratch_cursor)) break;
    }
  }
  TRANSFER_BUFFER[0] = (const void *)count;
  TRANSFER_BUFFER[1] = result;
}

References calloc(), count, i, marshal_node(), NULL, scratch_cursor, TRANSFER_BUFFER, ts_node_is_named(), ts_node_named_child_count(), ts_tree_cursor_current_node(), ts_tree_cursor_goto_first_child(), ts_tree_cursor_goto_next_sibling(), ts_tree_cursor_reset(), and unmarshal_node().

ts_node_named_descendant_for_index_wasm()

void ts_node_named_descendant_for_index_wasm

(

const TSTree *

tree

)

Definition at line 395 of file binding.c.

                                                                 {
  TSNode node = unmarshal_node(tree);
  const void **address = TRANSFER_BUFFER + 5;
  uint32_t start = code_unit_to_byte((uint32_t)address[0]);
  uint32_t end = code_unit_to_byte((uint32_t)address[1]);
  marshal_node(TRANSFER_BUFFER, ts_node_named_descendant_for_byte_range(node, start, end));
}

References code_unit_to_byte(), test_evm::end, marshal_node(), start, TRANSFER_BUFFER, ts_node_named_descendant_for_byte_range(), and unmarshal_node().

ts_node_named_descendant_for_position_wasm()

void ts_node_named_descendant_for_position_wasm

(

const TSTree *

tree

)

Definition at line 411 of file binding.c.

                                                                    {
  TSNode node = unmarshal_node(tree);
  const void **address = TRANSFER_BUFFER + 5;
  TSPoint start = unmarshal_point(address); address += 2;
  TSPoint end = unmarshal_point(address);
  marshal_node(TRANSFER_BUFFER, ts_node_named_descendant_for_point_range(node, start, end));
}

References test_evm::end, marshal_node(), start, TRANSFER_BUFFER, ts_node_named_descendant_for_point_range(), unmarshal_node(), and unmarshal_point().

ts_node_next_named_sibling_wasm()

void ts_node_next_named_sibling_wasm

(

const TSTree *

tree

)

Definition at line 372 of file binding.c.

                                                         {
  TSNode node = unmarshal_node(tree);
  marshal_node(TRANSFER_BUFFER, ts_node_next_named_sibling(node));
}

References marshal_node(), TRANSFER_BUFFER, ts_node_next_named_sibling(), and unmarshal_node().

ts_node_next_sibling_wasm()

void ts_node_next_sibling_wasm

(

const TSTree *

tree

)

Definition at line 362 of file binding.c.

                                                   {
  TSNode node = unmarshal_node(tree);
  marshal_node(TRANSFER_BUFFER, ts_node_next_sibling(node));
}

References marshal_node(), TRANSFER_BUFFER, ts_node_next_sibling(), and unmarshal_node().

ts_node_parent_wasm()

void ts_node_parent_wasm

(

const TSTree *

tree

)

Definition at line 382 of file binding.c.

                                             {
  TSNode node = unmarshal_node(tree);
  marshal_node(TRANSFER_BUFFER, ts_node_parent(node));
}

References marshal_node(), TRANSFER_BUFFER, ts_node_parent(), and unmarshal_node().

ts_node_prev_named_sibling_wasm()

void ts_node_prev_named_sibling_wasm

(

const TSTree *

tree

)

Definition at line 377 of file binding.c.

                                                         {
  TSNode node = unmarshal_node(tree);
  marshal_node(TRANSFER_BUFFER, ts_node_prev_named_sibling(node));
}

References marshal_node(), TRANSFER_BUFFER, ts_node_prev_named_sibling(), and unmarshal_node().

ts_node_prev_sibling_wasm()

void ts_node_prev_sibling_wasm

(

const TSTree *

tree

)

Definition at line 367 of file binding.c.

                                                   {
  TSNode node = unmarshal_node(tree);
  marshal_node(TRANSFER_BUFFER, ts_node_prev_sibling(node));
}

References marshal_node(), TRANSFER_BUFFER, ts_node_prev_sibling(), and unmarshal_node().

ts_node_start_index_wasm()

uint32_t ts_node_start_index_wasm

(

const TSTree *

tree

)

Definition at line 429 of file binding.c.

                                                      {
  TSNode node = unmarshal_node(tree);
  return byte_to_code_unit(ts_node_start_byte(node));
}

References byte_to_code_unit(), ts_node_start_byte(), and unmarshal_node().

ts_node_start_point_wasm()

void ts_node_start_point_wasm

(

const TSTree *

tree

)

Definition at line 419 of file binding.c.

                                                  {
  TSNode node = unmarshal_node(tree);
  marshal_point(ts_node_start_point(node));
}

References marshal_point(), ts_node_start_point(), and unmarshal_node().

ts_node_symbol_wasm()

uint16_t ts_node_symbol_wasm

(

const TSTree *

tree

)

Definition at line 332 of file binding.c.

                                                 {
  TSNode node = unmarshal_node(tree);
  return ts_node_symbol(node);
}

References ts_node_symbol(), and unmarshal_node().

ts_node_to_string_wasm()

char* ts_node_to_string_wasm

(

const TSTree *

tree

)

Definition at line 439 of file binding.c.

                                                 {
  TSNode node = unmarshal_node(tree);
  return ts_node_string(node);
}

References ts_node_string(), and unmarshal_node().

ts_parser_enable_logger_wasm()

void ts_parser_enable_logger_wasm	(	TSParser *	self,
		bool	should_log
	)

Definition at line 158 of file binding.c.

                                                                   {
  TSLogger logger = {self, should_log ? call_log_callback : NULL};
  ts_parser_set_logger(self, logger);
}

References call_log_callback(), NULL, and ts_parser_set_logger().

ts_parser_new_wasm()

void ts_parser_new_wasm

(

)

Definition at line 151 of file binding.c.

                          {
  TSParser *parser = ts_parser_new();
  char *input_buffer = calloc(INPUT_BUFFER_SIZE, sizeof(char));
  TRANSFER_BUFFER[0] = parser;
  TRANSFER_BUFFER[1] = input_buffer;
}

References calloc(), INPUT_BUFFER_SIZE, cmd_descs_generate::parser, TRANSFER_BUFFER, and ts_parser_new().

ts_parser_parse_wasm()

TSTree* ts_parser_parse_wasm	(	TSParser *	self,
		char *	input_buffer,
		const TSTree *	old_tree,
		TSRange *	ranges,
		uint32_t	range_count
	)

Definition at line 163 of file binding.c.

  {
  TSInput input = {
    input_buffer,
    call_parse_callback,
    TSInputEncodingUTF16
  };
  if (range_count) {
    for (unsigned i = 0; i < range_count; i++) {
      unmarshal_range(&ranges[i]);
    }
    ts_parser_set_included_ranges(self, ranges, range_count);
    free(ranges);
  } else {
    ts_parser_set_included_ranges(self, NULL, 0);
  }
  return ts_parser_parse(self, old_tree, input);
}

References call_parse_callback(), free(), i, input(), NULL, ts_parser_parse(), ts_parser_set_included_ranges(), TSInputEncodingUTF16, and unmarshal_range().

ts_query_captures_wasm()

void ts_query_captures_wasm	(	const TSQuery *	self,
		const TSTree *	tree,
		uint32_t	start_row,
		uint32_t	start_column,
		uint32_t	end_row,
		uint32_t	end_column,
		uint32_t	match_limit
	)

Definition at line 638 of file binding.c.

  {
  if (!scratch_query_cursor) scratch_query_cursor = ts_query_cursor_new();
  if (match_limit == 0) {
    ts_query_cursor_set_match_limit(scratch_query_cursor, UINT32_MAX);
  } else {
    ts_query_cursor_set_match_limit(scratch_query_cursor, match_limit);
  }
 
  TSNode node = unmarshal_node(tree);
  TSPoint start_point = {start_row, code_unit_to_byte(start_column)};
  TSPoint end_point = {end_row, code_unit_to_byte(end_column)};
  ts_query_cursor_set_point_range(scratch_query_cursor, start_point, end_point);
  ts_query_cursor_exec(scratch_query_cursor, self, node);
 
  unsigned index = 0;
  unsigned capture_count = 0;
  Array(const void *) result = array_new();
 
  TSQueryMatch match;
  uint32_t capture_index;
  while (ts_query_cursor_next_capture(
    scratch_query_cursor,
    &match,
    &capture_index
  )) {
    capture_count++;
 
    array_grow_by(&result, 3 + 6 * match.capture_count);
    result.contents[index++] = (const void *)(uint32_t)match.pattern_index;
    result.contents[index++] = (const void *)(uint32_t)match.capture_count;
    result.contents[index++] = (const void *)(uint32_t)capture_index;
    for (unsigned i = 0; i < match.capture_count; i++) {
      const TSQueryCapture *capture = &match.captures[i];
      result.contents[index++] = (const void *)capture->index;
      marshal_node(result.contents + index, capture->node);
      index += 5;
    }
  }
 
  bool did_exceed_match_limit =
    ts_query_cursor_did_exceed_match_limit(scratch_query_cursor);
  TRANSFER_BUFFER[0] = (const void *)(capture_count);
  TRANSFER_BUFFER[1] = result.contents;
  TRANSFER_BUFFER[2] = (const void *)(did_exceed_match_limit);
}

References Array, array_grow_by, array_new, code_unit_to_byte(), i, TSQueryCapture::index, marshal_node(), match, TSQueryCapture::node, scratch_query_cursor, TRANSFER_BUFFER, ts_query_cursor_did_exceed_match_limit(), ts_query_cursor_exec(), ts_query_cursor_new(), ts_query_cursor_next_capture(), ts_query_cursor_set_match_limit(), ts_query_cursor_set_point_range(), UINT32_MAX, and unmarshal_node().

ts_query_matches_wasm()

void ts_query_matches_wasm	(	const TSQuery *	self,
		const TSTree *	tree,
		uint32_t	start_row,
		uint32_t	start_column,
		uint32_t	end_row,
		uint32_t	end_column,
		uint32_t	match_limit
	)

Definition at line 591 of file binding.c.

  {
  if (!scratch_query_cursor) scratch_query_cursor = ts_query_cursor_new();
  if (match_limit == 0) {
    ts_query_cursor_set_match_limit(scratch_query_cursor, UINT32_MAX);
  } else {
    ts_query_cursor_set_match_limit(scratch_query_cursor, match_limit);
  }
 
  TSNode node = unmarshal_node(tree);
  TSPoint start_point = {start_row, code_unit_to_byte(start_column)};
  TSPoint end_point = {end_row, code_unit_to_byte(end_column)};
  ts_query_cursor_set_point_range(scratch_query_cursor, start_point, end_point);
  ts_query_cursor_exec(scratch_query_cursor, self, node);
 
  uint32_t index = 0;
  uint32_t match_count = 0;
  Array(const void *) result = array_new();
 
  TSQueryMatch match;
  while (ts_query_cursor_next_match(scratch_query_cursor, &match)) {
    match_count++;
    array_grow_by(&result, 2 + 6 * match.capture_count);
    result.contents[index++] = (const void *)(uint32_t)match.pattern_index;
    result.contents[index++] = (const void *)(uint32_t)match.capture_count;
    for (unsigned i = 0; i < match.capture_count; i++) {
      const TSQueryCapture *capture = &match.captures[i];
      result.contents[index++] = (const void *)capture->index;
      marshal_node(result.contents + index, capture->node);
      index += 5;
    }
  }
 
  bool did_exceed_match_limit =
    ts_query_cursor_did_exceed_match_limit(scratch_query_cursor);
  TRANSFER_BUFFER[0] = (const void *)(match_count);
  TRANSFER_BUFFER[1] = result.contents;
  TRANSFER_BUFFER[2] = (const void *)(did_exceed_match_limit);
}

References Array, array_grow_by, array_new, code_unit_to_byte(), i, TSQueryCapture::index, marshal_node(), match, TSQueryCapture::node, scratch_query_cursor, TRANSFER_BUFFER, ts_query_cursor_did_exceed_match_limit(), ts_query_cursor_exec(), ts_query_cursor_new(), ts_query_cursor_next_match(), ts_query_cursor_set_match_limit(), ts_query_cursor_set_point_range(), UINT32_MAX, and unmarshal_node().

ts_tree_cursor_current_field_id_wasm()

uint32_t ts_tree_cursor_current_field_id_wasm

(

const TSTree *

tree

)

Definition at line 315 of file binding.c.

                                                                  {
  TSTreeCursor cursor = unmarshal_cursor(TRANSFER_BUFFER, tree);
  return ts_tree_cursor_current_field_id(&cursor);
}

References TRANSFER_BUFFER, ts_tree_cursor_current_field_id(), and unmarshal_cursor().

ts_tree_cursor_current_node_id_wasm()

const uint32_t ts_tree_cursor_current_node_id_wasm

(

const TSTree *

tree

)

Definition at line 285 of file binding.c.

                                                                       {
  TSTreeCursor cursor = unmarshal_cursor(TRANSFER_BUFFER, tree);
  TSNode node = ts_tree_cursor_current_node(&cursor);
  return (uint32_t)node.id;
}

References TSNode::id, TRANSFER_BUFFER, ts_tree_cursor_current_node(), and unmarshal_cursor().

ts_tree_cursor_current_node_is_missing_wasm()

bool ts_tree_cursor_current_node_is_missing_wasm

(

const TSTree *

tree

)

Definition at line 279 of file binding.c.

                                                                     {
  TSTreeCursor cursor = unmarshal_cursor(TRANSFER_BUFFER, tree);
  TSNode node = ts_tree_cursor_current_node(&cursor);
  return ts_node_is_missing(node);
}

References TRANSFER_BUFFER, ts_node_is_missing(), ts_tree_cursor_current_node(), and unmarshal_cursor().

ts_tree_cursor_current_node_is_named_wasm()

bool ts_tree_cursor_current_node_is_named_wasm

(

const TSTree *

tree

)

Definition at line 273 of file binding.c.

                                                                   {
  TSTreeCursor cursor = unmarshal_cursor(TRANSFER_BUFFER, tree);
  TSNode node = ts_tree_cursor_current_node(&cursor);
  return ts_node_is_named(node);
}

References TRANSFER_BUFFER, ts_node_is_named(), ts_tree_cursor_current_node(), and unmarshal_cursor().

ts_tree_cursor_current_node_type_id_wasm()

uint16_t ts_tree_cursor_current_node_type_id_wasm

(

const TSTree *

tree

)

Definition at line 267 of file binding.c.

                                                                      {
  TSTreeCursor cursor = unmarshal_cursor(TRANSFER_BUFFER, tree);
  TSNode node = ts_tree_cursor_current_node(&cursor);
  return ts_node_symbol(node);
}

References TRANSFER_BUFFER, ts_node_symbol(), ts_tree_cursor_current_node(), and unmarshal_cursor().

ts_tree_cursor_current_node_wasm()

void ts_tree_cursor_current_node_wasm

(

const TSTree *

tree

)

Definition at line 320 of file binding.c.

                                                          {
  TSTreeCursor cursor = unmarshal_cursor(TRANSFER_BUFFER, tree);
  marshal_node(TRANSFER_BUFFER, ts_tree_cursor_current_node(&cursor));
}

References marshal_node(), TRANSFER_BUFFER, ts_tree_cursor_current_node(), and unmarshal_cursor().

ts_tree_cursor_delete_wasm()

void ts_tree_cursor_delete_wasm

(

const TSTree *

tree

)

Definition at line 234 of file binding.c.

                                                    {
  TSTreeCursor cursor = unmarshal_cursor(TRANSFER_BUFFER, tree);
  ts_tree_cursor_delete(&cursor);
}

References TRANSFER_BUFFER, ts_tree_cursor_delete(), and unmarshal_cursor().

ts_tree_cursor_end_index_wasm()

uint32_t ts_tree_cursor_end_index_wasm

(

const TSTree *

tree

)

Definition at line 309 of file binding.c.

                                                           {
  TSTreeCursor cursor = unmarshal_cursor(TRANSFER_BUFFER, tree);
  TSNode node = ts_tree_cursor_current_node(&cursor);
  return byte_to_code_unit(ts_node_end_byte(node));
}

References byte_to_code_unit(), TRANSFER_BUFFER, ts_node_end_byte(), ts_tree_cursor_current_node(), and unmarshal_cursor().

ts_tree_cursor_end_position_wasm()

void ts_tree_cursor_end_position_wasm

(

const TSTree *

tree

)

Definition at line 297 of file binding.c.

                                                          {
  TSTreeCursor cursor = unmarshal_cursor(TRANSFER_BUFFER, tree);
  TSNode node = ts_tree_cursor_current_node(&cursor);
  marshal_point(ts_node_end_point(node));
}

References marshal_point(), TRANSFER_BUFFER, ts_node_end_point(), ts_tree_cursor_current_node(), and unmarshal_cursor().

ts_tree_cursor_goto_first_child_wasm()

bool ts_tree_cursor_goto_first_child_wasm

(

const TSTree *

tree

)

Definition at line 246 of file binding.c.

                                                              {
  TSTreeCursor cursor = unmarshal_cursor(TRANSFER_BUFFER, tree);
  bool result = ts_tree_cursor_goto_first_child(&cursor);
  marshal_cursor(&cursor);
  return result;
}

References marshal_cursor(), TRANSFER_BUFFER, ts_tree_cursor_goto_first_child(), and unmarshal_cursor().

ts_tree_cursor_goto_next_sibling_wasm()

bool ts_tree_cursor_goto_next_sibling_wasm

(

const TSTree *

tree

)

Definition at line 253 of file binding.c.

                                                               {
  TSTreeCursor cursor = unmarshal_cursor(TRANSFER_BUFFER, tree);
  bool result = ts_tree_cursor_goto_next_sibling(&cursor);
  marshal_cursor(&cursor);
  return result;
}

References marshal_cursor(), TRANSFER_BUFFER, ts_tree_cursor_goto_next_sibling(), and unmarshal_cursor().

ts_tree_cursor_goto_parent_wasm()

bool ts_tree_cursor_goto_parent_wasm

(

const TSTree *

tree

)

Definition at line 260 of file binding.c.

                                                         {
  TSTreeCursor cursor = unmarshal_cursor(TRANSFER_BUFFER, tree);
  bool result = ts_tree_cursor_goto_parent(&cursor);
  marshal_cursor(&cursor);
  return result;
}

References marshal_cursor(), TRANSFER_BUFFER, ts_tree_cursor_goto_parent(), and unmarshal_cursor().

ts_tree_cursor_new_wasm()

void ts_tree_cursor_new_wasm

(

const TSTree *

tree

)

Definition at line 228 of file binding.c.

                                                 {
  TSNode node = unmarshal_node(tree);
  TSTreeCursor cursor = ts_tree_cursor_new(node);
  marshal_cursor(&cursor);
}

References marshal_cursor(), ts_tree_cursor_new(), and unmarshal_node().

ts_tree_cursor_reset_wasm()

void ts_tree_cursor_reset_wasm

(

const TSTree *

tree

)

Definition at line 239 of file binding.c.

                                                   {
  TSNode node = unmarshal_node(tree);
  TSTreeCursor cursor = unmarshal_cursor(&TRANSFER_BUFFER[5], tree);
  ts_tree_cursor_reset(&cursor, node);
  marshal_cursor(&cursor);
}

References marshal_cursor(), TRANSFER_BUFFER, ts_tree_cursor_reset(), unmarshal_cursor(), and unmarshal_node().

ts_tree_cursor_start_index_wasm()

uint32_t ts_tree_cursor_start_index_wasm

(

const TSTree *

tree

)

Definition at line 303 of file binding.c.

                                                             {
  TSTreeCursor cursor = unmarshal_cursor(TRANSFER_BUFFER, tree);
  TSNode node = ts_tree_cursor_current_node(&cursor);
  return byte_to_code_unit(ts_node_start_byte(node));
}

References byte_to_code_unit(), TRANSFER_BUFFER, ts_node_start_byte(), ts_tree_cursor_current_node(), and unmarshal_cursor().

ts_tree_cursor_start_position_wasm()

void ts_tree_cursor_start_position_wasm

(

const TSTree *

tree

)

Definition at line 291 of file binding.c.

                                                            {
  TSTreeCursor cursor = unmarshal_cursor(TRANSFER_BUFFER, tree);
  TSNode node = ts_tree_cursor_current_node(&cursor);
  marshal_point(ts_node_start_point(node));
}

References marshal_point(), TRANSFER_BUFFER, ts_node_start_point(), ts_tree_cursor_current_node(), and unmarshal_cursor().

ts_tree_edit_wasm()

void ts_tree_edit_wasm

(

TSTree *

tree

)

Definition at line 209 of file binding.c.

                                     {
  TSInputEdit edit = unmarshal_edit();
  ts_tree_edit(tree, &edit);
}

References ts_tree_edit(), and unmarshal_edit().

ts_tree_get_changed_ranges_wasm()

void ts_tree_get_changed_ranges_wasm	(	TSTree *	tree,
		TSTree *	other
	)

Definition at line 214 of file binding.c.

                                                                  {
  unsigned range_count;
  TSRange *ranges = ts_tree_get_changed_ranges(tree, other, &range_count);
  for (unsigned i = 0; i < range_count; i++) {
    marshal_range(&ranges[i]);
  }
  TRANSFER_BUFFER[0] = (const void *)range_count;
  TRANSFER_BUFFER[1] = (const void *)ranges;
}

References i, marshal_range(), TRANSFER_BUFFER, and ts_tree_get_changed_ranges().

ts_tree_root_node_wasm()

void ts_tree_root_node_wasm

(

const TSTree *

tree

)

Definition at line 205 of file binding.c.

                                                {
  marshal_node(TRANSFER_BUFFER, ts_tree_root_node(tree));
}

References marshal_node(), TRANSFER_BUFFER, and ts_tree_root_node().

unmarshal_cursor()

static TSTreeCursor unmarshal_cursor ( const void **  buffer, const TSTree *  tree  )

inlinestatic

Definition at line 58 of file binding.c.

                                                                                     {
  TSTreeCursor cursor;
  cursor.id = buffer[0];
  cursor.context[0] = (uint32_t)buffer[1];
  cursor.context[1] = (uint32_t)buffer[2];
  cursor.tree = tree;
  return cursor;
}

References TSTreeCursor::context, TSTreeCursor::id, and TSTreeCursor::tree.

Referenced by ts_tree_cursor_current_field_id_wasm(), 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_delete_wasm(), ts_tree_cursor_end_index_wasm(), ts_tree_cursor_end_position_wasm(), ts_tree_cursor_goto_first_child_wasm(), ts_tree_cursor_goto_next_sibling_wasm(), ts_tree_cursor_goto_parent_wasm(), ts_tree_cursor_reset_wasm(), ts_tree_cursor_start_index_wasm(), and ts_tree_cursor_start_position_wasm().

unmarshal_edit()

static TSInputEdit unmarshal_edit ( )

static

Definition at line 93 of file binding.c.

                                    {
  TSInputEdit edit;
  const void **address = TRANSFER_BUFFER;
  edit.start_point = unmarshal_point(address); address += 2;
  edit.old_end_point = unmarshal_point(address); address += 2;
  edit.new_end_point = unmarshal_point(address); address += 2;
  edit.start_byte = code_unit_to_byte((uint32_t)*address); address += 1;
  edit.old_end_byte = code_unit_to_byte((uint32_t)*address); address += 1;
  edit.new_end_byte = code_unit_to_byte((uint32_t)*address); address += 1;
  return edit;
}

References code_unit_to_byte(), TSInputEdit::new_end_byte, TSInputEdit::new_end_point, TSInputEdit::old_end_byte, TSInputEdit::old_end_point, TSInputEdit::start_byte, TSInputEdit::start_point, TRANSFER_BUFFER, and unmarshal_point().

Referenced by ts_tree_edit_wasm().

unmarshal_node()

static TSNode unmarshal_node ( const TSTree *  tree )

inlinestatic

Definition at line 41 of file binding.c.

                                                        {
  TSNode node;
  node.id = TRANSFER_BUFFER[0];
  node.context[0] = code_unit_to_byte((uint32_t)TRANSFER_BUFFER[1]);
  node.context[1] = (uint32_t)TRANSFER_BUFFER[2];
  node.context[2] = code_unit_to_byte((uint32_t)TRANSFER_BUFFER[3]);
  node.context[3] = (uint32_t)TRANSFER_BUFFER[4];
  node.tree = tree;
  return node;
}

References code_unit_to_byte(), TSNode::context, TSNode::id, TRANSFER_BUFFER, and TSNode::tree.

Referenced by ts_node_child_by_field_id_wasm(), ts_node_child_count_wasm(), ts_node_child_wasm(), ts_node_children_wasm(), ts_node_descendant_for_index_wasm(), ts_node_descendant_for_position_wasm(), ts_node_descendants_of_type_wasm(), ts_node_end_index_wasm(), ts_node_end_point_wasm(), ts_node_has_changes_wasm(), ts_node_has_error_wasm(), ts_node_is_missing_wasm(), ts_node_is_named_wasm(), ts_node_named_child_count_wasm(), ts_node_named_child_wasm(), ts_node_named_children_wasm(), ts_node_named_descendant_for_index_wasm(), ts_node_named_descendant_for_position_wasm(), ts_node_next_named_sibling_wasm(), ts_node_next_sibling_wasm(), ts_node_parent_wasm(), ts_node_prev_named_sibling_wasm(), ts_node_prev_sibling_wasm(), ts_node_start_index_wasm(), ts_node_start_point_wasm(), ts_node_symbol_wasm(), ts_node_to_string_wasm(), ts_query_captures_wasm(), ts_query_matches_wasm(), ts_tree_cursor_new_wasm(), and ts_tree_cursor_reset_wasm().

unmarshal_point()

static TSPoint unmarshal_point ( const void **  address )

static

Definition at line 72 of file binding.c.

                                                     {
  TSPoint point;
  point.row = (uint32_t)address[0];
  point.column = code_unit_to_byte((uint32_t)address[1]);
  return point;
}

References code_unit_to_byte().

Referenced by ts_node_descendant_for_position_wasm(), ts_node_named_descendant_for_position_wasm(), and unmarshal_edit().

unmarshal_range()

static void unmarshal_range ( TSRange *  range )

static

Definition at line 86 of file binding.c.

                                            {
  range->start_byte = code_unit_to_byte(range->start_byte);
  range->end_byte = code_unit_to_byte(range->end_byte);
  range->start_point.column = code_unit_to_byte(range->start_point.column);
  range->end_point.column = code_unit_to_byte(range->end_point.column);
}

References code_unit_to_byte(), and capstone::range.

Referenced by ts_parser_parse_wasm().

Variable Documentation

INPUT_BUFFER_SIZE

const uint32_t INPUT_BUFFER_SIZE = 10 * 1024

static

Definition at line 11 of file binding.c.

Referenced by call_parse_callback(), and ts_parser_new_wasm().

scratch_cursor

TSTreeCursor scratch_cursor = {0}

static

Definition at line 329 of file binding.c.

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

scratch_query_cursor

TSQueryCursor* scratch_query_cursor = NULL

static

Definition at line 330 of file binding.c.

Referenced by ts_query_captures_wasm(), and ts_query_matches_wasm().

TRANSFER_BUFFER

const void* TRANSFER_BUFFER[12]

Initial value:

= {
  NULL, NULL, NULL, NULL,
  NULL, NULL, NULL, NULL,
  NULL, NULL, NULL, NULL,
}

Definition at line 13 of file binding.c.

Referenced by marshal_cursor(), marshal_point(), ts_init(), ts_node_child_by_field_id_wasm(), ts_node_child_wasm(), ts_node_children_wasm(), ts_node_descendant_for_index_wasm(), ts_node_descendant_for_position_wasm(), ts_node_descendants_of_type_wasm(), ts_node_named_child_wasm(), ts_node_named_children_wasm(), ts_node_named_descendant_for_index_wasm(), ts_node_named_descendant_for_position_wasm(), ts_node_next_named_sibling_wasm(), ts_node_next_sibling_wasm(), ts_node_parent_wasm(), ts_node_prev_named_sibling_wasm(), ts_node_prev_sibling_wasm(), ts_parser_new_wasm(), ts_query_captures_wasm(), ts_query_matches_wasm(), ts_tree_cursor_current_field_id_wasm(), 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_delete_wasm(), ts_tree_cursor_end_index_wasm(), ts_tree_cursor_end_position_wasm(), ts_tree_cursor_goto_first_child_wasm(), ts_tree_cursor_goto_next_sibling_wasm(), ts_tree_cursor_goto_parent_wasm(), ts_tree_cursor_reset_wasm(), ts_tree_cursor_start_index_wasm(), ts_tree_cursor_start_position_wasm(), ts_tree_get_changed_ranges_wasm(), ts_tree_root_node_wasm(), unmarshal_edit(), and unmarshal_node().