init basic

ccompiler/frontend/parser/ast/func.c

@@ -0,0 +1,120 @@
+#include "../parser.h"
+#include "../symtab/symtab.h"
+#include "ast.h"
+
+#ifndef FUNC_PARAM_CACHE_SIZE
+#define FUNC_PARAM_CACHE_SIZE 32  // 合理初始值，可覆盖99%常见情况
+#endif
+
+struct FuncParamCache {
+    struct Token tokens[FUNC_PARAM_CACHE_SIZE];
+    int read_pos;    // 当前读取位置
+    int write_pos;   // 写入位置
+    int depth;       // 当前缓存深度
+};
+
+static enum TokenType peekcachetype(struct FuncParamCache* cache) {
+    return cache->tokens[cache->read_pos++].type;
+}
+
+// TODO 语义分析压入符号表
+static void parse_params(struct Parser* parser, struct FuncParamCache* cache, struct ASTNode* node) {
+    //  = peekcachetype(cache);
+    enum TokenType ttype;
+    // if (ttype != TOKEN_L_PAREN) {
+    //     error("function expected '('\n");
+    // }
+    struct ASTNode *params = new_ast_node();
+    node->func.params = params;
+    int params_size = 0;
+
+    while ((ttype = peekcachetype(cache)) != TOKEN_R_PAREN) {
+        switch (ttype) {
+        case TOKEN_COMMA:
+            break;
+        case TOKEN_ELLIPSIS:
+            ttype = peekcachetype(cache);
+            if (ttype != TOKEN_R_PAREN) {
+                error("... must be a last parameter list (expect ')')");
+            }
+            // TODO
+            error("not implement");
+            break;
+        case TOKEN_IDENT:
+            params->children[params_size++] = NULL;
+            break;
+        default:
+            // TODO 使用cache的类型解析
+            // parse_type(parser);
+            // TODO type parse
+            // ttype = peekcachetype(cache);
+            // ttype = peekcachetype(cache);
+            // if (ttype != TOKEN_IDENT) {
+            //     node->node_type = NT_DECL_FUNC;
+            //     flushpeektok(parser);
+            //     continue;
+            // }
+            // error("function expected ')' or ','\n");
+        }
+    }
+}
+
+enum ASTType check_is_func_decl(struct Parser* parser, struct FuncParamCache* cache) {
+    cache->depth = 1;
+    cache->read_pos = 0;
+    cache->write_pos = 0;
+    
+    while (cache->depth) {
+        struct Token* tok = peektok(parser);
+        poptok(parser);
+        if (cache->write_pos >= FUNC_PARAM_CACHE_SIZE - 1) {
+            error("function parameter list too long");
+        }
+        cache->tokens[cache->write_pos++] = *tok;
+        switch (tok->type) {
+        case TOKEN_L_PAREN:
+            cache->depth++;
+            break;
+        case TOKEN_R_PAREN:
+            cache->depth--;
+            break;
+        }
+    }
+
+    switch (peektoktype(parser)) {
+        case TOKEN_SEMICOLON:
+            poptok(parser);
+            return NT_DECL_FUNC;
+        case TOKEN_L_BRACE:
+            return NT_FUNC;
+            break;
+        default:
+            error("function define or decl need '{' or ';' but you don't got");
+    }
+}
+
+struct ASTNode* parse_func(struct Parser* parser) {
+    struct ASTNode* ret_type = parse_type(parser);
+    struct ASTNode* func_name = parse_ident(parser);
+
+    struct ASTNode* node = new_ast_node();
+    node->func.ret = ret_type;
+    node->func.name = func_name;
+
+    flushpeektok(parser);
+    expecttok(parser, TOKEN_L_PAREN);
+    struct FuncParamCache cache;
+    node->type = check_is_func_decl(parser, &cache);
+
+    symtab_add_symbol(parser->symtab, func_name->syms.tok.constant.str, node);
+    if (node->type == NT_DECL_FUNC) {
+        return node;
+    }
+
+    symtab_enter_scope(parser->symtab);
+    parse_params(parser, &cache, node);
+    node->func.body = parse_block(parser);
+    symtab_leave_scope(parser->symtab);
+
+    return node;
+}