codebase-graph 1.7.1

Native codebaseGraph CLI and MCP server for local code knowledge graphs.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

// Copied from tree-sitter-rust with modification.

#include "tree_sitter/parser.h"

enum TokenType {
    BLOCK_COMMENT_CONTENT
};

void * tree_sitter_wat_external_scanner_create() { return 0; }
void tree_sitter_wat_external_scanner_destroy(void *payload) {}
unsigned tree_sitter_wat_external_scanner_serialize(void *payload, char *buffer) {
    return 0;
}
void tree_sitter_wat_external_scanner_deserialize(void *payload, const char *buffer, unsigned length) {}

typedef enum {
    LeftParen,
    LeftSemi,
    Continuing,
} BlockCommentState;

typedef struct {
    BlockCommentState state;
    unsigned nestingDepth;
} BlockCommentProcessing;

static inline void process_left_paren(BlockCommentProcessing *processing, char current) {
    if (current == ';') {
        processing->nestingDepth += 1;
    }
    processing->state = Continuing;
};

static inline void process_left_semi(BlockCommentProcessing *processing, char current, TSLexer *lexer) {
    if (current == ';') {
        lexer->mark_end(lexer);
        processing->state = LeftSemi;
        return;
    }

    if (current == ')') {
        processing->nestingDepth -= 1;
    }

    processing->state = Continuing;
}

static inline void process_continuing(BlockCommentProcessing *processing, char current) {
    switch (current) {
        case '(':
            processing->state = LeftParen;
            break;
        case ';':
            processing->state = LeftSemi;
            break;
    }
}

static inline bool process_block_comment(TSLexer *lexer, const bool *valid_symbols) {
    char first = (char)lexer->lookahead;
    lexer->advance(lexer, false);

    if (valid_symbols[BLOCK_COMMENT_CONTENT]) {
        BlockCommentProcessing processing = {Continuing, 1};
        switch (first) {
            case ';':
                processing.state = LeftSemi;
                if (lexer->lookahead == ')') {
                    return false;
                }
                break;
            case '(':
                processing.state = LeftParen;
                break;
            default:
                processing.state = Continuing;
                break;
        }

        while (!lexer->eof(lexer) && processing.nestingDepth != 0) {
            first = (char)lexer->lookahead;
            switch (processing.state) {
                case LeftParen:
                    process_left_paren(&processing, first);
                    break;
                case LeftSemi:
                    process_left_semi(&processing, first, lexer);
                    break;
                case Continuing:
                    lexer->mark_end(lexer);
                    process_continuing(&processing, first);
                    break;
                default:
                    break;
            }
            lexer->advance(lexer, false);
            if (first == ')' && processing.nestingDepth != 0) {
                lexer->mark_end(lexer);
            }
        }
        lexer->result_symbol = BLOCK_COMMENT_CONTENT;
        return true;
    }

    return false;
}

bool tree_sitter_wat_external_scanner_scan(void *payload, TSLexer *lexer, const bool *valid_symbols) {
    if (valid_symbols[BLOCK_COMMENT_CONTENT]) {
        return process_block_comment(lexer, valid_symbols);
    }

    return false;
}