tree-sitter/include/tree_sitter/parser.h

#ifndef TREE_SITTER_PARSER_H_
#define TREE_SITTER_PARSER_H_

#ifdef __cplusplus
extern "C" {
#endif

#include <stdio.h>
#include "tree_sitter/runtime.h"

typedef struct TSTree TSTree;

#define ts_lex_state_error 0

typedef struct {
    TSInput input;
    int debug;
    const char *chunk;
    size_t chunk_start;
    size_t chunk_size;
    size_t position_in_chunk;
    size_t token_end_position;
    size_t token_start_position;
    int reached_end;
} TSLexer;

TSLexer ts_lexer_make();
int ts_lexer_advance(TSLexer *lexer);
TSTree * ts_lexer_build_node(TSLexer *lexer, TSSymbol symbol, int is_hidden);

static inline size_t ts_lexer_position(const TSLexer *lexer) {
    return lexer->chunk_start + lexer->position_in_chunk;
}

static inline char ts_lexer_lookahead_char(const TSLexer *lexer) {
    return lexer->chunk[lexer->position_in_chunk];
}

static inline void ts_lexer_start_token(TSLexer *lexer) {
    lexer->token_start_position = ts_lexer_position(lexer);
}

typedef unsigned short TSStateId;

typedef struct {
    size_t size;
    struct {
        TSTree *node;
        TSStateId state;
        int is_extra;
    } *entries;
} TSStack;

TSStack ts_stack_make();
void ts_stack_delete(TSStack *);
TSTree * ts_stack_reduce(TSStack *stack, TSSymbol symbol, size_t immediate_child_count, const int *hidden_symbol_flags, int gather_extras);
void ts_stack_shrink(TSStack *stack, size_t new_size);
void ts_stack_push(TSStack *stack, TSStateId state, TSTree *node);
TSStateId ts_stack_top_state(const TSStack *stack);
TSTree * ts_stack_top_node(const TSStack *stack);
size_t ts_stack_right_position(const TSStack *stack);

typedef enum {
    TSParseActionTypeError,
    TSParseActionTypeShift,
    TSParseActionTypeShiftExtra,
    TSParseActionTypeReduce,
    TSParseActionTypeReduceExtra,
    TSParseActionTypeAccept,
} TSParseActionType;

typedef struct {
    TSParseActionType type;
    union {
        TSStateId to_state;
        struct {
            TSSymbol symbol;
            unsigned short child_count;
        };
    } data;
} TSParseAction;

typedef struct {
    size_t symbol_count;
    const char **symbol_names;
    const int *hidden_symbol_flags;
    const TSParseAction *parse_table;
    const TSStateId *lex_states;
    TSTree * (* lex_fn)(TSParser *, TSStateId);
} TSParserConfig;

struct TSParser {
    TSLexer lexer;
    TSStack stack;
    int debug;
    TSTree *lookahead;
    TSTree *next_lookahead;
    TSParserConfig config;
};

TSParser * ts_parser_make(TSParserConfig);
void ts_parser_free(TSParser *);
TSParserConfig ts_parser_config(TSParser *);
const TSTree * ts_parser_parse(TSParser *parser, TSInput input, TSInputEdit *edit);
void ts_parser_start(TSParser *parser, TSInput input, TSInputEdit *edit);
TSTree * ts_parser_step(TSParser *parser);

#define SYMBOL_NAMES \
static const char *ts_symbol_names[]

#define HIDDEN_SYMBOLS \
static const int ts_hidden_symbol_flags[SYMBOL_COUNT]

#define LEX_STATES \
static TSStateId ts_lex_states[STATE_COUNT]

#define PARSE_TABLE \
static const TSParseAction ts_parse_actions[STATE_COUNT][SYMBOL_COUNT]

#define LEX_FN() \
static TSTree * ts_lex(TSParser *parser, TSStateId lex_state)

#define DEBUG_LEX(...) \
if (parser->lexer.debug) { fprintf(stderr, "\n" __VA_ARGS__); }

#define START_LEXER() \
DEBUG_LEX("LEX %d", lex_state); \
char lookahead; \
next_state: \
lookahead = ts_lexer_lookahead_char(&parser->lexer); \
DEBUG_LEX("CHAR '%c'", lookahead);

#define START_TOKEN() \
ts_lexer_start_token(&parser->lexer);

#define ADVANCE(state_index) \
{ \
    DEBUG_LEX("ADVANCE %d", state_index); \
    if (!ts_lexer_advance(&parser->lexer)) ACCEPT_TOKEN(ts_builtin_sym_end); \
    lex_state = state_index; goto next_state; \
}

#define ACCEPT_TOKEN(symbol) \
{ \
    DEBUG_LEX("TOKEN %s", ts_symbol_names[symbol]); \
    return ts_lexer_build_node(&parser->lexer, symbol, ts_hidden_symbol_flags[symbol]); \
}

#define LEX_ERROR() \
{ \
    DEBUG_LEX("ERROR"); \
    return ts_lexer_build_node(&parser->lexer, ts_builtin_sym_error, 0); \
}

#define LEX_PANIC() \
{ \
    DEBUG_LEX("LEX ERROR: unexpected state %d", lex_state); \
    return NULL; \
}

#define SHIFT(to_state_value) \
{ .type = TSParseActionTypeShift, .data = { .to_state = to_state_value } }

#define SHIFT_EXTRA() \
{ .type = TSParseActionTypeShiftExtra }

#define REDUCE_EXTRA(symbol_val) \
{ .type = TSParseActionTypeReduceExtra, .data = { .symbol = symbol_val } }

#define REDUCE(symbol_val, child_count_val) \
{ .type = TSParseActionTypeReduce, .data = { .symbol = symbol_val, .child_count = child_count_val } }

#define ACCEPT_INPUT() \
{ .type = TSParseActionTypeAccept }

#define EXPORT_PARSER(constructor_name) \
TSParser * constructor_name() { \
    return ts_parser_make((TSParserConfig) { \
        .symbol_count = SYMBOL_COUNT, \
        .hidden_symbol_flags = ts_hidden_symbol_flags, \
        .parse_table = (const TSParseAction *)ts_parse_actions, \
        .lex_states = ts_lex_states, \
        .symbol_names =  ts_symbol_names, \
        .lex_fn = ts_lex, \
    }); \
}

#ifdef __cplusplus
}
#endif

#endif  // TREE_SITTER_PARSER_H_