refactor(hashtable): 简化哈希表初始化接口并优化文件打开模式

- 将哈希表初始化从两步设置改为一步完成，直接传递哈希函数和比较函数
- 重构scc_hashtable_init函数签名，接受函数指针参数
- 更新内部字段名从key_cmp为cmp_func以保持一致性
- 添加类型定义scc_hashtable_hash_func_t和scc_hashtable_equal_func_t
- 修改PAL层文件操作接口，使用枚举模式替代固定只读模式
- 更新IR上下文、预处理器宏表等组件使用新的初始化方式
- 移除AST头文件中未使用的语义分析回调类型定义
- 修复预处理器中的空指针访问问题

libs/ast/include/scc_ast.h

@@ -3,21 +3,4 @@
 
 #include "ast_def.h"
 
-/**
- * @brief 语义分析回调函数类型
- */
-typedef void (*scc_sema_callback_t)(void *context,
-                                    scc_ast_node_type_t node_type, void *node);
-
-/**
- * @brief 语义分析回调集合
- */
-typedef struct scc_sema_callbacks {
-    scc_sema_callback_t on_decl;
-    scc_sema_callback_t on_stmt;
-    scc_sema_callback_t on_expr;
-    scc_sema_callback_t on_type;
-    void *context;
-} scc_sema_callbacks_t;
-
 #endif /* __SCC_AST_H__ */

libs/ir/src/ir_ctx.c

@@ -120,24 +120,15 @@ void scc_ir_ctx_init(scc_ir_cprog_ctx_t *ctx) {
     scc_vec_init(ctx->bblocks);
     scc_vec_init(ctx->funcs);
 
-    // 设置哈希函数
-    ctx->uid2nodes.hash_func = hash_key;
-    ctx->uid2nodes.key_cmp = cmp_key;
-    ctx->uid2types.hash_func = hash_key;
-    ctx->uid2types.key_cmp = cmp_key;
-    ctx->uid2bblocks.hash_func = hash_key;
-    ctx->uid2bblocks.key_cmp = cmp_key;
-    ctx->uid2funcs.hash_func = hash_key;
-    ctx->uid2funcs.key_cmp = cmp_key;
     // 初始化哈希表
-    scc_hashtable_init(&ctx->uid2nodes);
+    scc_hashtable_init(&ctx->uid2nodes, hash_key, cmp_key);
-    scc_hashtable_init(&ctx->uid2types);
+    scc_hashtable_init(&ctx->uid2types, hash_key, cmp_key);
-    scc_hashtable_init(&ctx->uid2bblocks);
+    scc_hashtable_init(&ctx->uid2bblocks, hash_key, cmp_key);
-    scc_hashtable_init(&ctx->uid2funcs);
+    scc_hashtable_init(&ctx->uid2funcs, hash_key, cmp_key);
 
-    ctx->type_uniquing.hash_func = (void *)hash_type;
+    scc_hashtable_init(&ctx->type_uniquing,
-    ctx->type_uniquing.key_cmp = (void *)cmp_type;
+                       (scc_hashtable_hash_func_t)hash_type,
-    scc_hashtable_init(&ctx->type_uniquing);
+                       (scc_hashtable_equal_func_t)cmp_type);
 
     // 预留UID 0 作为无效引用
     ctx->node_uid = 1;

libs/pproc/src/pproc_macro.c

@@ -143,9 +143,7 @@ static int hash_cmp(const void *key1, const void *key2) {
 
 void scc_pproc_marco_table_init(scc_pproc_macro_table_t *macros) {
     Assert(macros != null);
-    macros->table.hash_func = hash_func;
+    scc_hashtable_init(&macros->table, hash_func, hash_cmp);
-    macros->table.key_cmp = hash_cmp;
-    scc_hashtable_init(&macros->table);
 }
 
 static int macro_free(const void *key, void *value, void *context) {

libs/pproc/src/scc_pproc.c

@@ -3,10 +3,11 @@
 #include <scc_pproc.h>
 
 static int pproc_next_one_file(scc_pproc_t *pp, scc_lexer_tok_t *out) {
-    scc_lexer_tok_ring_t *stream = pp->cur_ring;
+    scc_lexer_tok_ring_t *stream = null;
     scc_lexer_tok_t tok = {0};
     int ok = 0;
 CONTINUE:
+    stream = pp->cur_ring;
     if (pp->expanded_ring.cap) {
         scc_ring_next_consume(pp->expanded_ring, *out, ok);
         if (ok == false) {
@@ -71,8 +72,9 @@ CONTINUE:
 }
 
 static int pproc_next(scc_pproc_t *pp, scc_lexer_tok_t *tok) {
-    int ret = pproc_next_one_file(pp, tok);
+    int ret = 0;
 CONTINUE:
+    ret = pproc_next_one_file(pp, tok);
     if (ret != 0) {
         return true;
     }

runtime/scc_core/include/scc_core_pal.h

@@ -34,7 +34,12 @@ void scc_pal_ewrite(const char *data, size_t len);
 /* File */
 
 typedef void *scc_pal_file_t;
-scc_pal_file_t scc_pal_fopen(const char *path);
+typedef enum {
+    SCC_FILE_PAL_READ,
+    SCC_FILE_PAL_WRITE,
+    SCC_FILE_PAL_APPEND,
+} scc_pal_fmode_t;
+scc_pal_file_t scc_pal_fopen(const char *path, scc_pal_fmode_t mode);
 void scc_pal_fclose(scc_pal_file_t f);
 size_t scc_pal_fread(scc_pal_file_t f, void *buf, size_t size);
 size_t scc_pal_fwrite(scc_pal_file_t f, const void *buf, size_t size);

runtime/scc_core/src/cfg.std_impl.c

@@ -20,8 +20,17 @@ void *scc_pal_realloc(void *ptr, size_t new_size) {
 
 void scc_pal_free(void *ptr) { free(ptr); }
 
-scc_pal_file_t scc_pal_fopen(const char *path) {
+scc_pal_file_t scc_pal_fopen(const char *path, scc_pal_fmode_t mode) {
-    return (scc_pal_file_t)fopen(path, "r+b");
+    switch (mode) {
+    case SCC_FILE_PAL_READ:
+        return fopen(path, "rb");
+    case SCC_FILE_PAL_WRITE:
+        return fopen(path, "wb");
+    case SCC_FILE_PAL_APPEND:
+        return fopen(path, "ab");
+    default:
+        return (scc_pal_file_t)0;
+    }
 }
 
 void scc_pal_fclose(scc_pal_file_t file) {

runtime/scc_core/src/core_impl.c

@@ -11,7 +11,7 @@
 void putchar_(char ch) { LOG_FATAL("you can't use printf.c directly"); }
 
 scc_file_t scc_fopen(const char *path, scc_fmode_t mode) {
-    return scc_pal_fopen(path);
+    return scc_pal_fopen(path, (scc_pal_fmode_t)mode); // FIXME
 }
 
 void scc_fclose(scc_file_t file) { scc_pal_fclose(file); }

runtime/scc_utils/include/scc_hashtable.h

@@ -33,6 +33,9 @@ typedef struct scc_hashtable_entry {
     scc_hashtable_entry_state_t state; /**< 当前条目状态 */
 } scc_hashtable_entry_t;
 
+typedef u32 (*scc_hashtable_hash_func_t)(const void *key);
+typedef int (*scc_hashtable_equal_func_t)(const void *key1, const void *key2);
+
 /**
  * @struct scc_hashtable_t
  * @brief 哈希表主体结构
@@ -48,14 +51,14 @@ typedef struct scc_hashtable {
      * @param key 键指针
      * @return 32位无符号哈希值
      */
-    u32 (*hash_func)(const void *key);
+    scc_hashtable_hash_func_t hash_func;
     /**
      * @brief 键比较函数指针
      * @param key1 第一个键指针
      * @param key2 第二个键指针
      * @return 相同返回0，不同返回非0
      */
-    int (*key_cmp)(const void *key1, const void *key2);
+    scc_hashtable_equal_func_t cmp_func;
 } scc_hashtable_t;
 
 /**
@@ -64,7 +67,9 @@ typedef struct scc_hashtable {
  *
  * @warning 必须设置hash_func和key_cmp后才能使用
  */
-void scc_hashtable_init(scc_hashtable_t *ht);
+void scc_hashtable_init(scc_hashtable_t *ht,
+                        scc_hashtable_hash_func_t hash_func,
+                        scc_hashtable_equal_func_t cmp_func);
 
 /**
  * @brief 插入/更新键值对

runtime/scc_utils/src/hashtable.c

@@ -4,11 +4,16 @@
 #define SCC_INIT_HASHMAP_SIZE (32)
 #endif
 
-void scc_hashtable_init(scc_hashtable_t *ht) {
+void scc_hashtable_init(scc_hashtable_t *ht,
+                        scc_hashtable_hash_func_t hash_func,
+                        scc_hashtable_equal_func_t cmp_func) {
+
     scc_vec_init(ht->entries);
     ht->count = 0;
     ht->tombstone_count = 0;
-    Assert(ht->key_cmp != NULL && ht->hash_func != NULL);
+    ht->cmp_func = cmp_func;
+    ht->hash_func = hash_func;
+    Assert(ht->cmp_func != null && ht->hash_func != null);
 }
 
 static int next_power_of_two(int n) {
@@ -40,7 +45,7 @@ static scc_hashtable_entry_t *find_entry(scc_hashtable_t *ht, const void *key,
         if (entry->state == ENTRY_TOMBSTONE) {
             if (!tombstone)
                 tombstone = entry;
-        } else if (entry->hash == hash && ht->key_cmp(entry->key, key) == 0) {
+        } else if (entry->hash == hash && ht->cmp_func(entry->key, key) == 0) {
             return entry;
         }
 

runtime/scc_utils/src/strpool.c

@@ -1,9 +1,8 @@
 #include <scc_strpool.h>
 
 void scc_strpool_init(scc_strpool_t *pool) {
-    pool->ht.hash_func = (u32 (*)(const void *))scc_strhash32;
+    scc_hashtable_init(&pool->ht, (scc_hashtable_hash_func_t)scc_strhash32,
-    pool->ht.key_cmp = (int (*)(const void *, const void *))scc_strcmp;
+                       (scc_hashtable_equal_func_t)scc_strcmp);
-    scc_hashtable_init(&pool->ht);
 }
 
 const char *scc_strpool_intern(scc_strpool_t *pool, const char *str) {