feat(parser): 添加声明列表支持并重构解析逻辑

- 添加 SCC_AST_DECL_LIST 节点类型用于表示声明列表
- 实现 scc_ast_decl_list_init 函数来初始化声明列表节点
- 重构 scc_parse_declaration 函数以支持逗号分隔的多个变量声明
- 分离类型说明符解析到独立的 scc_parse_declaration_specifiers 函数
- 支持 typedef 和多变量声明如 'int a, b;' 和 'int a = 1, b = 2;'
- 在 ast_dump 中添加对声明列表节点的打印支持

refactor(ast): 统一使用 scc_vec_foreach 宏替换手动循环

- 将 ast_dump.c 中的多个手动索引循环改为使用 scc_vec_foreach
- 提高代码可读性和安全性
- 避免索引越界错误

fix(parser): 修复语义分析中结构体符号表冲突

- 为结构体、联合体和枚举符号名添加前缀避免命名冲突
- 使用 '$S_'、'$U_'、'$E_' 前缀分别标识结构体、联合体和枚举

refactor(log): 统一终止处理方式

- 将 log_exit 替换为 log_abort 以更准确反映行为
- 更新相关依赖模块的实现

style(parser): 移除未使用的参数和清理代码

- 在 argparse.c 中添加 (void) 参数注释处理未使用的参数
- 清理 parse_expr.c 中未使用的函数声明
- 优化 parse_type.c 中的错误处理流程

libs/ast/include/ast_def.h

@@ -11,6 +11,7 @@ typedef enum {
     SCC_AST_UNKNOWN,
     // 声明
     scc_ast_decl_t_BEGIN, // 声明开始
+    SCC_AST_DECL_LIST,    // 声明列表
     SCC_AST_DECL_VAR,     // 变量声明
     SCC_AST_DECL_FUNC,    // 函数声明
     SCC_AST_DECL_PARAM,   // 参数声明
@@ -417,6 +418,9 @@ struct scc_ast_decl {
     scc_ast_node_t base;
     const char *name;
     union {
+        struct {
+            scc_ast_decl_vec_t vars;
+        } list;
         // 变量声明
         struct {
             scc_ast_type_t *type;

libs/ast/include/scc_ast.h

@@ -20,6 +20,16 @@ scc_ast_translation_unit_init(scc_ast_translation_unit_t *translation_unit,
     }
 }
 
+static inline void scc_ast_decl_list_init(scc_ast_decl_t *decl,
+                                          scc_ast_decl_vec_t *list_move) {
+    Assert(decl != null && list_move != null);
+    decl->base.loc = scc_pos_create();
+    decl->base.type = SCC_AST_DECL_LIST;
+    decl->name = null;
+    decl->list.vars = *list_move;
+    scc_vec_init(*list_move);
+}
+
 // name and var_init can be null
 static inline void scc_ast_decl_unsafe_val_init(scc_ast_decl_t *decl,
                                                 scc_ast_type_t *type,

libs/ast/src/ast_dump.c

@@ -17,6 +17,7 @@
 static const char *node_type_names[] = {
     [SCC_AST_UNKNOWN] = "Unknown",
     [scc_ast_decl_t_BEGIN] = "ERROR",
+    [SCC_AST_DECL_LIST] = "DeclList",
     [SCC_AST_DECL_VAR] = "VarDecl",
     [SCC_AST_DECL_FUNC] = "FuncDecl",
     [SCC_AST_DECL_PARAM] = "ParamDecl",
@@ -224,7 +225,7 @@ static inline void dump_child_node(scc_ast_node_t *child,
 
     scc_vec_push(ctx->stack, is_last);
     scc_ast_dump_node(ctx, child);
-    scc_vec_pop(ctx->stack);
+    (void)scc_vec_pop(ctx->stack);
 }
 
 // 用于构建复合类型名称的宏
@@ -343,7 +344,7 @@ static void dump_type_impl(scc_ast_type_t *type, scc_tree_dump_ctx_t *ctx) {
         SCC_TREE_DUMP_PRINT_PURE(ctx, ctx->node_color, "%s\n", "ReturnType");
         dump_child_node((scc_ast_node_t *)type->function.return_type, ctx,
                         true);
-        scc_vec_pop(ctx->stack);
+        (void)scc_vec_pop(ctx->stack);
 
         scc_vec_push(ctx->stack, true);
         if (scc_vec_size(type->function.param_types) != 0) {
@@ -360,7 +361,7 @@ static void dump_type_impl(scc_ast_type_t *type, scc_tree_dump_ctx_t *ctx) {
             PRINT_QUOTED_VALUE(ctx, "()");
             scc_tree_dump_printf(ctx, "\n");
         }
-        scc_vec_pop(ctx->stack);
+        (void)scc_vec_pop(ctx->stack);
         break;
     default:
         break;
@@ -445,7 +446,7 @@ static void dump_expr_impl(scc_ast_expr_t *expr, scc_tree_dump_ctx_t *ctx) {
             ctx, ctx->node_color, "%s %s\n",
             expr->base.type == SCC_AST_EXPR_MEMBER ? "Member" : "PtrMember",
             expr->member.name);
-        scc_vec_pop(ctx->stack);
+        (void)scc_vec_pop(ctx->stack);
         break;
 
     case SCC_AST_EXPR_CAST:
@@ -563,11 +564,10 @@ static void dump_stmt_impl(scc_ast_stmt_t *stmt, scc_tree_dump_ctx_t *ctx) {
         break;
     case SCC_AST_STMT_COMPOUND:
         end_node_dump(ctx);
-        for (size_t i = 0; i < stmt->compound.block_items.size; i++) {
-            scc_ast_node_t *item =
-                (scc_ast_node_t *)stmt->compound.block_items.data[i];
-            dump_child_node(item, ctx,
-                            i == stmt->compound.block_items.size - 1);
+        scc_vec_foreach(stmt->compound.block_items, i) {
+            dump_child_node(
+                (scc_ast_node_t *)scc_vec_at(stmt->compound.block_items, i),
+                ctx, i + 1 == stmt->compound.block_items.size);
         }
         break;
 
@@ -613,6 +613,12 @@ static void dump_decl_impl(scc_ast_decl_t *decl, scc_tree_dump_ctx_t *ctx) {
 
     // 递归转储子节点
     switch (decl->base.type) {
+    case SCC_AST_DECL_LIST:
+        scc_vec_foreach(decl->list.vars, i) {
+            dump_child_node((scc_ast_node_t *)scc_vec_at(decl->list.vars, i),
+                            ctx, i + 1 != scc_vec_size(decl->list.vars));
+        }
+        break;
     case SCC_AST_DECL_VAR:
         if (decl->var.type) {
             dump_child_node((scc_ast_node_t *)decl->var.type, ctx,
@@ -641,17 +647,18 @@ static void dump_decl_impl(scc_ast_decl_t *decl, scc_tree_dump_ctx_t *ctx) {
 
     case SCC_AST_DECL_STRUCT:
     case SCC_AST_DECL_UNION:
-        for (size_t i = 0; i < decl->record.fields.size; i++) {
-            dump_child_node((scc_ast_node_t *)decl->record.fields.data[i], ctx,
-                            i == decl->record.fields.size - 1);
+        scc_vec_foreach(decl->record.fields, i) {
+            dump_child_node(
+                (scc_ast_node_t *)scc_vec_at(decl->record.fields, i), ctx,
+                i + 1 != scc_vec_size(decl->record.fields));
         }
         break;
 
     case SCC_AST_DECL_ENUM:
-        for (size_t i = 0; i < decl->enumeration.enumerators.size; i++) {
+        scc_vec_foreach(decl->enumeration.enumerators, i) {
             dump_child_node(
-                (scc_ast_node_t *)decl->enumeration.enumerators.data[i], ctx,
-                i == decl->enumeration.enumerators.size - 1);
+                (scc_ast_node_t *)scc_vec_at(decl->enumeration.enumerators, i),
+                ctx, i + 1 != scc_vec_size(decl->enumeration.enumerators));
         }
         break;
 
@@ -675,9 +682,9 @@ static void dump_unit_impl(scc_ast_translation_unit_t *unit,
 
     start_node_dump(&unit->base, ctx);
     end_node_dump(ctx);
-    for (size_t i = 0; i < unit->declarations.size; i++) {
-        dump_child_node((scc_ast_node_t *)unit->declarations.data[i], ctx,
-                        i == unit->declarations.size - 1);
+    scc_vec_foreach(unit->declarations, i) {
+        dump_child_node((scc_ast_node_t *)scc_vec_at(unit->declarations, i),
+                        ctx, i + 1 != scc_vec_size(unit->declarations));
     }
 }