1.1--- a/lisp/ffi/tree-sitter/alien.h Fri Oct 04 21:11:52 2024 -0400
1.2+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
1.3@@ -1,1282 +0,0 @@
1.4-#ifndef TREE_SITTER_API_H_
1.5-#define TREE_SITTER_API_H_
1.6-
1.7-#ifndef TREE_SITTER_HIDE_SYMBOLS
1.8-#if defined(__GNUC__) || defined(__clang__)
1.9-#pragma GCC visibility push(default)
1.10-#endif
1.11-#endif
1.12-
1.13-#include <stdlib.h>
1.14-#include <stdint.h>
1.15-#include <stdbool.h>
1.16-
1.17-#ifdef __cplusplus
1.18-extern "C" {
1.19-#endif
1.20-
1.21-/****************************/
1.22-/* Section - ABI Versioning */
1.23-/****************************/
1.24-
1.25-/**
1.26- * The latest ABI version that is supported by the current version of the
1.27- * library. When Languages are generated by the Tree-sitter CLI, they are
1.28- * assigned an ABI version number that corresponds to the current CLI version.
1.29- * The Tree-sitter library is generally backwards-compatible with languages
1.30- * generated using older CLI versions, but is not forwards-compatible.
1.31- */
1.32-#define TREE_SITTER_LANGUAGE_VERSION 14
1.33-
1.34-/**
1.35- * The earliest ABI version that is supported by the current version of the
1.36- * library.
1.37- */
1.38-#define TREE_SITTER_MIN_COMPATIBLE_LANGUAGE_VERSION 13
1.39-
1.40-/*******************/
1.41-/* Section - Types */
1.42-/*******************/
1.43-
1.44-typedef uint16_t TSStateId;
1.45-typedef uint16_t TSSymbol;
1.46-typedef uint16_t TSFieldId;
1.47-typedef struct TSLanguage TSLanguage;
1.48-typedef struct TSParser TSParser;
1.49-typedef struct TSTree TSTree;
1.50-typedef struct TSQuery TSQuery;
1.51-typedef struct TSQueryCursor TSQueryCursor;
1.52-typedef struct TSLookaheadIterator TSLookaheadIterator;
1.53-
1.54-typedef enum TSInputEncoding {
1.55- TSInputEncodingUTF8,
1.56- TSInputEncodingUTF16,
1.57-} TSInputEncoding;
1.58-
1.59-typedef enum TSSymbolType {
1.60- TSSymbolTypeRegular,
1.61- TSSymbolTypeAnonymous,
1.62- TSSymbolTypeAuxiliary,
1.63-} TSSymbolType;
1.64-
1.65-typedef struct TSPoint {
1.66- uint32_t row;
1.67- uint32_t column;
1.68-} TSPoint;
1.69-
1.70-typedef struct TSRange {
1.71- TSPoint start_point;
1.72- TSPoint end_point;
1.73- uint32_t start_byte;
1.74- uint32_t end_byte;
1.75-} TSRange;
1.76-
1.77-typedef struct TSInput {
1.78- void *payload;
1.79- const char *(*read)(void *payload, uint32_t byte_index, TSPoint position, uint32_t *bytes_read);
1.80- TSInputEncoding encoding;
1.81-} TSInput;
1.82-
1.83-typedef enum TSLogType {
1.84- TSLogTypeParse,
1.85- TSLogTypeLex,
1.86-} TSLogType;
1.87-
1.88-typedef struct TSLogger {
1.89- void *payload;
1.90- void (*log)(void *payload, TSLogType log_type, const char *buffer);
1.91-} TSLogger;
1.92-
1.93-typedef struct TSInputEdit {
1.94- uint32_t start_byte;
1.95- uint32_t old_end_byte;
1.96- uint32_t new_end_byte;
1.97- TSPoint start_point;
1.98- TSPoint old_end_point;
1.99- TSPoint new_end_point;
1.100-} TSInputEdit;
1.101-
1.102-typedef struct TSNode {
1.103- uint32_t context[4];
1.104- const void *id;
1.105- const TSTree *tree;
1.106-} TSNode;
1.107-
1.108-typedef struct TSTreeCursor {
1.109- const void *tree;
1.110- const void *id;
1.111- uint32_t context[3];
1.112-} TSTreeCursor;
1.113-
1.114-typedef struct TSQueryCapture {
1.115- TSNode node;
1.116- uint32_t index;
1.117-} TSQueryCapture;
1.118-
1.119-typedef enum TSQuantifier {
1.120- TSQuantifierZero = 0, // must match the array initialization value
1.121- TSQuantifierZeroOrOne,
1.122- TSQuantifierZeroOrMore,
1.123- TSQuantifierOne,
1.124- TSQuantifierOneOrMore,
1.125-} TSQuantifier;
1.126-
1.127-typedef struct TSQueryMatch {
1.128- uint32_t id;
1.129- uint16_t pattern_index;
1.130- uint16_t capture_count;
1.131- const TSQueryCapture *captures;
1.132-} TSQueryMatch;
1.133-
1.134-typedef enum TSQueryPredicateStepType {
1.135- TSQueryPredicateStepTypeDone,
1.136- TSQueryPredicateStepTypeCapture,
1.137- TSQueryPredicateStepTypeString,
1.138-} TSQueryPredicateStepType;
1.139-
1.140-typedef struct TSQueryPredicateStep {
1.141- TSQueryPredicateStepType type;
1.142- uint32_t value_id;
1.143-} TSQueryPredicateStep;
1.144-
1.145-typedef enum TSQueryError {
1.146- TSQueryErrorNone = 0,
1.147- TSQueryErrorSyntax,
1.148- TSQueryErrorNodeType,
1.149- TSQueryErrorField,
1.150- TSQueryErrorCapture,
1.151- TSQueryErrorStructure,
1.152- TSQueryErrorLanguage,
1.153-} TSQueryError;
1.154-
1.155-/********************/
1.156-/* Section - Parser */
1.157-/********************/
1.158-
1.159-/**
1.160- * Create a new parser.
1.161- */
1.162-TSParser *ts_parser_new(void);
1.163-
1.164-/**
1.165- * Delete the parser, freeing all of the memory that it used.
1.166- */
1.167-void ts_parser_delete(TSParser *self);
1.168-
1.169-/**
1.170- * Get the parser's current language.
1.171- */
1.172-const TSLanguage *ts_parser_language(const TSParser *self);
1.173-
1.174-/**
1.175- * Set the language that the parser should use for parsing.
1.176- *
1.177- * Returns a boolean indicating whether or not the language was successfully
1.178- * assigned. True means assignment succeeded. False means there was a version
1.179- * mismatch: the language was generated with an incompatible version of the
1.180- * Tree-sitter CLI. Check the language's version using [`ts_language_version`]
1.181- * and compare it to this library's [`TREE_SITTER_LANGUAGE_VERSION`] and
1.182- * [`TREE_SITTER_MIN_COMPATIBLE_LANGUAGE_VERSION`] constants.
1.183- */
1.184-bool ts_parser_set_language(TSParser *self, const TSLanguage *language);
1.185-
1.186-/**
1.187- * Set the ranges of text that the parser should include when parsing.
1.188- *
1.189- * By default, the parser will always include entire documents. This function
1.190- * allows you to parse only a *portion* of a document but still return a syntax
1.191- * tree whose ranges match up with the document as a whole. You can also pass
1.192- * multiple disjoint ranges.
1.193- *
1.194- * The second and third parameters specify the location and length of an array
1.195- * of ranges. The parser does *not* take ownership of these ranges; it copies
1.196- * the data, so it doesn't matter how these ranges are allocated.
1.197- *
1.198- * If `count` is zero, then the entire document will be parsed. Otherwise,
1.199- * the given ranges must be ordered from earliest to latest in the document,
1.200- * and they must not overlap. That is, the following must hold for all:
1.201- *
1.202- * `i < count - 1`: `ranges[i].end_byte <= ranges[i + 1].start_byte`
1.203- *
1.204- * If this requirement is not satisfied, the operation will fail, the ranges
1.205- * will not be assigned, and this function will return `false`. On success,
1.206- * this function returns `true`
1.207- */
1.208-bool ts_parser_set_included_ranges(
1.209- TSParser *self,
1.210- const TSRange *ranges,
1.211- uint32_t count
1.212-);
1.213-
1.214-/**
1.215- * Get the ranges of text that the parser will include when parsing.
1.216- *
1.217- * The returned pointer is owned by the parser. The caller should not free it
1.218- * or write to it. The length of the array will be written to the given
1.219- * `count` pointer.
1.220- */
1.221-const TSRange *ts_parser_included_ranges(
1.222- const TSParser *self,
1.223- uint32_t *count
1.224-);
1.225-
1.226-/**
1.227- * Use the parser to parse some source code and create a syntax tree.
1.228- *
1.229- * If you are parsing this document for the first time, pass `NULL` for the
1.230- * `old_tree` parameter. Otherwise, if you have already parsed an earlier
1.231- * version of this document and the document has since been edited, pass the
1.232- * previous syntax tree so that the unchanged parts of it can be reused.
1.233- * This will save time and memory. For this to work correctly, you must have
1.234- * already edited the old syntax tree using the [`ts_tree_edit`] function in a
1.235- * way that exactly matches the source code changes.
1.236- *
1.237- * The [`TSInput`] parameter lets you specify how to read the text. It has the
1.238- * following three fields:
1.239- * 1. [`read`]: A function to retrieve a chunk of text at a given byte offset
1.240- * and (row, column) position. The function should return a pointer to the
1.241- * text and write its length to the [`bytes_read`] pointer. The parser does
1.242- * not take ownership of this buffer; it just borrows it until it has
1.243- * finished reading it. The function should write a zero value to the
1.244- * [`bytes_read`] pointer to indicate the end of the document.
1.245- * 2. [`payload`]: An arbitrary pointer that will be passed to each invocation
1.246- * of the [`read`] function.
1.247- * 3. [`encoding`]: An indication of how the text is encoded. Either
1.248- * `TSInputEncodingUTF8` or `TSInputEncodingUTF16`.
1.249- *
1.250- * This function returns a syntax tree on success, and `NULL` on failure. There
1.251- * are three possible reasons for failure:
1.252- * 1. The parser does not have a language assigned. Check for this using the
1.253- [`ts_parser_language`] function.
1.254- * 2. Parsing was cancelled due to a timeout that was set by an earlier call to
1.255- * the [`ts_parser_set_timeout_micros`] function. You can resume parsing from
1.256- * where the parser left out by calling [`ts_parser_parse`] again with the
1.257- * same arguments. Or you can start parsing from scratch by first calling
1.258- * [`ts_parser_reset`].
1.259- * 3. Parsing was cancelled using a cancellation flag that was set by an
1.260- * earlier call to [`ts_parser_set_cancellation_flag`]. You can resume parsing
1.261- * from where the parser left out by calling [`ts_parser_parse`] again with
1.262- * the same arguments.
1.263- *
1.264- * [`read`]: TSInput::read
1.265- * [`payload`]: TSInput::payload
1.266- * [`encoding`]: TSInput::encoding
1.267- * [`bytes_read`]: TSInput::read
1.268- */
1.269-TSTree *ts_parser_parse(
1.270- TSParser *self,
1.271- const TSTree *old_tree,
1.272- TSInput input
1.273-);
1.274-
1.275-/**
1.276- * Use the parser to parse some source code stored in one contiguous buffer.
1.277- * The first two parameters are the same as in the [`ts_parser_parse`] function
1.278- * above. The second two parameters indicate the location of the buffer and its
1.279- * length in bytes.
1.280- */
1.281-TSTree *ts_parser_parse_string(
1.282- TSParser *self,
1.283- const TSTree *old_tree,
1.284- const char *string,
1.285- uint32_t length
1.286-);
1.287-
1.288-/**
1.289- * Use the parser to parse some source code stored in one contiguous buffer with
1.290- * a given encoding. The first four parameters work the same as in the
1.291- * [`ts_parser_parse_string`] method above. The final parameter indicates whether
1.292- * the text is encoded as UTF8 or UTF16.
1.293- */
1.294-TSTree *ts_parser_parse_string_encoding(
1.295- TSParser *self,
1.296- const TSTree *old_tree,
1.297- const char *string,
1.298- uint32_t length,
1.299- TSInputEncoding encoding
1.300-);
1.301-
1.302-/**
1.303- * Instruct the parser to start the next parse from the beginning.
1.304- *
1.305- * If the parser previously failed because of a timeout or a cancellation, then
1.306- * by default, it will resume where it left off on the next call to
1.307- * [`ts_parser_parse`] or other parsing functions. If you don't want to resume,
1.308- * and instead intend to use this parser to parse some other document, you must
1.309- * call [`ts_parser_reset`] first.
1.310- */
1.311-void ts_parser_reset(TSParser *self);
1.312-
1.313-/**
1.314- * Set the maximum duration in microseconds that parsing should be allowed to
1.315- * take before halting.
1.316- *
1.317- * If parsing takes longer than this, it will halt early, returning NULL.
1.318- * See [`ts_parser_parse`] for more information.
1.319- */
1.320-void ts_parser_set_timeout_micros(TSParser *self, uint64_t timeout_micros);
1.321-
1.322-/**
1.323- * Get the duration in microseconds that parsing is allowed to take.
1.324- */
1.325-uint64_t ts_parser_timeout_micros(const TSParser *self);
1.326-
1.327-/**
1.328- * Set the parser's current cancellation flag pointer.
1.329- *
1.330- * If a non-null pointer is assigned, then the parser will periodically read
1.331- * from this pointer during parsing. If it reads a non-zero value, it will
1.332- * halt early, returning NULL. See [`ts_parser_parse`] for more information.
1.333- */
1.334-void ts_parser_set_cancellation_flag(TSParser *self, const size_t *flag);
1.335-
1.336-/**
1.337- * Get the parser's current cancellation flag pointer.
1.338- */
1.339-const size_t *ts_parser_cancellation_flag(const TSParser *self);
1.340-
1.341-/**
1.342- * Set the logger that a parser should use during parsing.
1.343- *
1.344- * The parser does not take ownership over the logger payload. If a logger was
1.345- * previously assigned, the caller is responsible for releasing any memory
1.346- * owned by the previous logger.
1.347- */
1.348-void ts_parser_set_logger(TSParser *self, TSLogger logger);
1.349-
1.350-/**
1.351- * Get the parser's current logger.
1.352- */
1.353-TSLogger ts_parser_logger(const TSParser *self);
1.354-
1.355-/**
1.356- * Set the file descriptor to which the parser should write debugging graphs
1.357- * during parsing. The graphs are formatted in the DOT language. You may want
1.358- * to pipe these graphs directly to a `dot(1)` process in order to generate
1.359- * SVG output. You can turn off this logging by passing a negative number.
1.360- */
1.361-void ts_parser_print_dot_graphs(TSParser *self, int fd);
1.362-
1.363-/******************/
1.364-/* Section - Tree */
1.365-/******************/
1.366-
1.367-/**
1.368- * Create a shallow copy of the syntax tree. This is very fast.
1.369- *
1.370- * You need to copy a syntax tree in order to use it on more than one thread at
1.371- * a time, as syntax trees are not thread safe.
1.372- */
1.373-TSTree *ts_tree_copy(const TSTree *self);
1.374-
1.375-/**
1.376- * Delete the syntax tree, freeing all of the memory that it used.
1.377- */
1.378-void ts_tree_delete(TSTree *self);
1.379-
1.380-/**
1.381- * Get the root node of the syntax tree.
1.382- */
1.383-TSNode ts_tree_root_node(const TSTree *self);
1.384-
1.385-/**
1.386- * Get the root node of the syntax tree, but with its position
1.387- * shifted forward by the given offset.
1.388- */
1.389-TSNode ts_tree_root_node_with_offset(
1.390- const TSTree *self,
1.391- uint32_t offset_bytes,
1.392- TSPoint offset_extent
1.393-);
1.394-
1.395-/**
1.396- * Get the language that was used to parse the syntax tree.
1.397- */
1.398-const TSLanguage *ts_tree_language(const TSTree *self);
1.399-
1.400-/**
1.401- * Get the array of included ranges that was used to parse the syntax tree.
1.402- *
1.403- * The returned pointer must be freed by the caller.
1.404- */
1.405-TSRange *ts_tree_included_ranges(const TSTree *self, uint32_t *length);
1.406-
1.407-/**
1.408- * Edit the syntax tree to keep it in sync with source code that has been
1.409- * edited.
1.410- *
1.411- * You must describe the edit both in terms of byte offsets and in terms of
1.412- * (row, column) coordinates.
1.413- */
1.414-void ts_tree_edit(TSTree *self, const TSInputEdit *edit);
1.415-
1.416-/**
1.417- * Compare an old edited syntax tree to a new syntax tree representing the same
1.418- * document, returning an array of ranges whose syntactic structure has changed.
1.419- *
1.420- * For this to work correctly, the old syntax tree must have been edited such
1.421- * that its ranges match up to the new tree. Generally, you'll want to call
1.422- * this function right after calling one of the [`ts_parser_parse`] functions.
1.423- * You need to pass the old tree that was passed to parse, as well as the new
1.424- * tree that was returned from that function.
1.425- *
1.426- * The returned array is allocated using `malloc` and the caller is responsible
1.427- * for freeing it using `free`. The length of the array will be written to the
1.428- * given `length` pointer.
1.429- */
1.430-TSRange *ts_tree_get_changed_ranges(
1.431- const TSTree *old_tree,
1.432- const TSTree *new_tree,
1.433- uint32_t *length
1.434-);
1.435-
1.436-/**
1.437- * Write a DOT graph describing the syntax tree to the given file.
1.438- */
1.439-void ts_tree_print_dot_graph(const TSTree *self, int file_descriptor);
1.440-
1.441-/******************/
1.442-/* Section - Node */
1.443-/******************/
1.444-
1.445-/**
1.446- * Get the node's type as a null-terminated string.
1.447- */
1.448-const char *ts_node_type(TSNode self);
1.449-
1.450-/**
1.451- * Get the node's type as a numerical id.
1.452- */
1.453-TSSymbol ts_node_symbol(TSNode self);
1.454-
1.455-/**
1.456- * Get the node's language.
1.457- */
1.458-const TSLanguage *ts_node_language(TSNode self);
1.459-
1.460-/**
1.461- * Get the node's type as it appears in the grammar ignoring aliases as a
1.462- * null-terminated string.
1.463- */
1.464-const char *ts_node_grammar_type(TSNode self);
1.465-
1.466-/**
1.467- * Get the node's type as a numerical id as it appears in the grammar ignoring
1.468- * aliases. This should be used in [`ts_language_next_state`] instead of
1.469- * [`ts_node_symbol`].
1.470- */
1.471-TSSymbol ts_node_grammar_symbol(TSNode self);
1.472-
1.473-/**
1.474- * Get the node's start byte.
1.475- */
1.476-uint32_t ts_node_start_byte(TSNode self);
1.477-
1.478-/**
1.479- * Get the node's start position in terms of rows and columns.
1.480- */
1.481-TSPoint ts_node_start_point(TSNode self);
1.482-
1.483-/**
1.484- * Get the node's end byte.
1.485- */
1.486-uint32_t ts_node_end_byte(TSNode self);
1.487-
1.488-/**
1.489- * Get the node's end position in terms of rows and columns.
1.490- */
1.491-TSPoint ts_node_end_point(TSNode self);
1.492-
1.493-/**
1.494- * Get an S-expression representing the node as a string.
1.495- *
1.496- * This string is allocated with `malloc` and the caller is responsible for
1.497- * freeing it using `free`.
1.498- */
1.499-char *ts_node_string(TSNode self);
1.500-
1.501-/**
1.502- * Check if the node is null. Functions like [`ts_node_child`] and
1.503- * [`ts_node_next_sibling`] will return a null node to indicate that no such node
1.504- * was found.
1.505- */
1.506-bool ts_node_is_null(TSNode self);
1.507-
1.508-/**
1.509- * Check if the node is *named*. Named nodes correspond to named rules in the
1.510- * grammar, whereas *anonymous* nodes correspond to string literals in the
1.511- * grammar.
1.512- */
1.513-bool ts_node_is_named(TSNode self);
1.514-
1.515-/**
1.516- * Check if the node is *missing*. Missing nodes are inserted by the parser in
1.517- * order to recover from certain kinds of syntax errors.
1.518- */
1.519-bool ts_node_is_missing(TSNode self);
1.520-
1.521-/**
1.522- * Check if the node is *extra*. Extra nodes represent things like comments,
1.523- * which are not required the grammar, but can appear anywhere.
1.524- */
1.525-bool ts_node_is_extra(TSNode self);
1.526-
1.527-/**
1.528- * Check if a syntax node has been edited.
1.529- */
1.530-bool ts_node_has_changes(TSNode self);
1.531-
1.532-/**
1.533- * Check if the node is a syntax error or contains any syntax errors.
1.534- */
1.535-bool ts_node_has_error(TSNode self);
1.536-
1.537-/**
1.538- * Check if the node is a syntax error.
1.539-*/
1.540-bool ts_node_is_error(TSNode self);
1.541-
1.542-/**
1.543- * Get this node's parse state.
1.544-*/
1.545-TSStateId ts_node_parse_state(TSNode self);
1.546-
1.547-/**
1.548- * Get the parse state after this node.
1.549-*/
1.550-TSStateId ts_node_next_parse_state(TSNode self);
1.551-
1.552-/**
1.553- * Get the node's immediate parent.
1.554- * Prefer [`ts_node_child_containing_descendant`] for
1.555- * iterating over the node's ancestors.
1.556- */
1.557-TSNode ts_node_parent(TSNode self);
1.558-
1.559-/**
1.560- * Get the node's child that contains `descendant`.
1.561- */
1.562-TSNode ts_node_child_containing_descendant(TSNode self, TSNode descendant);
1.563-
1.564-/**
1.565- * Get the node's child at the given index, where zero represents the first
1.566- * child.
1.567- */
1.568-TSNode ts_node_child(TSNode self, uint32_t child_index);
1.569-
1.570-/**
1.571- * Get the field name for node's child at the given index, where zero represents
1.572- * the first child. Returns NULL, if no field is found.
1.573- */
1.574-const char *ts_node_field_name_for_child(TSNode self, uint32_t child_index);
1.575-
1.576-/**
1.577- * Get the node's number of children.
1.578- */
1.579-uint32_t ts_node_child_count(TSNode self);
1.580-
1.581-/**
1.582- * Get the node's *named* child at the given index.
1.583- *
1.584- * See also [`ts_node_is_named`].
1.585- */
1.586-TSNode ts_node_named_child(TSNode self, uint32_t child_index);
1.587-
1.588-/**
1.589- * Get the node's number of *named* children.
1.590- *
1.591- * See also [`ts_node_is_named`].
1.592- */
1.593-uint32_t ts_node_named_child_count(TSNode self);
1.594-
1.595-/**
1.596- * Get the node's child with the given field name.
1.597- */
1.598-TSNode ts_node_child_by_field_name(
1.599- TSNode self,
1.600- const char *name,
1.601- uint32_t name_length
1.602-);
1.603-
1.604-/**
1.605- * Get the node's child with the given numerical field id.
1.606- *
1.607- * You can convert a field name to an id using the
1.608- * [`ts_language_field_id_for_name`] function.
1.609- */
1.610-TSNode ts_node_child_by_field_id(TSNode self, TSFieldId field_id);
1.611-
1.612-/**
1.613- * Get the node's next / previous sibling.
1.614- */
1.615-TSNode ts_node_next_sibling(TSNode self);
1.616-TSNode ts_node_prev_sibling(TSNode self);
1.617-
1.618-/**
1.619- * Get the node's next / previous *named* sibling.
1.620- */
1.621-TSNode ts_node_next_named_sibling(TSNode self);
1.622-TSNode ts_node_prev_named_sibling(TSNode self);
1.623-
1.624-/**
1.625- * Get the node's first child that extends beyond the given byte offset.
1.626- */
1.627-TSNode ts_node_first_child_for_byte(TSNode self, uint32_t byte);
1.628-
1.629-/**
1.630- * Get the node's first named child that extends beyond the given byte offset.
1.631- */
1.632-TSNode ts_node_first_named_child_for_byte(TSNode self, uint32_t byte);
1.633-
1.634-/**
1.635- * Get the node's number of descendants, including one for the node itself.
1.636- */
1.637-uint32_t ts_node_descendant_count(TSNode self);
1.638-
1.639-/**
1.640- * Get the smallest node within this node that spans the given range of bytes
1.641- * or (row, column) positions.
1.642- */
1.643-TSNode ts_node_descendant_for_byte_range(TSNode self, uint32_t start, uint32_t end);
1.644-TSNode ts_node_descendant_for_point_range(TSNode self, TSPoint start, TSPoint end);
1.645-
1.646-/**
1.647- * Get the smallest named node within this node that spans the given range of
1.648- * bytes or (row, column) positions.
1.649- */
1.650-TSNode ts_node_named_descendant_for_byte_range(TSNode self, uint32_t start, uint32_t end);
1.651-TSNode ts_node_named_descendant_for_point_range(TSNode self, TSPoint start, TSPoint end);
1.652-
1.653-/**
1.654- * Edit the node to keep it in-sync with source code that has been edited.
1.655- *
1.656- * This function is only rarely needed. When you edit a syntax tree with the
1.657- * [`ts_tree_edit`] function, all of the nodes that you retrieve from the tree
1.658- * afterward will already reflect the edit. You only need to use [`ts_node_edit`]
1.659- * when you have a [`TSNode`] instance that you want to keep and continue to use
1.660- * after an edit.
1.661- */
1.662-void ts_node_edit(TSNode *self, const TSInputEdit *edit);
1.663-
1.664-/**
1.665- * Check if two nodes are identical.
1.666- */
1.667-bool ts_node_eq(TSNode self, TSNode other);
1.668-
1.669-/************************/
1.670-/* Section - TreeCursor */
1.671-/************************/
1.672-
1.673-/**
1.674- * Create a new tree cursor starting from the given node.
1.675- *
1.676- * A tree cursor allows you to walk a syntax tree more efficiently than is
1.677- * possible using the [`TSNode`] functions. It is a mutable object that is always
1.678- * on a certain syntax node, and can be moved imperatively to different nodes.
1.679- */
1.680-TSTreeCursor ts_tree_cursor_new(TSNode node);
1.681-
1.682-/**
1.683- * Delete a tree cursor, freeing all of the memory that it used.
1.684- */
1.685-void ts_tree_cursor_delete(TSTreeCursor *self);
1.686-
1.687-/**
1.688- * Re-initialize a tree cursor to start at the original node that the cursor was
1.689- * constructed with.
1.690- */
1.691-void ts_tree_cursor_reset(TSTreeCursor *self, TSNode node);
1.692-
1.693-/**
1.694- * Re-initialize a tree cursor to the same position as another cursor.
1.695- *
1.696- * Unlike [`ts_tree_cursor_reset`], this will not lose parent information and
1.697- * allows reusing already created cursors.
1.698-*/
1.699-void ts_tree_cursor_reset_to(TSTreeCursor *dst, const TSTreeCursor *src);
1.700-
1.701-/**
1.702- * Get the tree cursor's current node.
1.703- */
1.704-TSNode ts_tree_cursor_current_node(const TSTreeCursor *self);
1.705-
1.706-/**
1.707- * Get the field name of the tree cursor's current node.
1.708- *
1.709- * This returns `NULL` if the current node doesn't have a field.
1.710- * See also [`ts_node_child_by_field_name`].
1.711- */
1.712-const char *ts_tree_cursor_current_field_name(const TSTreeCursor *self);
1.713-
1.714-/**
1.715- * Get the field id of the tree cursor's current node.
1.716- *
1.717- * This returns zero if the current node doesn't have a field.
1.718- * See also [`ts_node_child_by_field_id`], [`ts_language_field_id_for_name`].
1.719- */
1.720-TSFieldId ts_tree_cursor_current_field_id(const TSTreeCursor *self);
1.721-
1.722-/**
1.723- * Move the cursor to the parent of its current node.
1.724- *
1.725- * This returns `true` if the cursor successfully moved, and returns `false`
1.726- * if there was no parent node (the cursor was already on the root node).
1.727- */
1.728-bool ts_tree_cursor_goto_parent(TSTreeCursor *self);
1.729-
1.730-/**
1.731- * Move the cursor to the next sibling of its current node.
1.732- *
1.733- * This returns `true` if the cursor successfully moved, and returns `false`
1.734- * if there was no next sibling node.
1.735- */
1.736-bool ts_tree_cursor_goto_next_sibling(TSTreeCursor *self);
1.737-
1.738-/**
1.739- * Move the cursor to the previous sibling of its current node.
1.740- *
1.741- * This returns `true` if the cursor successfully moved, and returns `false` if
1.742- * there was no previous sibling node.
1.743- *
1.744- * Note, that this function may be slower than
1.745- * [`ts_tree_cursor_goto_next_sibling`] due to how node positions are stored. In
1.746- * the worst case, this will need to iterate through all the children upto the
1.747- * previous sibling node to recalculate its position.
1.748- */
1.749-bool ts_tree_cursor_goto_previous_sibling(TSTreeCursor *self);
1.750-
1.751-/**
1.752- * Move the cursor to the first child of its current node.
1.753- *
1.754- * This returns `true` if the cursor successfully moved, and returns `false`
1.755- * if there were no children.
1.756- */
1.757-bool ts_tree_cursor_goto_first_child(TSTreeCursor *self);
1.758-
1.759-/**
1.760- * Move the cursor to the last child of its current node.
1.761- *
1.762- * This returns `true` if the cursor successfully moved, and returns `false` if
1.763- * there were no children.
1.764- *
1.765- * Note that this function may be slower than [`ts_tree_cursor_goto_first_child`]
1.766- * because it needs to iterate through all the children to compute the child's
1.767- * position.
1.768- */
1.769-bool ts_tree_cursor_goto_last_child(TSTreeCursor *self);
1.770-
1.771-/**
1.772- * Move the cursor to the node that is the nth descendant of
1.773- * the original node that the cursor was constructed with, where
1.774- * zero represents the original node itself.
1.775- */
1.776-void ts_tree_cursor_goto_descendant(TSTreeCursor *self, uint32_t goal_descendant_index);
1.777-
1.778-/**
1.779- * Get the index of the cursor's current node out of all of the
1.780- * descendants of the original node that the cursor was constructed with.
1.781- */
1.782-uint32_t ts_tree_cursor_current_descendant_index(const TSTreeCursor *self);
1.783-
1.784-/**
1.785- * Get the depth of the cursor's current node relative to the original
1.786- * node that the cursor was constructed with.
1.787- */
1.788-uint32_t ts_tree_cursor_current_depth(const TSTreeCursor *self);
1.789-
1.790-/**
1.791- * Move the cursor to the first child of its current node that extends beyond
1.792- * the given byte offset or point.
1.793- *
1.794- * This returns the index of the child node if one was found, and returns -1
1.795- * if no such child was found.
1.796- */
1.797-int64_t ts_tree_cursor_goto_first_child_for_byte(TSTreeCursor *self, uint32_t goal_byte);
1.798-int64_t ts_tree_cursor_goto_first_child_for_point(TSTreeCursor *self, TSPoint goal_point);
1.799-
1.800-TSTreeCursor ts_tree_cursor_copy(const TSTreeCursor *cursor);
1.801-
1.802-/*******************/
1.803-/* Section - Query */
1.804-/*******************/
1.805-
1.806-/**
1.807- * Create a new query from a string containing one or more S-expression
1.808- * patterns. The query is associated with a particular language, and can
1.809- * only be run on syntax nodes parsed with that language.
1.810- *
1.811- * If all of the given patterns are valid, this returns a [`TSQuery`].
1.812- * If a pattern is invalid, this returns `NULL`, and provides two pieces
1.813- * of information about the problem:
1.814- * 1. The byte offset of the error is written to the `error_offset` parameter.
1.815- * 2. The type of error is written to the `error_type` parameter.
1.816- */
1.817-TSQuery *ts_query_new(
1.818- const TSLanguage *language,
1.819- const char *source,
1.820- uint32_t source_len,
1.821- uint32_t *error_offset,
1.822- TSQueryError *error_type
1.823-);
1.824-
1.825-/**
1.826- * Delete a query, freeing all of the memory that it used.
1.827- */
1.828-void ts_query_delete(TSQuery *self);
1.829-
1.830-/**
1.831- * Get the number of patterns, captures, or string literals in the query.
1.832- */
1.833-uint32_t ts_query_pattern_count(const TSQuery *self);
1.834-uint32_t ts_query_capture_count(const TSQuery *self);
1.835-uint32_t ts_query_string_count(const TSQuery *self);
1.836-
1.837-/**
1.838- * Get the byte offset where the given pattern starts in the query's source.
1.839- *
1.840- * This can be useful when combining queries by concatenating their source
1.841- * code strings.
1.842- */
1.843-uint32_t ts_query_start_byte_for_pattern(const TSQuery *self, uint32_t pattern_index);
1.844-
1.845-/**
1.846- * Get the byte offset where the given pattern ends in the query's source.
1.847- *
1.848- * This can be useful when combining queries by concatenating their source
1.849- * code strings.
1.850- */
1.851-uint32_t ts_query_end_byte_for_pattern(const TSQuery *self, uint32_t pattern_index);
1.852-
1.853-/**
1.854- * Get all of the predicates for the given pattern in the query.
1.855- *
1.856- * The predicates are represented as a single array of steps. There are three
1.857- * types of steps in this array, which correspond to the three legal values for
1.858- * the `type` field:
1.859- * - `TSQueryPredicateStepTypeCapture` - Steps with this type represent names
1.860- * of captures. Their `value_id` can be used with the
1.861- * [`ts_query_capture_name_for_id`] function to obtain the name of the capture.
1.862- * - `TSQueryPredicateStepTypeString` - Steps with this type represent literal
1.863- * strings. Their `value_id` can be used with the
1.864- * [`ts_query_string_value_for_id`] function to obtain their string value.
1.865- * - `TSQueryPredicateStepTypeDone` - Steps with this type are *sentinels*
1.866- * that represent the end of an individual predicate. If a pattern has two
1.867- * predicates, then there will be two steps with this `type` in the array.
1.868- */
1.869-const TSQueryPredicateStep *ts_query_predicates_for_pattern(
1.870- const TSQuery *self,
1.871- uint32_t pattern_index,
1.872- uint32_t *step_count
1.873-);
1.874-
1.875-/*
1.876- * Check if the given pattern in the query has a single root node.
1.877- */
1.878-bool ts_query_is_pattern_rooted(const TSQuery *self, uint32_t pattern_index);
1.879-
1.880-/*
1.881- * Check if the given pattern in the query is 'non local'.
1.882- *
1.883- * A non-local pattern has multiple root nodes and can match within a
1.884- * repeating sequence of nodes, as specified by the grammar. Non-local
1.885- * patterns disable certain optimizations that would otherwise be possible
1.886- * when executing a query on a specific range of a syntax tree.
1.887- */
1.888-bool ts_query_is_pattern_non_local(const TSQuery *self, uint32_t pattern_index);
1.889-
1.890-/*
1.891- * Check if a given pattern is guaranteed to match once a given step is reached.
1.892- * The step is specified by its byte offset in the query's source code.
1.893- */
1.894-bool ts_query_is_pattern_guaranteed_at_step(const TSQuery *self, uint32_t byte_offset);
1.895-
1.896-/**
1.897- * Get the name and length of one of the query's captures, or one of the
1.898- * query's string literals. Each capture and string is associated with a
1.899- * numeric id based on the order that it appeared in the query's source.
1.900- */
1.901-const char *ts_query_capture_name_for_id(
1.902- const TSQuery *self,
1.903- uint32_t index,
1.904- uint32_t *length
1.905-);
1.906-
1.907-/**
1.908- * Get the quantifier of the query's captures. Each capture is * associated
1.909- * with a numeric id based on the order that it appeared in the query's source.
1.910- */
1.911-TSQuantifier ts_query_capture_quantifier_for_id(
1.912- const TSQuery *self,
1.913- uint32_t pattern_index,
1.914- uint32_t capture_index
1.915-);
1.916-
1.917-const char *ts_query_string_value_for_id(
1.918- const TSQuery *self,
1.919- uint32_t index,
1.920- uint32_t *length
1.921-);
1.922-
1.923-/**
1.924- * Disable a certain capture within a query.
1.925- *
1.926- * This prevents the capture from being returned in matches, and also avoids
1.927- * any resource usage associated with recording the capture. Currently, there
1.928- * is no way to undo this.
1.929- */
1.930-void ts_query_disable_capture(TSQuery *self, const char *name, uint32_t length);
1.931-
1.932-/**
1.933- * Disable a certain pattern within a query.
1.934- *
1.935- * This prevents the pattern from matching and removes most of the overhead
1.936- * associated with the pattern. Currently, there is no way to undo this.
1.937- */
1.938-void ts_query_disable_pattern(TSQuery *self, uint32_t pattern_index);
1.939-
1.940-/**
1.941- * Create a new cursor for executing a given query.
1.942- *
1.943- * The cursor stores the state that is needed to iteratively search
1.944- * for matches. To use the query cursor, first call [`ts_query_cursor_exec`]
1.945- * to start running a given query on a given syntax node. Then, there are
1.946- * two options for consuming the results of the query:
1.947- * 1. Repeatedly call [`ts_query_cursor_next_match`] to iterate over all of the
1.948- * *matches* in the order that they were found. Each match contains the
1.949- * index of the pattern that matched, and an array of captures. Because
1.950- * multiple patterns can match the same set of nodes, one match may contain
1.951- * captures that appear *before* some of the captures from a previous match.
1.952- * 2. Repeatedly call [`ts_query_cursor_next_capture`] to iterate over all of the
1.953- * individual *captures* in the order that they appear. This is useful if
1.954- * don't care about which pattern matched, and just want a single ordered
1.955- * sequence of captures.
1.956- *
1.957- * If you don't care about consuming all of the results, you can stop calling
1.958- * [`ts_query_cursor_next_match`] or [`ts_query_cursor_next_capture`] at any point.
1.959- * You can then start executing another query on another node by calling
1.960- * [`ts_query_cursor_exec`] again.
1.961- */
1.962-TSQueryCursor *ts_query_cursor_new(void);
1.963-
1.964-/**
1.965- * Delete a query cursor, freeing all of the memory that it used.
1.966- */
1.967-void ts_query_cursor_delete(TSQueryCursor *self);
1.968-
1.969-/**
1.970- * Start running a given query on a given node.
1.971- */
1.972-void ts_query_cursor_exec(TSQueryCursor *self, const TSQuery *query, TSNode node);
1.973-
1.974-/**
1.975- * Manage the maximum number of in-progress matches allowed by this query
1.976- * cursor.
1.977- *
1.978- * Query cursors have an optional maximum capacity for storing lists of
1.979- * in-progress captures. If this capacity is exceeded, then the
1.980- * earliest-starting match will silently be dropped to make room for further
1.981- * matches. This maximum capacity is optional — by default, query cursors allow
1.982- * any number of pending matches, dynamically allocating new space for them as
1.983- * needed as the query is executed.
1.984- */
1.985-bool ts_query_cursor_did_exceed_match_limit(const TSQueryCursor *self);
1.986-uint32_t ts_query_cursor_match_limit(const TSQueryCursor *self);
1.987-void ts_query_cursor_set_match_limit(TSQueryCursor *self, uint32_t limit);
1.988-
1.989-/**
1.990- * Set the range of bytes or (row, column) positions in which the query
1.991- * will be executed.
1.992- */
1.993-void ts_query_cursor_set_byte_range(TSQueryCursor *self, uint32_t start_byte, uint32_t end_byte);
1.994-void ts_query_cursor_set_point_range(TSQueryCursor *self, TSPoint start_point, TSPoint end_point);
1.995-
1.996-/**
1.997- * Advance to the next match of the currently running query.
1.998- *
1.999- * If there is a match, write it to `*match` and return `true`.
1.1000- * Otherwise, return `false`.
1.1001- */
1.1002-bool ts_query_cursor_next_match(TSQueryCursor *self, TSQueryMatch *match);
1.1003-void ts_query_cursor_remove_match(TSQueryCursor *self, uint32_t match_id);
1.1004-
1.1005-/**
1.1006- * Advance to the next capture of the currently running query.
1.1007- *
1.1008- * If there is a capture, write its match to `*match` and its index within
1.1009- * the matche's capture list to `*capture_index`. Otherwise, return `false`.
1.1010- */
1.1011-bool ts_query_cursor_next_capture(
1.1012- TSQueryCursor *self,
1.1013- TSQueryMatch *match,
1.1014- uint32_t *capture_index
1.1015-);
1.1016-
1.1017-/**
1.1018- * Set the maximum start depth for a query cursor.
1.1019- *
1.1020- * This prevents cursors from exploring children nodes at a certain depth.
1.1021- * Note if a pattern includes many children, then they will still be checked.
1.1022- *
1.1023- * The zero max start depth value can be used as a special behavior and
1.1024- * it helps to destructure a subtree by staying on a node and using captures
1.1025- * for interested parts. Note that the zero max start depth only limit a search
1.1026- * depth for a pattern's root node but other nodes that are parts of the pattern
1.1027- * may be searched at any depth what defined by the pattern structure.
1.1028- *
1.1029- * Set to `UINT32_MAX` to remove the maximum start depth.
1.1030- */
1.1031-void ts_query_cursor_set_max_start_depth(TSQueryCursor *self, uint32_t max_start_depth);
1.1032-
1.1033-/**********************/
1.1034-/* Section - Language */
1.1035-/**********************/
1.1036-
1.1037-/**
1.1038- * Get another reference to the given language.
1.1039- */
1.1040-const TSLanguage *ts_language_copy(const TSLanguage *self);
1.1041-
1.1042-/**
1.1043- * Free any dynamically-allocated resources for this language, if
1.1044- * this is the last reference.
1.1045- */
1.1046-void ts_language_delete(const TSLanguage *self);
1.1047-
1.1048-/**
1.1049- * Get the number of distinct node types in the language.
1.1050- */
1.1051-uint32_t ts_language_symbol_count(const TSLanguage *self);
1.1052-
1.1053-/**
1.1054- * Get the number of valid states in this language.
1.1055-*/
1.1056-uint32_t ts_language_state_count(const TSLanguage *self);
1.1057-
1.1058-/**
1.1059- * Get a node type string for the given numerical id.
1.1060- */
1.1061-const char *ts_language_symbol_name(const TSLanguage *self, TSSymbol symbol);
1.1062-
1.1063-/**
1.1064- * Get the numerical id for the given node type string.
1.1065- */
1.1066-TSSymbol ts_language_symbol_for_name(
1.1067- const TSLanguage *self,
1.1068- const char *string,
1.1069- uint32_t length,
1.1070- bool is_named
1.1071-);
1.1072-
1.1073-/**
1.1074- * Get the number of distinct field names in the language.
1.1075- */
1.1076-uint32_t ts_language_field_count(const TSLanguage *self);
1.1077-
1.1078-/**
1.1079- * Get the field name string for the given numerical id.
1.1080- */
1.1081-const char *ts_language_field_name_for_id(const TSLanguage *self, TSFieldId id);
1.1082-
1.1083-/**
1.1084- * Get the numerical id for the given field name string.
1.1085- */
1.1086-TSFieldId ts_language_field_id_for_name(const TSLanguage *self, const char *name, uint32_t name_length);
1.1087-
1.1088-/**
1.1089- * Check whether the given node type id belongs to named nodes, anonymous nodes,
1.1090- * or a hidden nodes.
1.1091- *
1.1092- * See also [`ts_node_is_named`]. Hidden nodes are never returned from the API.
1.1093- */
1.1094-TSSymbolType ts_language_symbol_type(const TSLanguage *self, TSSymbol symbol);
1.1095-
1.1096-/**
1.1097- * Get the ABI version number for this language. This version number is used
1.1098- * to ensure that languages were generated by a compatible version of
1.1099- * Tree-sitter.
1.1100- *
1.1101- * See also [`ts_parser_set_language`].
1.1102- */
1.1103-uint32_t ts_language_version(const TSLanguage *self);
1.1104-
1.1105-/**
1.1106- * Get the next parse state. Combine this with lookahead iterators to generate
1.1107- * completion suggestions or valid symbols in error nodes. Use
1.1108- * [`ts_node_grammar_symbol`] for valid symbols.
1.1109-*/
1.1110-TSStateId ts_language_next_state(const TSLanguage *self, TSStateId state, TSSymbol symbol);
1.1111-
1.1112-/********************************/
1.1113-/* Section - Lookahead Iterator */
1.1114-/********************************/
1.1115-
1.1116-/**
1.1117- * Create a new lookahead iterator for the given language and parse state.
1.1118- *
1.1119- * This returns `NULL` if state is invalid for the language.
1.1120- *
1.1121- * Repeatedly using [`ts_lookahead_iterator_next`] and
1.1122- * [`ts_lookahead_iterator_current_symbol`] will generate valid symbols in the
1.1123- * given parse state. Newly created lookahead iterators will contain the `ERROR`
1.1124- * symbol.
1.1125- *
1.1126- * Lookahead iterators can be useful to generate suggestions and improve syntax
1.1127- * error diagnostics. To get symbols valid in an ERROR node, use the lookahead
1.1128- * iterator on its first leaf node state. For `MISSING` nodes, a lookahead
1.1129- * iterator created on the previous non-extra leaf node may be appropriate.
1.1130-*/
1.1131-TSLookaheadIterator *ts_lookahead_iterator_new(const TSLanguage *self, TSStateId state);
1.1132-
1.1133-/**
1.1134- * Delete a lookahead iterator freeing all the memory used.
1.1135-*/
1.1136-void ts_lookahead_iterator_delete(TSLookaheadIterator *self);
1.1137-
1.1138-/**
1.1139- * Reset the lookahead iterator to another state.
1.1140- *
1.1141- * This returns `true` if the iterator was reset to the given state and `false`
1.1142- * otherwise.
1.1143-*/
1.1144-bool ts_lookahead_iterator_reset_state(TSLookaheadIterator *self, TSStateId state);
1.1145-
1.1146-/**
1.1147- * Reset the lookahead iterator.
1.1148- *
1.1149- * This returns `true` if the language was set successfully and `false`
1.1150- * otherwise.
1.1151-*/
1.1152-bool ts_lookahead_iterator_reset(TSLookaheadIterator *self, const TSLanguage *language, TSStateId state);
1.1153-
1.1154-/**
1.1155- * Get the current language of the lookahead iterator.
1.1156-*/
1.1157-const TSLanguage *ts_lookahead_iterator_language(const TSLookaheadIterator *self);
1.1158-
1.1159-/**
1.1160- * Advance the lookahead iterator to the next symbol.
1.1161- *
1.1162- * This returns `true` if there is a new symbol and `false` otherwise.
1.1163-*/
1.1164-bool ts_lookahead_iterator_next(TSLookaheadIterator *self);
1.1165-
1.1166-/**
1.1167- * Get the current symbol of the lookahead iterator;
1.1168-*/
1.1169-TSSymbol ts_lookahead_iterator_current_symbol(const TSLookaheadIterator *self);
1.1170-
1.1171-/**
1.1172- * Get the current symbol type of the lookahead iterator as a null terminated
1.1173- * string.
1.1174-*/
1.1175-const char *ts_lookahead_iterator_current_symbol_name(const TSLookaheadIterator *self);
1.1176-
1.1177-/*************************************/
1.1178-/* Section - WebAssembly Integration */
1.1179-/************************************/
1.1180-
1.1181-typedef struct wasm_engine_t TSWasmEngine;
1.1182-typedef struct TSWasmStore TSWasmStore;
1.1183-
1.1184-typedef enum {
1.1185- TSWasmErrorKindNone = 0,
1.1186- TSWasmErrorKindParse,
1.1187- TSWasmErrorKindCompile,
1.1188- TSWasmErrorKindInstantiate,
1.1189- TSWasmErrorKindAllocate,
1.1190-} TSWasmErrorKind;
1.1191-
1.1192-typedef struct {
1.1193- TSWasmErrorKind kind;
1.1194- char *message;
1.1195-} TSWasmError;
1.1196-
1.1197-/**
1.1198- * Create a Wasm store.
1.1199- */
1.1200-TSWasmStore *ts_wasm_store_new(
1.1201- TSWasmEngine *engine,
1.1202- TSWasmError *error
1.1203-);
1.1204-
1.1205-/**
1.1206- * Free the memory associated with the given Wasm store.
1.1207- */
1.1208-void ts_wasm_store_delete(TSWasmStore *);
1.1209-
1.1210-/**
1.1211- * Create a language from a buffer of Wasm. The resulting language behaves
1.1212- * like any other Tree-sitter language, except that in order to use it with
1.1213- * a parser, that parser must have a Wasm store. Note that the language
1.1214- * can be used with any Wasm store, it doesn't need to be the same store that
1.1215- * was used to originally load it.
1.1216- */
1.1217-const TSLanguage *ts_wasm_store_load_language(
1.1218- TSWasmStore *,
1.1219- const char *name,
1.1220- const char *wasm,
1.1221- uint32_t wasm_len,
1.1222- TSWasmError *error
1.1223-);
1.1224-
1.1225-/**
1.1226- * Get the number of languages instantiated in the given wasm store.
1.1227- */
1.1228-size_t ts_wasm_store_language_count(const TSWasmStore *);
1.1229-
1.1230-/**
1.1231- * Check if the language came from a Wasm module. If so, then in order to use
1.1232- * this language with a Parser, that parser must have a Wasm store assigned.
1.1233- */
1.1234-bool ts_language_is_wasm(const TSLanguage *);
1.1235-
1.1236-/**
1.1237- * Assign the given Wasm store to the parser. A parser must have a Wasm store
1.1238- * in order to use Wasm languages.
1.1239- */
1.1240-void ts_parser_set_wasm_store(TSParser *, TSWasmStore *);
1.1241-
1.1242-/**
1.1243- * Remove the parser's current Wasm store and return it. This returns NULL if
1.1244- * the parser doesn't have a Wasm store.
1.1245- */
1.1246-TSWasmStore *ts_parser_take_wasm_store(TSParser *);
1.1247-
1.1248-/**********************************/
1.1249-/* Section - Global Configuration */
1.1250-/**********************************/
1.1251-
1.1252-/**
1.1253- * Set the allocation functions used by the library.
1.1254- *
1.1255- * By default, Tree-sitter uses the standard libc allocation functions,
1.1256- * but aborts the process when an allocation fails. This function lets
1.1257- * you supply alternative allocation functions at runtime.
1.1258- *
1.1259- * If you pass `NULL` for any parameter, Tree-sitter will switch back to
1.1260- * its default implementation of that function.
1.1261- *
1.1262- * If you call this function after the library has already been used, then
1.1263- * you must ensure that either:
1.1264- * 1. All the existing objects have been freed.
1.1265- * 2. The new allocator shares its state with the old one, so it is capable
1.1266- * of freeing memory that was allocated by the old allocator.
1.1267- */
1.1268-void ts_set_allocator(
1.1269- void *(*new_malloc)(size_t),
1.1270- void *(*new_calloc)(size_t, size_t),
1.1271- void *(*new_realloc)(void *, size_t),
1.1272- void (*new_free)(void *)
1.1273-);
1.1274-
1.1275-#ifdef __cplusplus
1.1276-}
1.1277-#endif
1.1278-
1.1279-#ifndef TREE_SITTER_HIDE_SYMBOLS
1.1280-#if defined(__GNUC__) || defined(__clang__)
1.1281-#pragma GCC visibility pop
1.1282-#endif
1.1283-#endif
1.1284-
1.1285-#endif // TREE_SITTER_API_H_
