Move parser functions to the header

- this way they can be inlined by the compiler if need be

include/parser.h

@@ -1,17 +1,38 @@
 #ifndef __tree_sitter_parser_h__
 #define __tree_sitter_parser_h__
-
+#ifdef __cplusplus
+extern "C" {
+#endif
+    
 #include "tree.h"
 #include "parse_config.h"
 #include <stdio.h>
 
-#ifdef __cplusplus
-extern "C" {
+// #define TS_DEBUG_PARSE
+// #define TS_DEBUG_LEX
+    
+#ifdef TS_DEBUG_LEX
+#define DEBUG_LEX(...) fprintf(stderr, __VA_ARGS__)
+#else
+#define DEBUG_LEX(...)
 #endif
+    
+#ifdef TS_DEBUG_PARSE
+#define DEBUG_PARSE(...) fprintf(stderr, __VA_ARGS__)
+#else
+#define DEBUG_PARSE(...)
+#endif
+    
+static int INITIAL_STACK_SIZE = 100;
 
 typedef int TSState;
-typedef struct TSStackEntry TSStackEntry;
-typedef struct TSParser {
+
+typedef struct {
+    TSState state;
+    TSTree *node;
+} TSStackEntry;
+
+typedef struct {
     const char *input;
     size_t position;
     TSTree *lookahead_node;
@@ -21,29 +42,96 @@ typedef struct TSParser {
     TSParseResult result;
 } TSParser;
 
-TSParser TSParserMake(const char *input);
-void TSParserShift(TSParser *parser, TSState state);
-void TSParserReduce(TSParser *parser, TSSymbol symbol, int child_count);
-void TSParserLexError(TSParser *parser, size_t count, const char **expected_inputs);
-void TSParserError(TSParser *parser, size_t count, const char **expected_inputs);
-void TSParserAcceptInput(TSParser *parser);
-void TSParserAdvance(TSParser *parser, TSState lex_state);
-TSState TSParserParseState(const TSParser *parser);
-TSState TSParserLexState(const TSParser *parser);
-TSParseResult TSParserResult(TSParser *parser);
-void TSParserSetLexState(TSParser *parser, TSState state);
-char TSParserLookaheadChar(const TSParser *parser);
-long TSParserLookaheadSym(const TSParser *parser);
-void TSParserSetLookaheadSym(TSParser *parser, TSSymbol symbol);
+static TSParser TSParserMake(const char *input) {
+    TSParser result = {
+        .input = input,
+        .position = 0,
+        .lookahead_node = NULL,
+        .lex_state = 0,
+        .stack = calloc(INITIAL_STACK_SIZE, sizeof(TSStackEntry)),
+        .stack_size = 0,
+        .result = {
+            .tree = NULL,
+            .error = {
+                .type = TSParseErrorTypeNone,
+                .expected_inputs = NULL,
+                .expected_input_count = 0
+            },
+        },
+    };
+    return result;
+}
+
+static char TSParserLookaheadChar(const TSParser *parser) {
+    return parser->input[parser->position];
+}
+
+static long TSParserLookaheadSym(const TSParser *parser) {
+    TSTree *node = parser->lookahead_node;
+    return node ? node->value : -1;
+}
+
+static TSState TSParserParseState(const TSParser *parser) {
+    return parser->stack[parser->stack_size - 1].state;
+}
+
+static void TSParserShift(TSParser *parser, TSState parse_state) {
+    DEBUG_PARSE("shift %d \n", parse_state);
+    TSStackEntry *entry = (parser->stack + parser->stack_size);
+    entry->state = parse_state;
+    entry->node = parser->lookahead_node;
+    parser->lookahead_node = NULL;
+    parser->stack_size++;
+}
+
+static void TSParserReduce(TSParser *parser, TSSymbol symbol, int child_count) {
+    parser->stack_size -= child_count;
+    
+    TSTree **children = malloc(child_count * sizeof(TSTree *));
+    for (int i = 0; i < child_count; i++) {
+        children[i] = parser->stack[parser->stack_size + i].node;
+    }
+    
+    parser->lookahead_node = TSTreeMake(symbol, child_count, children);
+    DEBUG_PARSE("reduce: %ld, state: %u \n", symbol, TSParserParseState(parser));
+}
+
+static void TSParserError(TSParser *parser, size_t count, const char **expected_inputs) {
+    TSParseError *error = &parser->result.error;
+    error->type = TSParseErrorTypeSyntactic;
+    error->expected_input_count = count;
+    error->expected_inputs = expected_inputs;
+    error->lookahead_sym = TSParserLookaheadSym(parser);
+}
+
+static void TSParserLexError(TSParser *parser, size_t count, const char **expected_inputs) {
+    TSParseError *error = &parser->result.error;
+    error->type = TSParseErrorTypeLexical;
+    error->expected_input_count = count;
+    error->expected_inputs = expected_inputs;
+    error->lookahead_sym = TSParserLookaheadSym(parser);
+}
+
+static void TSParserAdvance(TSParser *parser, TSState lex_state) {
+    DEBUG_LEX("character: '%c' \n", TSParserLookaheadChar(parser));
+    parser->position++;
+    parser->lex_state = lex_state;
+}
+
+static void TSParserSetLookaheadSym(TSParser *parser, TSSymbol symbol) {
+    DEBUG_LEX("token: %ld \n", symbol);
+    parser->lookahead_node = TSTreeMake(symbol, 0, NULL);
+}
+
+static void TSParserAcceptInput(TSParser *parser) {
+    parser->result.tree = parser->stack[parser->stack_size - 1].node;
+}
 
 #pragma mark - DSL
 
 #define START_PARSER() \
-TSParser p = TSParserMake(input),  *parser = &p; \
+TSParser p = TSParserMake(input), *parser = &p; \
 next_state:
-    
-#define LOOKAHEAD_SYM_NAME() \
-ts_symbol_names[LOOKAHEAD_SYM()]
 
 #define START_LEXER() \
 if (LOOKAHEAD_SYM() >= 0) return; \
@@ -60,26 +148,26 @@ TSParserLookaheadChar(parser)
 TSParserParseState(parser)
 
 #define LEX_STATE() \
-TSParserLexState(parser)
+parser->lex_state
+
+#define SET_LEX_STATE(state_index) \
+{ parser->lex_state = state_index; ts_lex(parser); }
 
 #define SHIFT(state) \
 { TSParserShift(parser, state); goto next_state; }
 
-#define SET_LEX_STATE(state_index) \
-{ TSParserSetLexState(parser, state_index); ts_lex(parser); }
-
 #define ADVANCE(state_index) \
 { TSParserAdvance(parser, state_index); goto next_state; }
 
+#define REDUCE(symbol, child_count) \
+{ TSParserReduce(parser, symbol, child_count); goto next_state; }
+
 #define ACCEPT_INPUT() \
 { TSParserAcceptInput(parser); goto done; }
 
 #define ACCEPT_TOKEN(symbol) \
 { TSParserSetLookaheadSym(parser, symbol); goto done; }
 
-#define REDUCE(symbol, child_count) \
-{ TSParserReduce(parser, symbol, child_count); goto next_state; }
-
 #define PARSE_ERROR(count, inputs) \
 { \
 static const char *expected_inputs[] = inputs; \
@@ -89,28 +177,27 @@ goto done; \
 
 #define LEX_ERROR(count, inputs) \
 { \
-    static const char *expected_inputs[] = inputs; \
-    TSParserLexError(parser, count, expected_inputs); \
-    goto done; \
+static const char *expected_inputs[] = inputs; \
+TSParserLexError(parser, count, expected_inputs); \
+goto done; \
 }
+
+#define LEX_PANIC() \
+printf("Lex error: unexpected state %ud", LEX_STATE());
     
+#define PARSE_PANIC() \
+printf("Parse error: unexpected state %ud", PARSE_STATE());
+
 #define EXPECT(...) __VA_ARGS__
 
 #define FINISH_PARSER() \
 done: \
-return TSParserResult(parser);
+return parser->result;
 
 #define FINISH_LEXER() \
 done:
-    
-#define LEX_PANIC() \
-printf("Lex error: unexpected state %ud", LEX_STATE());
-
-#define PARSE_PANIC() \
-printf("Parse error: unexpected state %ud", PARSE_STATE());
 
 #ifdef __cplusplus
 }
 #endif
-
 #endif