From d1f2efa4ae44ceb62aeb01fe330d748640fcb307 Mon Sep 17 00:00:00 2001
From: mxr <>
Date: Wed, 25 Mar 2026 18:59:47 +0800
Subject: [PATCH] =?UTF-8?q?feat(sem)=E8=A1=A5=E5=85=85=E7=AC=A6=E5=8F=B7?=
 =?UTF-8?q?=E8=A1=A8=E5=AF=B9=E5=BA=93=E5=87=BD=E6=95=B0=E7=9A=84=E6=94=AF?=
 =?UTF-8?q?=E6=8C=81?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 include/sem/SymbolTable.h |  3 ++
 src/sem/SymbolTable.cpp   | 98 ++++++++++++++++++++++++++++++++++++++-
 2 files changed, 99 insertions(+), 2 deletions(-)

diff --git a/include/sem/SymbolTable.h b/include/sem/SymbolTable.h
index 360126d..29b4fae 100644
--- a/include/sem/SymbolTable.h
+++ b/include/sem/SymbolTable.h
@@ -25,6 +25,7 @@ struct Symbol {
     int scope_level = 0;            // 定义时的作用域深度
     int stack_offset = -1;          // 局部变量/参数栈偏移（全局变量为 -1）
     bool is_initialized = false;    // 是否已初始化
+    bool is_builtin = false;               // 是否为库函数
 
     // 对于函数，额外存储参数列表（类型已包含在函数类型中，这里仅用于快速访问）
     std::vector<std::shared_ptr<ir::Type>> param_types;
@@ -64,6 +65,8 @@ class SymbolTable {
     // ----- 辅助函数：从语法树节点构造 Type -----
     static std::shared_ptr<ir::Type> getTypeFromVarDef(SysYParser::VarDefContext* ctx);
     static std::shared_ptr<ir::Type> getTypeFromFuncDef(SysYParser::FuncDefContext* ctx);
+
+    void registerBuiltinFunctions();
     
   private:
     // 作用域栈：每个元素是一个从名字到符号的映射
diff --git a/src/sem/SymbolTable.cpp b/src/sem/SymbolTable.cpp
index 1b29f7f..bd33f48 100644
--- a/src/sem/SymbolTable.cpp
+++ b/src/sem/SymbolTable.cpp
@@ -3,8 +3,8 @@
 
 // ---------- 构造函数 ----------
 SymbolTable::SymbolTable() {
-    // 初始化全局作用域
-    scopes_.emplace_back();
+    scopes_.emplace_back(); // 初始化全局作用域
+    registerBuiltinFunctions(); // 注册内置库函数
 }
 
 // ---------- 作用域管理 ----------
@@ -199,4 +199,98 @@ std::shared_ptr<ir::Type> SymbolTable::getTypeFromFuncDef(SysYParser::FuncDefCon
     }
 
     return ir::Type::GetFunctionType(ret_type, param_types);
+}
+
+// ----- 注册内置库函数-----
+void SymbolTable::registerBuiltinFunctions() {
+    // 确保当前处于全局作用域（scopes_ 只有一层）
+    // 1. getint: int getint()
+    Symbol getint;
+    getint.name = "getint";
+    getint.kind = SymbolKind::Function;
+    getint.type = Type::GetFunctionType(Type::GetInt32Type(), {});  // 无参数
+    getint.param_types = {};
+    getint.scope_level = 0;
+    getint.is_builtin = true;
+    addSymbol(getint);
+
+    // 2. getfloat: float getfloat()
+    Symbol getfloat;
+    getfloat.name = "getfloat";
+    getfloat.kind = SymbolKind::Function;
+    getfloat.type = Type::GetFunctionType(Type::GetFloatType(), {});
+    getfloat.param_types = {};
+    getfloat.scope_level = 0;
+    getfloat.is_builtin = true;
+    addSymbol(getfloat);
+
+    // 3. getch: int getch()
+    Symbol getch;
+    getch.name = "getch";
+    getch.kind = SymbolKind::Function;
+    getch.type = Type::GetFunctionType(Type::GetInt32Type(), {});
+    getch.param_types = {};
+    getch.scope_level = 0;
+    getch.is_builtin = true;
+    addSymbol(getch);
+
+    // 4. putint: void putint(int)
+    std::vector<std::shared_ptr<Type>> putint_params = { Type::GetInt32Type() };
+    Symbol putint;
+    putint.name = "putint";
+    putint.kind = SymbolKind::Function;
+    putint.type = Type::GetFunctionType(Type::GetVoidType(), putint_params);
+    putint.param_types = putint_params;
+    putint.scope_level = 0;
+    putint.is_builtin = true;
+    addSymbol(putint);
+
+    // 5. putfloat: void putfloat(float)
+    std::vector<std::shared_ptr<Type>> putfloat_params = { Type::GetFloatType() };
+    Symbol putfloat;
+    putfloat.name = "putfloat";
+    putfloat.kind = SymbolKind::Function;
+    putfloat.type = Type::GetFunctionType(Type::GetVoidType(), putfloat_params);
+    putfloat.param_types = putfloat_params;
+    putfloat.scope_level = 0;
+    putfloat.is_builtin = true;
+    addSymbol(putfloat);
+
+    // 6. putch: void putch(int)
+    std::vector<std::shared_ptr<Type>> putch_params = { Type::GetInt32Type() };
+    Symbol putch;
+    putch.name = "putch";
+    putch.kind = SymbolKind::Function;
+    putch.type = Type::GetFunctionType(Type::GetVoidType(), putch_params);
+    putch.param_types = putch_params;
+    putch.scope_level = 0;
+    putch.is_builtin = true;
+    addSymbol(putch);
+
+    // 7. getarray: int getarray(int a[])
+    // 参数类型: int a[] 退化为 int* 即 PtrInt32
+    std::vector<std::shared_ptr<Type>> getarray_params = { Type::GetPtrInt32Type() };
+    Symbol getarray;
+    getarray.name = "getarray";
+    getarray.kind = SymbolKind::Function;
+    getarray.type = Type::GetFunctionType(Type::GetInt32Type(), getarray_params);
+    getarray.param_types = getarray_params;
+    getarray.scope_level = 0;
+    getarray.is_builtin = true;
+    addSymbol(getarray);
+
+    // 8. putarray: void putarray(int n, int a[])
+    // 参数: int n, int a[] -> 实际类型: int, int*
+    std::vector<std::shared_ptr<Type>> putarray_params = { Type::GetInt32Type(), Type::GetPtrInt32Type() };
+    Symbol putarray;
+    putarray.name = "putarray";
+    putarray.kind = SymbolKind::Function;
+    putarray.type = Type::GetFunctionType(Type::GetVoidType(), putarray_params);
+    putarray.param_types = putarray_params;
+    putarray.scope_level = 0;
+    putarray.is_builtin = true;
+    addSymbol(putarray);
+
+    // 9. putf: void putf(char fmt[], ...)  —— 可选，但为了完整性
+    // 参数: char fmt[] 退化为 char*，但 SysY 中没有 char 类型，可能使用 int 数组或特殊处理，此处略过
 }
\ No newline at end of file