From 1ba132bb064b73fdf12ce8a7ce63c84c6d493735 Mon Sep 17 00:00:00 2001 From: ProgramSnail Date: Sun, 26 Mar 2023 15:20:53 +0300 Subject: [PATCH] interpreter_tree first iteration --- .clangd | 2 + CMakeLists.txt | 4 +- include/build_visitor.hpp | 0 include/contexts.hpp | 43 ++ include/execute_visitor.hpp | 0 include/find_symbols_visitor.hpp | 0 include/global_info.hpp | 25 + include/interpreter_tree.hpp | 549 +++++++++++++++++ include/node.hpp | 36 ++ include/parse_tree.hpp | 64 ++ include/symbols_info.hpp | 96 +++ include/typecheck_visitor.hpp | 0 include/visitor.hpp | 16 + src/node.cpp | 12 + tree_sitter/api.h | 983 +++++++++++++++++++++++++++++++ 15 files changed, 1829 insertions(+), 1 deletion(-) create mode 100644 .clangd create mode 100644 include/build_visitor.hpp create mode 100644 include/contexts.hpp create mode 100644 include/execute_visitor.hpp create mode 100644 include/find_symbols_visitor.hpp create mode 100644 include/global_info.hpp create mode 100644 include/interpreter_tree.hpp create mode 100644 include/node.hpp create mode 100644 include/parse_tree.hpp create mode 100644 include/symbols_info.hpp create mode 100644 include/typecheck_visitor.hpp create mode 100644 include/visitor.hpp create mode 100644 src/node.cpp create mode 100644 tree_sitter/api.h diff --git a/.clangd b/.clangd new file mode 100644 index 0000000..c7a47fe --- /dev/null +++ b/.clangd @@ -0,0 +1,2 @@ +CompileFlags: + Add: [-std=c++17] diff --git a/CMakeLists.txt b/CMakeLists.txt index 16fc8f5..d84b3a7 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -8,8 +8,10 @@ find_package(Catch2 2 REQUIRED) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall") +include_directories(include) +include(tree_sitter/api.h) + # add_executable(interpreter_tests tests/tests.cpp) # target_link_libraries(tests PRIVATE Catch2::Catch2WithMain) # add_executable(lang_interpreter src/main.cpp) - diff --git a/include/build_visitor.hpp b/include/build_visitor.hpp new file mode 100644 index 0000000..e69de29 diff --git a/include/contexts.hpp b/include/contexts.hpp new file mode 100644 index 0000000..5b6005b --- /dev/null +++ b/include/contexts.hpp @@ -0,0 +1,43 @@ +#pragma once + +#include +#include +#include + +// for clangd +#include "symbols_info.hpp" + +namespace info { + +class ContextManager { +public: + void CallFunction(const std::vector&); + void EnterContext(); + void ExitContext(); + + void DefineVariable(const VariableInfo& variable); + void ChangeVariableValue(const std::string& name, const Value& new_value); + const Value& GetVariableValue(const std::string& name); +private: + class Context { + public: + Context(bool hide_previous = false) : hide_previous_(hide_previous) {} + + void DefineVariable(const VariableInfo& variable); + void ChangeVaraibleValue(const std::string& name, const Value& neew_value); + const Value& GetVariableValue(const std::string& name); + + bool IsFirst() { return hide_previous_; } + private: + bool hide_previous_; + std::unordered_map variables_; + }; + + // TODO handle current namespace (for class names, function names, etc.) + // TODO ?? are global variables forbidden ?? + + Context global_context_; + std::vector contexts_; +}; + +} // namespace info diff --git a/include/execute_visitor.hpp b/include/execute_visitor.hpp new file mode 100644 index 0000000..e69de29 diff --git a/include/find_symbols_visitor.hpp b/include/find_symbols_visitor.hpp new file mode 100644 index 0000000..e69de29 diff --git a/include/global_info.hpp b/include/global_info.hpp new file mode 100644 index 0000000..bc16a82 --- /dev/null +++ b/include/global_info.hpp @@ -0,0 +1,25 @@ +#pragma once + +#include +#include + +// for clangd +#include "symbols_info.hpp" + +namespace info { + +class GlobalInfo { +public: + GlobalInfo(); + + // ?? EnterNamespace / ExitNamespace ?? + // concurrent work ?? + // AddType, AddFunction + // TODO +private: + std::unordered_map namespaces_; + NamespaceInfo global_namespace_; + // lock for concurrency ?? +}; + +} // namespace info diff --git a/include/interpreter_tree.hpp b/include/interpreter_tree.hpp new file mode 100644 index 0000000..f747b64 --- /dev/null +++ b/include/interpreter_tree.hpp @@ -0,0 +1,549 @@ +#pragma once + +#include +#include +#include +#include + +// for clangd +#include "node.hpp" + + +namespace interpreter { + +namespace tokens { + +// ----------------- Declarations ----------------- + +using AnyIdentifier = std::string; +using NameOrOperatorIdentifier = std::string; +using NameIdentifier = std::string; +using AnyTypeIdentifier = std::string; +using TypeIdentifier = std::string; +using AbstractTypeIdentifier = std::string; +using OperatorIdentifier = std::string; +using TypeclassIdentifier = std::string; + +// Sources ----------------- + +struct SourceFile; // TODO partitions +struct Sources; + +// Namespaces, partittions ----------------- + +struct Partition; +struct Namespace; + +// Definitions ----------------- + +struct ImportStatement; +struct UsageDefinition; +struct AliasDefinition; +struct VariableDefinition; +struct FunctionDeclaration; +struct FunctionDefinition; +struct AliasTypeDefinition; // | Parts of type definition +struct TypeDefinition; // | +struct TypeclassDefinition; + +using SourceStatement = std::variant< + ImportStatement, + UsageDefinition, + AliasDefinition, + VariableDefinition, // ?? + FunctionDeclaration, + FunctionDefinition, + AliasTypeDefinition, + TypeDefinition, + TypeclassDefinition, + Namespace>; + +// Definition parts + +struct ParametrizedType; +struct TupleType; +struct VariantType; +struct ParametrizedTypeclass; +using FunctionDeclarationType = std::variant< + ParametrizedType, + TupleType, + VariantType, + ParametrizedTypeclass>; + +struct DefinedName; +struct DefinedAnnotatedName; +struct DefinedType; +struct DefinedTypeclass; +struct DefinitionParameter; +struct DefinitionArgument; + +// Flow control ----------------- + +struct Match; +struct Condition; +struct WhileLoop; // WhileLoop <-> DoWhileLoop +struct ForLoop; +struct LoopLoop; + +using FlowControl = std::variant< + Match, + Condition, + WhileLoop, + ForLoop, + LoopLoop>; + +// Statements, expressions, blocks, etc. ----------------- + +struct Block; + +// + +struct NameExpression; +struct ScopedStatement; + +using SubExpressionToken = std::variant< + NameExpression, + ScopedStatement>; + +// + +struct FunctionCallExpression; +struct BinaryOperatorExpression; + +using SubExpression = std::variant< + FunctionCallExpression, + BinaryOperatorExpression, + SubExpressionToken>; + +// + +struct ReturnExpression; + +enum class LoopControlExpression { + Break, + Continue, +}; + +using PrefixedExpression = std::variant< + ReturnExpression, + LoopControlExpression, + Block>; + +// + +struct LambdaFunction; +struct TypeConstructor; +struct UnaryOperatorExpression; + +using Expression = std::variant< + LambdaFunction, + TypeConstructor, + PrefixedExpression, + UnaryOperatorExpression, + SubExpression>; + +// + +struct TupleExpression; +struct VariantExpression; + +using SuperExpression = std::variant< + FlowControl, + TupleExpression, + VariantExpression, + Expression>; + +// + +struct ScopedStatement; // ?? scoped statement is _superexpression ?? + +// Operators + +struct BinaryOperatorExpression; +struct UnaryOperatorExpression; + +// Simple Expressions + +struct FunctionCallExpression; +struct TupleExpression; +struct VariantExpression; +struct ReturnExpression; + +// Lambda + +struct LambdaFunction; + +// Name + +struct NameSuperExpression; +struct NameExpression; +struct TupleName; +struct VariantName; +struct AnnotatedName; + +using AnyName = std::variant< + AnnotatedName, + TupleName, + VariantName>; + +// Type + +struct TypeConstructor; + +// // TypeOrAnyType <-> AnyType + +struct TupleType; +struct VariantType; +struct VariantType; + +using AnyType = std::variant< + ParametrizedType, + TupleType, + VariantType>; + +// // TypeIdentifierDefinition <-> some '.' + TypeIdentifier +using TypeIdentifierDefinition = std::string; + +struct AnnotatedType; +// // TypeAnnotations - inplace ?? +struct ParametrizedType; +struct TypeExpression; + +using TypeSubExpression = std::variant< + AnyTypeIdentifier, + ParametrizedType>; + +// Typeclass + +struct AnnotatedTypeclass; +struct ParametrizedTypeclass; +struct TypeclassExpression; + +// Comments [IGNORE] ----------------- +// Identifiers, constants, etc. ----------------- + +struct FloatNumberLiteral; +struct NumberLiteral; +struct StringLiteral; +struct CharLiteral; + +using Literal = std::variant< + FloatNumberLiteral, + NumberLiteral, + StringLiteral, + CharLiteral>; + +// + +using NameSubSuperExpression = std::variant< + NameIdentifier, + Literal, + SuperExpression>; + +// ----------------- Sources ----------------- + +struct SourceFile : public Node { + std::vector> statements; +}; + +struct Sources : public Node { + std::vector statemets; +}; + +// ----------------- Namespaces, partittions ----------------- + +struct Partition : public Node { + enum class PartitionType { + Test, + Interface, + Core, + Lib, + Module, // rename ?? + Exe, + }; + + PartitionType type; + std::unique_ptr scope; +}; + +struct Namespace : public Node { + std::unique_ptr> name; + // TODO add const / var specification + std::unique_ptr scope; +}; + +// ----------------- Definitions ----------------- + +struct ImportStatement : public Node { + std::string module_name; + std::vector symbols; // TODO parametric import support +}; + +struct UsageDefinition : public Node { + TypeIdentifier module_identifier; + std::unique_ptr import_statement; +}; + +struct AliasDefinition : public Node { + std::unique_ptr name; + std::unique_ptr value; +}; + +struct VariableDefinition : public Node { + NameIdentifier name; + std::unique_ptr value; +}; + +struct FunctionDeclaration : public Node { + NameIdentifier name; + std::vector> argument_types; +}; + +struct FunctionDefintion : public Node { + std::unique_ptr name; + std::unique_ptr value; +}; + +struct AliasTypeDefinition : public Node { + std::unique_ptr name; + std::unique_ptr value; +}; + +struct TypeDefinition : public Node { + std::unique_ptr name; + std::unique_ptr value; +}; + +struct TypeclassDefinition : public Node { + std::unique_ptr name; + std::vector> requirements; +}; + +// Definition parts ----------------- + +struct DefinedName : public Node { + bool is_operator = false; // other format ?? + NameOrOperatorIdentifier name; // function name or operator + std::vector> parameters; + std::vector> arguments; +}; + +struct DefinedAnnotatedName : public Node { + NameIdentifier name; + std::unique_ptr> type; +}; + +struct DefinedType : public Node { + std::unique_ptr type; + std::vector> parameters; + std::vector> arguments; +}; + +struct DefinedTypeclass : public Node { + std::unique_ptr typeclass; + std::vector> parameters; + std::vector> arguments; +}; + +struct DefinitionParameter : public Node { + AbstractTypeIdentifier abstract_type; + std::vector> typeclasses; +}; + +struct DefinitionArgument : public Node { + NameIdentifier name; + std::vector> types; +}; + +// ----------------- Flow control ----------------- + +struct MatchCase { + std::unique_ptr value; + std::unique_ptr condition; + std::unique_ptr statement; +}; + +struct Match : public Node { + std::unique_ptr value; + std::vector matches; +}; + +struct Condition : public Node { + std::vector> conditions; // if, elif + std::vector> stetemets; // if, elif, else +}; + +struct WhileLoop : public Node { // WhileLoop <-> DoWhileLoop + std::unique_ptr condition; + std::unique_ptr statement; +}; + +struct ForLoop : public Node { + std::unique_ptr variable; + std::unique_ptr interval; + std::unique_ptr statement; +}; + +struct LoopLoop : public Node { + std::unique_ptr statement; +}; + +// ----------------- Statements, expressions, blocks, etc. ----------------- + +using BlockStatement = std::variant< + Expression, + AliasDefinition, + VariableDefinition, + FlowControl, + PrefixedExpression>; + +struct Block : public Node { + std::vector> statements; +}; + +struct ScopedStatement : public Node { + std::unique_ptr statement; +}; + +// Operators ----------------- + +struct BinaryOperatorExpression : public Node { + OperatorIdentifier operator_name; + std::unique_ptr left_expression; + std::unique_ptr right_expression; +}; + +struct UnaryOperatorExpression : public Node { // TODO fix prescendence + OperatorIdentifier operator_name; + std::unique_ptr expression; +}; + +// Simple Expressions ----------------- + +using FunctionArgument = std::variant; + +struct FunctionCallExpression : public Node { + std::unique_ptr name; + std::vector> arguments; +}; + +struct TupleExpression : public Node { + std::vector> expressions; +}; + +struct VariantExpression : public Node { + std::vector> expressions; +}; + +struct ReturnExpression : public Node { + std::unique_ptr expression; +}; + +// Lambda ----------------- + +struct LambdaFunction : public Node { + std::vector> parameters; + std::vector> arguments; + std::unique_ptr expression; +}; + +// Name ----------------- + +struct NameSuperExpression : public Node { + std::vector> namespaces; + std::vector> expressions; // last is not SuperExpression +}; + +struct NameExpression : public Node { + std::vector namespaces; + std::vector names; +}; + +struct TupleName : public Node { + std::vector> names; +}; + +struct VariantName : public Node { + std::vector> names; +}; + +struct AnnotatedName : public Node { + NameIdentifier name; + std::unique_ptr type; // optional +}; + +// TODO ?? mark all optional fields ?? + +// Type ----------------- + +struct TypeConstructor : public Node { + std::unique_ptr type; + std::vector>> parameters; +}; + +struct TupleType : public Node { + TypeIdentifierDefinition type; // optional + std::vector>> entities; // NameIdentifier is optional +}; + +struct VariantType : public Node { + TypeIdentifierDefinition type; // optional + std::vector>> constructors; +}; + +struct AnnotatedType : public Node { + std::unique_ptr type_expression; + std::vector> annotations; +}; + +using TypeParameter = std::variant; + +struct ParametrizedType : public Node { + std::unique_ptr type_expression; + std::vector> parameters; +}; + +struct TypeExpression : public Node { + std::vector> namespaces; + AnyTypeIdentifier type; +}; + +// Typeclass ----------------- + +struct AnnotatedTypeclass : public Node { + std::unique_ptr typeclass_expression; + std::vector> annotations; +}; + +struct ParametrizedTypeclass : public Node { + std::unique_ptr typeclass_expression; + std::vector> parameters; +}; + +struct TypeclassExpression : public Node { + std::vector> namespaces; + TypeclassIdentifier typeclass; +}; + +// ----------------- Comments [IGNORE] ----------------- +// ----------------- Identifiers, constants, etc. ----------------- + +struct FloatNumberLiteral : public Node { + double value; +}; + +struct NumberLiteral : public Node { + int64_t value; +}; + +struct StringLiteral : public Node { + std::string value; +}; + +struct CharLiteral : public Node { + char value; +}; + +} // namespace tokens + +} // namespace interpereter diff --git a/include/node.hpp b/include/node.hpp new file mode 100644 index 0000000..4960cff --- /dev/null +++ b/include/node.hpp @@ -0,0 +1,36 @@ +#pragma once + +#include + +// for clangd +#include "parse_tree.hpp" + +namespace info { + class GlobalInfo; + class Context; +} // namespace info + +namespace interpreter { +class Visitor; + +struct Node { +//public: + Node(info::GlobalInfo& global_info) : global_info_(global_info) {} + + virtual void Accept(Visitor* visitor); + + /* ------------ use visitor instead ------------ + virtual void build(parser::ParseTree::Cursor& cursor) = 0; // build tree from parse tree + + virtual void find_symbols() = 0; // find types, typeclasses, namespaces, .. + virtual void assign_types() = 0; // typecheck + virtual void execute(info::Context& context) = 0; // execute part of tree + */ +/*private: + size_t start_position_; // ?? + size_t end_position_; // ?? + Node* parent_; // ?? + info::GlobalInfo& global_info_;*/ +}; + +} // namespace interpreter diff --git a/include/parse_tree.hpp b/include/parse_tree.hpp new file mode 100644 index 0000000..bcebf3b --- /dev/null +++ b/include/parse_tree.hpp @@ -0,0 +1,64 @@ +#pragma once + +#include + +// for clangd +#include "tree_sitter/api.h" + + +namespace parser { + +class ParseTree { +public: + class Node { + public: + Node() = delete; + + std::string GetType(); + std::pair GetStartPoint(); + std::pair GetEndPoint(); + std::string GetAsSExpression(); + + bool IsNull(); + bool IsNamed(); + bool IsMissing(); + bool IsExtra(); // comments, etc. + bool HasError(); + + Node NthChild(size_t n); + size_t ChildCount(); + + Node NthNamedChild(size_t n); + size_t NamedChildCount(); + + Node ChildByName(const std::string& name); + + // ?? use field id instaed of name ?? + // ?? node equality check needed ?? + private: + TSNode node_; + }; + class Cursor { + public: + Cursor(const Node& node); + + void ResetTo(const Node& node); + + Node GetCurrentNode(); + std::string GetCurrentNodeName(); + + bool GoToParent(); + bool GoToNextSibling(); + bool GoToFirstChild(); + private: + TSTreeCursor cursor_; + }; + + ParseTree(const std::string& input); + + Node GetRoot(); +private: + TSTree* tree_; +}; + +} // namespace parser diff --git a/include/symbols_info.hpp b/include/symbols_info.hpp new file mode 100644 index 0000000..f29e7bf --- /dev/null +++ b/include/symbols_info.hpp @@ -0,0 +1,96 @@ +#pragma once + +#include +#include +#include +#include +#include + +// for clangd + +namespace interpreter { + class Node; +} // namespace interpreter + +namespace info { + +using NumberValue = long long; +using FloatNumberValue = float; +using StringValue = std::string; + +struct SimpleValue { + std::variant value; +}; + +struct Value { + enum class ValueStructure { + Simple, // one value + Variant, // one value from list, can have arguments + // MultiVariant, // constructed variant // ?? + Tuple, // tuple of values + }; + ValueStructure structure; + std::vector> values; +}; +// better variant value storage (then string) ?? + +struct Info { + std::string name; +}; + +struct VariantTypeInfo; +struct TupleTypeInfo; +struct AliasTypeInfo; + +enum class BuiltInTypeInfo { + StringT, + IntT, + FloatT, +}; + +using TypeInfo = std::variant; + +struct VariableInfo : public Info { + Value value; + TypeInfo* type = nullptr; +}; +// TODO lambda functions as values + +// TODO aliases ?? + +struct TupleTypeInfo : public Info { + std::vector, TypeInfo>> fields; +}; + +struct VariantTypeInfo : public Info { + std::vector> constructors; + // ?? any type instead of tuple type ?? +}; + +struct AliasTypeInfo : public Info { + bool isAnotherType; // = true by default ?? + TypeInfo* type = nullptr; +}; + +struct TypeclassInfo : public Info { + // TODO +}; + +struct PointerInfo { + VariableInfo* variable; +}; + +struct FunctionInfo : public Info { + interpreter::Node* definition; + std::vector args; + // add requirements ?? +}; + +struct NamespaceInfo : public Info { + std::unordered_map types; + std::unordered_map variables; + std::unordered_map functions; + std::unordered_map namespaces; +}; + +} // namespace info diff --git a/include/typecheck_visitor.hpp b/include/typecheck_visitor.hpp new file mode 100644 index 0000000..e69de29 diff --git a/include/visitor.hpp b/include/visitor.hpp new file mode 100644 index 0000000..be644a2 --- /dev/null +++ b/include/visitor.hpp @@ -0,0 +1,16 @@ +#pragma once + +// for clangd +#include "interpreter_tree.hpp" + +namespace interpreter { + +class Visitor { +public: + virtual void Visit(Node* node) = 0; // ?? + // visit(SomethingNode node) + // ... +private: +}; + +} // namespace interpreter diff --git a/src/node.cpp b/src/node.cpp new file mode 100644 index 0000000..0fbb3ad --- /dev/null +++ b/src/node.cpp @@ -0,0 +1,12 @@ +// for clangd +#include "../include/node.hpp" +#include "../include/visitor.hpp" + + +namespace interpreter { + +void Node::Accept(Visitor* visitor) { + visitor->Visit(this); +} + +} // namespace interpreter diff --git a/tree_sitter/api.h b/tree_sitter/api.h new file mode 100644 index 0000000..65b6bea --- /dev/null +++ b/tree_sitter/api.h @@ -0,0 +1,983 @@ +#ifndef TREE_SITTER_API_H_ +#define TREE_SITTER_API_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include +#include +#include + +/****************************/ +/* Section - ABI Versioning */ +/****************************/ + +/** + * The latest ABI version that is supported by the current version of the + * library. When Languages are generated by the Tree-sitter CLI, they are + * assigned an ABI version number that corresponds to the current CLI version. + * The Tree-sitter library is generally backwards-compatible with languages + * generated using older CLI versions, but is not forwards-compatible. + */ +#define TREE_SITTER_LANGUAGE_VERSION 14 + +/** + * The earliest ABI version that is supported by the current version of the + * library. + */ +#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 */ +/********************/ + +/** + * Create a new parser. + */ +TSParser *ts_parser_new(void); + +/** + * Delete the parser, freeing all of the memory that it used. + */ +void ts_parser_delete(TSParser *parser); + +/** + * Set the language that the parser should use for parsing. + * + * Returns a boolean indicating whether or not the language was successfully + * assigned. True means assignment succeeded. False means there was a version + * mismatch: the language was generated with an incompatible version of the + * Tree-sitter CLI. Check the language's version using `ts_language_version` + * and compare it to this library's `TREE_SITTER_LANGUAGE_VERSION` and + * `TREE_SITTER_MIN_COMPATIBLE_LANGUAGE_VERSION` constants. + */ +bool ts_parser_set_language(TSParser *self, const TSLanguage *language); + +/** + * Get the parser's current language. + */ +const TSLanguage *ts_parser_language(const TSParser *self); + +/** + * Set the ranges of text that the parser should include when parsing. + * + * By default, the parser will always include entire documents. This function + * allows you to parse only a *portion* of a document but still return a syntax + * tree whose ranges match up with the document as a whole. You can also pass + * multiple disjoint ranges. + * + * The second and third parameters specify the location and length of an array + * of ranges. The parser does *not* take ownership of these ranges; it copies + * the data, so it doesn't matter how these ranges are allocated. + * + * If `length` is zero, then the entire document will be parsed. Otherwise, + * the given ranges must be ordered from earliest to latest in the document, + * and they must not overlap. That is, the following must hold for all + * `i` < `length - 1`: ranges[i].end_byte <= ranges[i + 1].start_byte + * + * If this requirement is not satisfied, the operation will fail, the ranges + * will not be assigned, and this function will return `false`. On success, + * this function returns `true` + */ +bool ts_parser_set_included_ranges( + TSParser *self, + const TSRange *ranges, + uint32_t length +); + +/** + * Get the ranges of text that the parser will include when parsing. + * + * The returned pointer is owned by the parser. The caller should not free it + * or write to it. The length of the array will be written to the given + * `length` pointer. + */ +const TSRange *ts_parser_included_ranges( + const TSParser *self, + uint32_t *length +); + +/** + * Use the parser to parse some source code and create a syntax tree. + * + * If you are parsing this document for the first time, pass `NULL` for the + * `old_tree` parameter. Otherwise, if you have already parsed an earlier + * version of this document and the document has since been edited, pass the + * previous syntax tree so that the unchanged parts of it can be reused. + * This will save time and memory. For this to work correctly, you must have + * already edited the old syntax tree using the `ts_tree_edit` function in a + * way that exactly matches the source code changes. + * + * The `TSInput` parameter lets you specify how to read the text. It has the + * following three fields: + * 1. `read`: A function to retrieve a chunk of text at a given byte offset + * and (row, column) position. The function should return a pointer to the + * text and write its length to the `bytes_read` pointer. The parser does + * not take ownership of this buffer; it just borrows it until it has + * finished reading it. The function should write a zero value to the + * `bytes_read` pointer to indicate the end of the document. + * 2. `payload`: An arbitrary pointer that will be passed to each invocation + * of the `read` function. + * 3. `encoding`: An indication of how the text is encoded. Either + * `TSInputEncodingUTF8` or `TSInputEncodingUTF16`. + * + * This function returns a syntax tree on success, and `NULL` on failure. There + * are three possible reasons for failure: + * 1. The parser does not have a language assigned. Check for this using the + `ts_parser_language` function. + * 2. Parsing was cancelled due to a timeout that was set by an earlier call to + * the `ts_parser_set_timeout_micros` function. You can resume parsing from + * where the parser left out by calling `ts_parser_parse` again with the + * same arguments. Or you can start parsing from scratch by first calling + * `ts_parser_reset`. + * 3. Parsing was cancelled using a cancellation flag that was set by an + * earlier call to `ts_parser_set_cancellation_flag`. You can resume parsing + * from where the parser left out by calling `ts_parser_parse` again with + * the same arguments. + */ +TSTree *ts_parser_parse( + TSParser *self, + const TSTree *old_tree, + TSInput input +); + +/** + * Use the parser to parse some source code stored in one contiguous buffer. + * The first two parameters are the same as in the `ts_parser_parse` function + * above. The second two parameters indicate the location of the buffer and its + * length in bytes. + */ +TSTree *ts_parser_parse_string( + TSParser *self, + const TSTree *old_tree, + const char *string, + uint32_t length +); + +/** + * Use the parser to parse some source code stored in one contiguous buffer with + * a given encoding. The first four parameters work the same as in the + * `ts_parser_parse_string` method above. The final parameter indicates whether + * the text is encoded as UTF8 or UTF16. + */ +TSTree *ts_parser_parse_string_encoding( + TSParser *self, + const TSTree *old_tree, + const char *string, + uint32_t length, + TSInputEncoding encoding +); + +/** + * Instruct the parser to start the next parse from the beginning. + * + * If the parser previously failed because of a timeout or a cancellation, then + * by default, it will resume where it left off on the next call to + * `ts_parser_parse` or other parsing functions. If you don't want to resume, + * and instead intend to use this parser to parse some other document, you must + * call `ts_parser_reset` first. + */ +void ts_parser_reset(TSParser *self); + +/** + * Set the maximum duration in microseconds that parsing should be allowed to + * take before halting. + * + * If parsing takes longer than this, it will halt early, returning NULL. + * See `ts_parser_parse` for more information. + */ +void ts_parser_set_timeout_micros(TSParser *self, uint64_t timeout); + +/** + * Get the duration in microseconds that parsing is allowed to take. + */ +uint64_t ts_parser_timeout_micros(const TSParser *self); + +/** + * Set the parser's current cancellation flag pointer. + * + * If a non-null pointer is assigned, then the parser will periodically read + * from this pointer during parsing. If it reads a non-zero value, it will + * halt early, returning NULL. See `ts_parser_parse` for more information. + */ +void ts_parser_set_cancellation_flag(TSParser *self, const size_t *flag); + +/** + * Get the parser's current cancellation flag pointer. + */ +const size_t *ts_parser_cancellation_flag(const TSParser *self); + +/** + * Set the logger that a parser should use during parsing. + * + * The parser does not take ownership over the logger payload. If a logger was + * previously assigned, the caller is responsible for releasing any memory + * owned by the previous logger. + */ +void ts_parser_set_logger(TSParser *self, TSLogger logger); + +/** + * Get the parser's current logger. + */ +TSLogger ts_parser_logger(const TSParser *self); + +/** + * Set the file descriptor to which the parser should write debugging graphs + * during parsing. The graphs are formatted in the DOT language. You may want + * to pipe these graphs directly to a `dot(1)` process in order to generate + * SVG output. You can turn off this logging by passing a negative number. + */ +void ts_parser_print_dot_graphs(TSParser *self, int file); + +/******************/ +/* Section - Tree */ +/******************/ + +/** + * Create a shallow copy of the syntax tree. This is very fast. + * + * You need to copy a syntax tree in order to use it on more than one thread at + * a time, as syntax trees are not thread safe. + */ +TSTree *ts_tree_copy(const TSTree *self); + +/** + * Delete the syntax tree, freeing all of the memory that it used. + */ +void ts_tree_delete(TSTree *self); + +/** + * Get the root node of the syntax tree. + */ +TSNode ts_tree_root_node(const TSTree *self); + +/** + * Get the root node of the syntax tree, but with its position + * shifted forward by the given offset. + */ +TSNode ts_tree_root_node_with_offset( + const TSTree *self, + uint32_t offset_bytes, + TSPoint offset_point +); + +/** + * Get the language that was used to parse the syntax tree. + */ +const TSLanguage *ts_tree_language(const TSTree *); + +/** + * Get the array of included ranges that was used to parse the syntax tree. + * + * The returned pointer must be freed by the caller. + */ +TSRange *ts_tree_included_ranges(const TSTree *, uint32_t *length); + +/** + * Edit the syntax tree to keep it in sync with source code that has been + * edited. + * + * You must describe the edit both in terms of byte offsets and in terms of + * (row, column) coordinates. + */ +void ts_tree_edit(TSTree *self, const TSInputEdit *edit); + +/** + * Compare an old edited syntax tree to a new syntax tree representing the same + * document, returning an array of ranges whose syntactic structure has changed. + * + * For this to work correctly, the old syntax tree must have been edited such + * that its ranges match up to the new tree. Generally, you'll want to call + * this function right after calling one of the `ts_parser_parse` functions. + * You need to pass the old tree that was passed to parse, as well as the new + * tree that was returned from that function. + * + * The returned array is allocated using `malloc` and the caller is responsible + * for freeing it using `free`. The length of the array will be written to the + * given `length` pointer. + */ +TSRange *ts_tree_get_changed_ranges( + const TSTree *old_tree, + const TSTree *new_tree, + uint32_t *length +); + +/** + * Write a DOT graph describing the syntax tree to the given file. + */ +void ts_tree_print_dot_graph(const TSTree *, int file_descriptor); + +/******************/ +/* Section - Node */ +/******************/ + +/** + * Get the node's type as a null-terminated string. + */ +const char *ts_node_type(TSNode); + +/** + * Get the node's type as a numerical id. + */ +TSSymbol ts_node_symbol(TSNode); + +/** + * Get the node's start byte. + */ +uint32_t ts_node_start_byte(TSNode); + +/** + * Get the node's start position in terms of rows and columns. + */ +TSPoint ts_node_start_point(TSNode); + +/** + * Get the node's end byte. + */ +uint32_t ts_node_end_byte(TSNode); + +/** + * Get the node's end position in terms of rows and columns. + */ +TSPoint ts_node_end_point(TSNode); + +/** + * Get an S-expression representing the node as a string. + * + * This string is allocated with `malloc` and the caller is responsible for + * freeing it using `free`. + */ +char *ts_node_string(TSNode); + +/** + * Check if the node is null. Functions like `ts_node_child` and + * `ts_node_next_sibling` will return a null node to indicate that no such node + * was found. + */ +bool ts_node_is_null(TSNode); + +/** + * Check if the node is *named*. Named nodes correspond to named rules in the + * grammar, whereas *anonymous* nodes correspond to string literals in the + * grammar. + */ +bool ts_node_is_named(TSNode); + +/** + * Check if the node is *missing*. Missing nodes are inserted by the parser in + * order to recover from certain kinds of syntax errors. + */ +bool ts_node_is_missing(TSNode); + +/** + * Check if the node is *extra*. Extra nodes represent things like comments, + * which are not required the grammar, but can appear anywhere. + */ +bool ts_node_is_extra(TSNode); + +/** + * Check if a syntax node has been edited. + */ +bool ts_node_has_changes(TSNode); + +/** + * Check if the node is a syntax error or contains any syntax errors. + */ +bool ts_node_has_error(TSNode); + +/** + * Get the node's immediate parent. + */ +TSNode ts_node_parent(TSNode); + +/** + * Get the node's child at the given index, where zero represents the first + * child. + */ +TSNode ts_node_child(TSNode, uint32_t); + +/** + * Get the field name for node's child at the given index, where zero represents + * the first child. Returns NULL, if no field is found. + */ +const char *ts_node_field_name_for_child(TSNode, uint32_t); + +/** + * Get the node's number of children. + */ +uint32_t ts_node_child_count(TSNode); + +/** + * Get the node's *named* child at the given index. + * + * See also `ts_node_is_named`. + */ +TSNode ts_node_named_child(TSNode, uint32_t); + +/** + * Get the node's number of *named* children. + * + * See also `ts_node_is_named`. + */ +uint32_t ts_node_named_child_count(TSNode); + +/** + * Get the node's child with the given field name. + */ +TSNode ts_node_child_by_field_name( + TSNode self, + const char *field_name, + uint32_t field_name_length +); + +/** + * Get the node's child with the given numerical field id. + * + * You can convert a field name to an id using the + * `ts_language_field_id_for_name` function. + */ +TSNode ts_node_child_by_field_id(TSNode, TSFieldId); + +/** + * Get the node's next / previous sibling. + */ +TSNode ts_node_next_sibling(TSNode); +TSNode ts_node_prev_sibling(TSNode); + +/** + * Get the node's next / previous *named* sibling. + */ +TSNode ts_node_next_named_sibling(TSNode); +TSNode ts_node_prev_named_sibling(TSNode); + +/** + * Get the node's first child that extends beyond the given byte offset. + */ +TSNode ts_node_first_child_for_byte(TSNode, uint32_t); + +/** + * Get the node's first named child that extends beyond the given byte offset. + */ +TSNode ts_node_first_named_child_for_byte(TSNode, uint32_t); + +/** + * Get the smallest node within this node that spans the given range of bytes + * or (row, column) positions. + */ +TSNode ts_node_descendant_for_byte_range(TSNode, uint32_t, uint32_t); +TSNode ts_node_descendant_for_point_range(TSNode, TSPoint, TSPoint); + +/** + * Get the smallest named node within this node that spans the given range of + * bytes or (row, column) positions. + */ +TSNode ts_node_named_descendant_for_byte_range(TSNode, uint32_t, uint32_t); +TSNode ts_node_named_descendant_for_point_range(TSNode, TSPoint, TSPoint); + +/** + * Edit the node to keep it in-sync with source code that has been edited. + * + * This function is only rarely needed. When you edit a syntax tree with the + * `ts_tree_edit` function, all of the nodes that you retrieve from the tree + * afterward will already reflect the edit. You only need to use `ts_node_edit` + * when you have a `TSNode` instance that you want to keep and continue to use + * after an edit. + */ +void ts_node_edit(TSNode *, const TSInputEdit *); + +/** + * Check if two nodes are identical. + */ +bool ts_node_eq(TSNode, TSNode); + +/************************/ +/* Section - TreeCursor */ +/************************/ + +/** + * Create a new tree cursor starting from the given node. + * + * A tree cursor allows you to walk a syntax tree more efficiently than is + * possible using the `TSNode` functions. It is a mutable object that is always + * on a certain syntax node, and can be moved imperatively to different nodes. + */ +TSTreeCursor ts_tree_cursor_new(TSNode); + +/** + * Delete a tree cursor, freeing all of the memory that it used. + */ +void ts_tree_cursor_delete(TSTreeCursor *); + +/** + * Re-initialize a tree cursor to start at a different node. + */ +void ts_tree_cursor_reset(TSTreeCursor *, TSNode); + +/** + * Get the tree cursor's current node. + */ +TSNode ts_tree_cursor_current_node(const TSTreeCursor *); + +/** + * Get the field name of the tree cursor's current node. + * + * This returns `NULL` if the current node doesn't have a field. + * See also `ts_node_child_by_field_name`. + */ +const char *ts_tree_cursor_current_field_name(const TSTreeCursor *); + +/** + * Get the field id of the tree cursor's current node. + * + * This returns zero if the current node doesn't have a field. + * See also `ts_node_child_by_field_id`, `ts_language_field_id_for_name`. + */ +TSFieldId ts_tree_cursor_current_field_id(const TSTreeCursor *); + +/** + * Move the cursor to the parent of its current node. + * + * This returns `true` if the cursor successfully moved, and returns `false` + * if there was no parent node (the cursor was already on the root node). + */ +bool ts_tree_cursor_goto_parent(TSTreeCursor *); + +/** + * Move the cursor to the next sibling of its current node. + * + * This returns `true` if the cursor successfully moved, and returns `false` + * if there was no next sibling node. + */ +bool ts_tree_cursor_goto_next_sibling(TSTreeCursor *); + +/** + * Move the cursor to the first child of its current node. + * + * This returns `true` if the cursor successfully moved, and returns `false` + * if there were no children. + */ +bool ts_tree_cursor_goto_first_child(TSTreeCursor *); + +/** + * Move the cursor to the first child of its current node that extends beyond + * the given byte offset or point. + * + * This returns the index of the child node if one was found, and returns -1 + * if no such child was found. + */ +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 */ +/*******************/ + +/** + * Create a new query from a string containing one or more S-expression + * patterns. The query is associated with a particular language, and can + * only be run on syntax nodes parsed with that language. + * + * If all of the given patterns are valid, this returns a `TSQuery`. + * If a pattern is invalid, this returns `NULL`, and provides two pieces + * of information about the problem: + * 1. The byte offset of the error is written to the `error_offset` parameter. + * 2. The type of error is written to the `error_type` parameter. + */ +TSQuery *ts_query_new( + const TSLanguage *language, + const char *source, + uint32_t source_len, + uint32_t *error_offset, + TSQueryError *error_type +); + +/** + * Delete a query, freeing all of the memory that it used. + */ +void ts_query_delete(TSQuery *); + +/** + * Get the number of patterns, captures, or string literals in the query. + */ +uint32_t ts_query_pattern_count(const TSQuery *); +uint32_t ts_query_capture_count(const TSQuery *); +uint32_t ts_query_string_count(const TSQuery *); + +/** + * Get the byte offset where the given pattern starts in the query's source. + * + * This can be useful when combining queries by concatenating their source + * code strings. + */ +uint32_t ts_query_start_byte_for_pattern(const TSQuery *, uint32_t); + +/** + * Get all of the predicates for the given pattern in the query. + * + * The predicates are represented as a single array of steps. There are three + * types of steps in this array, which correspond to the three legal values for + * the `type` field: + * - `TSQueryPredicateStepTypeCapture` - Steps with this type represent names + * of captures. Their `value_id` can be used with the + * `ts_query_capture_name_for_id` function to obtain the name of the capture. + * - `TSQueryPredicateStepTypeString` - Steps with this type represent literal + * strings. Their `value_id` can be used with the + * `ts_query_string_value_for_id` function to obtain their string value. + * - `TSQueryPredicateStepTypeDone` - Steps with this type are *sentinels* + * that represent the end of an individual predicate. If a pattern has two + * predicates, then there will be two steps with this `type` in the array. + */ +const TSQueryPredicateStep *ts_query_predicates_for_pattern( + const TSQuery *self, + uint32_t pattern_index, + uint32_t *length +); + +/* + * Check if the given pattern in the query has a single root node. + */ +bool ts_query_is_pattern_rooted(const TSQuery *self, uint32_t pattern_index); + +/* + * Check if the given pattern in the query is 'non local'. + * + * A non-local pattern has multiple root nodes and can match within a + * repeating sequence of nodes, as specified by the grammar. Non-local + * patterns disable certain optimizations that would otherwise be possible + * when executing a query on a specific range of a syntax tree. + */ +bool ts_query_is_pattern_non_local(const TSQuery *self, uint32_t pattern_index); + +/* + * Check if a given pattern is guaranteed to match once a given step is reached. + * The step is specified by its byte offset in the query's source code. + */ +bool ts_query_is_pattern_guaranteed_at_step(const TSQuery *self, uint32_t byte_offset); + +/** + * Get the name and length of one of the query's captures, or one of the + * query's string literals. Each capture and string is associated with a + * numeric id based on the order that it appeared in the query's source. + */ +const char *ts_query_capture_name_for_id( + const TSQuery *, + uint32_t id, + uint32_t *length +); + +/** + * Get the quantifier of the query's captures. Each capture is * associated + * with a numeric id based on the order that it appeared in the query's source. + */ +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 +); + +/** + * Disable a certain capture within a query. + * + * This prevents the capture from being returned in matches, and also avoids + * any resource usage associated with recording the capture. Currently, there + * is no way to undo this. + */ +void ts_query_disable_capture(TSQuery *, const char *, uint32_t); + +/** + * Disable a certain pattern within a query. + * + * This prevents the pattern from matching and removes most of the overhead + * associated with the pattern. Currently, there is no way to undo this. + */ +void ts_query_disable_pattern(TSQuery *, uint32_t); + +/** + * Create a new cursor for executing a given query. + * + * The cursor stores the state that is needed to iteratively search + * for matches. To use the query cursor, first call `ts_query_cursor_exec` + * to start running a given query on a given syntax node. Then, there are + * two options for consuming the results of the query: + * 1. Repeatedly call `ts_query_cursor_next_match` to iterate over all of the + * *matches* in the order that they were found. Each match contains the + * index of the pattern that matched, and an array of captures. Because + * multiple patterns can match the same set of nodes, one match may contain + * captures that appear *before* some of the captures from a previous match. + * 2. Repeatedly call `ts_query_cursor_next_capture` to iterate over all of the + * individual *captures* in the order that they appear. This is useful if + * don't care about which pattern matched, and just want a single ordered + * sequence of captures. + * + * If you don't care about consuming all of the results, you can stop calling + * `ts_query_cursor_next_match` or `ts_query_cursor_next_capture` at any point. + * You can then start executing another query on another node by calling + * `ts_query_cursor_exec` again. + */ +TSQueryCursor *ts_query_cursor_new(void); + +/** + * Delete a query cursor, freeing all of the memory that it used. + */ +void ts_query_cursor_delete(TSQueryCursor *); + +/** + * Start running a given query on a given node. + */ +void ts_query_cursor_exec(TSQueryCursor *, const TSQuery *, TSNode); + +/** + * Manage the maximum number of in-progress matches allowed by this query + * cursor. + * + * Query cursors have an optional maximum capacity for storing lists of + * in-progress captures. If this capacity is exceeded, then the + * earliest-starting match will silently be dropped to make room for further + * matches. This maximum capacity is optional — by default, query cursors allow + * any number of pending matches, dynamically allocating new space for them as + * needed as the query is executed. + */ +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); + +/** + * Set the range of bytes or (row, column) positions in which the query + * will be executed. + */ +void ts_query_cursor_set_byte_range(TSQueryCursor *, uint32_t, uint32_t); +void ts_query_cursor_set_point_range(TSQueryCursor *, TSPoint, TSPoint); + +/** + * Advance to the next match of the currently running query. + * + * If there is a match, write it to `*match` and return `true`. + * Otherwise, return `false`. + */ +bool ts_query_cursor_next_match(TSQueryCursor *, TSQueryMatch *match); +void ts_query_cursor_remove_match(TSQueryCursor *, uint32_t id); + +/** + * Advance to the next capture of the currently running query. + * + * If there is a capture, write its match to `*match` and its index within + * the matche's capture list to `*capture_index`. Otherwise, return `false`. + */ +bool ts_query_cursor_next_capture( + TSQueryCursor *, + TSQueryMatch *match, + uint32_t *capture_index +); + +/**********************/ +/* Section - Language */ +/**********************/ + +/** + * Get the number of distinct node types in the language. + */ +uint32_t ts_language_symbol_count(const TSLanguage *); + +/** + * Get a node type string for the given numerical id. + */ +const char *ts_language_symbol_name(const TSLanguage *, TSSymbol); + +/** + * Get the numerical id for the given node type string. + */ +TSSymbol ts_language_symbol_for_name( + const TSLanguage *self, + const char *string, + uint32_t length, + bool is_named +); + +/** + * Get the number of distinct field names in the language. + */ +uint32_t ts_language_field_count(const TSLanguage *); + +/** + * Get the field name string for the given numerical id. + */ +const char *ts_language_field_name_for_id(const TSLanguage *, TSFieldId); + +/** + * Get the numerical id for the given field name string. + */ +TSFieldId ts_language_field_id_for_name(const TSLanguage *, const char *, uint32_t); + +/** + * Check whether the given node type id belongs to named nodes, anonymous nodes, + * or a hidden nodes. + * + * See also `ts_node_is_named`. Hidden nodes are never returned from the API. + */ +TSSymbolType ts_language_symbol_type(const TSLanguage *, TSSymbol); + +/** + * Get the ABI version number for this language. This version number is used + * to ensure that languages were generated by a compatible version of + * Tree-sitter. + * + * See also `ts_parser_set_language`. + */ +uint32_t ts_language_version(const TSLanguage *); + +/**********************************/ +/* Section - Global Configuration */ +/**********************************/ + +/** + * Set the allocation functions used by the library. + * + * By default, Tree-sitter uses the standard libc allocation functions, + * but aborts the process when an allocation fails. This function lets + * you supply alternative allocation functions at runtime. + * + * If you pass `NULL` for any parameter, Tree-sitter will switch back to + * its default implementation of that function. + * + * If you call this function after the library has already been used, then + * you must ensure that either: + * 1. All the existing objects have been freed. + * 2. The new allocator shares its state with the old one, so it is capable + * of freeing memory that was allocated by the old allocator. + */ +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_ +