api.h

Go to the documentation of this file.

#ifndef TREE_SITTER_API_H_
#define TREE_SITTER_API_H_
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <stdbool.h>
 
/****************************/
/* Section - ABI Versioning */
/****************************/
 
#define TREE_SITTER_LANGUAGE_VERSION 14
 
#define TREE_SITTER_MIN_COMPATIBLE_LANGUAGE_VERSION 13
 
/*******************/
/* Section - Types */
/*******************/
 
typedef uint16_t TSSymbol;
typedef uint16_t TSFieldId;
typedef struct TSLanguage TSLanguage;
typedef struct TSParser TSParser;
typedef struct TSTree TSTree;
typedef struct TSQuery TSQuery;
typedef struct TSQueryCursor TSQueryCursor;
 
typedef enum {
  TSInputEncodingUTF8,
  TSInputEncodingUTF16,
} TSInputEncoding;
 
typedef enum {
  TSSymbolTypeRegular,
  TSSymbolTypeAnonymous,
  TSSymbolTypeAuxiliary,
} TSSymbolType;
 
typedef struct {
  uint32_t row;
  uint32_t column;
} TSPoint;
 
typedef struct {
  TSPoint start_point;
  TSPoint end_point;
  uint32_t start_byte;
  uint32_t end_byte;
} TSRange;
 
typedef struct {
  void *payload;
  const char *(*read)(void *payload, uint32_t byte_index, TSPoint position, uint32_t *bytes_read);
  TSInputEncoding encoding;
} TSInput;
 
typedef enum {
  TSLogTypeParse,
  TSLogTypeLex,
} TSLogType;
 
typedef struct {
  void *payload;
  void (*log)(void *payload, TSLogType, const char *);
} TSLogger;
 
typedef struct {
  uint32_t start_byte;
  uint32_t old_end_byte;
  uint32_t new_end_byte;
  TSPoint start_point;
  TSPoint old_end_point;
  TSPoint new_end_point;
} TSInputEdit;
 
typedef struct {
  uint32_t context[4];
  const void *id;
  const TSTree *tree;
} TSNode;
 
typedef struct {
  const void *tree;
  const void *id;
  uint32_t context[2];
} TSTreeCursor;
 
typedef struct {
  TSNode node;
  uint32_t index;
} TSQueryCapture;
 
typedef enum {
  TSQuantifierZero = 0, // must match the array initialization value
  TSQuantifierZeroOrOne,
  TSQuantifierZeroOrMore,
  TSQuantifierOne,
  TSQuantifierOneOrMore,
} TSQuantifier;
 
typedef struct {
  uint32_t id;
  uint16_t pattern_index;
  uint16_t capture_count;
  const TSQueryCapture *captures;
} TSQueryMatch;
 
typedef enum {
  TSQueryPredicateStepTypeDone,
  TSQueryPredicateStepTypeCapture,
  TSQueryPredicateStepTypeString,
} TSQueryPredicateStepType;
 
typedef struct {
  TSQueryPredicateStepType type;
  uint32_t value_id;
} TSQueryPredicateStep;
 
typedef enum {
  TSQueryErrorNone = 0,
  TSQueryErrorSyntax,
  TSQueryErrorNodeType,
  TSQueryErrorField,
  TSQueryErrorCapture,
  TSQueryErrorStructure,
  TSQueryErrorLanguage,
} TSQueryError;
 
/********************/
/* Section - Parser */
/********************/
 
TSParser *ts_parser_new(void);
 
void ts_parser_delete(TSParser *parser);
 
bool ts_parser_set_language(TSParser *self, const TSLanguage *language);
 
const TSLanguage *ts_parser_language(const TSParser *self);
 
bool ts_parser_set_included_ranges(
  TSParser *self,
  const TSRange *ranges,
  uint32_t length
);
 
const TSRange *ts_parser_included_ranges(
  const TSParser *self,
  uint32_t *length
);
 
TSTree *ts_parser_parse(
  TSParser *self,
  const TSTree *old_tree,
  TSInput input
);
 
TSTree *ts_parser_parse_string(
  TSParser *self,
  const TSTree *old_tree,
  const char *string,
  uint32_t length
);
 
TSTree *ts_parser_parse_string_encoding(
  TSParser *self,
  const TSTree *old_tree,
  const char *string,
  uint32_t length,
  TSInputEncoding encoding
);
 
void ts_parser_reset(TSParser *self);
 
void ts_parser_set_timeout_micros(TSParser *self, uint64_t timeout);
 
uint64_t ts_parser_timeout_micros(const TSParser *self);
 
void ts_parser_set_cancellation_flag(TSParser *self, const size_t *flag);
 
const size_t *ts_parser_cancellation_flag(const TSParser *self);
 
void ts_parser_set_logger(TSParser *self, TSLogger logger);
 
TSLogger ts_parser_logger(const TSParser *self);
 
void ts_parser_print_dot_graphs(TSParser *self, int file);
 
/******************/
/* Section - Tree */
/******************/
 
TSTree *ts_tree_copy(const TSTree *self);
 
void ts_tree_delete(TSTree *self);
 
TSNode ts_tree_root_node(const TSTree *self);
 
const TSLanguage *ts_tree_language(const TSTree *);
 
void ts_tree_edit(TSTree *self, const TSInputEdit *edit);
 
TSRange *ts_tree_get_changed_ranges(
  const TSTree *old_tree,
  const TSTree *new_tree,
  uint32_t *length
);
 
void ts_tree_print_dot_graph(const TSTree *, FILE *);
 
/******************/
/* Section - Node */
/******************/
 
const char *ts_node_type(TSNode);
 
TSSymbol ts_node_symbol(TSNode);
 
uint32_t ts_node_start_byte(TSNode);
 
TSPoint ts_node_start_point(TSNode);
 
uint32_t ts_node_end_byte(TSNode);
 
TSPoint ts_node_end_point(TSNode);
 
char *ts_node_string(TSNode);
 
bool ts_node_is_null(TSNode);
 
bool ts_node_is_named(TSNode);
 
bool ts_node_is_missing(TSNode);
 
bool ts_node_is_extra(TSNode);
 
bool ts_node_has_changes(TSNode);
 
bool ts_node_has_error(TSNode);
 
TSNode ts_node_parent(TSNode);
 
TSNode ts_node_child(TSNode, uint32_t);
 
const char *ts_node_field_name_for_child(TSNode, uint32_t);
 
uint32_t ts_node_child_count(TSNode);
 
TSNode ts_node_named_child(TSNode, uint32_t);
 
uint32_t ts_node_named_child_count(TSNode);
 
TSNode ts_node_child_by_field_name(
  TSNode self,
  const char *field_name,
  uint32_t field_name_length
);
 
TSNode ts_node_child_by_field_id(TSNode, TSFieldId);
 
TSNode ts_node_next_sibling(TSNode);
TSNode ts_node_prev_sibling(TSNode);
 
TSNode ts_node_next_named_sibling(TSNode);
TSNode ts_node_prev_named_sibling(TSNode);
 
TSNode ts_node_first_child_for_byte(TSNode, uint32_t);
 
TSNode ts_node_first_named_child_for_byte(TSNode, uint32_t);
 
TSNode ts_node_descendant_for_byte_range(TSNode, uint32_t, uint32_t);
TSNode ts_node_descendant_for_point_range(TSNode, TSPoint, TSPoint);
 
TSNode ts_node_named_descendant_for_byte_range(TSNode, uint32_t, uint32_t);
TSNode ts_node_named_descendant_for_point_range(TSNode, TSPoint, TSPoint);
 
void ts_node_edit(TSNode *, const TSInputEdit *);
 
bool ts_node_eq(TSNode, TSNode);
 
/************************/
/* Section - TreeCursor */
/************************/
 
TSTreeCursor ts_tree_cursor_new(TSNode);
 
void ts_tree_cursor_delete(TSTreeCursor *);
 
void ts_tree_cursor_reset(TSTreeCursor *, TSNode);
 
TSNode ts_tree_cursor_current_node(const TSTreeCursor *);
 
const char *ts_tree_cursor_current_field_name(const TSTreeCursor *);
 
TSFieldId ts_tree_cursor_current_field_id(const TSTreeCursor *);
 
bool ts_tree_cursor_goto_parent(TSTreeCursor *);
 
bool ts_tree_cursor_goto_next_sibling(TSTreeCursor *);
 
bool ts_tree_cursor_goto_first_child(TSTreeCursor *);
 
int64_t ts_tree_cursor_goto_first_child_for_byte(TSTreeCursor *, uint32_t);
int64_t ts_tree_cursor_goto_first_child_for_point(TSTreeCursor *, TSPoint);
 
TSTreeCursor ts_tree_cursor_copy(const TSTreeCursor *);
 
/*******************/
/* Section - Query */
/*******************/
 
TSQuery *ts_query_new(
  const TSLanguage *language,
  const char *source,
  uint32_t source_len,
  uint32_t *error_offset,
  TSQueryError *error_type
);
 
void ts_query_delete(TSQuery *);
 
uint32_t ts_query_pattern_count(const TSQuery *);
uint32_t ts_query_capture_count(const TSQuery *);
uint32_t ts_query_string_count(const TSQuery *);
 
uint32_t ts_query_start_byte_for_pattern(const TSQuery *, uint32_t);
 
const TSQueryPredicateStep *ts_query_predicates_for_pattern(
  const TSQuery *self,
  uint32_t pattern_index,
  uint32_t *length
);
 
bool ts_query_is_pattern_guaranteed_at_step(
  const TSQuery *self,
  uint32_t byte_offset
);
 
const char *ts_query_capture_name_for_id(
  const TSQuery *,
  uint32_t id,
  uint32_t *length
);
 
TSQuantifier ts_query_capture_quantifier_for_id(
  const TSQuery *,
  uint32_t pattern_id,
  uint32_t capture_id
);
 
const char *ts_query_string_value_for_id(
  const TSQuery *,
  uint32_t id,
  uint32_t *length
);
 
void ts_query_disable_capture(TSQuery *, const char *, uint32_t);
 
void ts_query_disable_pattern(TSQuery *, uint32_t);
 
TSQueryCursor *ts_query_cursor_new(void);
 
void ts_query_cursor_delete(TSQueryCursor *);
 
void ts_query_cursor_exec(TSQueryCursor *, const TSQuery *, TSNode);
 
bool ts_query_cursor_did_exceed_match_limit(const TSQueryCursor *);
uint32_t ts_query_cursor_match_limit(const TSQueryCursor *);
void ts_query_cursor_set_match_limit(TSQueryCursor *, uint32_t);
 
void ts_query_cursor_set_byte_range(TSQueryCursor *, uint32_t, uint32_t);
void ts_query_cursor_set_point_range(TSQueryCursor *, TSPoint, TSPoint);
 
bool ts_query_cursor_next_match(TSQueryCursor *, TSQueryMatch *match);
void ts_query_cursor_remove_match(TSQueryCursor *, uint32_t id);
 
bool ts_query_cursor_next_capture(
  TSQueryCursor *,
  TSQueryMatch *match,
  uint32_t *capture_index
);
 
/**********************/
/* Section - Language */
/**********************/
 
uint32_t ts_language_symbol_count(const TSLanguage *);
 
const char *ts_language_symbol_name(const TSLanguage *, TSSymbol);
 
TSSymbol ts_language_symbol_for_name(
  const TSLanguage *self,
  const char *string,
  uint32_t length,
  bool is_named
);
 
uint32_t ts_language_field_count(const TSLanguage *);
 
const char *ts_language_field_name_for_id(const TSLanguage *, TSFieldId);
 
TSFieldId ts_language_field_id_for_name(const TSLanguage *, const char *, uint32_t);
 
TSSymbolType ts_language_symbol_type(const TSLanguage *, TSSymbol);
 
uint32_t ts_language_version(const TSLanguage *);
 
/**********************************/
/* Section - Global Configuration */
/**********************************/
 
void ts_set_allocator(
  void *(*new_malloc)(size_t),
    void *(*new_calloc)(size_t, size_t),
    void *(*new_realloc)(void *, size_t),
    void (*new_free)(void *)
);
 
#ifdef __cplusplus
}
#endif
 
#endif  // TREE_SITTER_API_H_