Skip to content

Local code intelligence for developers and AI agents. Connect code, docs and infrastructure in a persistent graph, with CBM Lens, MCP tools, agent integrations and change-aware test selection.

8.3 KB
Raw Blame
#ifndef TREE_SITTER_PARSER_H_
#define TREE_SITTER_PARSER_H_

#ifdef __cplusplus
extern "C" {
#endif

#include <stdbool.h>
#include <stdint.h>
#include <stdlib.h>

#define ts_builtin_sym_error ((TSSymbol) - 1)
#define ts_builtin_sym_end 0
#define TREE_SITTER_SERIALIZATION_BUFFER_SIZE 1024

#ifndef TREE_SITTER_API_H_
typedef uint16_t TSStateId;
typedef uint16_t TSSymbol;
typedef uint16_t TSFieldId;
typedef struct TSLanguage TSLanguage;
typedef struct TSLanguageMetadata {
    uint8_t major_version;
    uint8_t minor_version;
    uint8_t patch_version;
} TSLanguageMetadata;
#endif

typedef struct {
    TSFieldId field_id;
    uint8_t child_index;
    bool inherited;
} TSFieldMapEntry;

// Used to index the field and supertype maps.
typedef struct {
    uint16_t index;
    uint16_t length;
} TSMapSlice;

typedef struct {
    bool visible;
    bool named;
    bool supertype;
} TSSymbolMetadata;

typedef struct TSLexer TSLexer;

struct TSLexer {
    int32_t lookahead;
    TSSymbol result_symbol;
    void (*advance)(TSLexer *, bool);
    void (*mark_end)(TSLexer *);
    uint32_t (*get_column)(TSLexer *);
    bool (*is_at_included_range_start)(const TSLexer *);
    bool (*eof)(const TSLexer *);
    void (*log)(const TSLexer *, const char *, ...);
};

typedef enum {
    TSParseActionTypeShift,
    TSParseActionTypeReduce,
    TSParseActionTypeAccept,
    TSParseActionTypeRecover,
} TSParseActionType;

typedef union {
    struct {
        uint8_t type;
        TSStateId state;
        bool extra;
        bool repetition;
    } shift;
    struct {
        uint8_t type;
        uint8_t child_count;
        TSSymbol symbol;
        int16_t dynamic_precedence;
        uint16_t production_id;
    } reduce;
    uint8_t type;
} TSParseAction;

typedef struct {
    uint16_t lex_state;
    uint16_t external_lex_state;
} TSLexMode;

typedef struct {
    uint16_t lex_state;
    uint16_t external_lex_state;
    uint16_t reserved_word_set_id;
} TSLexerMode;

typedef union {
    TSParseAction action;
    struct {
        uint8_t count;
        bool reusable;
    } entry;
} TSParseActionEntry;

typedef struct {
    int32_t start;
    int32_t end;
} TSCharacterRange;

struct TSLanguage {
    uint32_t abi_version;
    uint32_t symbol_count;
    uint32_t alias_count;
    uint32_t token_count;
    uint32_t external_token_count;
    uint32_t state_count;
    uint32_t large_state_count;
    uint32_t production_id_count;
    uint32_t field_count;
    uint16_t max_alias_sequence_length;
    const uint16_t *parse_table;
    const uint16_t *small_parse_table;
    const uint32_t *small_parse_table_map;
    const TSParseActionEntry *parse_actions;
    const char *const *symbol_names;
    const char *const *field_names;
    const TSMapSlice *field_map_slices;
    const TSFieldMapEntry *field_map_entries;
    const TSSymbolMetadata *symbol_metadata;
    const TSSymbol *public_symbol_map;
    const uint16_t *alias_map;
    const TSSymbol *alias_sequences;
    const TSLexerMode *lex_modes;
    bool (*lex_fn)(TSLexer *, TSStateId);
    bool (*keyword_lex_fn)(TSLexer *, TSStateId);
    TSSymbol keyword_capture_token;
    struct {
        const bool *states;
        const TSSymbol *symbol_map;
        void *(*create)(void);
        void (*destroy)(void *);
        bool (*scan)(void *, TSLexer *, const bool *symbol_whitelist);
        unsigned (*serialize)(void *, char *);
        void (*deserialize)(void *, const char *, unsigned);
    } external_scanner;
    const TSStateId *primary_state_ids;
    const char *name;
    const TSSymbol *reserved_words;
    uint16_t max_reserved_word_set_size;
    uint32_t supertype_count;
    const TSSymbol *supertype_symbols;
    const TSMapSlice *supertype_map_slices;
    const TSSymbol *supertype_map_entries;
    TSLanguageMetadata metadata;
};

static inline bool set_contains(const TSCharacterRange *ranges, uint32_t len, int32_t lookahead) {
    uint32_t index = 0;
    uint32_t size = len - index;
    while (size > 1) {
        uint32_t half_size = size / 2;
        uint32_t mid_index = index + half_size;
        const TSCharacterRange *range = &ranges[mid_index];
        if (lookahead >= range->start && lookahead <= range->end) {
            return true;
        } else if (lookahead > range->end) {
            index = mid_index;
        }
        size -= half_size;
    }
    const TSCharacterRange *range = &ranges[index];
    return (lookahead >= range->start && lookahead <= range->end);
}

/*
 *  Lexer Macros
 */

#ifdef _MSC_VER
#define UNUSED __pragma(warning(suppress : 4101))
#else
#define UNUSED __attribute__((unused))
#endif

#define START_LEXER()            \
    bool result = false;         \
    bool skip = false;           \
    UNUSED                       \
    bool eof = false;            \
    int32_t lookahead;           \
    goto start;                  \
    next_state:                  \
    lexer->advance(lexer, skip); \
    start:                       \
    skip = false;                \
    lookahead = lexer->lookahead;

#define ADVANCE(state_value) \
    {                        \
        state = state_value; \
        goto next_state;     \
    }

#define ADVANCE_MAP(...)                                                 \
    {                                                                    \
        static const uint16_t map[] = {__VA_ARGS__};                     \
        for (uint32_t i = 0; i < sizeof(map) / sizeof(map[0]); i += 2) { \
            if (map[i] == lookahead) {                                   \
                state = map[i + 1];                                      \
                goto next_state;                                         \
            }                                                            \
        }                                                                \
    }

#define SKIP(state_value)    \
    {                        \
        skip = true;         \
        state = state_value; \
        goto next_state;     \
    }

#define ACCEPT_TOKEN(symbol_value)       \
    result = true;                       \
    lexer->result_symbol = symbol_value; \
    lexer->mark_end(lexer);

#define END_STATE() return result;

/*
 *  Parse Table Macros
 */

#define SMALL_STATE(id) ((id) - LARGE_STATE_COUNT)

#define STATE(id) id

#define ACTIONS(id) id

#define SHIFT(state_value)                                                     \
    {                                                                          \
        {                                                                      \
            .shift = {.type = TSParseActionTypeShift, .state = (state_value) } \
        }                                                                      \
    }

#define SHIFT_REPEAT(state_value)                                                                  \
    {                                                                                              \
        {                                                                                          \
            .shift = {.type = TSParseActionTypeShift, .state = (state_value), .repetition = true } \
        }                                                                                          \
    }

#define SHIFT_EXTRA()                                                 \
    {                                                                 \
        {                                                             \
            .shift = {.type = TSParseActionTypeShift, .extra = true } \
        }                                                             \
    }

#define REDUCE(symbol_name, children, precedence, prod_id) \
    {                                                      \
        {                                                  \
            .reduce = {.type = TSParseActionTypeReduce,    \
                       .symbol = symbol_name,              \
                       .child_count = children,            \
                       .dynamic_precedence = precedence,   \
                       .production_id = prod_id},          \
        }                                                  \
    }

#define RECOVER()                            \
    {                                        \
        { .type = TSParseActionTypeRecover } \
    }

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

#ifdef __cplusplus
}
#endif

#endif // TREE_SITTER_PARSER_H_