feat(ast2ir): 添加浮点类型支持和复合初始化功能

- 在ABI类型计算中添加FLOAT和DOUBLE类型的映射
- 修复AST操作符注释中的歧义描述
- 为ast2ir上下文添加类型缓存以解决递归结构体定义问题
- 实现复合初始化表达式的支持，包括数组和结构体初始化
- 添加前置和后置自增/自减操作符的IR转换
- 实现三元条件表达式的IR生成
- 添加类型转换(cast)和sizeof操作符的支持
- 重构数组长度推断逻辑并添加类型大小计算函数
- 实现结构体和联合体的递归类型解析
- 添加函数指针调用相关的IR节点类型定义

fix(ast): 修正间接操作符的注释说明

refactor(ast2ir): 优化代码结构并添加必要的断言验证

runtime/scc_core/include/scc_core_macro.h

@@ -13,4 +13,14 @@
 #define scc_min(a, b) ((a) < (b) ? (a) : (b))
 #define scc_max(a, b) ((a) > (b) ? (a) : (b))
 
+#ifdef __GNUC__
+#define SCC_MAYBE_UNUSED __attribute__((unused))
+#elif defined(_MSC_VER)
+#define SCC_MAYBE_UNUSED __pragma(warning(suppress : 4100))
+#elif defined(__clang__)
+#define SCC_MAYBE_UNUSED __attribute__((unused))
+#else
+#define SCC_MAYBE_UNUSED
+#endif
+
 #endif // __SCC_CORE_MACRO_H__

runtime/scc_core/include/scc_core_vec.h

@@ -15,13 +15,16 @@
 #include "scc_core_type.h"
 #define __scc_vec_realloc scc_realloc
 #define __scc_vec_free scc_free
+#define __scc_vec_memcpy scc_memcpy
 #else
 #include <stddef.h>
 #include <stdlib.h>
+#include <string.h>
 
 typedef size_t usize;
 #define __scc_vec_realloc realloc
 #define __scc_vec_free free
+#define __scc_vec_memcpy memcpy
 
 #ifndef LOG_FATAL
 #include <stdio.h>
@@ -169,4 +172,86 @@ typedef size_t usize;
         (vec).data = array;                                                    \
     } while (0)
 
+/**
+ * @def scc_vec_sized_realloc(vec, elem_size, new_cap)
+ * @brief 内部宏：按 elem_size 重新分配内存
+ */
+#define scc_vec_sized_realloc(vec, elem_size, new_cap)                         \
+    do {                                                                       \
+        void *new_data =                                                       \
+            __scc_vec_realloc((vec).data, (new_cap) * (elem_size));            \
+        if (!new_data)                                                         \
+            LOG_FATAL("scc_vec_sized_realloc: failed\n");                      \
+        (vec).data = new_data;                                                 \
+        (vec).cap = new_cap;                                                   \
+    } while (0)
+
+/**
+ * @def scc_vec_sized_push(vec, elem_size, src_ptr)
+ * @brief 添加一个元素（从 src_ptr 拷贝 elem_size 字节）
+ * @param vec        SCC_VEC(type) 定义的向量变量（type 可为 char 或 void）
+ * @param elem_size  每个元素占用的字节数
+ * @param src_ptr    源数据的指针
+ * @param copy_size  要拷贝的字节数
+ *
+ * @note 使用前需确保 vec.data 类型与 src_ptr 无关，内部会按字节拷贝。
+ *       推荐声明时为 `SCC_VEC(char)` 或 `SCC_VEC(unsigned char)`。
+ */
+#define scc_vec_sized_push(vec, elem_size, src_ptr, copy_size)                 \
+    do {                                                                       \
+        if ((vec).size >= (vec).cap) {                                         \
+            usize new_cap = (vec).cap ? (vec).cap * 2 : 4;                     \
+            scc_vec_sized_realloc(vec, elem_size, new_cap);                    \
+        }                                                                      \
+        char *slot = (char *)(vec).data + (vec).size * (elem_size);            \
+        __scc_vec_memcpy(slot, (src_ptr), (copy_size));                        \
+        (vec).size++;                                                          \
+    } while (0)
+
+/**
+ * @def scc_vec_sized_at_ptr(vec, elem_size, idx)
+ * @brief 获取第 idx 个元素的指针（void*）
+ * @return 指向元素的指针，需转换为具体类型使用
+ */
+#define scc_vec_sized_at_ptr(vec, elem_size, idx)                              \
+    ((void *)((char *)(vec).data + (idx) * (elem_size)))
+
+/**
+ * @def scc_vec_sized_foreach(vec, elem_size, elem_ptr_var, block)
+ * @brief 遍历所有元素
+ * @param elem_ptr_var  循环内的变量名（void* 类型）
+ * @param block         循环体语句块
+ */
+#define scc_vec_sized_foreach(vec, elem_size, elem_ptr_var, block)             \
+    do {                                                                       \
+        for (usize __i = 0; __i < (vec).size; ++__i) {                         \
+            void *elem_ptr_var = scc_vec_sized_at_ptr(vec, elem_size, __i);    \
+            block;                                                             \
+        }                                                                      \
+    } while (0)
+
+/**
+ * @def scc_vec_sized_pop(vec, elem_size)
+ * @brief 弹出最后一个元素（仅减小 size，不返回数据）
+ */
+#define scc_vec_sized_pop(vec, elem_size)                                      \
+    do {                                                                       \
+        if ((vec).size == 0)                                                   \
+            LOG_FATAL("scc_vec_sized_pop: empty\n");                           \
+        (vec).size--;                                                          \
+    } while (0)
+
+/**
+ * @def scc_vec_sized_clear(vec)
+ * @brief 清空向量（重置 size = 0，不释放内存）
+ */
+#define scc_vec_sized_clear(vec) ((vec).size = 0)
+
+/**
+ * @def scc_vec_sized_free(vec)
+ * @brief 释放向量内存（与原始 scc_vec_free 相同，可复用）
+ * @note 注意：如果元素内部有堆资源，需在释放前自行遍历调用析构函数。
+ */
+#define scc_vec_sized_free(vec) scc_vec_free(vec)
+
 #endif /* __SCC_CORE_VEC_H__ */

runtime/scc_core/src/core_impl.c

@@ -39,8 +39,15 @@ usize scc_fread(scc_file_t file, void *buffer, usize size) {
     return scc_pal_fread(file, buffer, size);
 }
 
-usize scc_fwrite(scc_file_t file, const void *buffer, usize size) {
-    return scc_pal_fwrite(file, buffer, size);
+usize scc_fwrite(scc_file_t file, const void *buf, usize size) {
+    if (file == scc_stdout) {
+        scc_pal_write(buf, size);
+    } else if (file == scc_stderr) {
+        scc_pal_ewrite(buf, size);
+    } else {
+        return scc_pal_fwrite(file, buf, size);
+    }
+    return 0;
 }
 
 cbool scc_fexists(const char *path) {