smcc/ccompiler/frontend/parser/ast/term.c

#include "../parser.h"
#include "../type.h"
#include "ast.h"

// /* 状态跳转表定义 */
// typedef void (*StateHandler)(struct Parser*, struct ASTNode**);

// enum TypeParseState {
//     TPS_BASE_TYPE,    // 解析基础类型 (int/char等)
//     TPS_QUALIFIER,    // 解析限定符 (const/volatile)
//     TPS_POINTER,      // 解析指针 (*)
//     TPS_ARRAY,        // 解析数组维度 ([n])
//     TPS_FUNC_PARAMS,  // 解析函数参数列表
//     TPS_END,
// };

// ;

// /* 状态处理函数前置声明 */
// static void handle_base_type(struct Parser*, struct ASTNode**);
// static void handle_qualifier(struct Parser*, struct ASTNode**);
// static void handle_pointer(struct Parser*, struct ASTNode**);
// static void handle_array(struct Parser*, struct ASTNode**);
// static void handle_func_params(struct Parser*, struct ASTNode**);
// static void handle_error(struct Parser*, struct ASTNode**);

// /* 状态跳转表（核心优化部分） */
// static const struct StateTransition {
//     enum TokenType tok;      // 触发token
//     StateHandler handler;    // 处理函数
//     enum TypeParseState next_state; // 下一个状态
// } state_table[][8] = {
//     [TPS_QUALIFIER] = {
//         {TOKEN_CONST,      handle_qualifier, TPS_QUALIFIER},
//         {TOKEN_VOLATILE,   handle_qualifier, TPS_QUALIFIER},
//         {TOKEN_VOID,       handle_base_type, TPS_POINTER},
//         {TOKEN_CHAR,       handle_base_type, TPS_POINTER},
//         {TOKEN_INT,        handle_base_type, TPS_POINTER},
//         {TOKEN_EOF,        handle_error,     TPS_QUALIFIER},
//         /* 其他token默认处理 */
//         {0,                NULL,             TPS_BASE_TYPE}
//     },
//     [TPS_BASE_TYPE] = {
//         {TOKEN_MUL,        handle_pointer,   TPS_POINTER},
//         {TOKEN_L_BRACKET,  handle_array,     TPS_ARRAY},
//         {TOKEN_L_PAREN,    handle_func_params,TPS_FUNC_PARAMS},
//         {TOKEN_EOF,        NULL,             TPS_END},
//         {0,                NULL,             TPS_POINTER}
//     },
//     [TPS_POINTER] = {
//         {TOKEN_MUL,        handle_pointer,   TPS_POINTER},
//         {TOKEN_L_BRACKET,  handle_array,     TPS_ARRAY},
//         {TOKEN_L_PAREN,    handle_func_params,TPS_FUNC_PARAMS},
//         {0,                NULL,             TPS_END}
//     },
//     [TPS_ARRAY] = {
//         {TOKEN_L_BRACKET,  handle_array,     TPS_ARRAY},
//         {TOKEN_L_PAREN,    handle_func_params,TPS_FUNC_PARAMS},
//         {0,                NULL,             TPS_END}
//     },
//     [TPS_FUNC_PARAMS] = {
//         {0,                NULL,             TPS_END}
//     }
// };

// /* 新的类型解析函数 */
// struct ASTNode* parse_type(struct Parser* p) {
//     struct ASTNode* type_root = NULL;
//     struct ASTNode** current = &type_root;
//     enum TypeParseState state = TPS_QUALIFIER;

//     while (state != TPS_END) {
//         enum TokenType t = peektoktype(p);
//         const struct StateTransition* trans = state_table[state];

//         // 查找匹配的转换规则
//         while (trans->tok != 0 && trans->tok != t) {
//             trans++;
//         }

//         if (trans->handler) {
//             trans->handler(p, current);
//         } else if (trans->tok == 0) { // 默认规则
//             state = trans->next_state;
//             continue;
//         } else {
//             error("syntax error type parse error");
//         }

//         state = trans->next_state;
//     }

//     return type_root;
// }

// /* 具体状态处理函数实现 */
// static void handle_qualifier(struct Parser* p, struct ASTNode** current) {
//     struct ASTNode* node = new_ast_node();
//     node->node_type = NT_TYPE_QUAL;
//     node->data.data_type = poptok(p).type;

//     if (*current) {
//         (*current)->child.decl.type = node;
//     } else {
//         *current = node;
//     }
// }

// static void handle_base_type(struct Parser* p, struct ASTNode** current) {
//     struct ASTNode* node = new_ast_node();
//     node->node_type = NT_TYPE_BASE;
//     node->data.data_type = poptok(p).type;

//     // 链接到当前节点链的末端
//     while (*current && (*current)->child.decl.type) {
//         current = &(*current)->child.decl.type;
//     }
    
//     if (*current) {
//         (*current)->child.decl.type = node;
//     } else {
//         *current = node;
//     }
// }

// static void handle_pointer(struct Parser* p, struct ASTNode** current) {
//     poptok(p); // 吃掉*
//     struct ASTNode* node = new_ast_node();
//     node->node_type = NT_TYPE_PTR;

//     // 插入到当前节点之前
//     node->child.decl.type = *current;
//     *current = node;
// }

// /* 其他处理函数类似实现... */

struct ASTNode* parser_ident_without_pop(struct Parser* parser) {
    flushpeektok(parser);
    struct Token* tok = peektok(parser);
    if (tok->type != TOKEN_IDENT) {
        error("syntax error: want identifier but got %d", tok->type);
    }
    struct ASTNode* node = new_ast_node();
    node->type = NT_TERM_IDENT;
    node->syms.tok = *tok;
    node->syms.decl_node = NULL;
    return node;
}

struct ASTNode* parse_ident(struct Parser* parser) {
    struct ASTNode* node = parser_ident_without_pop(parser);
    poptok(parser);
    return node;
}

struct ASTNode* parse_type(struct Parser* parser) {
    flushpeektok(parser);
    enum TokenType ttype = peektoktype(parser);
    enum DataType dtype;
    switch(ttype) {
        case TOKEN_VOID:    dtype = TYPE_VOID; break;
        case TOKEN_CHAR:    dtype = TYPE_CHAR; break;
        case TOKEN_SHORT:   dtype = TYPE_SHORT; break;
        case TOKEN_INT:     dtype = TYPE_INT; break;
        case TOKEN_LONG:    dtype = TYPE_LONG; break;
        case TOKEN_FLOAT:   dtype = TYPE_FLOAT; break;
        case TOKEN_DOUBLE:  dtype = TYPE_DOUBLE; break;
        default:
            error("无效的类型说明符");
    }

    struct ASTNode* node = new_ast_node();
    node->type = NT_TERM_TYPE;
    // node->data.data_type = dtype;
    poptok(parser);

    if (peektoktype(parser) == TOKEN_MUL) {
        poptok(parser);
    }
    return node;
}