通过了test_case下的测试，修改测试脚本由于不同平台换行符的差异导致测试失败的问题

实现合并

command.md

@@ -0,0 +1,78 @@
+## Lab1
+
+# 1.构建
+cmake -S . -B build -DCMAKE_BUILD_TYPE=Release -DCOMPILER_PARSE_ONLY=ON
+cmake --build build -j "$(nproc)"
+
+# 2.单例查看
+./build/bin/compiler --emit-parse-tree test/test_case/functional/simple_add.sy
+
+# 3.批量检查
+find test/test_case -name '*.sy' | sort | while read f; do ./build/bin/compiler --emit-parse-tree "$f" >/dev/null || echo "FAIL $f"; done
+
+
+核心原则：不要在“落后于远端 master”的本地 master 上直接开发和提交。
+
+你以后按这套流程，基本就不会分岔。
+
+**日常标准流程**
+
+1. 每次开始前先同步主干  
+```bash
+git switch master
+git fetch origin
+git pull --ff-only origin master
+```
+
+2. 从最新 master 拉功能分支开发  
+```bash
+git switch -c feature/xxx
+```
+
+3. 开发中频繁提交到功能分支  
+```bash
+git add -A
+git commit -m "feat: xxx"
+```
+
+4. 推送功能分支（不要直接推 master）  
+```bash
+git push -u origin feature/xxx
+```
+
+5. 合并前，先把你的分支“重放”到最新 master 上  
+```bash
+git fetch origin
+git rebase origin/master
+```
+有冲突就解决后：
+```bash
+git add -A
+git rebase --continue
+```
+
+6. 再合并回 master（本地或平台 PR 都可）  
+本地合并推荐：
+```bash
+git switch master
+git pull --ff-only origin master
+git merge --ff-only feature/xxx
+git push origin master
+```
+`--ff-only` 的好处是：只允许线性历史，能最大限度避免分叉和脏 merge。
+
+---
+
+**你这次分岔的根因**
+你的本地 master 没先追上远端 master（远端有新提交），然后直接 merge/push，导致出现两个方向的提交历史。
+
+---
+
+**三条硬规则（记住就行）**
+1. 不在落后状态的 master 上开发。  
+2. 合并前一定 `fetch + rebase origin/master`。  
+3. 推 master 前先 `pull --ff-only`，失败就先处理，不要强推。
+
+---
+
+如果你愿意，我可以给你一份适配你仓库的 Git alias（如 `gsync`, `gstart`, `gfinish`），以后 3 条命令就走完整流程。

doc/Lab2-中间表示生成.md

@@ -20,6 +20,8 @@ Lab2 的目标是在该示例基础上扩展语义覆盖范围，并逐步把更
 - `include/sem/SymbolTable.h`
 - `src/sem/Sema.cpp`
 - `src/sem/SymbolTable.cpp`
+
+
 - `include/ir/IR.h`
 - `src/ir/Context.cpp`
 - `src/ir/Value.cpp`

doc/Lab2-小组协作修改方案.md

@@ -0,0 +1,353 @@
+# Lab2 小组协作修改方案（可直接执行）
+
+## 1. 目标与现状
+
+当前仓库的最小实现只能覆盖：
+
+1. 局部 int 变量的 alloca/load/store。
+2. 整数字面量、变量引用、加法表达式。
+3. return 语句。
+4. 单函数 main 的最小流程。
+
+Lab2 的目标是把语法覆盖扩展到课程要求范围，并通过 IR 验证链路。
+
+统一验收标准：
+
+1. 能生成结构正确的 IR。
+2. 通过脚本运行并和 .out 比对一致。
+3. 最终覆盖 test/test_case 下应测样例。
+
+---
+
+## 2. 团队分工建议
+
+建议至少拆成 4 条工作线并行推进。
+
+### A. IR 基础设施组（你负责）
+
+负责文件：
+
+- include/ir/IR.h
+- src/ir/Instruction.cpp
+- src/ir/IRBuilder.cpp
+- src/ir/Type.cpp
+- src/ir/BasicBlock.cpp
+- src/ir/Function.cpp
+- src/ir/Module.cpp
+- src/ir/IRPrinter.cpp
+
+职责：
+
+1. 补齐 IR 指令与构建接口（算术、比较、分支、调用、内存访问等）。
+2. 保证基本块终结规则与 use-def 关系一致。
+3. 保证 IRPrinter 输出格式可被 llc/clang 工具链接受。
+
+### B. 语义分析组（Sema）
+
+负责文件：
+
+- include/sem/Sema.h
+- include/sem/SymbolTable.h
+- src/sem/Sema.cpp
+- src/sem/SymbolTable.cpp
+- src/sem/ConstEval.cpp
+
+职责：
+
+1. 名称绑定、作用域管理、重复定义与未定义检查。
+2. 常量表达式求值与 const 相关约束。
+3. 为 IRGen 提供稳定的绑定结果。
+
+### C. IR 生成组（IRGen）
+
+负责文件：
+
+- include/irgen/IRGen.h
+- src/irgen/IRGenFunc.cpp
+- src/irgen/IRGenStmt.cpp
+- src/irgen/IRGenExp.cpp
+- src/irgen/IRGenDecl.cpp
+- src/irgen/IRGenDriver.cpp
+
+职责：
+
+1. 按语法树节点生成 IR。
+2. 正确构造控制流图（if/while/break/continue）。
+3. 正确处理函数定义、调用、参数、局部变量与数组访问。
+
+### D. 测试与集成组
+
+负责内容：
+
+- 脚本化回归。
+- 失败样例归因（grammar/sema/irgen/ir/printer 哪层出错）。
+- 每日合并后 smoke test。
+
+---
+
+## 3. 必须先对齐的接口约定（第一天完成）
+
+这一步不做，后面会高频返工。
+
+### 3.1 Sema -> IRGen 约定
+
+1. 变量使用节点如何唯一绑定到声明节点。
+2. 函数符号如何绑定（函数重名、参数信息、返回类型）。
+3. 块作用域遮蔽规则：同名变量按最近作用域优先。
+
+### 3.2 IRGen -> IRBuilder 约定
+
+1. 每类语句/表达式映射到哪些构建接口。
+2. 基本块终结规则：ret/br 后禁止继续在同块插指令。
+3. 比较和逻辑运算的返回类型与约定值。
+4. 调用约定：参数顺序、返回值处理、void 调用行为。
+
+### 3.3 IR -> IRPrinter 约定
+
+1. 新增指令的打印语法。
+2. 类型打印规则（int/float/ptr/array/function）。
+3. 全局对象、函数声明与定义的输出顺序。
+
+### 3.4 IR 第一版接口清单（函数名级别，建议 Day1 冻结）
+
+这份清单用于你先做 src/ir，其他同学按接口跟随开发。
+
+第一批只覆盖 M1 到 M3 的最小闭环，M4 和 M5 另开第二版接口。
+
+1. 当前已存在并继续保留
+
+- IRBuilder.CreateConstInt(int v)
+- IRBuilder.CreateBinary(Opcode op, Value* lhs, Value* rhs, const std::string& name)
+- IRBuilder.CreateAdd(Value* lhs, Value* rhs, const std::string& name)
+- IRBuilder.CreateAllocaI32(const std::string& name)
+- IRBuilder.CreateLoad(Value* ptr, const std::string& name)
+- IRBuilder.CreateStore(Value* val, Value* ptr)
+- IRBuilder.CreateRet(Value* v)
+
+2. 第一版必须新增（M1）
+
+- Opcode 扩展：Div、Mod
+- IRBuilder.CreateSub(Value* lhs, Value* rhs, const std::string& name)
+- IRBuilder.CreateMul(Value* lhs, Value* rhs, const std::string& name)
+- IRBuilder.CreateDiv(Value* lhs, Value* rhs, const std::string& name)
+- IRBuilder.CreateMod(Value* lhs, Value* rhs, const std::string& name)
+- 一元负号先复用 CreateSub(0, x)
+- 一元逻辑非先复用比较接口（见下一条）
+
+3. 第一版建议新增（M1 到 M3）
+
+- CmpOp 枚举：Eq、Ne、Lt、Le、Gt、Ge
+- IRBuilder.CreateCmp(CmpOp op, Value* lhs, Value* rhs, const std::string& name)
+- IRBuilder.CreateBr(BasicBlock* target)
+- IRBuilder.CreateCondBr(Value* cond, BasicBlock* true_bb, BasicBlock* false_bb)
+
+4. 第二版预留（M2）
+
+- IRBuilder.CreateCall(Function* callee, const std::vector<Value*>& args, const std::string& name)
+- Function 需要完整函数签名表示（返回类型 + 形参类型）
+
+5. 基本块终结规则（第一版必须执行）
+
+1. terminator 指令包含 Ret、Br、CondBr。
+2. BasicBlock 一旦出现 terminator，禁止继续追加普通指令。
+3. IRGen 负责在新块上重新设置插入点。
+
+6. 参数与类型约定（第一版）
+
+1. M1 到 M3 阶段先统一为 i32 值语义。
+2. cond 分支条件统一约定为 i32，0 为假，非 0 为真。
+3. CreateBinary 输入输出类型必须一致；不一致直接报错。
+
+7. 打印约定（IRPrinter 第一版）
+
+1. Sub、Mul、Div、Mod、比较、Br、CondBr、Call 必须同步可打印。
+2. 新增指令的打印格式由 IR 组给出单页示例，IRGen 组按示例比对。
+
+8. 接口冻结与变更流程
+
+1. Day1 晚上冻结第一版接口，不再改函数签名。
+2. Day2 到 Day3 只允许修实现 bug，不改接口名字和参数。
+3. 必须改接口时，提前半天发迁移说明并提供一条替代写法。
+
+---
+
+## 4. 分阶段里程碑（按功能从低风险到高风险）
+
+## M1：整数基础表达式与赋值
+
+目标样例：
+
+- test/test_case/functional/simple_add.sy
+- test/test_case/functional/11_add2.sy
+- test/test_case/functional/13_sub2.sy
+- test/test_case/functional/36_op_priority2.sy
+
+完成定义：
+
+1. 支持赋值语句。
+2. 支持一元 + - !。
+3. 支持二元 + - * / %。
+4. 支持比较表达式的语义与 IR 生成。
+
+## M2：函数与作用域
+
+目标样例：
+
+- test/test_case/functional/09_func_defn.sy
+- test/test_case/functional/25_scope3.sy
+
+完成定义：
+
+1. 多函数定义。
+2. 参数传递与函数调用。
+3. 块级作用域与变量遮蔽正确。
+
+## M3：控制流
+
+目标样例：
+
+- test/test_case/functional/29_break.sy
+
+完成定义：
+
+1. if/else。
+2. while。
+3. break/continue（循环栈管理）。
+
+## M4：数组与全局对象
+
+目标样例：
+
+- test/test_case/functional/05_arr_defn4.sy
+- test/test_case/functional/22_matrix_multiply.sy
+
+完成定义：
+
+1. 数组定义、初始化与下标访问。
+2. 全局变量/常量。
+3. constExp 维度与初始化相关检查。
+
+## M5：浮点（若课程阶段要求）
+
+目标样例：
+
+- test/test_case/functional/95_float.sy
+
+完成定义：
+
+1. float 类型与常量。
+2. int/float 隐式转换。
+3. float 运算、比较、控制流条件。
+
+---
+
+## 5. 你负责的 src/ir 详细任务清单
+
+建议按下面顺序提交，每次只做一类能力，便于联调。
+
+### T1. 指令枚举和 IRBuilder 基础扩展
+
+1. 补齐一元/二元整数运算。
+2. 补齐比较与条件分支指令。
+3. 提供统一的 CreateBinary、CreateCmp、CreateBr、CreateCondBr、CreateCall。
+
+### T2. 基本块与终结指令约束
+
+1. BasicBlock 显式记录 terminator。
+2. 插入终结指令后拒绝继续插普通指令。
+3. Function 级别提供校验接口（可用于 debug 断言）。
+
+### T3. 类型与函数签名表达
+
+1. 类型系统支持函数参数和返回类型表达。
+2. 调用点参数个数与签名一致性检查（至少 debug 模式可查）。
+
+### T4. IRPrinter 同步
+
+1. 新增指令全部可打印。
+2. 打印结果可通过 llc。
+3. 保证测试输出稳定（避免不必要随机命名波动）。
+
+### T5. 数组与地址计算（如果 M4 开启）
+
+1. 元素地址计算接口。
+2. 多维下标线性化或 GEP 风格接口。
+
+---
+
+## 6. 每日协作机制（必须执行）
+
+1. 每天固定 15 分钟站会：同步昨天完成、今天计划、阻塞点。
+2. 每个接口变更先发讨论再改，避免主干反复冲突。
+3. 每个里程碑前冻结接口半天，只做修 bug 和联调。
+
+推荐沟通模板：
+
+1. 我改了什么接口。
+2. 旧行为与新行为差异。
+3. 受影响文件。
+4. 调用方需要同步的改动。
+5. 最晚切换时间点。
+
+---
+
+## 7. 分支与提交流程
+
+1. 一人一功能分支，不直接在主分支开发。
+2. 提交粒度小而清晰：一个提交只解决一类问题。
+3. 提交信息建议：feat(ir), fix(irgen), fix(sema), test(lab2)。
+4. 合并前必须附上通过样例列表。
+
+---
+
+## 8. 统一验证命令
+
+构建：
+
+```bash
+cmake -S . -B build -DCMAKE_BUILD_TYPE=Release -DCOMPILER_PARSE_ONLY=OFF
+cmake --build build -j "$(nproc)"
+```
+
+单样例验证：
+
+```bash
+./scripts/verify_ir.sh test/test_case/functional/simple_add.sy test/test_result/function/ir --run
+```
+
+功能样例批量验证：
+
+```bash
+for f in test/test_case/functional/*.sy; do
+  echo "== $f =="
+  ./scripts/verify_ir.sh "$f" test/test_result/function/ir --run || break
+done
+```
+
+---
+
+## 9. 风险与应对
+
+1. 风险：grammar 变更导致 visitor 接口失配。
+应对：变更 grammar 后第一时间重新生成 ANTLR 文件并通知 Sema/IRGen。
+
+2. 风险：IRPrinter 语法偏差导致 llc 失败。
+应对：新增指令时同步补打印和最小样例回归。
+
+3. 风险：组员并行修改同一接口冲突严重。
+应对：接口 owner 机制，IR 接口由 IR 组最终拍板。
+
+4. 风险：只测 simple_add，阶段性误判成功。
+应对：每个里程碑绑定指定样例集，全部通过才进入下一阶段。
+
+---
+
+## 10. 本周可执行排期（示例）
+
+1. Day1：接口对齐会，完成 M1 任务拆分。
+2. Day2：IR 组完成 T1/T2，Sema/IRGen 同步接入。
+3. Day3：打通 M1 全样例。
+4. Day4：推进 M2（函数与作用域）。
+5. Day5：推进 M3（控制流）并做一次集成回归。
+
+如果进度顺利，再进入 M4（数组与全局）。

forIRGenInterfaces.md

@@ -0,0 +1,108 @@
+我先快速读取当前 IRGen 的入口与表达式/语句文件，然后按“节点到接口调用映射”给你一份可以直接交给 IRGen 同学实现的调用说明。
+
+Read [](file:///home/shrink/nudt-compiler-cpp/include/ir/IR.h#320-320), lines 320 to 387
+
+Read [](file:///home/shrink/nudt-compiler-cpp/include/irgen/IRGen.h)
+
+Read [](file:///home/shrink/nudt-compiler-cpp/src/irgen/IRGenExp.cpp)
+
+Read [](file:///home/shrink/nudt-compiler-cpp/src/irgen/IRGenStmt.cpp)
+
+Read [](file:///home/shrink/nudt-compiler-cpp/src/irgen/IRGenFunc.cpp)
+
+可以，下面给你一份面向 IRGen 同学的“如何调用你新增 IR 接口”的实现说明，按落地顺序写。
+
+先看调用边界
+
+1. IRGen 只负责把语法树翻译成 IR，不做符号查找  
+变量和函数绑定依赖 Sema 结果，参考 IRGenExp.cpp 的变量读取流程。  
+2. 所有指令创建都通过 IRBuilder  
+新增接口定义在 IR.h。  
+3. 终结指令规则必须遵守  
+Ret/Br/CondBr 一旦插入当前块，这个块不能再插普通指令，规则在 Instruction.cpp 和 BasicBlock.cpp。
+
+建议 IRGen 调用映射
+
+一、表达式层
+
+1. 加减乘除模
+- a + b: CreateAdd(lhs, rhs, temp)
+- a - b: CreateSub(lhs, rhs, temp)
+- a * b: CreateMul(lhs, rhs, temp)
+- a / b: CreateDiv(lhs, rhs, temp)
+- a % b: CreateMod(lhs, rhs, temp)
+
+2. 比较表达式
+- == != < <= > >= 统一走 CreateCmp(op, lhs, rhs, temp)
+- 返回 i32，约定 0 为假，非 0 为真
+
+3. 一元运算建议
+- -x: CreateSub(const0, x, temp)
+- !x: CreateCmp(Eq, x, const0, temp)
+- +x: 直接返回 x
+
+4. 变量读取和赋值
+- 读取: 先由 Sema 绑定 use 到 decl，再从 storage_map 找槽位，CreateLoad
+- 赋值: EvalExpr(rhs) 后对槽位 CreateStore(rhs_val, slot)
+
+对应修改文件：
+- IRGenExp.cpp
+- IRGenDecl.cpp
+- IRGenStmt.cpp
+
+二、控制流层
+
+1. if/else
+- 创建三个块: then, else, merge
+- cond = EvalExpr(condExp)
+- 当前块插 CreateCondBr(cond, then, else)
+- 切入 then 块生成语句，末尾若未终结则 CreateBr(merge)
+- 切入 else 块同理
+- 最后 SetInsertPoint(merge)
+
+2. while
+- 创建三个块: cond, body, exit
+- 进入前先 CreateBr(cond)
+- cond 块计算条件，CreateCondBr(cond_val, body, exit)
+- body 块生成循环体，若未终结则回跳 CreateBr(cond)
+- 最后 SetInsertPoint(exit)
+
+3. break/continue
+- IRGen 维护循环栈，每层保存 continue_target 和 break_target
+- break 直接 CreateBr(break_target)
+- continue 直接 CreateBr(continue_target)
+
+对应修改文件：
+- IRGenStmt.cpp
+
+三、函数与调用层
+
+1. 函数定义
+- 用 Module.CreateFunction(name, ret_type, param_types) 建函数
+- 入口块 SetInsertPoint(entry)
+- 形参落栈策略建议：每个参数先 alloca，再 store 到本地槽位，后续统一按 load/store 访问
+
+2. 函数调用
+- 先拿到 callee 对应的 Function
+- 实参逐个 EvalExpr 得到 args
+- 调用 CreateCall(callee, args, temp)
+- 若返回值非 void，把返回 Value 继续参与表达式计算
+
+对应修改文件：
+- IRGenFunc.cpp
+- IRGenExp.cpp
+
+四、你要提醒 IRGen 同学的两个关键点
+
+1. 插入点管理  
+每次生成 Br/CondBr/Ret 后，必须切换到新块再继续生成。否则会触发块已终结错误。  
+2. grammar 上下文名先对齐  
+你们当前 IRGen 里还在用 ParenExpContext、AdditiveExpContext 这类命名，实际 grammar 是另一套层级时要先改 Visitor 入口，否则接口再全也接不上。可先核对 SysY.g4 与 IRGen.h。
+
+最小接入顺序
+
+1. 先接表达式算术与比较（M1）  
+2. 再接 if/while/break/continue（M3）  
+3. 再接函数参数和调用（M2）
+
+如果你要，我下一步可以给你一版“按当前 grammar 的具体 visitor 函数名”逐条对照表，IRGen 同学可以直接照着改函数签名和调用点。

include/ir/IR.h

@@ -37,7 +37,6 @@
 #include <unordered_map>
 #include <utility>
 #include <vector>
-#include <variant>
 
 namespace ir {
 
@@ -46,15 +45,17 @@ class Value;
 class User;
 class ConstantValue;
 class ConstantInt;
-class ConstantFloat;
-class ConstantArray;
 class GlobalValue;
 class Instruction;
 class BasicBlock;
 class Function;
-class Module;
 
-// ======================== Use 类 ========================
+// Use 表示一个 Value 的一次使用记录。
+// 当前实现设计：
+// - value：被使用的值
+// - user：使用该值的 User
+// - operand_index：该值在 user 操作数列表中的位置
+
 class Use {
  public:
   Use() = default;
@@ -75,130 +76,54 @@ class Use {
   size_t operand_index_ = 0;
 };
 
-// ======================== Context 类 ========================
+// IR 上下文：集中管理类型、常量等共享资源，便于复用与扩展。
 class Context {
  public:
   Context() = default;
   ~Context();
-
+  // 去重创建 i32 常量。
-  // 常量创建
   ConstantInt* GetConstInt(int v);
-  ConstantFloat* GetConstFloat(float v);
 
-  // 临时变量名生成
   std::string NextTemp();
 
  private:
   std::unordered_map<int, std::unique_ptr<ConstantInt>> const_ints_;
-  std::unordered_map<float, std::unique_ptr<ConstantFloat>> const_floats_;
   int temp_index_ = -1;
 };
 
-// ======================== Type 类型体系 ========================
-// 类型基类，支持参数化类型
 class Type {
  public:
-  enum class Kind {
+  enum class Kind { Void, Int32, PtrInt32 };
-    Void,
-    Int32,
-    Float32,
-    Pointer,
-    Array,
-    Function,
-    Label
-  };
-
   explicit Type(Kind k);
-  virtual ~Type() = default;
+  // 使用静态共享对象获取类型。
-
+  // 同一类型可直接比较返回值是否相等，例如：
-  Kind GetKind() const;
+  // Type::GetInt32Type() == Type::GetInt32Type()
-  bool IsVoid() const;
-  bool IsInt32() const;
-  bool IsFloat32() const;
-  bool IsPointer() const;
-  bool IsArray() const;
-  bool IsFunction() const;
-  bool IsLabel() const;
-  bool IsPtrInt32() const;  // 兼容旧接口
-  bool IsPtrFloat32() const;  // 判断是否为 float32*
-
-  bool operator==(const Type& other) const;
-  bool operator!=(const Type& other) const;
-
-  // 静态单例获取基础类型
   static const std::shared_ptr<Type>& GetVoidType();
   static const std::shared_ptr<Type>& GetInt32Type();
-  static const std::shared_ptr<Type>& GetFloat32Type();
-  static const std::shared_ptr<Type>& GetLabelType();
   static const std::shared_ptr<Type>& GetPtrInt32Type();
-
+  Kind GetKind() const;
-  // 复合类型工厂方法
+  bool IsVoid() const;
-  static std::shared_ptr<Type> GetPointerType(std::shared_ptr<Type> pointee);
+  bool IsInt32() const;
-  static std::shared_ptr<Type> GetArrayType(std::shared_ptr<Type> elem, size_t size);
+  bool IsPtrInt32() const;
-  static std::shared_ptr<Type> GetFunctionType(std::shared_ptr<Type> ret,
-                                               std::vector<std::shared_ptr<Type>> params);
 
  private:
   Kind kind_;
 };
 
-// 指针类型
-class PointerType : public Type {
- public:
-  PointerType(std::shared_ptr<Type> pointee)
-      : Type(Type::Kind::Pointer), pointee_(std::move(pointee)) {}
-  const std::shared_ptr<Type>& GetPointeeType() const { return pointee_; }
-
- private:
-  std::shared_ptr<Type> pointee_;
-};
-
-// 数组类型
-class ArrayType : public Type {
- public:
-  ArrayType(std::shared_ptr<Type> elem, size_t size)
-      : Type(Type::Kind::Array), elem_type_(std::move(elem)), size_(size) {}
-  const std::shared_ptr<Type>& GetElementType() const { return elem_type_; }
-  size_t GetSize() const { return size_; }
-
- private:
-  std::shared_ptr<Type> elem_type_;
-  size_t size_;
-};
-
-// 函数类型
-class FunctionType : public Type {
- public:
-  FunctionType(std::shared_ptr<Type> ret, std::vector<std::shared_ptr<Type>> params)
-      : Type(Type::Kind::Function), ret_type_(std::move(ret)), param_types_(std::move(params)) {}
-  const std::shared_ptr<Type>& GetReturnType() const { return ret_type_; }
-  const std::vector<std::shared_ptr<Type>>& GetParamTypes() const { return param_types_; }
-
- private:
-  std::shared_ptr<Type> ret_type_;
-  std::vector<std::shared_ptr<Type>> param_types_;
-};
-
-// ======================== Value 类 ========================
 class Value {
  public:
   Value(std::shared_ptr<Type> ty, std::string name);
   virtual ~Value() = default;
-
   const std::shared_ptr<Type>& GetType() const;
   const std::string& GetName() const;
   void SetName(std::string n);
   bool IsVoid() const;
   bool IsInt32() const;
-  bool IsFloat32() const;
+  bool IsPtrInt32() const;
-  bool IsPtrInt32() const;  // 兼容旧接口，实际上判断是否为 i32*
-  bool IsPtrFloat32() const;  // 判断是否为 float32*
   bool IsConstant() const;
   bool IsInstruction() const;
   bool IsUser() const;
   bool IsFunction() const;
-  bool IsGlobalValue() const;
-
   void AddUse(User* user, size_t operand_index);
   void RemoveUse(User* user, size_t operand_index);
   const std::vector<Use>& GetUses() const;
@@ -210,7 +135,8 @@ class Value {
   std::vector<Use> uses_;
 };
 
-// ======================== 常量体系 ========================
+// ConstantValue 是常量体系的基类。
+// 当前只实现了 ConstantInt，后续可继续扩展更多常量种类。
 class ConstantValue : public Value {
  public:
   ConstantValue(std::shared_ptr<Type> ty, std::string name = "");
@@ -225,26 +151,38 @@ class ConstantInt : public ConstantValue {
   int value_{};
 };
 
-class ConstantFloat : public ConstantValue {
+// Argument 表示函数的形式参数，作为 Value 在函数体内直接被引用。
+class Argument : public Value {
  public:
-  ConstantFloat(std::shared_ptr<Type> ty, float v);
+  Argument(std::shared_ptr<Type> ty, std::string name, size_t index);
-  float GetValue() const { return value_; }
+  size_t GetArgIndex() const { return arg_index_; }
 
  private:
-  float value_{};
+  size_t arg_index_;
 };
 
-// 常量数组（简单聚合，可存储常量元素）
+// 第一版 Lab2 需要的指令集合。
-class ConstantArray : public ConstantValue {
+enum class Opcode {
- public:
+  Add,
-  ConstantArray(std::shared_ptr<Type> ty, std::vector<ConstantValue*> elems);
+  Sub,
-  const std::vector<ConstantValue*>& GetElements() const { return elements_; }
+  Mul,
-
+  Div,
- private:
+  Mod,
-  std::vector<ConstantValue*> elements_;
+  Cmp,
+  Br,
+  CondBr,
+  Call,
+  Alloca,
+  Load,
+  Store,
+  Ret,
+  Gep,  // getelementptr：数组元素地址计算
 };
 
-// ======================== User 类 ========================
+enum class CmpOp { Eq, Ne, Lt, Le, Gt, Ge };
+
+// User 是所有“会使用其他 Value 作为输入”的 IR 对象的抽象基类。
+// 当前实现中只有 Instruction 继承自 User。
 class User : public Value {
  public:
   User(std::shared_ptr<Type> ty, std::string name);
@@ -253,44 +191,35 @@ class User : public Value {
   void SetOperand(size_t index, Value* value);
 
  protected:
+  // 统一的 operand 入口。
   void AddOperand(Value* value);
 
  private:
   std::vector<Value*> operands_;
 };
 
-// ======================== GlobalValue 类 ========================
+// GlobalValue 是全局值/全局变量体系的空壳占位类。
+// 当前只补齐类层次，具体初始化器、打印和链接语义后续再补。
 class GlobalValue : public User {
  public:
   GlobalValue(std::shared_ptr<Type> ty, std::string name);
-  ConstantValue* GetInitializer() const { return init_; }
-  void SetInitializer(ConstantValue* init) { init_ = init; }
-
- private:
-  ConstantValue* init_ = nullptr;
 };
 
-// ======================== 指令操作码 ========================
+// GlobalVariable 代表一个全局整型变量、常量或数组。
-enum class Opcode {
+// 标量：打印为 @name = global i32 N。
-  // 算术
+// 数组：打印为 @name = global [count x i32] zeroinitializer。
-  Add, Sub, Mul, Div, Mod,
+class GlobalVariable : public GlobalValue {
-  // 位运算
+ public:
-  And, Or, Xor, Shl, LShr, AShr,
+  GlobalVariable(std::string name, int init_val = 0, int count = 1);
-  // 比较
+  int GetInitValue() const { return init_val_; }
-  ICmp, FCmp,
+  int GetCount() const { return count_; }
-  // 内存
+  bool IsArray() const { return count_ > 1; }
-  Alloca, Load, Store,
+
-  // 控制流
+ private:
-  Ret, Br, CondBr,
+  int init_val_;
-  // 函数调用
+  int count_;
-  Call,
-  // 数组访问
-  GEP,
-  // Phi
-  Phi
 };
 
-// ======================== Instruction 类 ========================
 class Instruction : public User {
  public:
   Instruction(Opcode op, std::shared_ptr<Type> ty, std::string name = "");
@@ -304,7 +233,6 @@ class Instruction : public User {
   BasicBlock* parent_ = nullptr;
 };
 
-// 二元运算指令
 class BinaryInst : public Instruction {
  public:
   BinaryInst(Opcode op, std::shared_ptr<Type> ty, Value* lhs, Value* rhs,
@@ -313,93 +241,86 @@ class BinaryInst : public Instruction {
   Value* GetRhs() const;
 };
 
-// 比较指令（icmp/fcmp）
 class CmpInst : public Instruction {
  public:
-  enum Predicate {
+  CmpInst(CmpOp op, std::shared_ptr<Type> ty, Value* lhs, Value* rhs,
-    EQ, NE, LT, LE, GT, GE
+          std::string name);
-  };
+  CmpOp GetCmpOp() const;
-  CmpInst(Opcode op, Predicate pred, Value* lhs, Value* rhs, std::string name);
+  Value* GetLhs() const;
-  Predicate GetPredicate() const { return pred_; }
+  Value* GetRhs() const;
-  Value* GetLhs() const { return lhs_; }
-  Value* GetRhs() const { return rhs_; }
 
  private:
-  Predicate pred_;
+  CmpOp cmp_op_;
-  Value* lhs_;
-  Value* rhs_;
 };
 
-// 返回指令
 class ReturnInst : public Instruction {
  public:
-  ReturnInst(std::shared_ptr<Type> void_ty, Value* val = nullptr);
+  ReturnInst(std::shared_ptr<Type> void_ty, Value* val);
   Value* GetValue() const;
 };
 
-// 无条件分支
+class AllocaInst : public Instruction {
-class BranchInst : public Instruction {
  public:
-  BranchInst(BasicBlock* target);
+  // 标量 alloca（分配 1 个 i32）
-  BasicBlock* GetTarget() const;
+  AllocaInst(std::shared_ptr<Type> ptr_ty, std::string name);
-};
+  // 数组 alloca（分配 count 个 i32，count 为编译期常量）
+  AllocaInst(std::shared_ptr<Type> ptr_ty, std::string name, int count);
+  int GetCount() const { return count_; }
+  bool IsArray() const { return count_ > 1; }
 
-// 条件分支
+ private:
-class CondBranchInst : public Instruction {
+  int count_ = 1;
- public:
-  CondBranchInst(Value* cond, BasicBlock* true_bb, BasicBlock* false_bb);
-  Value* GetCond() const;
-  BasicBlock* GetTrueBlock() const;
-  BasicBlock* GetFalseBlock() const;
 };
 
-// 函数调用
+class LoadInst : public Instruction {
-class CallInst : public Instruction {
  public:
-  CallInst(Function* callee, std::vector<Value*> args, std::string name);
+  LoadInst(std::shared_ptr<Type> val_ty, Value* ptr, std::string name);
-  Function* GetCallee() const;
+  Value* GetPtr() const;
-  const std::vector<Value*>& GetArgs() const;
 };
 
-// Phi 指令（用于 SSA）
+class StoreInst : public Instruction {
-class PhiInst : public Instruction {
  public:
-  PhiInst(std::shared_ptr<Type> ty, std::string name);
+  StoreInst(std::shared_ptr<Type> void_ty, Value* val, Value* ptr);
-  void AddIncoming(Value* val, BasicBlock* block);
+  Value* GetValue() const;
-  const std::vector<std::pair<Value*, BasicBlock*>>& GetIncomings() const;
+  Value* GetPtr() const;
 };
 
-// GetElementPtr 指令（数组/结构体指针计算）
+class BranchInst : public Instruction {
-class GetElementPtrInst : public Instruction {
  public:
-  GetElementPtrInst(std::shared_ptr<Type> ty, Value* ptr,
+  BranchInst(std::shared_ptr<Type> void_ty, BasicBlock* target);
-                    std::vector<Value*> indices, std::string name);
+  BasicBlock* GetTarget() const;
-  Value* GetPtr() const;
-  const std::vector<Value*>& GetIndices() const;
 };
 
-// 分配栈内存指令
+class CondBranchInst : public Instruction {
-class AllocaInst : public Instruction {
  public:
-  AllocaInst(std::shared_ptr<Type> ptr_ty, std::string name);
+  CondBranchInst(std::shared_ptr<Type> void_ty, Value* cond,
+                 BasicBlock* true_bb, BasicBlock* false_bb);
+  Value* GetCond() const;
+  BasicBlock* GetTrueBlock() const;
+  BasicBlock* GetFalseBlock() const;
 };
 
-// 加载指令
+class CallInst : public Instruction {
-class LoadInst : public Instruction {
  public:
-  LoadInst(std::shared_ptr<Type> val_ty, Value* ptr, std::string name);
+  CallInst(std::shared_ptr<Type> ret_ty, Function* callee,
-  Value* GetPtr() const;
+           std::vector<Value*> args, std::string name);
+  Function* GetCallee() const;
+  size_t GetNumArgs() const;
+  Value* GetArg(size_t index) const;
 };
 
-// 存储指令
+// GepInst：getelementptr i32, i32* base, i32 index
-class StoreInst : public Instruction {
+// 用于从数组基址 + 线性偏移量计算元素指针。
+class GepInst : public Instruction {
  public:
-  StoreInst(std::shared_ptr<Type> void_ty, Value* val, Value* ptr);
+  GepInst(std::shared_ptr<Type> ptr_ty, Value* base, Value* index,
-  Value* GetValue() const;
+          std::string name);
-  Value* GetPtr() const;
+  Value* GetBase() const;
+  Value* GetIndex() const;
 };
 
-// ======================== BasicBlock 类 ========================
+// BasicBlock 已纳入 Value 体系，便于后续向更完整 IR 类图靠拢。
+// 当前其类型仍使用 void 作为占位，后续可替换为专门的 label type。
 class BasicBlock : public Value {
  public:
   explicit BasicBlock(std::string name);
@@ -411,9 +332,6 @@ class BasicBlock : public Value {
   const std::vector<BasicBlock*>& GetSuccessors() const;
   void AddPredecessor(BasicBlock* pred);
   void AddSuccessor(BasicBlock* succ);
-  void RemovePredecessor(BasicBlock* pred);
-  void RemoveSuccessor(BasicBlock* succ);
-
   template <typename T, typename... Args>
   T* Append(Args&&... args) {
     if (HasTerminator()) {
@@ -434,72 +352,63 @@ class BasicBlock : public Value {
   std::vector<BasicBlock*> successors_;
 };
 
-// ======================== Function 类 ========================
+// Function 当前也采用了最小实现。
+// 需要特别注意：由于项目里还没有单独的 FunctionType，
+// Function 继承自 Value 后，其 type_ 目前只保存”返回类型”，
+// 并不能完整表达”返回类型 + 形参列表”这一整套函数签名。
 class Function : public Value {
  public:
-  // 构造函数，接收函数名、返回类型和参数类型列表（可选）
   Function(std::string name, std::shared_ptr<Type> ret_type,
            std::vector<std::shared_ptr<Type>> param_types = {});
-
   BasicBlock* CreateBlock(const std::string& name);
   BasicBlock* GetEntry();
   const BasicBlock* GetEntry() const;
+  const std::vector<std::shared_ptr<Type>>& GetParamTypes() const;
+  size_t GetNumParams() const;
+  Argument* GetArgument(size_t index) const;
   const std::vector<std::unique_ptr<BasicBlock>>& GetBlocks() const;
 
-  // 参数管理
+  // 外部函数声明（无函数体，打印为 declare）。
-  const std::vector<Value*>& GetParams() const { return params_; }
+  void SetExternal(bool v) { is_external_ = v; }
-  void AddParam(Value* param);
+  bool IsExternal() const { return is_external_; }
-
-  // 函数类型（完整签名）
-  std::shared_ptr<FunctionType> GetFunctionType() const;
 
  private:
   BasicBlock* entry_ = nullptr;
+  std::vector<std::shared_ptr<Type>> param_types_;
+  std::vector<std::unique_ptr<Argument>> args_;
   std::vector<std::unique_ptr<BasicBlock>> blocks_;
-  std::vector<Value*> params_;  // 参数值（通常是 Argument 类型，后续可定义）
+  bool is_external_ = false;
-  // Owned parameter storage to keep argument Values alive
-  std::vector<std::unique_ptr<Value>> owned_params_;
-  std::shared_ptr<FunctionType> func_type_;  // 缓存函数类型
 };
 
-// ======================== Module 类 ========================
 class Module {
  public:
   Module() = default;
   Context& GetContext();
   const Context& GetContext() const;
-
-  // 创建函数，支持参数类型
   Function* CreateFunction(const std::string& name,
                            std::shared_ptr<Type> ret_type,
                            std::vector<std::shared_ptr<Type>> param_types = {});
-
+  Function* FindFunction(const std::string& name) const;
-  // 创建全局变量
-  GlobalValue* CreateGlobalVariable(const std::string& name,
-                                    std::shared_ptr<Type> ty,
-                                    ConstantValue* init = nullptr);
-
   const std::vector<std::unique_ptr<Function>>& GetFunctions() const;
-  const std::vector<std::unique_ptr<GlobalValue>>& GetGlobalVariables() const;
+
+  GlobalVariable* CreateGlobalVar(const std::string& name, int init_val = 0, int count = 1);
+  GlobalVariable* FindGlobalVar(const std::string& name) const;
+  const std::vector<std::unique_ptr<GlobalVariable>>& GetGlobalVars() const;
 
  private:
   Context context_;
+  std::vector<std::unique_ptr<GlobalVariable>> global_vars_;
   std::vector<std::unique_ptr<Function>> functions_;
-  std::vector<std::unique_ptr<GlobalValue>> global_vars_;
 };
 
-// ======================== IRBuilder 类 ========================
 class IRBuilder {
  public:
-  IRBuilder(Context& ctx, BasicBlock* bb = nullptr);
+  IRBuilder(Context& ctx, BasicBlock* bb);
   void SetInsertPoint(BasicBlock* bb);
   BasicBlock* GetInsertBlock() const;
 
-  // 常量创建
+  // 构造常量、二元运算、返回指令的最小集合。
   ConstantInt* CreateConstInt(int v);
-  ConstantFloat* CreateConstFloat(float v);
-
-  // 算术指令
   BinaryInst* CreateBinary(Opcode op, Value* lhs, Value* rhs,
                            const std::string& name);
   BinaryInst* CreateAdd(Value* lhs, Value* rhs, const std::string& name);
@@ -507,46 +416,28 @@ class IRBuilder {
   BinaryInst* CreateMul(Value* lhs, Value* rhs, const std::string& name);
   BinaryInst* CreateDiv(Value* lhs, Value* rhs, const std::string& name);
   BinaryInst* CreateMod(Value* lhs, Value* rhs, const std::string& name);
-
+  CmpInst* CreateCmp(CmpOp op, Value* lhs, Value* rhs, const std::string& name);
-  // 比较指令
-  CmpInst* CreateICmp(CmpInst::Predicate pred, Value* lhs, Value* rhs,
-                      const std::string& name);
-  CmpInst* CreateFCmp(CmpInst::Predicate pred, Value* lhs, Value* rhs,
-                      const std::string& name);
-
-  // 内存指令
   AllocaInst* CreateAllocaI32(const std::string& name);
-  AllocaInst* CreateAllocaFloat(const std::string& name);
+  AllocaInst* CreateAllocaArray(int count, const std::string& name);
-  AllocaInst* CreateAlloca(std::shared_ptr<Type> ty, const std::string& name);
   LoadInst* CreateLoad(Value* ptr, const std::string& name);
   StoreInst* CreateStore(Value* val, Value* ptr);
-
-  // 控制流指令
-  ReturnInst* CreateRet(Value* v);
   BranchInst* CreateBr(BasicBlock* target);
   CondBranchInst* CreateCondBr(Value* cond, BasicBlock* true_bb,
                                BasicBlock* false_bb);
-
+  CallInst* CreateCall(Function* callee, const std::vector<Value*>& args,
-  // 函数调用
-  CallInst* CreateCall(Function* callee, std::vector<Value*> args,
                        const std::string& name);
-
+  GepInst* CreateGep(Value* base, Value* index, const std::string& name);
-  // 数组访问
+  ReturnInst* CreateRet(Value* v);
-  GetElementPtrInst* CreateGEP(Value* ptr, std::vector<Value*> indices,
+  ReturnInst* CreateRetVoid();
-                               const std::string& name);
-
-  // Phi 指令
-  PhiInst* CreatePhi(std::shared_ptr<Type> ty, const std::string& name);
 
  private:
   Context& ctx_;
   BasicBlock* insert_block_;
 };
 
-// ======================== IRPrinter 类 ========================
 class IRPrinter {
  public:
   void Print(const Module& module, std::ostream& os);
 };
 
-}  // namespace ir
+}  // namespace ir

include/irgen/IRGen.h

@@ -7,6 +7,7 @@
 #include <memory>
 #include <string>
 #include <unordered_map>
+#include <vector>
 
 #include "SysYBaseVisitor.h"
 #include "SysYParser.h"
@@ -22,26 +23,34 @@ class Value;
 
 class IRGenImpl final : public SysYBaseVisitor {
  public:
-  IRGenImpl(ir::Module& module, IRGenContext& sema);
+  // const 变量名 -> 编译期整数值，用于数组维度折叠。
+  using ConstEnv = std::unordered_map<std::string, int>;
+
+  IRGenImpl(ir::Module& module, const SemanticContext& sema);
 
   std::any visitCompUnit(SysYParser::CompUnitContext* ctx) override;
   std::any visitFuncDef(SysYParser::FuncDefContext* ctx) override;
-  std::any visitBlock(SysYParser::BlockContext* ctx) override;
+  std::any visitBlockStmt(SysYParser::BlockStmtContext* ctx) override;
   std::any visitBlockItem(SysYParser::BlockItemContext* ctx) override;
   std::any visitDecl(SysYParser::DeclContext* ctx) override;
+  std::any visitConstDecl(SysYParser::ConstDeclContext* ctx) override;
+  std::any visitConstDef(SysYParser::ConstDefContext* ctx) override;
+  std::any visitVarDecl(SysYParser::VarDeclContext* ctx) override;
   std::any visitStmt(SysYParser::StmtContext* ctx) override;
   std::any visitVarDef(SysYParser::VarDefContext* ctx) override;
+  std::any visitReturnStmt(SysYParser::ReturnStmtContext* ctx) override;
+  std::any visitExp(SysYParser::ExpContext* ctx) override;
+  std::any visitCond(SysYParser::CondContext* ctx) override;
   std::any visitPrimaryExp(SysYParser::PrimaryExpContext* ctx) override;
   std::any visitNumber(SysYParser::NumberContext* ctx) override;
-  std::any visitLVal(SysYParser::LValContext* ctx) override;
+  std::any visitLValue(SysYParser::LValueContext* ctx) override;
-  std::any visitAddExp(SysYParser::AddExpContext* ctx) override;
   std::any visitUnaryExp(SysYParser::UnaryExpContext* ctx) override;
   std::any visitMulExp(SysYParser::MulExpContext* ctx) override;
+  std::any visitAddExp(SysYParser::AddExpContext* ctx) override;
   std::any visitRelExp(SysYParser::RelExpContext* ctx) override;
   std::any visitEqExp(SysYParser::EqExpContext* ctx) override;
   std::any visitLAndExp(SysYParser::LAndExpContext* ctx) override;
   std::any visitLOrExp(SysYParser::LOrExpContext* ctx) override;
-  std::any visitConstDef(SysYParser::ConstDefContext* ctx) override;
 
  private:
   enum class BlockFlow {
@@ -49,24 +58,72 @@ class IRGenImpl final : public SysYBaseVisitor {
     Terminated,
   };
 
+  struct LoopTargets {
+    ir::BasicBlock* continue_target;
+    ir::BasicBlock* break_target;
+  };
+
+  // 判断当前是否处于全局作用域（函数外部）。
+  bool IsGlobalScope() const { return func_ == nullptr; }
+
   BlockFlow VisitBlockItemResult(SysYParser::BlockItemContext& item);
   ir::Value* EvalExpr(SysYParser::ExpContext& expr);
+  ir::Value* EvalCond(SysYParser::CondContext& cond);
+  ir::Value* ToBoolValue(ir::Value* v);
+  std::string NextBlockName();
+
+  // 预声明 SysY runtime 外部函数。
+  void DeclareRuntimeFunctions();
+
+  // 根据 sema 绑定或 name 查找局部/全局存储槽位（返回 i32* Value）。
+  // 如果 lvalue 有下标，还会生成 GEP 指令并返回元素指针。
+  ir::Value* ResolveStorage(SysYParser::LValueContext* lvalue);
+
+  // 编译期常量整数求值（用于数组维度）。
+  int EvalConstExpr(SysYParser::ConstExpContext* ctx) const;
+  // 将 ExpContext（即 addExp）按编译期常量求值（用于 funcFParam 维度）。
+  int EvalExpAsConst(SysYParser::ExpContext* ctx) const;
+
+  // 查找变量的数组维度（先查局部，再查全局）。
+  const std::vector<int>* FindArrayDims(const std::string& name) const;
+
+  // 将一组数组下标表达式（已求值为 ir::Value*）折叠为线性偏移 ir::Value*。
+  ir::Value* ComputeLinearIndex(const std::vector<int>& dims,
+                                const std::vector<SysYParser::ExpContext*>& subs);
+
+  // 扁平化 constInitValue 到整数数组（供 const 数组初始化使用）。
+  void FlattenConstInit(SysYParser::ConstInitValueContext* ctx,
+                        const std::vector<int>& dims, int dim_idx,
+                        std::vector<int>& out, int& pos);
+
+  // 扁平化 initValue 到 ir::Value* 数组（供普通数组初始化使用）。
+  void FlattenInit(SysYParser::InitValueContext* ctx,
+                   const std::vector<int>& dims, int dim_idx,
+                   std::vector<ir::Value*>& out, int& pos);
+
+  ir::AllocaInst* CreateEntryAllocaI32(const std::string& name);
+  ir::AllocaInst* CreateEntryAllocaArray(int count, const std::string& name);
 
   ir::Module& module_;
-  IRGenContext& sema_;
+  const SemanticContext& sema_;
   ir::Function* func_;
   ir::IRBuilder builder_;
-  // 名称绑定由 Sema 负责；IRGen 只维护“声明 -> 存储槽位”的代码生成状态。
+  // 声明 -> 存储槽位（局部 alloca 或全局变量，均为 i32*）。
-  std::unordered_map<antlr4::ParserRuleContext*, ir::Value*> storage_map_;
+  std::unordered_map<SysYParser::VarDefContext*, ir::Value*> storage_map_;
-  // 额外增加按名称的快速映射，以防有时无法直接通过声明节点指针匹配。
+  // 名称 -> 槽位（参数、const 变量等不经 sema binding 的后备查找）。
-  std::unordered_map<std::string, ir::Value*> name_map_;
+  std::unordered_map<std::string, ir::Value*> named_storage_;
-  // 常量名称到整数值的快速映射（供数组维度解析使用）
+  // 全局变量名 -> GlobalVariable*（跨函数持久）。
-  std::unordered_map<std::string, long> const_values_;
+  std::unordered_map<std::string, ir::Value*> global_storage_;
-  // 当前正在处理的声明基础类型（由 visitDecl 设置，visitVarDef/visitConstDef 使用）
+  // 编译期 const 整数环境（全局 + 当前函数）。
-  std::string current_btype_;
+  ConstEnv const_env_;
-  std::vector<ir::BasicBlock*> break_targets_;
+  // 数组维度信息：全局数组（跨函数持久）。
-  std::vector<ir::BasicBlock*> continue_targets_;
+  std::unordered_map<std::string, std::vector<int>> global_array_dims_;
+  // 数组维度信息：局部数组/参数（每函数清空）。
+  std::unordered_map<std::string, std::vector<int>> local_array_dims_;
+  // 逻辑与/或短路求值复用的函数级临时槽位，避免循环中动态 alloca 导致栈膨胀。
+  ir::Value* short_circuit_slot_ = nullptr;
+  std::vector<LoopTargets> loop_stack_;
 };
 
 std::unique_ptr<ir::Module> GenerateIR(SysYParser::CompUnitContext& tree,
-                                       IRGenContext& sema);
+                                       const SemanticContext& sema);

include/sem/Sema.h

@@ -1,181 +1,151 @@
 #ifndef SEMANTIC_ANALYSIS_H
 #define SEMANTIC_ANALYSIS_H
 
-#include "SymbolTable.h"
-#include "SysYBaseVisitor.h"
-#include <vector>
-#include <string>
-#include <sstream>
-#include <unordered_map>
 #include <any>
 #include <memory>
+#include <sstream>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include "SymbolTable.h"
+#include "SysYBaseVisitor.h"
+#include "SysYParser.h"
 
-// 错误信息结构体
 struct ErrorMsg {
-    std::string msg;
+  std::string msg;
-    int line;
+  int line;
-    int column;
+  int column;
-    ErrorMsg(std::string m, int l, int c) : msg(std::move(m)), line(l), column(c) {}
-};
 
-// 前向声明
+  ErrorMsg(std::string m, int l, int c) : msg(std::move(m)), line(l), column(c) {}
-namespace antlr4 {
+};
-    class ParserRuleContext;
-    namespace tree {
-        class ParseTree;
-    }
-}
 
-// 语义/IR生成上下文核心类
 class IRGenContext {
-public:
+ public:
-    // 错误管理
+  void RecordError(const ErrorMsg& err) { errors_.push_back(err); }
-    void RecordError(const ErrorMsg& err) { errors_.push_back(err); }
+  const std::vector<ErrorMsg>& GetErrors() const { return errors_; }
-    const std::vector<ErrorMsg>& GetErrors() const { return errors_; }
+  bool HasError() const { return !errors_.empty(); }
-    bool HasError() const { return !errors_.empty(); }
+  void ClearErrors() { errors_.clear(); }
-    void ClearErrors() { errors_.clear(); }
+
-
+  void SetType(void* ctx, SymbolType type) { node_type_map_[ctx] = type; }
-    // 类型绑定/查询 - 使用 void* 以兼容测试代码
+
-    void SetType(void* ctx, SymbolType type) {
+  SymbolType GetType(void* ctx) const {
-        node_type_map_[ctx] = type;
+    auto it = node_type_map_.find(ctx);
-    }
+    return it == node_type_map_.end() ? SymbolType::TYPE_UNKNOWN : it->second;
-    
+  }
-    SymbolType GetType(void* ctx) const {
+
-        auto it = node_type_map_.find(ctx);
+  void SetConstVal(void* ctx, const std::any& val) { const_val_map_[ctx] = val; }
-        return it == node_type_map_.end() ? SymbolType::TYPE_UNKNOWN : it->second;
+
-    }
+  std::any GetConstVal(void* ctx) const {
-
+    auto it = const_val_map_.find(ctx);
-    // 常量值绑定/查询 - 使用 void* 以兼容测试代码
+    return it == const_val_map_.end() ? std::any() : it->second;
-    void SetConstVal(void* ctx, const std::any& val) {
+  }
-        const_val_map_[ctx] = val;
+
-    }
+  void EnterLoop() { sym_table_.EnterLoop(); }
-    
+  void ExitLoop() { sym_table_.ExitLoop(); }
-    std::any GetConstVal(void* ctx) const {
+  bool InLoop() const { return sym_table_.InLoop(); }
-        auto it = const_val_map_.find(ctx);
+
-        return it == const_val_map_.end() ? std::any() : it->second;
+  bool IsIntType(const std::any& val) const {
-    }
+    return val.type() == typeid(long) || val.type() == typeid(int);
-
+  }
-    // 循环状态管理
+
-    void EnterLoop() { sym_table_.EnterLoop(); }
+  bool IsFloatType(const std::any& val) const {
-    void ExitLoop() { sym_table_.ExitLoop(); }
+    return val.type() == typeid(double) || val.type() == typeid(float);
-    bool InLoop() const { return sym_table_.InLoop(); }
+  }
-
+
-    // 类型判断工具函数
+  SymbolType GetCurrentFuncReturnType() const { return current_func_ret_type_; }
-    bool IsIntType(const std::any& val) const {
+  void SetCurrentFuncReturnType(SymbolType type) { current_func_ret_type_ = type; }
-        return val.type() == typeid(long) || val.type() == typeid(int);
+
-    }
+  SymbolTable& GetSymbolTable() { return sym_table_; }
-    
+  const SymbolTable& GetSymbolTable() const { return sym_table_; }
-    bool IsFloatType(const std::any& val) const {
+
-        return val.type() == typeid(double) || val.type() == typeid(float);
+  void EnterScope() { sym_table_.EnterScope(); }
-    }
+  void LeaveScope() { sym_table_.LeaveScope(); }
-
+  size_t GetScopeDepth() const { return sym_table_.GetScopeDepth(); }
-    // 当前函数返回类型
+
-    SymbolType GetCurrentFuncReturnType() const {
+ private:
-        return current_func_ret_type_;
+  SymbolTable sym_table_;
-    }
+  std::unordered_map<void*, SymbolType> node_type_map_;
-    
+  std::unordered_map<void*, std::any> const_val_map_;
-    void SetCurrentFuncReturnType(SymbolType type) {
+  std::vector<ErrorMsg> errors_;
-        current_func_ret_type_ = type;
+  SymbolType current_func_ret_type_ = SymbolType::TYPE_UNKNOWN;
-    }
+};
-
+
-    // 符号表访问
+class SemanticContext {
-    SymbolTable& GetSymbolTable() { return sym_table_; }
+ public:
-    const SymbolTable& GetSymbolTable() const { return sym_table_; }
+  void BindVarUse(const SysYParser::LValueContext* use,
-
+                  SysYParser::VarDefContext* decl) {
-    // 作用域管理
+    var_uses_[use] = decl;
-    void EnterScope() { sym_table_.EnterScope(); }
+  }
-    void LeaveScope() { sym_table_.LeaveScope(); }
+
-    size_t GetScopeDepth() const { return sym_table_.GetScopeDepth(); }
+  SysYParser::VarDefContext* ResolveVarUse(
-
+      const SysYParser::LValueContext* use) const {
-private:
+    auto it = var_uses_.find(use);
-    SymbolTable sym_table_;
+    return it == var_uses_.end() ? nullptr : it->second;
-    std::unordered_map<void*, SymbolType> node_type_map_;
+  }
-    std::unordered_map<void*, std::any> const_val_map_;
+
-    std::vector<ErrorMsg> errors_;
+ private:
-    SymbolType current_func_ret_type_ = SymbolType::TYPE_UNKNOWN;
+  std::unordered_map<const SysYParser::LValueContext*, SysYParser::VarDefContext*>
+      var_uses_;
 };
 
-// 错误信息格式化工具函数
 inline std::string FormatErrMsg(const std::string& msg, int line, int col) {
-    std::ostringstream oss;
+  std::ostringstream oss;
-    oss << "[行:" << line << ",列:" << col << "] " << msg;
+  oss << "[行:" << line << ",列:" << col << "] " << msg;
-    return oss.str();
+  return oss.str();
 }
 
-// 语义分析访问器 - 继承自生成的基类
 class SemaVisitor : public SysYBaseVisitor {
-public:
+ public:
-    explicit SemaVisitor(IRGenContext& ctx) : ir_ctx_(ctx) {}
+  explicit SemaVisitor(IRGenContext& ctx, SemanticContext* sema_ctx = nullptr)
-
+      : ir_ctx_(ctx), sema_ctx_(sema_ctx) {}
-    // 必须实现的 ANTLR4 接口
+
-    std::any visit(antlr4::tree::ParseTree* tree) override {
+  std::any visitCompUnit(SysYParser::CompUnitContext* ctx) override;
-        if (tree) {
+  std::any visitDecl(SysYParser::DeclContext* ctx) override;
-            return tree->accept(this);
+  std::any visitConstDecl(SysYParser::ConstDeclContext* ctx) override;
-        }
+  std::any visitBtype(SysYParser::BtypeContext* ctx) override;
-        return std::any();
+  std::any visitConstDef(SysYParser::ConstDefContext* ctx) override;
-    }
+  std::any visitConstInitValue(SysYParser::ConstInitValueContext* ctx) override;
-    
+  std::any visitVarDecl(SysYParser::VarDeclContext* ctx) override;
-    std::any visitTerminal(antlr4::tree::TerminalNode* node) override {
+  std::any visitVarDef(SysYParser::VarDefContext* ctx) override;
-        return std::any();
+  std::any visitInitValue(SysYParser::InitValueContext* ctx) override;
-    }
+  std::any visitFuncDef(SysYParser::FuncDefContext* ctx) override;
-    
+  std::any visitFuncType(SysYParser::FuncTypeContext* ctx) override;
-    std::any visitErrorNode(antlr4::tree::ErrorNode* node) override {
+  std::any visitFuncFParams(SysYParser::FuncFParamsContext* ctx) override;
-        if (node) {
+  std::any visitFuncFParam(SysYParser::FuncFParamContext* ctx) override;
-            int line = node->getSymbol()->getLine();
+  std::any visitBlockStmt(SysYParser::BlockStmtContext* ctx) override;
-            int col = node->getSymbol()->getCharPositionInLine() + 1;
+  std::any visitBlockItem(SysYParser::BlockItemContext* ctx) override;
-            ir_ctx_.RecordError(ErrorMsg("语法错误节点", line, col));
+  std::any visitStmt(SysYParser::StmtContext* ctx) override;
-        }
+  std::any visitReturnStmt(SysYParser::ReturnStmtContext* ctx) override;
-        return std::any();
+  std::any visitExp(SysYParser::ExpContext* ctx) override;
-    }
+  std::any visitCond(SysYParser::CondContext* ctx) override;
-
+  std::any visitLValue(SysYParser::LValueContext* ctx) override;
-    // 核心访问方法
+  std::any visitPrimaryExp(SysYParser::PrimaryExpContext* ctx) override;
-    std::any visitCompUnit(SysYParser::CompUnitContext* ctx) override;
+  std::any visitNumber(SysYParser::NumberContext* ctx) override;
-    std::any visitFuncDef(SysYParser::FuncDefContext* ctx) override;
+  std::any visitUnaryExp(SysYParser::UnaryExpContext* ctx) override;
-    std::any visitDecl(SysYParser::DeclContext* ctx) override;
+  std::any visitUnaryOp(SysYParser::UnaryOpContext* ctx) override;
-    std::any visitConstDecl(SysYParser::ConstDeclContext* ctx) override;
+  std::any visitFuncRParams(SysYParser::FuncRParamsContext* ctx) override;
-    std::any visitVarDecl(SysYParser::VarDeclContext* ctx) override;
+  std::any visitMulExp(SysYParser::MulExpContext* ctx) override;
-    std::any visitBlock(SysYParser::BlockContext* ctx) override;
+  std::any visitAddExp(SysYParser::AddExpContext* ctx) override;
-    std::any visitStmt(SysYParser::StmtContext* ctx) override;
+  std::any visitRelExp(SysYParser::RelExpContext* ctx) override;
-    std::any visitLVal(SysYParser::LValContext* ctx) override;
+  std::any visitEqExp(SysYParser::EqExpContext* ctx) override;
-    std::any visitExp(SysYParser::ExpContext* ctx) override;
+  std::any visitLAndExp(SysYParser::LAndExpContext* ctx) override;
-    std::any visitCond(SysYParser::CondContext* ctx) override;
+  std::any visitLOrExp(SysYParser::LOrExpContext* ctx) override;
-    std::any visitPrimaryExp(SysYParser::PrimaryExpContext* ctx) override;
+  std::any visitConstExp(SysYParser::ConstExpContext* ctx) override;
-    std::any visitUnaryExp(SysYParser::UnaryExpContext* ctx) override;
+
-    std::any visitMulExp(SysYParser::MulExpContext* ctx) override;
+  IRGenContext& GetContext() { return ir_ctx_; }
-    std::any visitAddExp(SysYParser::AddExpContext* ctx) override;
+  const IRGenContext& GetContext() const { return ir_ctx_; }
-    std::any visitRelExp(SysYParser::RelExpContext* ctx) override;
+
-    std::any visitEqExp(SysYParser::EqExpContext* ctx) override;
+ private:
-    std::any visitLAndExp(SysYParser::LAndExpContext* ctx) override;
+  void RecordNodeError(antlr4::ParserRuleContext* ctx, const std::string& msg);
-    std::any visitLOrExp(SysYParser::LOrExpContext* ctx) override;
+
-    std::any visitConstExp(SysYParser::ConstExpContext* ctx) override;
+  IRGenContext& ir_ctx_;
-    std::any visitNumber(SysYParser::NumberContext* ctx) override;
+  SemanticContext* sema_ctx_ = nullptr;
-    std::any visitFuncRParams(SysYParser::FuncRParamsContext* ctx) override;
+  SymbolType current_decl_type_ = SymbolType::TYPE_UNKNOWN;
-    
+  bool current_decl_is_const_ = false;
-    // 通用子节点访问
-    std::any visitChildren(antlr4::tree::ParseTree* node) override {
-        std::any result;
-        if (node) {
-            for (auto* child : node->children) {
-                if (child) {
-                    result = child->accept(this);
-                }
-            }
-        }
-        return result;
-    }
-
-    // 获取上下文引用
-    IRGenContext& GetContext() { return ir_ctx_; }
-    const IRGenContext& GetContext() const { return ir_ctx_; }
-
-private:
-    IRGenContext& ir_ctx_;
 };
 
-// 语义分析入口函数
 void RunSemanticAnalysis(SysYParser::CompUnitContext* ctx, IRGenContext& ir_ctx);
+SemanticContext RunSema(SysYParser::CompUnitContext& comp_unit);
 
-// 兼容主程序的简单包装：返回构造好的 IRGenContext（按值）
+#endif  // SEMANTIC_ANALYSIS_H
-IRGenContext RunSema(SysYParser::CompUnitContext& ctx);
-
-#endif // SEMANTIC_ANALYSIS_H

node_modules/.package-lock.json

@@ -0,0 +1,6 @@
+{
+  "name": "nudt-compiler-cpp",
+  "lockfileVersion": 2,
+  "requires": true,
+  "packages": {}
+}

node_modules/@anthropic-ai/claude-code/vendor/ripgrep/COPYING

@@ -0,0 +1,3 @@
+This project is dual-licensed under the Unlicense and MIT licenses.
+
+You may use this code under the terms of either license.

node_modules/@img/sharp-libvips-linux-x64/README.md

@@ -0,0 +1,46 @@
+# `@img/sharp-libvips-linux-x64`
+
+Prebuilt libvips and dependencies for use with sharp on Linux (glibc) x64.
+
+## Licensing
+
+This software contains third-party libraries
+used under the terms of the following licences:
+
+| Library       | Used under the terms of                                                                                   |
+|---------------|-----------------------------------------------------------------------------------------------------------|
+| aom           | BSD 2-Clause + [Alliance for Open Media Patent License 1.0](https://aomedia.org/license/patent-license/)  |
+| cairo         | Mozilla Public License 2.0                                                                                |
+| cgif          | MIT Licence                                                                                               |
+| expat         | MIT Licence                                                                                               |
+| fontconfig    | [fontconfig Licence](https://gitlab.freedesktop.org/fontconfig/fontconfig/blob/main/COPYING) (BSD-like)   |
+| freetype      | [freetype Licence](https://git.savannah.gnu.org/cgit/freetype/freetype2.git/tree/docs/FTL.TXT) (BSD-like) |
+| fribidi       | LGPLv3                                                                                                    |
+| glib          | LGPLv3                                                                                                    |
+| harfbuzz      | MIT Licence                                                                                               |
+| highway       | Apache-2.0 License, BSD 3-Clause                                                                          |
+| lcms          | MIT Licence                                                                                               |
+| libarchive    | BSD 2-Clause                                                                                              |
+| libexif       | LGPLv3                                                                                                    |
+| libffi        | MIT Licence                                                                                               |
+| libheif       | LGPLv3                                                                                                    |
+| libimagequant | [BSD 2-Clause](https://github.com/lovell/libimagequant/blob/main/COPYRIGHT)                               |
+| libnsgif      | MIT Licence                                                                                               |
+| libpng        | [libpng License](https://github.com/pnggroup/libpng/blob/master/LICENSE)                                  |
+| librsvg       | LGPLv3                                                                                                    |
+| libspng       | [BSD 2-Clause, libpng License](https://github.com/randy408/libspng/blob/master/LICENSE)                   |
+| libtiff       | [libtiff License](https://gitlab.com/libtiff/libtiff/blob/master/LICENSE.md) (BSD-like)                   |
+| libvips       | LGPLv3                                                                                                    |
+| libwebp       | New BSD License                                                                                           |
+| libxml2       | MIT Licence                                                                                               |
+| mozjpeg       | [zlib License, IJG License, BSD-3-Clause](https://github.com/mozilla/mozjpeg/blob/master/LICENSE.md)      |
+| pango         | LGPLv3                                                                                                    |
+| pixman        | MIT Licence                                                                                               |
+| proxy-libintl | LGPLv3                                                                                                    |
+| zlib-ng       | [zlib Licence](https://github.com/zlib-ng/zlib-ng/blob/develop/LICENSE.md)                                |
+
+Use of libraries under the terms of the LGPLv3 is via the
+"any later version" clause of the LGPLv2 or LGPLv2.1.
+
+Please report any errors or omissions via
+https://github.com/lovell/sharp-libvips/issues/new

node_modules/@img/sharp-libvips-linux-x64/lib/glib-2.0/include/glibconfig.h

@@ -0,0 +1,221 @@
+/* glibconfig.h
+ *
+ * This is a generated file.  Please modify 'glibconfig.h.in'
+ */
+
+#ifndef __GLIBCONFIG_H__
+#define __GLIBCONFIG_H__
+
+#include <glib/gmacros.h>
+
+#include <limits.h>
+#include <float.h>
+#define GLIB_HAVE_ALLOCA_H
+
+#define GLIB_STATIC_COMPILATION 1
+#define GOBJECT_STATIC_COMPILATION 1
+#define GIO_STATIC_COMPILATION 1
+#define GMODULE_STATIC_COMPILATION 1
+#define GI_STATIC_COMPILATION 1
+#define G_INTL_STATIC_COMPILATION 1
+#define FFI_STATIC_BUILD 1
+
+/* Specifies that GLib's g_print*() functions wrap the
+ * system printf functions.  This is useful to know, for example,
+ * when using glibc's register_printf_function().
+ */
+#define GLIB_USING_SYSTEM_PRINTF
+
+G_BEGIN_DECLS
+
+#define G_MINFLOAT	FLT_MIN
+#define G_MAXFLOAT	FLT_MAX
+#define G_MINDOUBLE	DBL_MIN
+#define G_MAXDOUBLE	DBL_MAX
+#define G_MINSHORT	SHRT_MIN
+#define G_MAXSHORT	SHRT_MAX
+#define G_MAXUSHORT	USHRT_MAX
+#define G_MININT	INT_MIN
+#define G_MAXINT	INT_MAX
+#define G_MAXUINT	UINT_MAX
+#define G_MINLONG	LONG_MIN
+#define G_MAXLONG	LONG_MAX
+#define G_MAXULONG	ULONG_MAX
+
+typedef signed char gint8;
+typedef unsigned char guint8;
+
+typedef signed short gint16;
+typedef unsigned short guint16;
+
+#define G_GINT16_MODIFIER "h"
+#define G_GINT16_FORMAT "hi"
+#define G_GUINT16_FORMAT "hu"
+
+
+typedef signed int gint32;
+typedef unsigned int guint32;
+
+#define G_GINT32_MODIFIER ""
+#define G_GINT32_FORMAT "i"
+#define G_GUINT32_FORMAT "u"
+
+
+#define G_HAVE_GINT64 1          /* deprecated, always true */
+
+typedef signed long gint64;
+typedef unsigned long guint64;
+
+#define G_GINT64_CONSTANT(val)	(val##L)
+#define G_GUINT64_CONSTANT(val)	(val##UL)
+
+#define G_GINT64_MODIFIER "l"
+#define G_GINT64_FORMAT "li"
+#define G_GUINT64_FORMAT "lu"
+
+
+#define GLIB_SIZEOF_VOID_P 8
+#define GLIB_SIZEOF_LONG   8
+#define GLIB_SIZEOF_SIZE_T 8
+#define GLIB_SIZEOF_SSIZE_T 8
+
+typedef signed long gssize;
+typedef unsigned long gsize;
+#define G_GSIZE_MODIFIER "l"
+#define G_GSSIZE_MODIFIER "l"
+#define G_GSIZE_FORMAT "lu"
+#define G_GSSIZE_FORMAT "li"
+
+#define G_MAXSIZE	G_MAXULONG
+#define G_MINSSIZE	G_MINLONG
+#define G_MAXSSIZE	G_MAXLONG
+
+typedef gint64 goffset;
+#define G_MINOFFSET	G_MININT64
+#define G_MAXOFFSET	G_MAXINT64
+
+#define G_GOFFSET_MODIFIER      G_GINT64_MODIFIER
+#define G_GOFFSET_FORMAT        G_GINT64_FORMAT
+#define G_GOFFSET_CONSTANT(val) G_GINT64_CONSTANT(val)
+
+#define G_POLLFD_FORMAT "%d"
+
+#define GPOINTER_TO_INT(p)	((gint)  (glong) (p))
+#define GPOINTER_TO_UINT(p)	((guint) (gulong) (p))
+
+#define GINT_TO_POINTER(i)	((gpointer) (glong) (i))
+#define GUINT_TO_POINTER(u)	((gpointer) (gulong) (u))
+
+typedef signed long gintptr;
+typedef unsigned long guintptr;
+
+#define G_GINTPTR_MODIFIER      "l"
+#define G_GINTPTR_FORMAT        "li"
+#define G_GUINTPTR_FORMAT       "lu"
+
+#define GLIB_MAJOR_VERSION 2
+#define GLIB_MINOR_VERSION 86
+#define GLIB_MICRO_VERSION 1
+
+#define G_OS_UNIX
+
+#define G_VA_COPY va_copy
+
+#define G_VA_COPY_AS_ARRAY 1
+
+#define G_HAVE_ISO_VARARGS 1
+
+/* gcc-2.95.x supports both gnu style and ISO varargs, but if -ansi
+ * is passed ISO vararg support is turned off, and there is no work
+ * around to turn it on, so we unconditionally turn it off.
+ */
+#if __GNUC__ == 2 && __GNUC_MINOR__ == 95
+#  undef G_HAVE_ISO_VARARGS
+#endif
+
+#define G_HAVE_GROWING_STACK 0
+
+#ifndef _MSC_VER
+# define G_HAVE_GNUC_VARARGS 1
+#endif
+
+#if defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590)
+#define G_GNUC_INTERNAL __attribute__((visibility("hidden")))
+#elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x550)
+#define G_GNUC_INTERNAL __hidden
+#elif defined (__GNUC__) && defined (G_HAVE_GNUC_VISIBILITY)
+#define G_GNUC_INTERNAL __attribute__((visibility("hidden")))
+#else
+#define G_GNUC_INTERNAL
+#endif
+
+#define G_THREADS_ENABLED
+#define G_THREADS_IMPL_POSIX
+
+#define G_ATOMIC_LOCK_FREE
+
+#define GINT16_TO_LE(val)	((gint16) (val))
+#define GUINT16_TO_LE(val)	((guint16) (val))
+#define GINT16_TO_BE(val)	((gint16) GUINT16_SWAP_LE_BE (val))
+#define GUINT16_TO_BE(val)	(GUINT16_SWAP_LE_BE (val))
+
+#define GINT32_TO_LE(val)	((gint32) (val))
+#define GUINT32_TO_LE(val)	((guint32) (val))
+#define GINT32_TO_BE(val)	((gint32) GUINT32_SWAP_LE_BE (val))
+#define GUINT32_TO_BE(val)	(GUINT32_SWAP_LE_BE (val))
+
+#define GINT64_TO_LE(val)	((gint64) (val))
+#define GUINT64_TO_LE(val)	((guint64) (val))
+#define GINT64_TO_BE(val)	((gint64) GUINT64_SWAP_LE_BE (val))
+#define GUINT64_TO_BE(val)	(GUINT64_SWAP_LE_BE (val))
+
+#define GLONG_TO_LE(val)	((glong) GINT64_TO_LE (val))
+#define GULONG_TO_LE(val)	((gulong) GUINT64_TO_LE (val))
+#define GLONG_TO_BE(val)	((glong) GINT64_TO_BE (val))
+#define GULONG_TO_BE(val)	((gulong) GUINT64_TO_BE (val))
+#define GINT_TO_LE(val)		((gint) GINT32_TO_LE (val))
+#define GUINT_TO_LE(val)	((guint) GUINT32_TO_LE (val))
+#define GINT_TO_BE(val)		((gint) GINT32_TO_BE (val))
+#define GUINT_TO_BE(val)	((guint) GUINT32_TO_BE (val))
+#define GSIZE_TO_LE(val)	((gsize) GUINT64_TO_LE (val))
+#define GSSIZE_TO_LE(val)	((gssize) GINT64_TO_LE (val))
+#define GSIZE_TO_BE(val)	((gsize) GUINT64_TO_BE (val))
+#define GSSIZE_TO_BE(val)	((gssize) GINT64_TO_BE (val))
+#define G_BYTE_ORDER G_LITTLE_ENDIAN
+
+#define GLIB_SYSDEF_POLLIN =1
+#define GLIB_SYSDEF_POLLOUT =4
+#define GLIB_SYSDEF_POLLPRI =2
+#define GLIB_SYSDEF_POLLHUP =16
+#define GLIB_SYSDEF_POLLERR =8
+#define GLIB_SYSDEF_POLLNVAL =32
+
+/* No way to disable deprecation warnings for macros, so only emit deprecation
+ * warnings on platforms where usage of this macro is broken */
+#if defined(__APPLE__) || defined(_MSC_VER) || defined(__CYGWIN__)
+#define G_MODULE_SUFFIX "so" GLIB_DEPRECATED_MACRO_IN_2_76
+#else
+#define G_MODULE_SUFFIX "so"
+#endif
+
+typedef int GPid;
+#define G_PID_FORMAT "i"
+
+#define GLIB_SYSDEF_AF_UNIX 1
+#define GLIB_SYSDEF_AF_INET 2
+#define GLIB_SYSDEF_AF_INET6 10
+
+#define GLIB_SYSDEF_MSG_OOB 1
+#define GLIB_SYSDEF_MSG_PEEK 2
+#define GLIB_SYSDEF_MSG_DONTROUTE 4
+
+#define G_DIR_SEPARATOR '/'
+#define G_DIR_SEPARATOR_S "/"
+#define G_SEARCHPATH_SEPARATOR ':'
+#define G_SEARCHPATH_SEPARATOR_S ":"
+
+#undef G_HAVE_FREE_SIZED
+
+G_END_DECLS
+
+#endif /* __GLIBCONFIG_H__ */

node_modules/@img/sharp-libvips-linux-x64/lib/index.js

@@ -0,0 +1 @@
+module.exports = __dirname;

node_modules/@img/sharp-libvips-linux-x64/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@img/sharp-libvips-linux-x64",
+  "version": "1.2.4",
+  "description": "Prebuilt libvips and dependencies for use with sharp on Linux (glibc) x64",
+  "author": "Lovell Fuller <npm@lovell.info>",
+  "homepage": "https://sharp.pixelplumbing.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lovell/sharp-libvips.git",
+    "directory": "npm/linux-x64"
+  },
+  "license": "LGPL-3.0-or-later",
+  "funding": {
+    "url": "https://opencollective.com/libvips"
+  },
+  "preferUnplugged": true,
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "lib",
+    "versions.json"
+  ],
+  "type": "commonjs",
+  "exports": {
+    "./lib": "./lib/index.js",
+    "./package": "./package.json",
+    "./versions": "./versions.json"
+  },
+  "config": {
+    "glibc": ">=2.26"
+  },
+  "os": [
+    "linux"
+  ],
+  "libc": [
+    "glibc"
+  ],
+  "cpu": [
+    "x64"
+  ]
+}

node_modules/@img/sharp-libvips-linux-x64/versions.json

@@ -0,0 +1,30 @@
+{
+  "aom": "3.13.1",
+  "archive": "3.8.2",
+  "cairo": "1.18.4",
+  "cgif": "0.5.0",
+  "exif": "0.6.25",
+  "expat": "2.7.3",
+  "ffi": "3.5.2",
+  "fontconfig": "2.17.1",
+  "freetype": "2.14.1",
+  "fribidi": "1.0.16",
+  "glib": "2.86.1",
+  "harfbuzz": "12.1.0",
+  "heif": "1.20.2",
+  "highway": "1.3.0",
+  "imagequant": "2.4.1",
+  "lcms": "2.17",
+  "mozjpeg": "0826579",
+  "pango": "1.57.0",
+  "pixman": "0.46.4",
+  "png": "1.6.50",
+  "proxy-libintl": "0.5",
+  "rsvg": "2.61.2",
+  "spng": "0.7.4",
+  "tiff": "4.7.1",
+  "vips": "8.17.3",
+  "webp": "1.6.0",
+  "xml2": "2.15.1",
+  "zlib-ng": "2.2.5"
+}

node_modules/@img/sharp-libvips-linuxmusl-x64/README.md

@@ -0,0 +1,46 @@
+# `@img/sharp-libvips-linuxmusl-x64`
+
+Prebuilt libvips and dependencies for use with sharp on Linux (musl) x64.
+
+## Licensing
+
+This software contains third-party libraries
+used under the terms of the following licences:
+
+| Library       | Used under the terms of                                                                                   |
+|---------------|-----------------------------------------------------------------------------------------------------------|
+| aom           | BSD 2-Clause + [Alliance for Open Media Patent License 1.0](https://aomedia.org/license/patent-license/)  |
+| cairo         | Mozilla Public License 2.0                                                                                |
+| cgif          | MIT Licence                                                                                               |
+| expat         | MIT Licence                                                                                               |
+| fontconfig    | [fontconfig Licence](https://gitlab.freedesktop.org/fontconfig/fontconfig/blob/main/COPYING) (BSD-like)   |
+| freetype      | [freetype Licence](https://git.savannah.gnu.org/cgit/freetype/freetype2.git/tree/docs/FTL.TXT) (BSD-like) |
+| fribidi       | LGPLv3                                                                                                    |
+| glib          | LGPLv3                                                                                                    |
+| harfbuzz      | MIT Licence                                                                                               |
+| highway       | Apache-2.0 License, BSD 3-Clause                                                                          |
+| lcms          | MIT Licence                                                                                               |
+| libarchive    | BSD 2-Clause                                                                                              |
+| libexif       | LGPLv3                                                                                                    |
+| libffi        | MIT Licence                                                                                               |
+| libheif       | LGPLv3                                                                                                    |
+| libimagequant | [BSD 2-Clause](https://github.com/lovell/libimagequant/blob/main/COPYRIGHT)                               |
+| libnsgif      | MIT Licence                                                                                               |
+| libpng        | [libpng License](https://github.com/pnggroup/libpng/blob/master/LICENSE)                                  |
+| librsvg       | LGPLv3                                                                                                    |
+| libspng       | [BSD 2-Clause, libpng License](https://github.com/randy408/libspng/blob/master/LICENSE)                   |
+| libtiff       | [libtiff License](https://gitlab.com/libtiff/libtiff/blob/master/LICENSE.md) (BSD-like)                   |
+| libvips       | LGPLv3                                                                                                    |
+| libwebp       | New BSD License                                                                                           |
+| libxml2       | MIT Licence                                                                                               |
+| mozjpeg       | [zlib License, IJG License, BSD-3-Clause](https://github.com/mozilla/mozjpeg/blob/master/LICENSE.md)      |
+| pango         | LGPLv3                                                                                                    |
+| pixman        | MIT Licence                                                                                               |
+| proxy-libintl | LGPLv3                                                                                                    |
+| zlib-ng       | [zlib Licence](https://github.com/zlib-ng/zlib-ng/blob/develop/LICENSE.md)                                |
+
+Use of libraries under the terms of the LGPLv3 is via the
+"any later version" clause of the LGPLv2 or LGPLv2.1.
+
+Please report any errors or omissions via
+https://github.com/lovell/sharp-libvips/issues/new

node_modules/@img/sharp-libvips-linuxmusl-x64/lib/glib-2.0/include/glibconfig.h

@@ -0,0 +1,221 @@
+/* glibconfig.h
+ *
+ * This is a generated file.  Please modify 'glibconfig.h.in'
+ */
+
+#ifndef __GLIBCONFIG_H__
+#define __GLIBCONFIG_H__
+
+#include <glib/gmacros.h>
+
+#include <limits.h>
+#include <float.h>
+#define GLIB_HAVE_ALLOCA_H
+
+#define GLIB_STATIC_COMPILATION 1
+#define GOBJECT_STATIC_COMPILATION 1
+#define GIO_STATIC_COMPILATION 1
+#define GMODULE_STATIC_COMPILATION 1
+#define GI_STATIC_COMPILATION 1
+#define G_INTL_STATIC_COMPILATION 1
+#define FFI_STATIC_BUILD 1
+
+/* Specifies that GLib's g_print*() functions wrap the
+ * system printf functions.  This is useful to know, for example,
+ * when using glibc's register_printf_function().
+ */
+#define GLIB_USING_SYSTEM_PRINTF
+
+G_BEGIN_DECLS
+
+#define G_MINFLOAT	FLT_MIN
+#define G_MAXFLOAT	FLT_MAX
+#define G_MINDOUBLE	DBL_MIN
+#define G_MAXDOUBLE	DBL_MAX
+#define G_MINSHORT	SHRT_MIN
+#define G_MAXSHORT	SHRT_MAX
+#define G_MAXUSHORT	USHRT_MAX
+#define G_MININT	INT_MIN
+#define G_MAXINT	INT_MAX
+#define G_MAXUINT	UINT_MAX
+#define G_MINLONG	LONG_MIN
+#define G_MAXLONG	LONG_MAX
+#define G_MAXULONG	ULONG_MAX
+
+typedef signed char gint8;
+typedef unsigned char guint8;
+
+typedef signed short gint16;
+typedef unsigned short guint16;
+
+#define G_GINT16_MODIFIER "h"
+#define G_GINT16_FORMAT "hi"
+#define G_GUINT16_FORMAT "hu"
+
+
+typedef signed int gint32;
+typedef unsigned int guint32;
+
+#define G_GINT32_MODIFIER ""
+#define G_GINT32_FORMAT "i"
+#define G_GUINT32_FORMAT "u"
+
+
+#define G_HAVE_GINT64 1          /* deprecated, always true */
+
+typedef signed long gint64;
+typedef unsigned long guint64;
+
+#define G_GINT64_CONSTANT(val)	(val##L)
+#define G_GUINT64_CONSTANT(val)	(val##UL)
+
+#define G_GINT64_MODIFIER "l"
+#define G_GINT64_FORMAT "li"
+#define G_GUINT64_FORMAT "lu"
+
+
+#define GLIB_SIZEOF_VOID_P 8
+#define GLIB_SIZEOF_LONG   8
+#define GLIB_SIZEOF_SIZE_T 8
+#define GLIB_SIZEOF_SSIZE_T 8
+
+typedef signed long gssize;
+typedef unsigned long gsize;
+#define G_GSIZE_MODIFIER "l"
+#define G_GSSIZE_MODIFIER "l"
+#define G_GSIZE_FORMAT "lu"
+#define G_GSSIZE_FORMAT "li"
+
+#define G_MAXSIZE	G_MAXULONG
+#define G_MINSSIZE	G_MINLONG
+#define G_MAXSSIZE	G_MAXLONG
+
+typedef gint64 goffset;
+#define G_MINOFFSET	G_MININT64
+#define G_MAXOFFSET	G_MAXINT64
+
+#define G_GOFFSET_MODIFIER      G_GINT64_MODIFIER
+#define G_GOFFSET_FORMAT        G_GINT64_FORMAT
+#define G_GOFFSET_CONSTANT(val) G_GINT64_CONSTANT(val)
+
+#define G_POLLFD_FORMAT "%d"
+
+#define GPOINTER_TO_INT(p)	((gint)  (glong) (p))
+#define GPOINTER_TO_UINT(p)	((guint) (gulong) (p))
+
+#define GINT_TO_POINTER(i)	((gpointer) (glong) (i))
+#define GUINT_TO_POINTER(u)	((gpointer) (gulong) (u))
+
+typedef signed long gintptr;
+typedef unsigned long guintptr;
+
+#define G_GINTPTR_MODIFIER      "l"
+#define G_GINTPTR_FORMAT        "li"
+#define G_GUINTPTR_FORMAT       "lu"
+
+#define GLIB_MAJOR_VERSION 2
+#define GLIB_MINOR_VERSION 86
+#define GLIB_MICRO_VERSION 1
+
+#define G_OS_UNIX
+
+#define G_VA_COPY va_copy
+
+#define G_VA_COPY_AS_ARRAY 1
+
+#define G_HAVE_ISO_VARARGS 1
+
+/* gcc-2.95.x supports both gnu style and ISO varargs, but if -ansi
+ * is passed ISO vararg support is turned off, and there is no work
+ * around to turn it on, so we unconditionally turn it off.
+ */
+#if __GNUC__ == 2 && __GNUC_MINOR__ == 95
+#  undef G_HAVE_ISO_VARARGS
+#endif
+
+#define G_HAVE_GROWING_STACK 0
+
+#ifndef _MSC_VER
+# define G_HAVE_GNUC_VARARGS 1
+#endif
+
+#if defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590)
+#define G_GNUC_INTERNAL __attribute__((visibility("hidden")))
+#elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x550)
+#define G_GNUC_INTERNAL __hidden
+#elif defined (__GNUC__) && defined (G_HAVE_GNUC_VISIBILITY)
+#define G_GNUC_INTERNAL __attribute__((visibility("hidden")))
+#else
+#define G_GNUC_INTERNAL
+#endif
+
+#define G_THREADS_ENABLED
+#define G_THREADS_IMPL_POSIX
+
+#define G_ATOMIC_LOCK_FREE
+
+#define GINT16_TO_LE(val)	((gint16) (val))
+#define GUINT16_TO_LE(val)	((guint16) (val))
+#define GINT16_TO_BE(val)	((gint16) GUINT16_SWAP_LE_BE (val))
+#define GUINT16_TO_BE(val)	(GUINT16_SWAP_LE_BE (val))
+
+#define GINT32_TO_LE(val)	((gint32) (val))
+#define GUINT32_TO_LE(val)	((guint32) (val))
+#define GINT32_TO_BE(val)	((gint32) GUINT32_SWAP_LE_BE (val))
+#define GUINT32_TO_BE(val)	(GUINT32_SWAP_LE_BE (val))
+
+#define GINT64_TO_LE(val)	((gint64) (val))
+#define GUINT64_TO_LE(val)	((guint64) (val))
+#define GINT64_TO_BE(val)	((gint64) GUINT64_SWAP_LE_BE (val))
+#define GUINT64_TO_BE(val)	(GUINT64_SWAP_LE_BE (val))
+
+#define GLONG_TO_LE(val)	((glong) GINT64_TO_LE (val))
+#define GULONG_TO_LE(val)	((gulong) GUINT64_TO_LE (val))
+#define GLONG_TO_BE(val)	((glong) GINT64_TO_BE (val))
+#define GULONG_TO_BE(val)	((gulong) GUINT64_TO_BE (val))
+#define GINT_TO_LE(val)		((gint) GINT32_TO_LE (val))
+#define GUINT_TO_LE(val)	((guint) GUINT32_TO_LE (val))
+#define GINT_TO_BE(val)		((gint) GINT32_TO_BE (val))
+#define GUINT_TO_BE(val)	((guint) GUINT32_TO_BE (val))
+#define GSIZE_TO_LE(val)	((gsize) GUINT64_TO_LE (val))
+#define GSSIZE_TO_LE(val)	((gssize) GINT64_TO_LE (val))
+#define GSIZE_TO_BE(val)	((gsize) GUINT64_TO_BE (val))
+#define GSSIZE_TO_BE(val)	((gssize) GINT64_TO_BE (val))
+#define G_BYTE_ORDER G_LITTLE_ENDIAN
+
+#define GLIB_SYSDEF_POLLIN =1
+#define GLIB_SYSDEF_POLLOUT =4
+#define GLIB_SYSDEF_POLLPRI =2
+#define GLIB_SYSDEF_POLLHUP =16
+#define GLIB_SYSDEF_POLLERR =8
+#define GLIB_SYSDEF_POLLNVAL =32
+
+/* No way to disable deprecation warnings for macros, so only emit deprecation
+ * warnings on platforms where usage of this macro is broken */
+#if defined(__APPLE__) || defined(_MSC_VER) || defined(__CYGWIN__)
+#define G_MODULE_SUFFIX "so" GLIB_DEPRECATED_MACRO_IN_2_76
+#else
+#define G_MODULE_SUFFIX "so"
+#endif
+
+typedef int GPid;
+#define G_PID_FORMAT "i"
+
+#define GLIB_SYSDEF_AF_UNIX 1
+#define GLIB_SYSDEF_AF_INET 2
+#define GLIB_SYSDEF_AF_INET6 10
+
+#define GLIB_SYSDEF_MSG_OOB 1
+#define GLIB_SYSDEF_MSG_PEEK 2
+#define GLIB_SYSDEF_MSG_DONTROUTE 4
+
+#define G_DIR_SEPARATOR '/'
+#define G_DIR_SEPARATOR_S "/"
+#define G_SEARCHPATH_SEPARATOR ':'
+#define G_SEARCHPATH_SEPARATOR_S ":"
+
+#undef G_HAVE_FREE_SIZED
+
+G_END_DECLS
+
+#endif /* __GLIBCONFIG_H__ */

node_modules/@img/sharp-libvips-linuxmusl-x64/lib/index.js

@@ -0,0 +1 @@
+module.exports = __dirname;

node_modules/@img/sharp-libvips-linuxmusl-x64/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@img/sharp-libvips-linuxmusl-x64",
+  "version": "1.2.4",
+  "description": "Prebuilt libvips and dependencies for use with sharp on Linux (musl) x64",
+  "author": "Lovell Fuller <npm@lovell.info>",
+  "homepage": "https://sharp.pixelplumbing.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lovell/sharp-libvips.git",
+    "directory": "npm/linuxmusl-x64"
+  },
+  "license": "LGPL-3.0-or-later",
+  "funding": {
+    "url": "https://opencollective.com/libvips"
+  },
+  "preferUnplugged": true,
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "lib",
+    "versions.json"
+  ],
+  "type": "commonjs",
+  "exports": {
+    "./lib": "./lib/index.js",
+    "./package": "./package.json",
+    "./versions": "./versions.json"
+  },
+  "config": {
+    "musl": ">=1.2.2"
+  },
+  "os": [
+    "linux"
+  ],
+  "libc": [
+    "musl"
+  ],
+  "cpu": [
+    "x64"
+  ]
+}

node_modules/@img/sharp-libvips-linuxmusl-x64/versions.json

@@ -0,0 +1,30 @@
+{
+  "aom": "3.13.1",
+  "archive": "3.8.2",
+  "cairo": "1.18.4",
+  "cgif": "0.5.0",
+  "exif": "0.6.25",
+  "expat": "2.7.3",
+  "ffi": "3.5.2",
+  "fontconfig": "2.17.1",
+  "freetype": "2.14.1",
+  "fribidi": "1.0.16",
+  "glib": "2.86.1",
+  "harfbuzz": "12.1.0",
+  "heif": "1.20.2",
+  "highway": "1.3.0",
+  "imagequant": "2.4.1",
+  "lcms": "2.17",
+  "mozjpeg": "0826579",
+  "pango": "1.57.0",
+  "pixman": "0.46.4",
+  "png": "1.6.50",
+  "proxy-libintl": "0.5",
+  "rsvg": "2.61.2",
+  "spng": "0.7.4",
+  "tiff": "4.7.1",
+  "vips": "8.17.3",
+  "webp": "1.6.0",
+  "xml2": "2.15.1",
+  "zlib-ng": "2.2.5"
+}

package-lock.json

@@ -0,0 +1,6 @@
+{
+  "name": "nudt-compiler-cpp",
+  "lockfileVersion": 2,
+  "requires": true,
+  "packages": {}
+}

package.json

@@ -0,0 +1 @@
+{}

report.md

@@ -0,0 +1,97 @@
+Lab1 语法树构建
+
+要做什么：补全 SysY 文法，保证更多合法程序可被解析并打印语法树。
+主要改哪些文件：
+Lab1-语法树构建.md
+SysY.g4
+AntlrDriver.cpp
+SyntaxTreePrinter.cpp
+修改方式：
+扩展 grammar 规则和 token；保持解析入口稳定；错误信息要可定位到行列；语法树打印结构清晰。
+验收：parse-tree 模式批量通过测试集。
+Lab2 中间表示生成
+
+要做什么：把语义检查和 IR 生成从最小子集扩展到课程要求语法。
+主要改哪些文件：
+Lab2-中间表示生成.md
+Sema.h
+SymbolTable.h
+Sema.cpp
+SymbolTable.cpp
+IR.h
+IRBuilder.cpp
+Instruction.cpp
+IRPrinter.cpp
+IRGen.h
+IRGenDecl.cpp
+IRGenStmt.cpp
+IRGenExp.cpp
+IRGenFunc.cpp
+IRGenDriver.cpp
+修改方式：
+先补语义绑定和错误检查，再补 IR 指令与类型，最后在 Visitor 里把各类语句表达式翻译到 IR。
+验收：IR 能生成，并且 verify_ir 脚本 run 模式和输出比对通过。
+Lab3 指令选择与汇编生成
+
+要做什么：把 IR 正确 lower 到 AArch64 汇编，覆盖更多语义。
+主要改哪些文件：
+Lab3-指令选择与汇编生成.md
+MIR.h
+Lowering.cpp
+RegAlloc.cpp
+FrameLowering.cpp
+AsmPrinter.cpp
+修改方式：
+扩充 MIR 指令和操作数表示；完善 lowering 映射；保证栈帧和函数序言尾声正确；输出可汇编可运行的 asm。
+验收：verify_asm 脚本 run 模式通过。
+Lab4 基本标量优化
+
+要做什么：先做 mem2reg，再做常量相关优化、DCE、CFG 简化、CSE 等。
+主要改哪些文件：
+Lab4-基本标量优化.md
+Mem2Reg.cpp
+ConstFold.cpp
+ConstProp.cpp
+DCE.cpp
+CSE.cpp
+CFGSimplify.cpp
+PassManager.cpp
+DominatorTree.cpp
+LoopInfo.cpp
+修改方式：
+实现每个 pass 的核心逻辑，并在 PassManager 固化顺序和迭代策略。
+验收：优化前后语义一致，IR/ASM 回归测试通过。
+Lab5 寄存器分配与后端优化
+
+要做什么：从固定寄存器模板，升级到虚拟寄存器+真实分配+spill/reload，再做后端局部优化。
+主要改哪些文件：
+Lab5-寄存器分配.md
+MIR.h
+Lowering.cpp
+RegAlloc.cpp
+FrameLowering.cpp
+AsmPrinter.cpp
+Peephole.cpp
+PassManager.cpp
+修改方式：
+Lowering 先产出 vreg；RA 选图着色或线扫；处理调用约定和栈槽；最后做 peephole 与冗余访存清理。
+验收：全测试正确，且汇编明显减少无效 move/load/store。
+Lab6 并行与循环优化
+
+要做什么：识别循环结构并做循环优化，必要时尝试并行化识别。
+主要改哪些文件：
+Lab6-并行与循环优化.md
+DominatorTree.cpp
+LoopInfo.cpp
+PassManager.cpp
+CMakeLists.txt
+修改方式：
+补稳定的循环分析，再实现 LICM、强度削弱、展开、分裂中的一部分，并接入 pass 流程。
+验收：功能回归全通过，同时在代表性用例看到性能或代码质量收益。
+你可以直接照这个顺序推进
+
+先做 Lab2，优先把语义和 IR 生成功能面补全。
+再做 Lab3，保证语义到汇编端到端正确。
+接着做 Lab4，把优化 pass 跑通。
+然后做 Lab5，完成真实寄存器分配。
+最后做 Lab6，补循环优化和并行化探索。

scripts/run_verify_all.sh

@@ -1,60 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-ROOT=$(cd "$(dirname "$0")/.." && pwd)
-FUNC_DIR="$ROOT/test/test_case/functional"
-OUT_BASE="$ROOT/test/test_result/function/ir"
-LOG_DIR="$ROOT/test/test_result/function/ir_logs"
-VERIFY="$ROOT/scripts/verify_ir.sh"
-
-mkdir -p "$OUT_BASE"
-mkdir -p "$LOG_DIR"
-
-if [ ! -x "$VERIFY" ]; then
-  echo "verify script not executable, trying to run with bash: $VERIFY"
-fi
-
-files=("$FUNC_DIR"/*.sy)
-if [ ${#files[@]} -eq 0 ]; then
-  echo "No .sy files found in $FUNC_DIR" >&2
-  exit 1
-fi
-
-total=0
-pass=0
-fail=0
-failed_list=()
-
-for f in "${files[@]}"; do
-  ((total++))
-  name=$(basename "$f")
-  echo "=== Test: $name ==="
-  log="$LOG_DIR/${name%.sy}.log"
-  set +e
-  bash "$VERIFY" "$f" "$OUT_BASE" --run >"$log" 2>&1
-  rc=$?
-  set -e
-  if [ $rc -eq 0 ]; then
-    echo "PASS: $name"
-    ((pass++))
-  else
-    echo "FAIL: $name (log: $log)"
-    failed_list+=("$name")
-    ((fail++))
-  fi
-done
-
-echo
-echo "Summary: total=$total pass=$pass fail=$fail"
-if [ $fail -ne 0 ]; then
-  echo "Failed tests:"; for t in "${failed_list[@]}"; do echo " - $t"; done
-  echo "Tail of failure logs (last 200 lines each):"
-  for t in "${failed_list[@]}"; do
-    logfile="$LOG_DIR/${t%.sy}.log"
-    echo
-    echo "--- $t ---"
-    tail -n 200 "$logfile" || true
-  done
-fi
-
-exit $fail

scripts/verify_ir.sh

@@ -60,7 +60,7 @@ if [[ "$run_exec" == true ]]; then
   stdout_file="$out_dir/$stem.stdout"
   actual_file="$out_dir/$stem.actual.out"
   llc -filetype=obj "$out_file" -o "$obj"
-  clang "$obj" -o "$exe"
+  clang -no-pie "$obj" sylib/sylib.c -o "$exe" -lm
   echo "运行 $exe ..."
   set +e
   if [[ -f "$stdin_file" ]]; then
@@ -81,7 +81,7 @@ if [[ "$run_exec" == true ]]; then
   } > "$actual_file"
 
   if [[ -f "$expected_file" ]]; then
-    if diff -u "$expected_file" "$actual_file"; then
+    if diff -u <(sed -e 's/\r$//' -e '$a\\' "$expected_file") <(sed -e 's/\r$//' -e '$a\\' "$actual_file"); then
       echo "输出匹配: $expected_file"
     else
       echo "输出不匹配: $expected_file" >&2

src/antlr4/SysY.g4

@@ -1,11 +1,88 @@
+// SysY Lab1 语法：覆盖常见声明、控制流、数组、函数与表达式优先级。
+
 grammar SysY;
 
-// ======================
+/*===-------------------------------------------===*/
-// Parser Rules
+/* Lexer rules                                     */
-// ======================
+/*===-------------------------------------------===*/
+
+CONST: 'const';
+INT: 'int';
+FLOAT: 'float';
+VOID: 'void';
+IF: 'if';
+ELSE: 'else';
+WHILE: 'while';
+BREAK: 'break';
+CONTINUE: 'continue';
+RETURN: 'return';
+
+ASSIGN: '=';
+EQ: '==';
+NE: '!=';
+LT: '<';
+GT: '>';
+LE: '<=';
+GE: '>=';
+
+ADD: '+';
+SUB: '-';
+MUL: '*';
+DIV: '/';
+MOD: '%';
+NOT: '!';
+AND: '&&';
+OR: '||';
+
+LPAREN: '(';
+RPAREN: ')';
+LBRACK: '[';
+RBRACK: ']';
+LBRACE: '{';
+RBRACE: '}';
+COMMA: ',';
+SEMICOLON: ';';
+
+ID: [a-zA-Z_][a-zA-Z_0-9]*;
+
+FLITERAL
+    : DECIMAL_FLOAT
+    | HEX_FLOAT
+    ;
+
+ILITERAL
+    : HEX_INT
+    | OCT_INT
+    | DEC_INT
+    ;
+
+fragment DEC_INT: '0' | [1-9] [0-9]*;
+fragment OCT_INT: '0' [0-7]+;
+fragment HEX_INT: '0' [xX] [0-9a-fA-F]+;
+
+fragment DECIMAL_FLOAT
+    : [0-9]+ '.' [0-9]* EXP?
+    | '.' [0-9]+ EXP?
+    | [0-9]+ EXP
+    ;
+
+fragment HEX_FLOAT
+    : '0' [xX] [0-9a-fA-F]+ ('.' [0-9a-fA-F]*)? [pP] [+-]? [0-9]+
+    | '0' [xX] '.' [0-9a-fA-F]+ [pP] [+-]? [0-9]+
+    ;
+
+fragment EXP: [eE] [+-]? [0-9]+;
+
+WS: [ \t\r\n] -> skip;
+LINECOMMENT: '//' ~[\r\n]* -> skip;
+BLOCKCOMMENT: '/*' .*? '*/' -> skip;
+
+/*===-------------------------------------------===*/
+/* Syntax rules                                    */
+/*===-------------------------------------------===*/
 
 compUnit
-    : (decl | funcDef)+
+    : (decl | funcDef)+ EOF
     ;
 
 decl
@@ -14,57 +91,56 @@ decl
     ;
 
 constDecl
-    : 'const' bType constDef (',' constDef)* ';'
+    : CONST btype constDef (COMMA constDef)* SEMICOLON
-    ;
-
-bType
-    : 'int'
-    | 'float'
     ;
 
 constDef
-    : Ident ('[' constExp ']')* '=' constInitVal
+    : ID (LBRACK constExp RBRACK)* ASSIGN constInitValue
     ;
 
-constInitVal
+constInitValue
     : constExp
-    | '{' (constInitVal (',' constInitVal)*)? '}'
+    | LBRACE (constInitValue (COMMA constInitValue)*)? RBRACE
     ;
 
 varDecl
-    : bType varDef (',' varDef)* ';'
+    : btype varDef (COMMA varDef)* SEMICOLON
+    ;
+
+btype
+    : INT
+    | FLOAT
     ;
 
 varDef
-    : Ident ('[' constExp ']')*
+    : ID (LBRACK constExp RBRACK)* (ASSIGN initValue)?
-    | Ident ('[' constExp ']')* '=' initVal
     ;
 
-initVal
+initValue
     : exp
-    | '{' (initVal (',' initVal)*)? '}'
+    | LBRACE (initValue (COMMA initValue)*)? RBRACE
     ;
 
 funcDef
-    : funcType Ident '(' funcFParams? ')' block
+    : funcType ID LPAREN (funcFParams)? RPAREN blockStmt
     ;
 
 funcType
-    : 'void'
+    : INT
-    | 'int'
+    | FLOAT
-    | 'float'
+    | VOID
     ;
 
 funcFParams
-    : funcFParam (',' funcFParam)*
+    : funcFParam (COMMA funcFParam)*
     ;
 
 funcFParam
-    : bType Ident ('[' ']' ('[' exp ']')*)?
+    : btype ID (LBRACK RBRACK (LBRACK exp RBRACK)*)?
     ;
 
-block
+blockStmt
-    : '{' blockItem* '}'
+    : LBRACE blockItem* RBRACE
     ;
 
 blockItem
@@ -73,14 +149,18 @@ blockItem
     ;
 
 stmt
-    : lVal '=' exp ';'
+    : lValue ASSIGN exp SEMICOLON
-    | exp? ';'
+    | (exp)? SEMICOLON
-    | block
+    | blockStmt
-    | 'if' '(' cond ')' stmt ('else' stmt)?
+    | IF LPAREN cond RPAREN stmt (ELSE stmt)?
-    | 'while' '(' cond ')' stmt
+    | WHILE LPAREN cond RPAREN stmt
-    | 'break' ';'
+    | BREAK SEMICOLON
-    | 'continue' ';'
+    | CONTINUE SEMICOLON
-    | 'return' exp? ';'
+    | returnStmt
+    ;
+
+returnStmt
+    : RETURN (exp)? SEMICOLON
     ;
 
 exp
@@ -91,111 +171,67 @@ cond
     : lOrExp
     ;
 
-lVal
+lValue
-    : Ident ('[' exp ']')*
+    : ID (LBRACK exp RBRACK)*
     ;
 
 primaryExp
-    : '(' exp ')'
+    : LPAREN exp RPAREN
-    | lVal
+    | lValue
     | number
     ;
 
 number
-    : FloatConst
+    : ILITERAL
-    | IntConst
+    | FLITERAL
     ;
 
 unaryExp
     : primaryExp
-    | Ident '(' funcRParams? ')'
+    | ID LPAREN (funcRParams)? RPAREN
     | unaryOp unaryExp
     ;
 
 unaryOp
-    : '+'
+    : ADD
-    | '-'
+    | SUB
-    | '!'
+    | NOT
     ;
 
 funcRParams
-    : exp (',' exp)*
+    : exp (COMMA exp)*
     ;
 
 mulExp
-    : unaryExp (('*' | '/' | '%') unaryExp)*
+    : unaryExp
+    | mulExp (MUL | DIV | MOD) unaryExp
     ;
-
+    
 addExp
-    : mulExp (('+' | '-') mulExp)*
+    : mulExp
+    | addExp (ADD | SUB) mulExp
     ;
 
 relExp
-    : addExp (('<' | '>' | '<=' | '>=') addExp)*
+    : addExp
+    | relExp (LT | GT | LE | GE) addExp
     ;
 
 eqExp
-    : relExp (('==' | '!=') relExp)*
+    : relExp
+    | eqExp (EQ | NE) relExp
     ;
 
 lAndExp
-    : eqExp ('&&' eqExp)*
+    : eqExp
+    | lAndExp AND eqExp
     ;
 
 lOrExp
-    : lAndExp ('||' lAndExp)*
+    : lAndExp
+    | lOrExp OR lAndExp
     ;
 
 constExp
     : addExp
     ;
-
-// ======================
-// Lexer Rules
-// ======================
-
-fragment DIGIT : [0-9] ;
-fragment HEXDIGIT : [0-9a-fA-F] ;
-fragment EXP : [eE][+-]? DIGIT+ ;
-fragment PEXP : [pP][+-]? DIGIT+ ;
-
-// Float（含 hex float）
-FloatConst
-    : ('0x' | '0X')
-      (
-        HEXDIGIT+ '.' HEXDIGIT*
-      | '.' HEXDIGIT+
-      | HEXDIGIT+
-      )
-      PEXP
-    | '.' DIGIT+ EXP?
-    | DIGIT+ '.' DIGIT* EXP?
-    | DIGIT+ EXP
-    ;
-
-// Int（完整三种）
-IntConst
-    : '0'
-    | [1-9][0-9]*          // decimal
-    | '0'[0-7]+            // octal
-    | ('0x' | '0X')[0-9a-fA-F]+  // hex
-    ;
-
-// ---------- 标识符 ----------
-Ident
-    : [a-zA-Z_][a-zA-Z0-9_]*
-    ;
-
-// ---------- 空白 ----------
-WS
-    : [ \t\r\n]+ -> skip
-    ;
-
-// ---------- 注释 ----------
-LINE_COMMENT
-    : '//' ~[\r\n]* -> skip
-    ;
-
-BLOCK_COMMENT
-    : '/*' .*? '*/' -> skip
-    ;

src/antlr4/SysYBaseVisitor.cpp

@@ -0,0 +1,7 @@
+
+// Generated from SysY.g4 by ANTLR 4.7.2
+
+
+#include "SysYBaseVisitor.h"
+
+

src/antlr4/SysYBaseVisitor.h

@@ -0,0 +1,144 @@
+
+// Generated from SysY.g4 by ANTLR 4.7.2
+
+#pragma once
+
+
+#include "antlr4-runtime.h"
+#include "SysYVisitor.h"
+
+
+/**
+ * This class provides an empty implementation of SysYVisitor, which can be
+ * extended to create a visitor which only needs to handle a subset of the available methods.
+ */
+class  SysYBaseVisitor : public SysYVisitor {
+public:
+
+  virtual antlrcpp::Any visitCompUnit(SysYParser::CompUnitContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual antlrcpp::Any visitDecl(SysYParser::DeclContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual antlrcpp::Any visitConstDecl(SysYParser::ConstDeclContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual antlrcpp::Any visitBType(SysYParser::BTypeContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual antlrcpp::Any visitConstDef(SysYParser::ConstDefContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual antlrcpp::Any visitConstInitVal(SysYParser::ConstInitValContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual antlrcpp::Any visitVarDecl(SysYParser::VarDeclContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual antlrcpp::Any visitVarDef(SysYParser::VarDefContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual antlrcpp::Any visitInitVal(SysYParser::InitValContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual antlrcpp::Any visitFuncDef(SysYParser::FuncDefContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual antlrcpp::Any visitFuncType(SysYParser::FuncTypeContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual antlrcpp::Any visitFuncFParams(SysYParser::FuncFParamsContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual antlrcpp::Any visitFuncFParam(SysYParser::FuncFParamContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual antlrcpp::Any visitBlock(SysYParser::BlockContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual antlrcpp::Any visitBlockItem(SysYParser::BlockItemContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual antlrcpp::Any visitStmt(SysYParser::StmtContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual antlrcpp::Any visitExp(SysYParser::ExpContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual antlrcpp::Any visitCond(SysYParser::CondContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual antlrcpp::Any visitLVal(SysYParser::LValContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual antlrcpp::Any visitPrimaryExp(SysYParser::PrimaryExpContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual antlrcpp::Any visitNumber(SysYParser::NumberContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual antlrcpp::Any visitUnaryExp(SysYParser::UnaryExpContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual antlrcpp::Any visitUnaryOp(SysYParser::UnaryOpContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual antlrcpp::Any visitFuncRParams(SysYParser::FuncRParamsContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual antlrcpp::Any visitMulExp(SysYParser::MulExpContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual antlrcpp::Any visitAddExp(SysYParser::AddExpContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual antlrcpp::Any visitRelExp(SysYParser::RelExpContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual antlrcpp::Any visitEqExp(SysYParser::EqExpContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual antlrcpp::Any visitLAndExp(SysYParser::LAndExpContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual antlrcpp::Any visitLOrExp(SysYParser::LOrExpContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual antlrcpp::Any visitConstExp(SysYParser::ConstExpContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+
+};
+

src/antlr4/SysYLexer.cpp

@@ -0,0 +1,377 @@
+
+// Generated from SysY.g4 by ANTLR 4.7.2
+
+
+#include "SysYLexer.h"
+
+
+using namespace antlr4;
+
+
+SysYLexer::SysYLexer(CharStream *input) : Lexer(input) {
+  _interpreter = new atn::LexerATNSimulator(this, _atn, _decisionToDFA, _sharedContextCache);
+}
+
+SysYLexer::~SysYLexer() {
+  delete _interpreter;
+}
+
+std::string SysYLexer::getGrammarFileName() const {
+  return "SysY.g4";
+}
+
+const std::vector<std::string>& SysYLexer::getRuleNames() const {
+  return _ruleNames;
+}
+
+const std::vector<std::string>& SysYLexer::getChannelNames() const {
+  return _channelNames;
+}
+
+const std::vector<std::string>& SysYLexer::getModeNames() const {
+  return _modeNames;
+}
+
+const std::vector<std::string>& SysYLexer::getTokenNames() const {
+  return _tokenNames;
+}
+
+dfa::Vocabulary& SysYLexer::getVocabulary() const {
+  return _vocabulary;
+}
+
+const std::vector<uint16_t> SysYLexer::getSerializedATN() const {
+  return _serializedATN;
+}
+
+const atn::ATN& SysYLexer::getATN() const {
+  return _atn;
+}
+
+
+
+
+// Static vars and initialization.
+std::vector<dfa::DFA> SysYLexer::_decisionToDFA;
+atn::PredictionContextCache SysYLexer::_sharedContextCache;
+
+// We own the ATN which in turn owns the ATN states.
+atn::ATN SysYLexer::_atn;
+std::vector<uint16_t> SysYLexer::_serializedATN;
+
+std::vector<std::string> SysYLexer::_ruleNames = {
+  u8"T__0", u8"T__1", u8"T__2", u8"T__3", u8"T__4", u8"T__5", u8"T__6", 
+  u8"T__7", u8"T__8", u8"T__9", u8"T__10", u8"T__11", u8"T__12", u8"T__13", 
+  u8"T__14", u8"T__15", u8"T__16", u8"T__17", u8"T__18", u8"T__19", u8"T__20", 
+  u8"T__21", u8"T__22", u8"T__23", u8"T__24", u8"T__25", u8"T__26", u8"T__27", 
+  u8"T__28", u8"T__29", u8"T__30", u8"T__31", u8"T__32", u8"DIGIT", u8"HEXDIGIT", 
+  u8"EXP", u8"PEXP", u8"FloatConst", u8"IntConst", u8"Ident", u8"WS", u8"LINE_COMMENT", 
+  u8"BLOCK_COMMENT"
+};
+
+std::vector<std::string> SysYLexer::_channelNames = {
+  "DEFAULT_TOKEN_CHANNEL", "HIDDEN"
+};
+
+std::vector<std::string> SysYLexer::_modeNames = {
+  u8"DEFAULT_MODE"
+};
+
+std::vector<std::string> SysYLexer::_literalNames = {
+  "", u8"'const'", u8"','", u8"';'", u8"'int'", u8"'float'", u8"'['", u8"']'", 
+  u8"'='", u8"'{'", u8"'}'", u8"'('", u8"')'", u8"'void'", u8"'if'", u8"'else'", 
+  u8"'while'", u8"'break'", u8"'continue'", u8"'return'", u8"'+'", u8"'-'", 
+  u8"'!'", u8"'*'", u8"'/'", u8"'%'", u8"'<'", u8"'>'", u8"'<='", u8"'>='", 
+  u8"'=='", u8"'!='", u8"'&&'", u8"'||'"
+};
+
+std::vector<std::string> SysYLexer::_symbolicNames = {
+  "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
+  "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", u8"FloatConst", 
+  u8"IntConst", u8"Ident", u8"WS", u8"LINE_COMMENT", u8"BLOCK_COMMENT"
+};
+
+dfa::Vocabulary SysYLexer::_vocabulary(_literalNames, _symbolicNames);
+
+std::vector<std::string> SysYLexer::_tokenNames;
+
+SysYLexer::Initializer::Initializer() {
+  // This code could be in a static initializer lambda, but VS doesn't allow access to private class members from there.
+	for (size_t i = 0; i < _symbolicNames.size(); ++i) {
+		std::string name = _vocabulary.getLiteralName(i);
+		if (name.empty()) {
+			name = _vocabulary.getSymbolicName(i);
+		}
+
+		if (name.empty()) {
+			_tokenNames.push_back("<INVALID>");
+		} else {
+      _tokenNames.push_back(name);
+    }
+	}
+
+  _serializedATN = {
+    0x3, 0x608b, 0xa72a, 0x8133, 0xb9ed, 0x417c, 0x3be7, 0x7786, 0x5964, 
+    0x2, 0x29, 0x160, 0x8, 0x1, 0x4, 0x2, 0x9, 0x2, 0x4, 0x3, 0x9, 0x3, 
+    0x4, 0x4, 0x9, 0x4, 0x4, 0x5, 0x9, 0x5, 0x4, 0x6, 0x9, 0x6, 0x4, 0x7, 
+    0x9, 0x7, 0x4, 0x8, 0x9, 0x8, 0x4, 0x9, 0x9, 0x9, 0x4, 0xa, 0x9, 0xa, 
+    0x4, 0xb, 0x9, 0xb, 0x4, 0xc, 0x9, 0xc, 0x4, 0xd, 0x9, 0xd, 0x4, 0xe, 
+    0x9, 0xe, 0x4, 0xf, 0x9, 0xf, 0x4, 0x10, 0x9, 0x10, 0x4, 0x11, 0x9, 
+    0x11, 0x4, 0x12, 0x9, 0x12, 0x4, 0x13, 0x9, 0x13, 0x4, 0x14, 0x9, 0x14, 
+    0x4, 0x15, 0x9, 0x15, 0x4, 0x16, 0x9, 0x16, 0x4, 0x17, 0x9, 0x17, 0x4, 
+    0x18, 0x9, 0x18, 0x4, 0x19, 0x9, 0x19, 0x4, 0x1a, 0x9, 0x1a, 0x4, 0x1b, 
+    0x9, 0x1b, 0x4, 0x1c, 0x9, 0x1c, 0x4, 0x1d, 0x9, 0x1d, 0x4, 0x1e, 0x9, 
+    0x1e, 0x4, 0x1f, 0x9, 0x1f, 0x4, 0x20, 0x9, 0x20, 0x4, 0x21, 0x9, 0x21, 
+    0x4, 0x22, 0x9, 0x22, 0x4, 0x23, 0x9, 0x23, 0x4, 0x24, 0x9, 0x24, 0x4, 
+    0x25, 0x9, 0x25, 0x4, 0x26, 0x9, 0x26, 0x4, 0x27, 0x9, 0x27, 0x4, 0x28, 
+    0x9, 0x28, 0x4, 0x29, 0x9, 0x29, 0x4, 0x2a, 0x9, 0x2a, 0x4, 0x2b, 0x9, 
+    0x2b, 0x4, 0x2c, 0x9, 0x2c, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 
+    0x3, 0x2, 0x3, 0x2, 0x3, 0x3, 0x3, 0x3, 0x3, 0x4, 0x3, 0x4, 0x3, 0x5, 
+    0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x3, 0x6, 0x3, 0x6, 0x3, 0x6, 0x3, 0x6, 
+    0x3, 0x6, 0x3, 0x6, 0x3, 0x7, 0x3, 0x7, 0x3, 0x8, 0x3, 0x8, 0x3, 0x9, 
+    0x3, 0x9, 0x3, 0xa, 0x3, 0xa, 0x3, 0xb, 0x3, 0xb, 0x3, 0xc, 0x3, 0xc, 
+    0x3, 0xd, 0x3, 0xd, 0x3, 0xe, 0x3, 0xe, 0x3, 0xe, 0x3, 0xe, 0x3, 0xe, 
+    0x3, 0xf, 0x3, 0xf, 0x3, 0xf, 0x3, 0x10, 0x3, 0x10, 0x3, 0x10, 0x3, 
+    0x10, 0x3, 0x10, 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 
+    0x3, 0x11, 0x3, 0x12, 0x3, 0x12, 0x3, 0x12, 0x3, 0x12, 0x3, 0x12, 0x3, 
+    0x12, 0x3, 0x13, 0x3, 0x13, 0x3, 0x13, 0x3, 0x13, 0x3, 0x13, 0x3, 0x13, 
+    0x3, 0x13, 0x3, 0x13, 0x3, 0x13, 0x3, 0x14, 0x3, 0x14, 0x3, 0x14, 0x3, 
+    0x14, 0x3, 0x14, 0x3, 0x14, 0x3, 0x14, 0x3, 0x15, 0x3, 0x15, 0x3, 0x16, 
+    0x3, 0x16, 0x3, 0x17, 0x3, 0x17, 0x3, 0x18, 0x3, 0x18, 0x3, 0x19, 0x3, 
+    0x19, 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1b, 0x3, 0x1b, 0x3, 0x1c, 0x3, 0x1c, 
+    0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1e, 0x3, 0x1e, 0x3, 0x1e, 0x3, 
+    0x1f, 0x3, 0x1f, 0x3, 0x1f, 0x3, 0x20, 0x3, 0x20, 0x3, 0x20, 0x3, 0x21, 
+    0x3, 0x21, 0x3, 0x21, 0x3, 0x22, 0x3, 0x22, 0x3, 0x22, 0x3, 0x23, 0x3, 
+    0x23, 0x3, 0x24, 0x3, 0x24, 0x3, 0x25, 0x3, 0x25, 0x5, 0x25, 0xcd, 0xa, 
+    0x25, 0x3, 0x25, 0x6, 0x25, 0xd0, 0xa, 0x25, 0xd, 0x25, 0xe, 0x25, 0xd1, 
+    0x3, 0x26, 0x3, 0x26, 0x5, 0x26, 0xd6, 0xa, 0x26, 0x3, 0x26, 0x6, 0x26, 
+    0xd9, 0xa, 0x26, 0xd, 0x26, 0xe, 0x26, 0xda, 0x3, 0x27, 0x3, 0x27, 0x3, 
+    0x27, 0x3, 0x27, 0x5, 0x27, 0xe1, 0xa, 0x27, 0x3, 0x27, 0x6, 0x27, 0xe4, 
+    0xa, 0x27, 0xd, 0x27, 0xe, 0x27, 0xe5, 0x3, 0x27, 0x3, 0x27, 0x7, 0x27, 
+    0xea, 0xa, 0x27, 0xc, 0x27, 0xe, 0x27, 0xed, 0xb, 0x27, 0x3, 0x27, 0x3, 
+    0x27, 0x6, 0x27, 0xf1, 0xa, 0x27, 0xd, 0x27, 0xe, 0x27, 0xf2, 0x3, 0x27, 
+    0x6, 0x27, 0xf6, 0xa, 0x27, 0xd, 0x27, 0xe, 0x27, 0xf7, 0x5, 0x27, 0xfa, 
+    0xa, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x6, 0x27, 0x100, 
+    0xa, 0x27, 0xd, 0x27, 0xe, 0x27, 0x101, 0x3, 0x27, 0x5, 0x27, 0x105, 
+    0xa, 0x27, 0x3, 0x27, 0x6, 0x27, 0x108, 0xa, 0x27, 0xd, 0x27, 0xe, 0x27, 
+    0x109, 0x3, 0x27, 0x3, 0x27, 0x7, 0x27, 0x10e, 0xa, 0x27, 0xc, 0x27, 
+    0xe, 0x27, 0x111, 0xb, 0x27, 0x3, 0x27, 0x5, 0x27, 0x114, 0xa, 0x27, 
+    0x3, 0x27, 0x6, 0x27, 0x117, 0xa, 0x27, 0xd, 0x27, 0xe, 0x27, 0x118, 
+    0x3, 0x27, 0x3, 0x27, 0x5, 0x27, 0x11d, 0xa, 0x27, 0x3, 0x28, 0x3, 0x28, 
+    0x3, 0x28, 0x7, 0x28, 0x122, 0xa, 0x28, 0xc, 0x28, 0xe, 0x28, 0x125, 
+    0xb, 0x28, 0x3, 0x28, 0x3, 0x28, 0x6, 0x28, 0x129, 0xa, 0x28, 0xd, 0x28, 
+    0xe, 0x28, 0x12a, 0x3, 0x28, 0x3, 0x28, 0x3, 0x28, 0x3, 0x28, 0x5, 0x28, 
+    0x131, 0xa, 0x28, 0x3, 0x28, 0x6, 0x28, 0x134, 0xa, 0x28, 0xd, 0x28, 
+    0xe, 0x28, 0x135, 0x5, 0x28, 0x138, 0xa, 0x28, 0x3, 0x29, 0x3, 0x29, 
+    0x7, 0x29, 0x13c, 0xa, 0x29, 0xc, 0x29, 0xe, 0x29, 0x13f, 0xb, 0x29, 
+    0x3, 0x2a, 0x6, 0x2a, 0x142, 0xa, 0x2a, 0xd, 0x2a, 0xe, 0x2a, 0x143, 
+    0x3, 0x2a, 0x3, 0x2a, 0x3, 0x2b, 0x3, 0x2b, 0x3, 0x2b, 0x3, 0x2b, 0x7, 
+    0x2b, 0x14c, 0xa, 0x2b, 0xc, 0x2b, 0xe, 0x2b, 0x14f, 0xb, 0x2b, 0x3, 
+    0x2b, 0x3, 0x2b, 0x3, 0x2c, 0x3, 0x2c, 0x3, 0x2c, 0x3, 0x2c, 0x7, 0x2c, 
+    0x157, 0xa, 0x2c, 0xc, 0x2c, 0xe, 0x2c, 0x15a, 0xb, 0x2c, 0x3, 0x2c, 
+    0x3, 0x2c, 0x3, 0x2c, 0x3, 0x2c, 0x3, 0x2c, 0x3, 0x158, 0x2, 0x2d, 0x3, 
+    0x3, 0x5, 0x4, 0x7, 0x5, 0x9, 0x6, 0xb, 0x7, 0xd, 0x8, 0xf, 0x9, 0x11, 
+    0xa, 0x13, 0xb, 0x15, 0xc, 0x17, 0xd, 0x19, 0xe, 0x1b, 0xf, 0x1d, 0x10, 
+    0x1f, 0x11, 0x21, 0x12, 0x23, 0x13, 0x25, 0x14, 0x27, 0x15, 0x29, 0x16, 
+    0x2b, 0x17, 0x2d, 0x18, 0x2f, 0x19, 0x31, 0x1a, 0x33, 0x1b, 0x35, 0x1c, 
+    0x37, 0x1d, 0x39, 0x1e, 0x3b, 0x1f, 0x3d, 0x20, 0x3f, 0x21, 0x41, 0x22, 
+    0x43, 0x23, 0x45, 0x2, 0x47, 0x2, 0x49, 0x2, 0x4b, 0x2, 0x4d, 0x24, 
+    0x4f, 0x25, 0x51, 0x26, 0x53, 0x27, 0x55, 0x28, 0x57, 0x29, 0x3, 0x2, 
+    0xd, 0x3, 0x2, 0x32, 0x3b, 0x5, 0x2, 0x32, 0x3b, 0x43, 0x48, 0x63, 0x68, 
+    0x4, 0x2, 0x47, 0x47, 0x67, 0x67, 0x4, 0x2, 0x2d, 0x2d, 0x2f, 0x2f, 
+    0x4, 0x2, 0x52, 0x52, 0x72, 0x72, 0x3, 0x2, 0x33, 0x3b, 0x3, 0x2, 0x32, 
+    0x39, 0x5, 0x2, 0x43, 0x5c, 0x61, 0x61, 0x63, 0x7c, 0x6, 0x2, 0x32, 
+    0x3b, 0x43, 0x5c, 0x61, 0x61, 0x63, 0x7c, 0x5, 0x2, 0xb, 0xc, 0xf, 0xf, 
+    0x22, 0x22, 0x4, 0x2, 0xc, 0xc, 0xf, 0xf, 0x2, 0x17a, 0x2, 0x3, 0x3, 
+    0x2, 0x2, 0x2, 0x2, 0x5, 0x3, 0x2, 0x2, 0x2, 0x2, 0x7, 0x3, 0x2, 0x2, 
+    0x2, 0x2, 0x9, 0x3, 0x2, 0x2, 0x2, 0x2, 0xb, 0x3, 0x2, 0x2, 0x2, 0x2, 
+    0xd, 0x3, 0x2, 0x2, 0x2, 0x2, 0xf, 0x3, 0x2, 0x2, 0x2, 0x2, 0x11, 0x3, 
+    0x2, 0x2, 0x2, 0x2, 0x13, 0x3, 0x2, 0x2, 0x2, 0x2, 0x15, 0x3, 0x2, 0x2, 
+    0x2, 0x2, 0x17, 0x3, 0x2, 0x2, 0x2, 0x2, 0x19, 0x3, 0x2, 0x2, 0x2, 0x2, 
+    0x1b, 0x3, 0x2, 0x2, 0x2, 0x2, 0x1d, 0x3, 0x2, 0x2, 0x2, 0x2, 0x1f, 
+    0x3, 0x2, 0x2, 0x2, 0x2, 0x21, 0x3, 0x2, 0x2, 0x2, 0x2, 0x23, 0x3, 0x2, 
+    0x2, 0x2, 0x2, 0x25, 0x3, 0x2, 0x2, 0x2, 0x2, 0x27, 0x3, 0x2, 0x2, 0x2, 
+    0x2, 0x29, 0x3, 0x2, 0x2, 0x2, 0x2, 0x2b, 0x3, 0x2, 0x2, 0x2, 0x2, 0x2d, 
+    0x3, 0x2, 0x2, 0x2, 0x2, 0x2f, 0x3, 0x2, 0x2, 0x2, 0x2, 0x31, 0x3, 0x2, 
+    0x2, 0x2, 0x2, 0x33, 0x3, 0x2, 0x2, 0x2, 0x2, 0x35, 0x3, 0x2, 0x2, 0x2, 
+    0x2, 0x37, 0x3, 0x2, 0x2, 0x2, 0x2, 0x39, 0x3, 0x2, 0x2, 0x2, 0x2, 0x3b, 
+    0x3, 0x2, 0x2, 0x2, 0x2, 0x3d, 0x3, 0x2, 0x2, 0x2, 0x2, 0x3f, 0x3, 0x2, 
+    0x2, 0x2, 0x2, 0x41, 0x3, 0x2, 0x2, 0x2, 0x2, 0x43, 0x3, 0x2, 0x2, 0x2, 
+    0x2, 0x4d, 0x3, 0x2, 0x2, 0x2, 0x2, 0x4f, 0x3, 0x2, 0x2, 0x2, 0x2, 0x51, 
+    0x3, 0x2, 0x2, 0x2, 0x2, 0x53, 0x3, 0x2, 0x2, 0x2, 0x2, 0x55, 0x3, 0x2, 
+    0x2, 0x2, 0x2, 0x57, 0x3, 0x2, 0x2, 0x2, 0x3, 0x59, 0x3, 0x2, 0x2, 0x2, 
+    0x5, 0x5f, 0x3, 0x2, 0x2, 0x2, 0x7, 0x61, 0x3, 0x2, 0x2, 0x2, 0x9, 0x63, 
+    0x3, 0x2, 0x2, 0x2, 0xb, 0x67, 0x3, 0x2, 0x2, 0x2, 0xd, 0x6d, 0x3, 0x2, 
+    0x2, 0x2, 0xf, 0x6f, 0x3, 0x2, 0x2, 0x2, 0x11, 0x71, 0x3, 0x2, 0x2, 
+    0x2, 0x13, 0x73, 0x3, 0x2, 0x2, 0x2, 0x15, 0x75, 0x3, 0x2, 0x2, 0x2, 
+    0x17, 0x77, 0x3, 0x2, 0x2, 0x2, 0x19, 0x79, 0x3, 0x2, 0x2, 0x2, 0x1b, 
+    0x7b, 0x3, 0x2, 0x2, 0x2, 0x1d, 0x80, 0x3, 0x2, 0x2, 0x2, 0x1f, 0x83, 
+    0x3, 0x2, 0x2, 0x2, 0x21, 0x88, 0x3, 0x2, 0x2, 0x2, 0x23, 0x8e, 0x3, 
+    0x2, 0x2, 0x2, 0x25, 0x94, 0x3, 0x2, 0x2, 0x2, 0x27, 0x9d, 0x3, 0x2, 
+    0x2, 0x2, 0x29, 0xa4, 0x3, 0x2, 0x2, 0x2, 0x2b, 0xa6, 0x3, 0x2, 0x2, 
+    0x2, 0x2d, 0xa8, 0x3, 0x2, 0x2, 0x2, 0x2f, 0xaa, 0x3, 0x2, 0x2, 0x2, 
+    0x31, 0xac, 0x3, 0x2, 0x2, 0x2, 0x33, 0xae, 0x3, 0x2, 0x2, 0x2, 0x35, 
+    0xb0, 0x3, 0x2, 0x2, 0x2, 0x37, 0xb2, 0x3, 0x2, 0x2, 0x2, 0x39, 0xb4, 
+    0x3, 0x2, 0x2, 0x2, 0x3b, 0xb7, 0x3, 0x2, 0x2, 0x2, 0x3d, 0xba, 0x3, 
+    0x2, 0x2, 0x2, 0x3f, 0xbd, 0x3, 0x2, 0x2, 0x2, 0x41, 0xc0, 0x3, 0x2, 
+    0x2, 0x2, 0x43, 0xc3, 0x3, 0x2, 0x2, 0x2, 0x45, 0xc6, 0x3, 0x2, 0x2, 
+    0x2, 0x47, 0xc8, 0x3, 0x2, 0x2, 0x2, 0x49, 0xca, 0x3, 0x2, 0x2, 0x2, 
+    0x4b, 0xd3, 0x3, 0x2, 0x2, 0x2, 0x4d, 0x11c, 0x3, 0x2, 0x2, 0x2, 0x4f, 
+    0x137, 0x3, 0x2, 0x2, 0x2, 0x51, 0x139, 0x3, 0x2, 0x2, 0x2, 0x53, 0x141, 
+    0x3, 0x2, 0x2, 0x2, 0x55, 0x147, 0x3, 0x2, 0x2, 0x2, 0x57, 0x152, 0x3, 
+    0x2, 0x2, 0x2, 0x59, 0x5a, 0x7, 0x65, 0x2, 0x2, 0x5a, 0x5b, 0x7, 0x71, 
+    0x2, 0x2, 0x5b, 0x5c, 0x7, 0x70, 0x2, 0x2, 0x5c, 0x5d, 0x7, 0x75, 0x2, 
+    0x2, 0x5d, 0x5e, 0x7, 0x76, 0x2, 0x2, 0x5e, 0x4, 0x3, 0x2, 0x2, 0x2, 
+    0x5f, 0x60, 0x7, 0x2e, 0x2, 0x2, 0x60, 0x6, 0x3, 0x2, 0x2, 0x2, 0x61, 
+    0x62, 0x7, 0x3d, 0x2, 0x2, 0x62, 0x8, 0x3, 0x2, 0x2, 0x2, 0x63, 0x64, 
+    0x7, 0x6b, 0x2, 0x2, 0x64, 0x65, 0x7, 0x70, 0x2, 0x2, 0x65, 0x66, 0x7, 
+    0x76, 0x2, 0x2, 0x66, 0xa, 0x3, 0x2, 0x2, 0x2, 0x67, 0x68, 0x7, 0x68, 
+    0x2, 0x2, 0x68, 0x69, 0x7, 0x6e, 0x2, 0x2, 0x69, 0x6a, 0x7, 0x71, 0x2, 
+    0x2, 0x6a, 0x6b, 0x7, 0x63, 0x2, 0x2, 0x6b, 0x6c, 0x7, 0x76, 0x2, 0x2, 
+    0x6c, 0xc, 0x3, 0x2, 0x2, 0x2, 0x6d, 0x6e, 0x7, 0x5d, 0x2, 0x2, 0x6e, 
+    0xe, 0x3, 0x2, 0x2, 0x2, 0x6f, 0x70, 0x7, 0x5f, 0x2, 0x2, 0x70, 0x10, 
+    0x3, 0x2, 0x2, 0x2, 0x71, 0x72, 0x7, 0x3f, 0x2, 0x2, 0x72, 0x12, 0x3, 
+    0x2, 0x2, 0x2, 0x73, 0x74, 0x7, 0x7d, 0x2, 0x2, 0x74, 0x14, 0x3, 0x2, 
+    0x2, 0x2, 0x75, 0x76, 0x7, 0x7f, 0x2, 0x2, 0x76, 0x16, 0x3, 0x2, 0x2, 
+    0x2, 0x77, 0x78, 0x7, 0x2a, 0x2, 0x2, 0x78, 0x18, 0x3, 0x2, 0x2, 0x2, 
+    0x79, 0x7a, 0x7, 0x2b, 0x2, 0x2, 0x7a, 0x1a, 0x3, 0x2, 0x2, 0x2, 0x7b, 
+    0x7c, 0x7, 0x78, 0x2, 0x2, 0x7c, 0x7d, 0x7, 0x71, 0x2, 0x2, 0x7d, 0x7e, 
+    0x7, 0x6b, 0x2, 0x2, 0x7e, 0x7f, 0x7, 0x66, 0x2, 0x2, 0x7f, 0x1c, 0x3, 
+    0x2, 0x2, 0x2, 0x80, 0x81, 0x7, 0x6b, 0x2, 0x2, 0x81, 0x82, 0x7, 0x68, 
+    0x2, 0x2, 0x82, 0x1e, 0x3, 0x2, 0x2, 0x2, 0x83, 0x84, 0x7, 0x67, 0x2, 
+    0x2, 0x84, 0x85, 0x7, 0x6e, 0x2, 0x2, 0x85, 0x86, 0x7, 0x75, 0x2, 0x2, 
+    0x86, 0x87, 0x7, 0x67, 0x2, 0x2, 0x87, 0x20, 0x3, 0x2, 0x2, 0x2, 0x88, 
+    0x89, 0x7, 0x79, 0x2, 0x2, 0x89, 0x8a, 0x7, 0x6a, 0x2, 0x2, 0x8a, 0x8b, 
+    0x7, 0x6b, 0x2, 0x2, 0x8b, 0x8c, 0x7, 0x6e, 0x2, 0x2, 0x8c, 0x8d, 0x7, 
+    0x67, 0x2, 0x2, 0x8d, 0x22, 0x3, 0x2, 0x2, 0x2, 0x8e, 0x8f, 0x7, 0x64, 
+    0x2, 0x2, 0x8f, 0x90, 0x7, 0x74, 0x2, 0x2, 0x90, 0x91, 0x7, 0x67, 0x2, 
+    0x2, 0x91, 0x92, 0x7, 0x63, 0x2, 0x2, 0x92, 0x93, 0x7, 0x6d, 0x2, 0x2, 
+    0x93, 0x24, 0x3, 0x2, 0x2, 0x2, 0x94, 0x95, 0x7, 0x65, 0x2, 0x2, 0x95, 
+    0x96, 0x7, 0x71, 0x2, 0x2, 0x96, 0x97, 0x7, 0x70, 0x2, 0x2, 0x97, 0x98, 
+    0x7, 0x76, 0x2, 0x2, 0x98, 0x99, 0x7, 0x6b, 0x2, 0x2, 0x99, 0x9a, 0x7, 
+    0x70, 0x2, 0x2, 0x9a, 0x9b, 0x7, 0x77, 0x2, 0x2, 0x9b, 0x9c, 0x7, 0x67, 
+    0x2, 0x2, 0x9c, 0x26, 0x3, 0x2, 0x2, 0x2, 0x9d, 0x9e, 0x7, 0x74, 0x2, 
+    0x2, 0x9e, 0x9f, 0x7, 0x67, 0x2, 0x2, 0x9f, 0xa0, 0x7, 0x76, 0x2, 0x2, 
+    0xa0, 0xa1, 0x7, 0x77, 0x2, 0x2, 0xa1, 0xa2, 0x7, 0x74, 0x2, 0x2, 0xa2, 
+    0xa3, 0x7, 0x70, 0x2, 0x2, 0xa3, 0x28, 0x3, 0x2, 0x2, 0x2, 0xa4, 0xa5, 
+    0x7, 0x2d, 0x2, 0x2, 0xa5, 0x2a, 0x3, 0x2, 0x2, 0x2, 0xa6, 0xa7, 0x7, 
+    0x2f, 0x2, 0x2, 0xa7, 0x2c, 0x3, 0x2, 0x2, 0x2, 0xa8, 0xa9, 0x7, 0x23, 
+    0x2, 0x2, 0xa9, 0x2e, 0x3, 0x2, 0x2, 0x2, 0xaa, 0xab, 0x7, 0x2c, 0x2, 
+    0x2, 0xab, 0x30, 0x3, 0x2, 0x2, 0x2, 0xac, 0xad, 0x7, 0x31, 0x2, 0x2, 
+    0xad, 0x32, 0x3, 0x2, 0x2, 0x2, 0xae, 0xaf, 0x7, 0x27, 0x2, 0x2, 0xaf, 
+    0x34, 0x3, 0x2, 0x2, 0x2, 0xb0, 0xb1, 0x7, 0x3e, 0x2, 0x2, 0xb1, 0x36, 
+    0x3, 0x2, 0x2, 0x2, 0xb2, 0xb3, 0x7, 0x40, 0x2, 0x2, 0xb3, 0x38, 0x3, 
+    0x2, 0x2, 0x2, 0xb4, 0xb5, 0x7, 0x3e, 0x2, 0x2, 0xb5, 0xb6, 0x7, 0x3f, 
+    0x2, 0x2, 0xb6, 0x3a, 0x3, 0x2, 0x2, 0x2, 0xb7, 0xb8, 0x7, 0x40, 0x2, 
+    0x2, 0xb8, 0xb9, 0x7, 0x3f, 0x2, 0x2, 0xb9, 0x3c, 0x3, 0x2, 0x2, 0x2, 
+    0xba, 0xbb, 0x7, 0x3f, 0x2, 0x2, 0xbb, 0xbc, 0x7, 0x3f, 0x2, 0x2, 0xbc, 
+    0x3e, 0x3, 0x2, 0x2, 0x2, 0xbd, 0xbe, 0x7, 0x23, 0x2, 0x2, 0xbe, 0xbf, 
+    0x7, 0x3f, 0x2, 0x2, 0xbf, 0x40, 0x3, 0x2, 0x2, 0x2, 0xc0, 0xc1, 0x7, 
+    0x28, 0x2, 0x2, 0xc1, 0xc2, 0x7, 0x28, 0x2, 0x2, 0xc2, 0x42, 0x3, 0x2, 
+    0x2, 0x2, 0xc3, 0xc4, 0x7, 0x7e, 0x2, 0x2, 0xc4, 0xc5, 0x7, 0x7e, 0x2, 
+    0x2, 0xc5, 0x44, 0x3, 0x2, 0x2, 0x2, 0xc6, 0xc7, 0x9, 0x2, 0x2, 0x2, 
+    0xc7, 0x46, 0x3, 0x2, 0x2, 0x2, 0xc8, 0xc9, 0x9, 0x3, 0x2, 0x2, 0xc9, 
+    0x48, 0x3, 0x2, 0x2, 0x2, 0xca, 0xcc, 0x9, 0x4, 0x2, 0x2, 0xcb, 0xcd, 
+    0x9, 0x5, 0x2, 0x2, 0xcc, 0xcb, 0x3, 0x2, 0x2, 0x2, 0xcc, 0xcd, 0x3, 
+    0x2, 0x2, 0x2, 0xcd, 0xcf, 0x3, 0x2, 0x2, 0x2, 0xce, 0xd0, 0x5, 0x45, 
+    0x23, 0x2, 0xcf, 0xce, 0x3, 0x2, 0x2, 0x2, 0xd0, 0xd1, 0x3, 0x2, 0x2, 
+    0x2, 0xd1, 0xcf, 0x3, 0x2, 0x2, 0x2, 0xd1, 0xd2, 0x3, 0x2, 0x2, 0x2, 
+    0xd2, 0x4a, 0x3, 0x2, 0x2, 0x2, 0xd3, 0xd5, 0x9, 0x6, 0x2, 0x2, 0xd4, 
+    0xd6, 0x9, 0x5, 0x2, 0x2, 0xd5, 0xd4, 0x3, 0x2, 0x2, 0x2, 0xd5, 0xd6, 
+    0x3, 0x2, 0x2, 0x2, 0xd6, 0xd8, 0x3, 0x2, 0x2, 0x2, 0xd7, 0xd9, 0x5, 
+    0x45, 0x23, 0x2, 0xd8, 0xd7, 0x3, 0x2, 0x2, 0x2, 0xd9, 0xda, 0x3, 0x2, 
+    0x2, 0x2, 0xda, 0xd8, 0x3, 0x2, 0x2, 0x2, 0xda, 0xdb, 0x3, 0x2, 0x2, 
+    0x2, 0xdb, 0x4c, 0x3, 0x2, 0x2, 0x2, 0xdc, 0xdd, 0x7, 0x32, 0x2, 0x2, 
+    0xdd, 0xe1, 0x7, 0x7a, 0x2, 0x2, 0xde, 0xdf, 0x7, 0x32, 0x2, 0x2, 0xdf, 
+    0xe1, 0x7, 0x5a, 0x2, 0x2, 0xe0, 0xdc, 0x3, 0x2, 0x2, 0x2, 0xe0, 0xde, 
+    0x3, 0x2, 0x2, 0x2, 0xe1, 0xf9, 0x3, 0x2, 0x2, 0x2, 0xe2, 0xe4, 0x5, 
+    0x47, 0x24, 0x2, 0xe3, 0xe2, 0x3, 0x2, 0x2, 0x2, 0xe4, 0xe5, 0x3, 0x2, 
+    0x2, 0x2, 0xe5, 0xe3, 0x3, 0x2, 0x2, 0x2, 0xe5, 0xe6, 0x3, 0x2, 0x2, 
+    0x2, 0xe6, 0xe7, 0x3, 0x2, 0x2, 0x2, 0xe7, 0xeb, 0x7, 0x30, 0x2, 0x2, 
+    0xe8, 0xea, 0x5, 0x47, 0x24, 0x2, 0xe9, 0xe8, 0x3, 0x2, 0x2, 0x2, 0xea, 
+    0xed, 0x3, 0x2, 0x2, 0x2, 0xeb, 0xe9, 0x3, 0x2, 0x2, 0x2, 0xeb, 0xec, 
+    0x3, 0x2, 0x2, 0x2, 0xec, 0xfa, 0x3, 0x2, 0x2, 0x2, 0xed, 0xeb, 0x3, 
+    0x2, 0x2, 0x2, 0xee, 0xf0, 0x7, 0x30, 0x2, 0x2, 0xef, 0xf1, 0x5, 0x47, 
+    0x24, 0x2, 0xf0, 0xef, 0x3, 0x2, 0x2, 0x2, 0xf1, 0xf2, 0x3, 0x2, 0x2, 
+    0x2, 0xf2, 0xf0, 0x3, 0x2, 0x2, 0x2, 0xf2, 0xf3, 0x3, 0x2, 0x2, 0x2, 
+    0xf3, 0xfa, 0x3, 0x2, 0x2, 0x2, 0xf4, 0xf6, 0x5, 0x47, 0x24, 0x2, 0xf5, 
+    0xf4, 0x3, 0x2, 0x2, 0x2, 0xf6, 0xf7, 0x3, 0x2, 0x2, 0x2, 0xf7, 0xf5, 
+    0x3, 0x2, 0x2, 0x2, 0xf7, 0xf8, 0x3, 0x2, 0x2, 0x2, 0xf8, 0xfa, 0x3, 
+    0x2, 0x2, 0x2, 0xf9, 0xe3, 0x3, 0x2, 0x2, 0x2, 0xf9, 0xee, 0x3, 0x2, 
+    0x2, 0x2, 0xf9, 0xf5, 0x3, 0x2, 0x2, 0x2, 0xfa, 0xfb, 0x3, 0x2, 0x2, 
+    0x2, 0xfb, 0xfc, 0x5, 0x4b, 0x26, 0x2, 0xfc, 0x11d, 0x3, 0x2, 0x2, 0x2, 
+    0xfd, 0xff, 0x7, 0x30, 0x2, 0x2, 0xfe, 0x100, 0x5, 0x45, 0x23, 0x2, 
+    0xff, 0xfe, 0x3, 0x2, 0x2, 0x2, 0x100, 0x101, 0x3, 0x2, 0x2, 0x2, 0x101, 
+    0xff, 0x3, 0x2, 0x2, 0x2, 0x101, 0x102, 0x3, 0x2, 0x2, 0x2, 0x102, 0x104, 
+    0x3, 0x2, 0x2, 0x2, 0x103, 0x105, 0x5, 0x49, 0x25, 0x2, 0x104, 0x103, 
+    0x3, 0x2, 0x2, 0x2, 0x104, 0x105, 0x3, 0x2, 0x2, 0x2, 0x105, 0x11d, 
+    0x3, 0x2, 0x2, 0x2, 0x106, 0x108, 0x5, 0x45, 0x23, 0x2, 0x107, 0x106, 
+    0x3, 0x2, 0x2, 0x2, 0x108, 0x109, 0x3, 0x2, 0x2, 0x2, 0x109, 0x107, 
+    0x3, 0x2, 0x2, 0x2, 0x109, 0x10a, 0x3, 0x2, 0x2, 0x2, 0x10a, 0x10b, 
+    0x3, 0x2, 0x2, 0x2, 0x10b, 0x10f, 0x7, 0x30, 0x2, 0x2, 0x10c, 0x10e, 
+    0x5, 0x45, 0x23, 0x2, 0x10d, 0x10c, 0x3, 0x2, 0x2, 0x2, 0x10e, 0x111, 
+    0x3, 0x2, 0x2, 0x2, 0x10f, 0x10d, 0x3, 0x2, 0x2, 0x2, 0x10f, 0x110, 
+    0x3, 0x2, 0x2, 0x2, 0x110, 0x113, 0x3, 0x2, 0x2, 0x2, 0x111, 0x10f, 
+    0x3, 0x2, 0x2, 0x2, 0x112, 0x114, 0x5, 0x49, 0x25, 0x2, 0x113, 0x112, 
+    0x3, 0x2, 0x2, 0x2, 0x113, 0x114, 0x3, 0x2, 0x2, 0x2, 0x114, 0x11d, 
+    0x3, 0x2, 0x2, 0x2, 0x115, 0x117, 0x5, 0x45, 0x23, 0x2, 0x116, 0x115, 
+    0x3, 0x2, 0x2, 0x2, 0x117, 0x118, 0x3, 0x2, 0x2, 0x2, 0x118, 0x116, 
+    0x3, 0x2, 0x2, 0x2, 0x118, 0x119, 0x3, 0x2, 0x2, 0x2, 0x119, 0x11a, 
+    0x3, 0x2, 0x2, 0x2, 0x11a, 0x11b, 0x5, 0x49, 0x25, 0x2, 0x11b, 0x11d, 
+    0x3, 0x2, 0x2, 0x2, 0x11c, 0xe0, 0x3, 0x2, 0x2, 0x2, 0x11c, 0xfd, 0x3, 
+    0x2, 0x2, 0x2, 0x11c, 0x107, 0x3, 0x2, 0x2, 0x2, 0x11c, 0x116, 0x3, 
+    0x2, 0x2, 0x2, 0x11d, 0x4e, 0x3, 0x2, 0x2, 0x2, 0x11e, 0x138, 0x7, 0x32, 
+    0x2, 0x2, 0x11f, 0x123, 0x9, 0x7, 0x2, 0x2, 0x120, 0x122, 0x9, 0x2, 
+    0x2, 0x2, 0x121, 0x120, 0x3, 0x2, 0x2, 0x2, 0x122, 0x125, 0x3, 0x2, 
+    0x2, 0x2, 0x123, 0x121, 0x3, 0x2, 0x2, 0x2, 0x123, 0x124, 0x3, 0x2, 
+    0x2, 0x2, 0x124, 0x138, 0x3, 0x2, 0x2, 0x2, 0x125, 0x123, 0x3, 0x2, 
+    0x2, 0x2, 0x126, 0x128, 0x7, 0x32, 0x2, 0x2, 0x127, 0x129, 0x9, 0x8, 
+    0x2, 0x2, 0x128, 0x127, 0x3, 0x2, 0x2, 0x2, 0x129, 0x12a, 0x3, 0x2, 
+    0x2, 0x2, 0x12a, 0x128, 0x3, 0x2, 0x2, 0x2, 0x12a, 0x12b, 0x3, 0x2, 
+    0x2, 0x2, 0x12b, 0x138, 0x3, 0x2, 0x2, 0x2, 0x12c, 0x12d, 0x7, 0x32, 
+    0x2, 0x2, 0x12d, 0x131, 0x7, 0x7a, 0x2, 0x2, 0x12e, 0x12f, 0x7, 0x32, 
+    0x2, 0x2, 0x12f, 0x131, 0x7, 0x5a, 0x2, 0x2, 0x130, 0x12c, 0x3, 0x2, 
+    0x2, 0x2, 0x130, 0x12e, 0x3, 0x2, 0x2, 0x2, 0x131, 0x133, 0x3, 0x2, 
+    0x2, 0x2, 0x132, 0x134, 0x9, 0x3, 0x2, 0x2, 0x133, 0x132, 0x3, 0x2, 
+    0x2, 0x2, 0x134, 0x135, 0x3, 0x2, 0x2, 0x2, 0x135, 0x133, 0x3, 0x2, 
+    0x2, 0x2, 0x135, 0x136, 0x3, 0x2, 0x2, 0x2, 0x136, 0x138, 0x3, 0x2, 
+    0x2, 0x2, 0x137, 0x11e, 0x3, 0x2, 0x2, 0x2, 0x137, 0x11f, 0x3, 0x2, 
+    0x2, 0x2, 0x137, 0x126, 0x3, 0x2, 0x2, 0x2, 0x137, 0x130, 0x3, 0x2, 
+    0x2, 0x2, 0x138, 0x50, 0x3, 0x2, 0x2, 0x2, 0x139, 0x13d, 0x9, 0x9, 0x2, 
+    0x2, 0x13a, 0x13c, 0x9, 0xa, 0x2, 0x2, 0x13b, 0x13a, 0x3, 0x2, 0x2, 
+    0x2, 0x13c, 0x13f, 0x3, 0x2, 0x2, 0x2, 0x13d, 0x13b, 0x3, 0x2, 0x2, 
+    0x2, 0x13d, 0x13e, 0x3, 0x2, 0x2, 0x2, 0x13e, 0x52, 0x3, 0x2, 0x2, 0x2, 
+    0x13f, 0x13d, 0x3, 0x2, 0x2, 0x2, 0x140, 0x142, 0x9, 0xb, 0x2, 0x2, 
+    0x141, 0x140, 0x3, 0x2, 0x2, 0x2, 0x142, 0x143, 0x3, 0x2, 0x2, 0x2, 
+    0x143, 0x141, 0x3, 0x2, 0x2, 0x2, 0x143, 0x144, 0x3, 0x2, 0x2, 0x2, 
+    0x144, 0x145, 0x3, 0x2, 0x2, 0x2, 0x145, 0x146, 0x8, 0x2a, 0x2, 0x2, 
+    0x146, 0x54, 0x3, 0x2, 0x2, 0x2, 0x147, 0x148, 0x7, 0x31, 0x2, 0x2, 
+    0x148, 0x149, 0x7, 0x31, 0x2, 0x2, 0x149, 0x14d, 0x3, 0x2, 0x2, 0x2, 
+    0x14a, 0x14c, 0xa, 0xc, 0x2, 0x2, 0x14b, 0x14a, 0x3, 0x2, 0x2, 0x2, 
+    0x14c, 0x14f, 0x3, 0x2, 0x2, 0x2, 0x14d, 0x14b, 0x3, 0x2, 0x2, 0x2, 
+    0x14d, 0x14e, 0x3, 0x2, 0x2, 0x2, 0x14e, 0x150, 0x3, 0x2, 0x2, 0x2, 
+    0x14f, 0x14d, 0x3, 0x2, 0x2, 0x2, 0x150, 0x151, 0x8, 0x2b, 0x2, 0x2, 
+    0x151, 0x56, 0x3, 0x2, 0x2, 0x2, 0x152, 0x153, 0x7, 0x31, 0x2, 0x2, 
+    0x153, 0x154, 0x7, 0x2c, 0x2, 0x2, 0x154, 0x158, 0x3, 0x2, 0x2, 0x2, 
+    0x155, 0x157, 0xb, 0x2, 0x2, 0x2, 0x156, 0x155, 0x3, 0x2, 0x2, 0x2, 
+    0x157, 0x15a, 0x3, 0x2, 0x2, 0x2, 0x158, 0x159, 0x3, 0x2, 0x2, 0x2, 
+    0x158, 0x156, 0x3, 0x2, 0x2, 0x2, 0x159, 0x15b, 0x3, 0x2, 0x2, 0x2, 
+    0x15a, 0x158, 0x3, 0x2, 0x2, 0x2, 0x15b, 0x15c, 0x7, 0x2c, 0x2, 0x2, 
+    0x15c, 0x15d, 0x7, 0x31, 0x2, 0x2, 0x15d, 0x15e, 0x3, 0x2, 0x2, 0x2, 
+    0x15e, 0x15f, 0x8, 0x2c, 0x2, 0x2, 0x15f, 0x58, 0x3, 0x2, 0x2, 0x2, 
+    0x1d, 0x2, 0xcc, 0xd1, 0xd5, 0xda, 0xe0, 0xe5, 0xeb, 0xf2, 0xf7, 0xf9, 
+    0x101, 0x104, 0x109, 0x10f, 0x113, 0x118, 0x11c, 0x123, 0x12a, 0x130, 
+    0x135, 0x137, 0x13d, 0x143, 0x14d, 0x158, 0x3, 0x8, 0x2, 0x2, 
+  };
+
+  atn::ATNDeserializer deserializer;
+  _atn = deserializer.deserialize(_serializedATN);
+
+  size_t count = _atn.getNumberOfDecisions();
+  _decisionToDFA.reserve(count);
+  for (size_t i = 0; i < count; i++) { 
+    _decisionToDFA.emplace_back(_atn.getDecisionState(i), i);
+  }
+}
+
+SysYLexer::Initializer SysYLexer::_init;

src/antlr4/SysYLexer.h

@@ -0,0 +1,62 @@
+
+// Generated from SysY.g4 by ANTLR 4.7.2
+
+#pragma once
+
+
+#include "antlr4-runtime.h"
+
+
+
+
+class  SysYLexer : public antlr4::Lexer {
+public:
+  enum {
+    T__0 = 1, T__1 = 2, T__2 = 3, T__3 = 4, T__4 = 5, T__5 = 6, T__6 = 7, 
+    T__7 = 8, T__8 = 9, T__9 = 10, T__10 = 11, T__11 = 12, T__12 = 13, T__13 = 14, 
+    T__14 = 15, T__15 = 16, T__16 = 17, T__17 = 18, T__18 = 19, T__19 = 20, 
+    T__20 = 21, T__21 = 22, T__22 = 23, T__23 = 24, T__24 = 25, T__25 = 26, 
+    T__26 = 27, T__27 = 28, T__28 = 29, T__29 = 30, T__30 = 31, T__31 = 32, 
+    T__32 = 33, FloatConst = 34, IntConst = 35, Ident = 36, WS = 37, LINE_COMMENT = 38, 
+    BLOCK_COMMENT = 39
+  };
+
+  SysYLexer(antlr4::CharStream *input);
+  ~SysYLexer();
+
+  virtual std::string getGrammarFileName() const override;
+  virtual const std::vector<std::string>& getRuleNames() const override;
+
+  virtual const std::vector<std::string>& getChannelNames() const override;
+  virtual const std::vector<std::string>& getModeNames() const override;
+  virtual const std::vector<std::string>& getTokenNames() const override; // deprecated, use vocabulary instead
+  virtual antlr4::dfa::Vocabulary& getVocabulary() const override;
+
+  virtual const std::vector<uint16_t> getSerializedATN() const override;
+  virtual const antlr4::atn::ATN& getATN() const override;
+
+private:
+  static std::vector<antlr4::dfa::DFA> _decisionToDFA;
+  static antlr4::atn::PredictionContextCache _sharedContextCache;
+  static std::vector<std::string> _ruleNames;
+  static std::vector<std::string> _tokenNames;
+  static std::vector<std::string> _channelNames;
+  static std::vector<std::string> _modeNames;
+
+  static std::vector<std::string> _literalNames;
+  static std::vector<std::string> _symbolicNames;
+  static antlr4::dfa::Vocabulary _vocabulary;
+  static antlr4::atn::ATN _atn;
+  static std::vector<uint16_t> _serializedATN;
+
+
+  // Individual action functions triggered by action() above.
+
+  // Individual semantic predicate functions triggered by sempred() above.
+
+  struct Initializer {
+    Initializer();
+  };
+  static Initializer _init;
+};
+

src/antlr4/SysYParser.h

@@ -0,0 +1,513 @@
+
+// Generated from SysY.g4 by ANTLR 4.7.2
+
+#pragma once
+
+
+#include "antlr4-runtime.h"
+
+
+
+
+class  SysYParser : public antlr4::Parser {
+public:
+  enum {
+    T__0 = 1, T__1 = 2, T__2 = 3, T__3 = 4, T__4 = 5, T__5 = 6, T__6 = 7, 
+    T__7 = 8, T__8 = 9, T__9 = 10, T__10 = 11, T__11 = 12, T__12 = 13, T__13 = 14, 
+    T__14 = 15, T__15 = 16, T__16 = 17, T__17 = 18, T__18 = 19, T__19 = 20, 
+    T__20 = 21, T__21 = 22, T__22 = 23, T__23 = 24, T__24 = 25, T__25 = 26, 
+    T__26 = 27, T__27 = 28, T__28 = 29, T__29 = 30, T__30 = 31, T__31 = 32, 
+    T__32 = 33, FloatConst = 34, IntConst = 35, Ident = 36, WS = 37, LINE_COMMENT = 38, 
+    BLOCK_COMMENT = 39
+  };
+
+  enum {
+    RuleCompUnit = 0, RuleDecl = 1, RuleConstDecl = 2, RuleBType = 3, RuleConstDef = 4, 
+    RuleConstInitVal = 5, RuleVarDecl = 6, RuleVarDef = 7, RuleInitVal = 8, 
+    RuleFuncDef = 9, RuleFuncType = 10, RuleFuncFParams = 11, RuleFuncFParam = 12, 
+    RuleBlock = 13, RuleBlockItem = 14, RuleStmt = 15, RuleExp = 16, RuleCond = 17, 
+    RuleLVal = 18, RulePrimaryExp = 19, RuleNumber = 20, RuleUnaryExp = 21, 
+    RuleUnaryOp = 22, RuleFuncRParams = 23, RuleMulExp = 24, RuleAddExp = 25, 
+    RuleRelExp = 26, RuleEqExp = 27, RuleLAndExp = 28, RuleLOrExp = 29, 
+    RuleConstExp = 30
+  };
+
+  SysYParser(antlr4::TokenStream *input);
+  ~SysYParser();
+
+  virtual std::string getGrammarFileName() const override;
+  virtual const antlr4::atn::ATN& getATN() const override { return _atn; };
+  virtual const std::vector<std::string>& getTokenNames() const override { return _tokenNames; }; // deprecated: use vocabulary instead.
+  virtual const std::vector<std::string>& getRuleNames() const override;
+  virtual antlr4::dfa::Vocabulary& getVocabulary() const override;
+
+
+  class CompUnitContext;
+  class DeclContext;
+  class ConstDeclContext;
+  class BTypeContext;
+  class ConstDefContext;
+  class ConstInitValContext;
+  class VarDeclContext;
+  class VarDefContext;
+  class InitValContext;
+  class FuncDefContext;
+  class FuncTypeContext;
+  class FuncFParamsContext;
+  class FuncFParamContext;
+  class BlockContext;
+  class BlockItemContext;
+  class StmtContext;
+  class ExpContext;
+  class CondContext;
+  class LValContext;
+  class PrimaryExpContext;
+  class NumberContext;
+  class UnaryExpContext;
+  class UnaryOpContext;
+  class FuncRParamsContext;
+  class MulExpContext;
+  class AddExpContext;
+  class RelExpContext;
+  class EqExpContext;
+  class LAndExpContext;
+  class LOrExpContext;
+  class ConstExpContext; 
+
+  class  CompUnitContext : public antlr4::ParserRuleContext {
+  public:
+    CompUnitContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    std::vector<DeclContext *> decl();
+    DeclContext* decl(size_t i);
+    std::vector<FuncDefContext *> funcDef();
+    FuncDefContext* funcDef(size_t i);
+
+    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
+   
+  };
+
+  CompUnitContext* compUnit();
+
+  class  DeclContext : public antlr4::ParserRuleContext {
+  public:
+    DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    ConstDeclContext *constDecl();
+    VarDeclContext *varDecl();
+
+    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
+   
+  };
+
+  DeclContext* decl();
+
+  class  ConstDeclContext : public antlr4::ParserRuleContext {
+  public:
+    ConstDeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    BTypeContext *bType();
+    std::vector<ConstDefContext *> constDef();
+    ConstDefContext* constDef(size_t i);
+
+    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
+   
+  };
+
+  ConstDeclContext* constDecl();
+
+  class  BTypeContext : public antlr4::ParserRuleContext {
+  public:
+    BTypeContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+
+    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
+   
+  };
+
+  BTypeContext* bType();
+
+  class  ConstDefContext : public antlr4::ParserRuleContext {
+  public:
+    ConstDefContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    antlr4::tree::TerminalNode *Ident();
+    ConstInitValContext *constInitVal();
+    std::vector<ConstExpContext *> constExp();
+    ConstExpContext* constExp(size_t i);
+
+    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
+   
+  };
+
+  ConstDefContext* constDef();
+
+  class  ConstInitValContext : public antlr4::ParserRuleContext {
+  public:
+    ConstInitValContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    ConstExpContext *constExp();
+    std::vector<ConstInitValContext *> constInitVal();
+    ConstInitValContext* constInitVal(size_t i);
+
+    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
+   
+  };
+
+  ConstInitValContext* constInitVal();
+
+  class  VarDeclContext : public antlr4::ParserRuleContext {
+  public:
+    VarDeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    BTypeContext *bType();
+    std::vector<VarDefContext *> varDef();
+    VarDefContext* varDef(size_t i);
+
+    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
+   
+  };
+
+  VarDeclContext* varDecl();
+
+  class  VarDefContext : public antlr4::ParserRuleContext {
+  public:
+    VarDefContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    antlr4::tree::TerminalNode *Ident();
+    std::vector<ConstExpContext *> constExp();
+    ConstExpContext* constExp(size_t i);
+    InitValContext *initVal();
+
+    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
+   
+  };
+
+  VarDefContext* varDef();
+
+  class  InitValContext : public antlr4::ParserRuleContext {
+  public:
+    InitValContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    ExpContext *exp();
+    std::vector<InitValContext *> initVal();
+    InitValContext* initVal(size_t i);
+
+    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
+   
+  };
+
+  InitValContext* initVal();
+
+  class  FuncDefContext : public antlr4::ParserRuleContext {
+  public:
+    FuncDefContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    FuncTypeContext *funcType();
+    antlr4::tree::TerminalNode *Ident();
+    BlockContext *block();
+    FuncFParamsContext *funcFParams();
+
+    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
+   
+  };
+
+  FuncDefContext* funcDef();
+
+  class  FuncTypeContext : public antlr4::ParserRuleContext {
+  public:
+    FuncTypeContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+
+    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
+   
+  };
+
+  FuncTypeContext* funcType();
+
+  class  FuncFParamsContext : public antlr4::ParserRuleContext {
+  public:
+    FuncFParamsContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    std::vector<FuncFParamContext *> funcFParam();
+    FuncFParamContext* funcFParam(size_t i);
+
+    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
+   
+  };
+
+  FuncFParamsContext* funcFParams();
+
+  class  FuncFParamContext : public antlr4::ParserRuleContext {
+  public:
+    FuncFParamContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    BTypeContext *bType();
+    antlr4::tree::TerminalNode *Ident();
+    std::vector<ExpContext *> exp();
+    ExpContext* exp(size_t i);
+
+    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
+   
+  };
+
+  FuncFParamContext* funcFParam();
+
+  class  BlockContext : public antlr4::ParserRuleContext {
+  public:
+    BlockContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    std::vector<BlockItemContext *> blockItem();
+    BlockItemContext* blockItem(size_t i);
+
+    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
+   
+  };
+
+  BlockContext* block();
+
+  class  BlockItemContext : public antlr4::ParserRuleContext {
+  public:
+    BlockItemContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    DeclContext *decl();
+    StmtContext *stmt();
+
+    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
+   
+  };
+
+  BlockItemContext* blockItem();
+
+  class  StmtContext : public antlr4::ParserRuleContext {
+  public:
+    StmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    LValContext *lVal();
+    ExpContext *exp();
+    BlockContext *block();
+    CondContext *cond();
+    std::vector<StmtContext *> stmt();
+    StmtContext* stmt(size_t i);
+
+    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
+   
+  };
+
+  StmtContext* stmt();
+
+  class  ExpContext : public antlr4::ParserRuleContext {
+  public:
+    ExpContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    AddExpContext *addExp();
+
+    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
+   
+  };
+
+  ExpContext* exp();
+
+  class  CondContext : public antlr4::ParserRuleContext {
+  public:
+    CondContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    LOrExpContext *lOrExp();
+
+    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
+   
+  };
+
+  CondContext* cond();
+
+  class  LValContext : public antlr4::ParserRuleContext {
+  public:
+    LValContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    antlr4::tree::TerminalNode *Ident();
+    std::vector<ExpContext *> exp();
+    ExpContext* exp(size_t i);
+
+    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
+   
+  };
+
+  LValContext* lVal();
+
+  class  PrimaryExpContext : public antlr4::ParserRuleContext {
+  public:
+    PrimaryExpContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    ExpContext *exp();
+    LValContext *lVal();
+    NumberContext *number();
+
+    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
+   
+  };
+
+  PrimaryExpContext* primaryExp();
+
+  class  NumberContext : public antlr4::ParserRuleContext {
+  public:
+    NumberContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    antlr4::tree::TerminalNode *FloatConst();
+    antlr4::tree::TerminalNode *IntConst();
+
+    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
+   
+  };
+
+  NumberContext* number();
+
+  class  UnaryExpContext : public antlr4::ParserRuleContext {
+  public:
+    UnaryExpContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    PrimaryExpContext *primaryExp();
+    antlr4::tree::TerminalNode *Ident();
+    FuncRParamsContext *funcRParams();
+    UnaryOpContext *unaryOp();
+    UnaryExpContext *unaryExp();
+
+    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
+   
+  };
+
+  UnaryExpContext* unaryExp();
+
+  class  UnaryOpContext : public antlr4::ParserRuleContext {
+  public:
+    UnaryOpContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+
+    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
+   
+  };
+
+  UnaryOpContext* unaryOp();
+
+  class  FuncRParamsContext : public antlr4::ParserRuleContext {
+  public:
+    FuncRParamsContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    std::vector<ExpContext *> exp();
+    ExpContext* exp(size_t i);
+
+    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
+   
+  };
+
+  FuncRParamsContext* funcRParams();
+
+  class  MulExpContext : public antlr4::ParserRuleContext {
+  public:
+    MulExpContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    std::vector<UnaryExpContext *> unaryExp();
+    UnaryExpContext* unaryExp(size_t i);
+
+    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
+   
+  };
+
+  MulExpContext* mulExp();
+
+  class  AddExpContext : public antlr4::ParserRuleContext {
+  public:
+    AddExpContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    std::vector<MulExpContext *> mulExp();
+    MulExpContext* mulExp(size_t i);
+
+    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
+   
+  };
+
+  AddExpContext* addExp();
+
+  class  RelExpContext : public antlr4::ParserRuleContext {
+  public:
+    RelExpContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    std::vector<AddExpContext *> addExp();
+    AddExpContext* addExp(size_t i);
+
+    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
+   
+  };
+
+  RelExpContext* relExp();
+
+  class  EqExpContext : public antlr4::ParserRuleContext {
+  public:
+    EqExpContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    std::vector<RelExpContext *> relExp();
+    RelExpContext* relExp(size_t i);
+
+    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
+   
+  };
+
+  EqExpContext* eqExp();
+
+  class  LAndExpContext : public antlr4::ParserRuleContext {
+  public:
+    LAndExpContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    std::vector<EqExpContext *> eqExp();
+    EqExpContext* eqExp(size_t i);
+
+    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
+   
+  };
+
+  LAndExpContext* lAndExp();
+
+  class  LOrExpContext : public antlr4::ParserRuleContext {
+  public:
+    LOrExpContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    std::vector<LAndExpContext *> lAndExp();
+    LAndExpContext* lAndExp(size_t i);
+
+    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
+   
+  };
+
+  LOrExpContext* lOrExp();
+
+  class  ConstExpContext : public antlr4::ParserRuleContext {
+  public:
+    ConstExpContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    AddExpContext *addExp();
+
+    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
+   
+  };
+
+  ConstExpContext* constExp();
+
+
+private:
+  static std::vector<antlr4::dfa::DFA> _decisionToDFA;
+  static antlr4::atn::PredictionContextCache _sharedContextCache;
+  static std::vector<std::string> _ruleNames;
+  static std::vector<std::string> _tokenNames;
+
+  static std::vector<std::string> _literalNames;
+  static std::vector<std::string> _symbolicNames;
+  static antlr4::dfa::Vocabulary _vocabulary;
+  static antlr4::atn::ATN _atn;
+  static std::vector<uint16_t> _serializedATN;
+
+
+  struct Initializer {
+    Initializer();
+  };
+  static Initializer _init;
+};
+

src/antlr4/SysYVisitor.cpp

@@ -0,0 +1,7 @@
+
+// Generated from SysY.g4 by ANTLR 4.7.2
+
+
+#include "SysYVisitor.h"
+
+

src/antlr4/SysYVisitor.h

@@ -0,0 +1,86 @@
+
+// Generated from SysY.g4 by ANTLR 4.7.2
+
+#pragma once
+
+
+#include "antlr4-runtime.h"
+#include "SysYParser.h"
+
+
+
+/**
+ * This class defines an abstract visitor for a parse tree
+ * produced by SysYParser.
+ */
+class  SysYVisitor : public antlr4::tree::AbstractParseTreeVisitor {
+public:
+
+  /**
+   * Visit parse trees produced by SysYParser.
+   */
+    virtual antlrcpp::Any visitCompUnit(SysYParser::CompUnitContext *context) = 0;
+
+    virtual antlrcpp::Any visitDecl(SysYParser::DeclContext *context) = 0;
+
+    virtual antlrcpp::Any visitConstDecl(SysYParser::ConstDeclContext *context) = 0;
+
+    virtual antlrcpp::Any visitBType(SysYParser::BTypeContext *context) = 0;
+
+    virtual antlrcpp::Any visitConstDef(SysYParser::ConstDefContext *context) = 0;
+
+    virtual antlrcpp::Any visitConstInitVal(SysYParser::ConstInitValContext *context) = 0;
+
+    virtual antlrcpp::Any visitVarDecl(SysYParser::VarDeclContext *context) = 0;
+
+    virtual antlrcpp::Any visitVarDef(SysYParser::VarDefContext *context) = 0;
+
+    virtual antlrcpp::Any visitInitVal(SysYParser::InitValContext *context) = 0;
+
+    virtual antlrcpp::Any visitFuncDef(SysYParser::FuncDefContext *context) = 0;
+
+    virtual antlrcpp::Any visitFuncType(SysYParser::FuncTypeContext *context) = 0;
+
+    virtual antlrcpp::Any visitFuncFParams(SysYParser::FuncFParamsContext *context) = 0;
+
+    virtual antlrcpp::Any visitFuncFParam(SysYParser::FuncFParamContext *context) = 0;
+
+    virtual antlrcpp::Any visitBlock(SysYParser::BlockContext *context) = 0;
+
+    virtual antlrcpp::Any visitBlockItem(SysYParser::BlockItemContext *context) = 0;
+
+    virtual antlrcpp::Any visitStmt(SysYParser::StmtContext *context) = 0;
+
+    virtual antlrcpp::Any visitExp(SysYParser::ExpContext *context) = 0;
+
+    virtual antlrcpp::Any visitCond(SysYParser::CondContext *context) = 0;
+
+    virtual antlrcpp::Any visitLVal(SysYParser::LValContext *context) = 0;
+
+    virtual antlrcpp::Any visitPrimaryExp(SysYParser::PrimaryExpContext *context) = 0;
+
+    virtual antlrcpp::Any visitNumber(SysYParser::NumberContext *context) = 0;
+
+    virtual antlrcpp::Any visitUnaryExp(SysYParser::UnaryExpContext *context) = 0;
+
+    virtual antlrcpp::Any visitUnaryOp(SysYParser::UnaryOpContext *context) = 0;
+
+    virtual antlrcpp::Any visitFuncRParams(SysYParser::FuncRParamsContext *context) = 0;
+
+    virtual antlrcpp::Any visitMulExp(SysYParser::MulExpContext *context) = 0;
+
+    virtual antlrcpp::Any visitAddExp(SysYParser::AddExpContext *context) = 0;
+
+    virtual antlrcpp::Any visitRelExp(SysYParser::RelExpContext *context) = 0;
+
+    virtual antlrcpp::Any visitEqExp(SysYParser::EqExpContext *context) = 0;
+
+    virtual antlrcpp::Any visitLAndExp(SysYParser::LAndExpContext *context) = 0;
+
+    virtual antlrcpp::Any visitLOrExp(SysYParser::LOrExpContext *context) = 0;
+
+    virtual antlrcpp::Any visitConstExp(SysYParser::ConstExpContext *context) = 0;
+
+
+};
+

src/ir/BasicBlock.cpp

@@ -9,8 +9,8 @@
 
 #include "ir/IR.h"
 
+#include <algorithm>
 #include <utility>
-#include <algorithm>  // 用于 std::find
 
 namespace ir {
 
@@ -22,6 +22,7 @@ Function* BasicBlock::GetParent() const { return parent_; }
 
 void BasicBlock::SetParent(Function* parent) { parent_ = parent; }
 
+
 bool BasicBlock::HasTerminator() const {
   return !instructions_.empty() && instructions_.back()->IsTerminator();
 }
@@ -42,36 +43,26 @@ const std::vector<BasicBlock*>& BasicBlock::GetSuccessors() const {
   return successors_;
 }
 
-// 添加前驱基本块（避免重复）
 void BasicBlock::AddPredecessor(BasicBlock* pred) {
-  if (std::find(predecessors_.begin(), predecessors_.end(), pred) ==
+  if (!pred) {
+    return;
+  }
+  if (std::find(predecessors_.begin(), predecessors_.end(), pred) !=
       predecessors_.end()) {
-    predecessors_.push_back(pred);
+    return;
   }
+  predecessors_.push_back(pred);
 }
 
-// 添加后继基本块（避免重复）
 void BasicBlock::AddSuccessor(BasicBlock* succ) {
-  if (std::find(successors_.begin(), successors_.end(), succ) ==
+  if (!succ) {
-      successors_.end()) {
+    return;
-    successors_.push_back(succ);
   }
-}
+  if (std::find(successors_.begin(), successors_.end(), succ) !=
-
+      successors_.end()) {
-// 移除前驱基本块
+    return;
-void BasicBlock::RemovePredecessor(BasicBlock* pred) {
-  auto it = std::find(predecessors_.begin(), predecessors_.end(), pred);
-  if (it != predecessors_.end()) {
-    predecessors_.erase(it);
-  }
-}
-
-// 移除后继基本块
-void BasicBlock::RemoveSuccessor(BasicBlock* succ) {
-  auto it = std::find(successors_.begin(), successors_.end(), succ);
-  if (it != successors_.end()) {
-    successors_.erase(it);
   }
+  successors_.push_back(succ);
 }
 
-}  // namespace ir
+}  // namespace ir

src/ir/Context.cpp

@@ -15,17 +15,9 @@ ConstantInt* Context::GetConstInt(int v) {
   return inserted->second.get();
 }
 
-ConstantFloat* Context::GetConstFloat(float v) {
-  auto it = const_floats_.find(v);
-  if (it != const_floats_.end()) return it->second.get();
-  auto inserted = const_floats_.emplace(
-      v, std::make_unique<ConstantFloat>(Type::GetFloat32Type(), v)).first;
-  return inserted->second.get();
-}
-
 std::string Context::NextTemp() {
   std::ostringstream oss;
-  oss << ++temp_index_;
+  oss << "%t" << ++temp_index_;
   return oss.str();
 }
 

src/ir/Function.cpp

@@ -3,20 +3,24 @@
 // - 记录函数属性/元信息（按需要扩展）
 #include "ir/IR.h"
 
+#include <stdexcept>
+
+#include "utils/Log.h"
+
 namespace ir {
 
+Argument::Argument(std::shared_ptr<Type> ty, std::string name, size_t index)
+    : Value(std::move(ty), std::move(name)), arg_index_(index) {}
+
 Function::Function(std::string name, std::shared_ptr<Type> ret_type,
                    std::vector<std::shared_ptr<Type>> param_types)
-    : Value(std::move(ret_type), std::move(name)) {
+    : Value(std::move(ret_type), std::move(name)),
-  func_type_ = std::static_pointer_cast<FunctionType>(
+      param_types_(std::move(param_types)) {
-      Type::GetFunctionType(GetType(), param_types));
+  for (size_t i = 0; i < param_types_.size(); ++i) {
-  entry_ = CreateBlock("entry");
+    args_.push_back(std::make_unique<Argument>(
-  // Create arguments
+        param_types_[i], "%arg" + std::to_string(i), i));
-  for (size_t i = 0; i < param_types.size(); ++i) {
-    owned_params_.push_back(std::make_unique<Value>(param_types[i], "arg" + std::to_string(i)));
-    params_.push_back(owned_params_.back().get());
-    // Note: arguments are owned in owned_params_ to ensure lifetime
   }
+  entry_ = CreateBlock("entry");
 }
 
 BasicBlock* Function::CreateBlock(const std::string& name) {
@@ -34,19 +38,21 @@ BasicBlock* Function::GetEntry() { return entry_; }
 
 const BasicBlock* Function::GetEntry() const { return entry_; }
 
-const std::vector<std::unique_ptr<BasicBlock>>& Function::GetBlocks() const {
+const std::vector<std::shared_ptr<Type>>& Function::GetParamTypes() const {
-  return blocks_;
+  return param_types_;
 }
 
-void Function::AddParam(Value* param) {
+size_t Function::GetNumParams() const { return param_types_.size(); }
-  if (!param) {
+
-    throw std::runtime_error("Function::AddParam cannot add null param");
+Argument* Function::GetArgument(size_t index) const {
+  if (index >= args_.size()) {
+    throw std::out_of_range(FormatError("ir", "Argument 索引越界"));
   }
-  params_.push_back(param);
+  return args_[index].get();
 }
 
-std::shared_ptr<FunctionType> Function::GetFunctionType() const {
+const std::vector<std::unique_ptr<BasicBlock>>& Function::GetBlocks() const {
-  return func_type_;
+  return blocks_;
 }
 
 }  // namespace ir

src/ir/GlobalValue.cpp

@@ -1,5 +1,4 @@
-// GlobalValue 占位实现：
+// GlobalValue / GlobalVariable 实现。
-// - 具体的全局初始化器、打印和链接语义需要自行补全
 
 #include "ir/IR.h"
 
@@ -8,4 +7,9 @@ namespace ir {
 GlobalValue::GlobalValue(std::shared_ptr<Type> ty, std::string name)
     : User(std::move(ty), std::move(name)) {}
 
+GlobalVariable::GlobalVariable(std::string name, int init_val, int count)
+    : GlobalValue(Type::GetPtrInt32Type(), std::move(name)),
+      init_val_(init_val),
+      count_(count) {}
+
 }  // namespace ir

src/ir/IRBuilder.cpp

@@ -21,10 +21,6 @@ ConstantInt* IRBuilder::CreateConstInt(int v) {
   return ctx_.GetConstInt(v);
 }
 
-ConstantFloat* IRBuilder::CreateConstFloat(float v) {
-  return ctx_.GetConstFloat(v);
-}
-
 BinaryInst* IRBuilder::CreateBinary(Opcode op, Value* lhs, Value* rhs,
                                     const std::string& name) {
   if (!insert_block_) {
@@ -46,6 +42,38 @@ BinaryInst* IRBuilder::CreateAdd(Value* lhs, Value* rhs,
   return CreateBinary(Opcode::Add, lhs, rhs, name);
 }
 
+BinaryInst* IRBuilder::CreateSub(Value* lhs, Value* rhs,
+                                 const std::string& name) {
+  return CreateBinary(Opcode::Sub, lhs, rhs, name);
+}
+
+BinaryInst* IRBuilder::CreateMul(Value* lhs, Value* rhs,
+                                 const std::string& name) {
+  return CreateBinary(Opcode::Mul, lhs, rhs, name);
+}
+
+BinaryInst* IRBuilder::CreateDiv(Value* lhs, Value* rhs,
+                                 const std::string& name) {
+  return CreateBinary(Opcode::Div, lhs, rhs, name);
+}
+
+BinaryInst* IRBuilder::CreateMod(Value* lhs, Value* rhs,
+                                 const std::string& name) {
+  return CreateBinary(Opcode::Mod, lhs, rhs, name);
+}
+
+CmpInst* IRBuilder::CreateCmp(CmpOp op, Value* lhs, Value* rhs,
+                              const std::string& name) {
+  if (!insert_block_) {
+    throw std::runtime_error(FormatError("ir", "IRBuilder 未设置插入点"));
+  }
+  if (!lhs || !rhs) {
+    throw std::runtime_error(
+        FormatError("ir", "IRBuilder::CreateCmp 缺少操作数"));
+  }
+  return insert_block_->Append<CmpInst>(op, Type::GetInt32Type(), lhs, rhs,
+                                        name);
+}
 
 AllocaInst* IRBuilder::CreateAllocaI32(const std::string& name) {
   if (!insert_block_) {
@@ -54,21 +82,24 @@ AllocaInst* IRBuilder::CreateAllocaI32(const std::string& name) {
   return insert_block_->Append<AllocaInst>(Type::GetPtrInt32Type(), name);
 }
 
-AllocaInst* IRBuilder::CreateAllocaFloat(const std::string& name) {
+AllocaInst* IRBuilder::CreateAllocaArray(int count, const std::string& name) {
   if (!insert_block_) {
     throw std::runtime_error(FormatError("ir", "IRBuilder 未设置插入点"));
   }
-  return insert_block_->Append<AllocaInst>(Type::GetPointerType(Type::GetFloat32Type()), name);
+  if (count <= 0) {
+    throw std::runtime_error(FormatError("ir", "IRBuilder::CreateAllocaArray 数组大小必须为正数"));
+  }
+  return insert_block_->Append<AllocaInst>(Type::GetPtrInt32Type(), name, count);
 }
 
-AllocaInst* IRBuilder::CreateAlloca(std::shared_ptr<Type> ty, const std::string& name) {
+GepInst* IRBuilder::CreateGep(Value* base, Value* index, const std::string& name) {
   if (!insert_block_) {
     throw std::runtime_error(FormatError("ir", "IRBuilder 未设置插入点"));
   }
-  if (!ty || !ty->IsPointer()) {
+  if (!base || !index) {
-    throw std::runtime_error(FormatError("ir", "CreateAlloca 仅支持指针类型"));
+    throw std::runtime_error(FormatError("ir", "IRBuilder::CreateGep 缺少操作数"));
   }
-  return insert_block_->Append<AllocaInst>(ty, name);
+  return insert_block_->Append<GepInst>(Type::GetPtrInt32Type(), base, index, name);
 }
 
 LoadInst* IRBuilder::CreateLoad(Value* ptr, const std::string& name) {
@@ -76,13 +107,10 @@ LoadInst* IRBuilder::CreateLoad(Value* ptr, const std::string& name) {
     throw std::runtime_error(FormatError("ir", "IRBuilder 未设置插入点"));
   }
   if (!ptr) {
-    throw std::runtime_error(FormatError("ir", "IRBuilder::CreateLoad 缺少 ptr"));
+    throw std::runtime_error(
-  }
+        FormatError("ir", "IRBuilder::CreateLoad 缺少 ptr"));
-  if (!ptr->GetType() || !ptr->GetType()->IsPointer()) {
-    throw std::runtime_error(FormatError("ir", "IRBuilder::CreateLoad ptr 必须为指针类型"));
   }
-  const auto* ptr_ty = static_cast<const PointerType*>(ptr->GetType().get());
+  return insert_block_->Append<LoadInst>(Type::GetInt32Type(), ptr, name);
-  return insert_block_->Append<LoadInst>(ptr_ty->GetPointeeType(), ptr, name);
 }
 
 StoreInst* IRBuilder::CreateStore(Value* val, Value* ptr) {
@@ -100,104 +128,59 @@ StoreInst* IRBuilder::CreateStore(Value* val, Value* ptr) {
   return insert_block_->Append<StoreInst>(Type::GetVoidType(), val, ptr);
 }
 
-ReturnInst* IRBuilder::CreateRet(Value* v) {
+BranchInst* IRBuilder::CreateBr(BasicBlock* target) {
   if (!insert_block_) {
     throw std::runtime_error(FormatError("ir", "IRBuilder 未设置插入点"));
   }
-  // ReturnInst expects its own type to be void; the returned value is an
+  if (!target) {
-  // operand. Always use void as the instruction type.
+    throw std::runtime_error(
-  return insert_block_->Append<ReturnInst>(Type::GetVoidType(), v);
+        FormatError("ir", "IRBuilder::CreateBr 缺少目标块"));
-}
-
-BinaryInst* IRBuilder::CreateSub(Value* lhs, Value* rhs, const std::string& name) {
-  return CreateBinary(Opcode::Sub, lhs, rhs, name);
-}
-
-BinaryInst* IRBuilder::CreateMul(Value* lhs, Value* rhs, const std::string& name) {
-  return CreateBinary(Opcode::Mul, lhs, rhs, name);
-}
-
-BinaryInst* IRBuilder::CreateDiv(Value* lhs, Value* rhs, const std::string& name) {
-  return CreateBinary(Opcode::Div, lhs, rhs, name);
-}
-
-BinaryInst* IRBuilder::CreateMod(Value* lhs, Value* rhs, const std::string& name) {
-  return CreateBinary(Opcode::Mod, lhs, rhs, name);
-}
-
-CmpInst* IRBuilder::CreateICmp(CmpInst::Predicate pred, Value* lhs, Value* rhs,
-                               const std::string& name) {
-  if (!insert_block_) {
-    throw std::runtime_error(FormatError("ir", "IRBuilder 未设置插入点"));
   }
-  return insert_block_->Append<CmpInst>(Opcode::ICmp, pred, lhs, rhs, name);
+  return insert_block_->Append<BranchInst>(Type::GetVoidType(), target);
 }
 
-CmpInst* IRBuilder::CreateFCmp(CmpInst::Predicate pred, Value* lhs, Value* rhs,
+CondBranchInst* IRBuilder::CreateCondBr(Value* cond, BasicBlock* true_bb,
-                               const std::string& name) {
+                                        BasicBlock* false_bb) {
   if (!insert_block_) {
     throw std::runtime_error(FormatError("ir", "IRBuilder 未设置插入点"));
   }
-  return insert_block_->Append<CmpInst>(Opcode::FCmp, pred, lhs, rhs, name);
+  if (!cond || !true_bb || !false_bb) {
-}
+    throw std::runtime_error(
-
+        FormatError("ir", "IRBuilder::CreateCondBr 参数不完整"));
-BranchInst* IRBuilder::CreateBr(BasicBlock* target) {
-  if (!insert_block_) {
-    throw std::runtime_error(FormatError("ir", "IRBuilder 未设置插入点"));
   }
-  return insert_block_->Append<BranchInst>(target);
+  return insert_block_->Append<CondBranchInst>(Type::GetVoidType(), cond,
+                                               true_bb, false_bb);
 }
 
-CondBranchInst* IRBuilder::CreateCondBr(Value* cond, BasicBlock* true_bb, BasicBlock* false_bb) {
+CallInst* IRBuilder::CreateCall(Function* callee,
+                                const std::vector<Value*>& args,
+                                const std::string& name) {
   if (!insert_block_) {
     throw std::runtime_error(FormatError("ir", "IRBuilder 未设置插入点"));
   }
-  return insert_block_->Append<CondBranchInst>(cond, true_bb, false_bb);
+  if (!callee) {
+    throw std::runtime_error(
+        FormatError("ir", "IRBuilder::CreateCall 缺少被调函数"));
+  }
+  return insert_block_->Append<CallInst>(callee->GetType(), callee, args, name);
 }
 
-CallInst* IRBuilder::CreateCall(Function* callee, std::vector<Value*> args, const std::string& name) {
+ReturnInst* IRBuilder::CreateRet(Value* v) {
   if (!insert_block_) {
     throw std::runtime_error(FormatError("ir", "IRBuilder 未设置插入点"));
   }
-  return insert_block_->Append<CallInst>(callee, args, name);
+  if (!v) {
+    throw std::runtime_error(
+        FormatError("ir", "IRBuilder::CreateRet 缺少返回值"));
+  }
+  return insert_block_->Append<ReturnInst>(Type::GetVoidType(), v);
 }
 
-GetElementPtrInst* IRBuilder::CreateGEP(Value* ptr, std::vector<Value*> indices, const std::string& name) {
+ReturnInst* IRBuilder::CreateRetVoid() {
-  if (!insert_block_) {
-    throw std::runtime_error(FormatError("ir", "IRBuilder 未设置插入点"));
-  }
-  // 计算结果类型：根据传入的 indices 逐步从 pointee 类型走到目标元素类型。
-  // 例如 ptr 是指向数组的指针，GEP 使用一个索引应返回指向数组元素的指针。
-  std::shared_ptr<Type> current;
-  if (ptr->GetType() && ptr->GetType()->IsPointer()) {
-    const PointerType* pty = static_cast<const PointerType*>(ptr->GetType().get());
-    current = pty->GetPointeeType();
-  } else {
-    current = ptr->GetType();
-  }
-  // 根据每个索引推进类型层次：数组 -> 元素类型，指针 -> 指向类型
-  for (size_t i = 0; i < indices.size(); ++i) {
-    if (!current) break;
-    if (current->IsArray()) {
-      const ArrayType* aty = static_cast<const ArrayType*>(current.get());
-      current = aty->GetElementType();
-    } else if (current->IsPointer()) {
-      const PointerType* ppty = static_cast<const PointerType*>(current.get());
-      current = ppty->GetPointeeType();
-    } else {
-      // 非数组/指针类型，无法继续下钻，保持当前类型
-      break;
-    }
-  }
-  auto result_ty = Type::GetPointerType(current);
-  return insert_block_->Append<GetElementPtrInst>(result_ty, ptr, indices, name);
-}
-
-PhiInst* IRBuilder::CreatePhi(std::shared_ptr<Type> ty, const std::string& name) {
   if (!insert_block_) {
     throw std::runtime_error(FormatError("ir", "IRBuilder 未设置插入点"));
   }
-  return insert_block_->Append<PhiInst>(ty, name);
+  return insert_block_->Append<ReturnInst>(Type::GetVoidType(), nullptr);
 }
 
 }  // namespace ir

src/ir/IRPrinter.cpp

@@ -12,140 +12,123 @@
 
 namespace ir {
 
-static std::string PredicateToString(CmpInst::Predicate pred, bool is_float) {
+static const char* TypeToString(const Type& ty) {
-  if (is_float) {
-    switch (pred) {
-      case CmpInst::EQ: return "oeq";
-      case CmpInst::NE: return "one";
-      case CmpInst::LT: return "olt";
-      case CmpInst::LE: return "ole";
-      case CmpInst::GT: return "ogt";
-      case CmpInst::GE: return "oge";
-    }
-  } else {
-    switch (pred) {
-      case CmpInst::EQ: return "eq";
-      case CmpInst::NE: return "ne";
-      case CmpInst::LT: return "slt";
-      case CmpInst::LE: return "sle";
-      case CmpInst::GT: return "sgt";
-      case CmpInst::GE: return "sge";
-    }
-  }
-  return "unknown";
-}
-
-static std::string TypeToString(const Type& ty) {
   switch (ty.GetKind()) {
     case Type::Kind::Void:
       return "void";
     case Type::Kind::Int32:
       return "i32";
-    case Type::Kind::Float32:
+    case Type::Kind::PtrInt32:
-      return "float";
+      return "i32*";
-    case Type::Kind::Pointer: {
-      const PointerType* p = static_cast<const PointerType*>(&ty);
-      return TypeToString(*p->GetPointeeType()) + "*";
-    }
-    case Type::Kind::Array: {
-      const ArrayType* a = static_cast<const ArrayType*>(&ty);
-      return std::string("[") + std::to_string(a->GetSize()) + " x " + TypeToString(*a->GetElementType()) + "]";
-    }
-    case Type::Kind::Function:
-      return "[function]";
-    case Type::Kind::Label:
-      return "label";
   }
   throw std::runtime_error(FormatError("ir", "未知类型"));
 }
 
 static const char* OpcodeToString(Opcode op) {
   switch (op) {
-    case Opcode::Add: return "add";
+    case Opcode::Add:
-    case Opcode::Sub: return "sub";
+      return "add";
-    case Opcode::Mul: return "mul";
+    case Opcode::Sub:
-    case Opcode::Div: return "sdiv";
+      return "sub";
-    case Opcode::Mod: return "srem";
+    case Opcode::Mul:
-    case Opcode::And: return "and";
+      return "mul";
-    case Opcode::Or: return "or";
+    case Opcode::Div:
-    case Opcode::Xor: return "xor";
+      return "sdiv";
-    case Opcode::Shl: return "shl";
+    case Opcode::Mod:
-    case Opcode::LShr: return "lshr";
+      return "srem";
-    case Opcode::AShr: return "ashr";
+    case Opcode::Cmp:
-    case Opcode::ICmp: return "icmp";
+      return "icmp";
-    case Opcode::FCmp: return "fcmp";
+    case Opcode::Br:
-    case Opcode::Alloca: return "alloca";
+      return "br";
-    case Opcode::Load: return "load";
+    case Opcode::CondBr:
-    case Opcode::Store: return "store";
+      return "br";
-    case Opcode::Ret: return "ret";
+    case Opcode::Call:
-    case Opcode::Br: return "br";
+      return "call";
-    case Opcode::CondBr: return "br";
+    case Opcode::Alloca:
-    case Opcode::Call: return "call";
+      return "alloca";
-    case Opcode::GEP: return "getelementptr";
+    case Opcode::Load:
-    case Opcode::Phi: return "phi";
+      return "load";
+    case Opcode::Store:
+      return "store";
+    case Opcode::Ret:
+      return "ret";
+    case Opcode::Gep:
+      return "getelementptr";
   }
   return "?";
 }
 
-static std::string ConstantValueToString(const ConstantValue* cv);
+static const char* CmpOpToString(CmpOp op) {
+  switch (op) {
+    case CmpOp::Eq:
+      return "eq";
+    case CmpOp::Ne:
+      return "ne";
+    case CmpOp::Lt:
+      return "slt";
+    case CmpOp::Le:
+      return "sle";
+    case CmpOp::Gt:
+      return "sgt";
+    case CmpOp::Ge:
+      return "sge";
+  }
+  return "?";
+}
 
 static std::string ValueToString(const Value* v) {
-  if (!v) return "<null>";
   if (auto* ci = dynamic_cast<const ConstantInt*>(v)) {
     return std::to_string(ci->GetValue());
   }
-  if (auto* cf = dynamic_cast<const ConstantFloat*>(v)) {
+  if (auto* gv = dynamic_cast<const GlobalVariable*>(v)) {
-    // simple float literal
+    return "@" + gv->GetName();
-    return std::to_string(cf->GetValue());
+  }
+  if (auto* func = dynamic_cast<const Function*>(v)) {
+    return "@" + func->GetName();
   }
-  if (auto* ca = dynamic_cast<const ConstantArray*>(v)) {
+  if (auto* arg = dynamic_cast<const Argument*>(v)) {
-    return ConstantValueToString(ca);
+    return arg->GetName();
   }
-  // fallback to name for instructions/alloca/vars — prefix with '%'
+  return v ? v->GetName() : "<null>";
-  return std::string("%") + v->GetName();
 }
 
-static std::string ConstantValueToString(const ConstantValue* cv) {
+void IRPrinter::Print(const Module& module, std::ostream& os) {
-  if (!cv) return "<null-const>";
+  // 先打印全局变量
-  if (auto* ci = dynamic_cast<const ConstantInt*>(cv)) return std::to_string(ci->GetValue());
+  for (const auto& gv : module.GetGlobalVars()) {
-  if (auto* cf = dynamic_cast<const ConstantFloat*>(cv)) {
+    if (!gv) continue;
-    std::string s = std::to_string(cf->GetValue());
+    if (gv->IsArray()) {
-    size_t dot = s.find('.');
+      os << "@" << gv->GetName() << " = global [" << gv->GetCount()
-    if (dot != std::string::npos) {
+         << " x i32] zeroinitializer\n";
-      size_t e = s.find('e');
+    } else {
-      if (e == std::string::npos) e = s.size();
+      os << "@" << gv->GetName() << " = global i32 " << gv->GetInitValue() << "\n";
-      while (e > dot + 1 && s[e-1] == '0') e--;
-      if (e == dot + 1) s = s.substr(0, dot + 1) + "0";
-      else s = s.substr(0, e);
-    }
-    return s;
-  }
-  if (auto* ca = dynamic_cast<const ConstantArray*>(cv)) {
-    // format: [ <elem_ty> <elem>, <elem_ty> <elem>, ... ]
-    const auto& elems = ca->GetElements();
-    std::string out = "[";
-    for (size_t i = 0; i < elems.size(); ++i) {
-      if (i) out += ", ";
-      // each element should be printed with its type and value
-      auto* e = elems[i];
-      std::string etype = TypeToString(*e->GetType());
-      out += etype + " " + ConstantValueToString(e);
     }
-    out += "]";
-    return out;
   }
-  return "<const-unk>";
+  if (!module.GetGlobalVars().empty()) os << "\n";
-}
 
-void IRPrinter::Print(const Module& module, std::ostream& os) {
   for (const auto& func : module.GetFunctions()) {
-    os << "define " << TypeToString(*func->GetType()) << " @" << func->GetName() << "(";
+    if (func->IsExternal()) {
-    const auto& params = func->GetParams();
+      // 外部函数声明：declare rettype @name(paramtypes)
-    for (size_t i = 0; i < params.size(); ++i) {
+      os << "declare " << TypeToString(*func->GetType()) << " @" << func->GetName() << "(";
-      if (i) os << ", ";
+      const auto& ptypes = func->GetParamTypes();
-      os << TypeToString(*params[i]->GetType()) << " " << ValueToString(params[i]);
+      for (size_t i = 0; i < ptypes.size(); ++i) {
+        if (i != 0) os << ", ";
+        os << TypeToString(*ptypes[i]);
+      }
+      os << ")\n";
+      continue;
+    }
+
+    std::string params;
+    const auto& param_types = func->GetParamTypes();
+    for (size_t i = 0; i < param_types.size(); ++i) {
+      if (i != 0) {
+        params += ", ";
+      }
+      params += TypeToString(*param_types[i]);
+      params += " %arg" + std::to_string(i);
     }
-    os << ") {\n";
+    os << "define " << TypeToString(*func->GetType()) << " @" << func->GetName()
+       << "(" << params << ") {\n";
     for (const auto& bb : func->GetBlocks()) {
       if (!bb) {
         continue;
@@ -158,39 +141,19 @@ void IRPrinter::Print(const Module& module, std::ostream& os) {
           case Opcode::Sub:
           case Opcode::Mul:
           case Opcode::Div:
-          case Opcode::Mod:
+          case Opcode::Mod: {
-          case Opcode::And:
-          case Opcode::Or:
-          case Opcode::Xor:
-          case Opcode::Shl:
-          case Opcode::LShr:
-          case Opcode::AShr: {
             auto* bin = static_cast<const BinaryInst*>(inst);
-            // choose opcode name: integer ops use e.g. 'add','sub', float ops use 'fadd','fsub', etc.
+            os << "  " << bin->GetName() << " = "
-            std::string op_name = OpcodeToString(bin->GetOpcode());
+               << OpcodeToString(bin->GetOpcode()) << " "
-            bool is_float = bin->GetLhs()->GetType()->IsFloat32();
+               << TypeToString(*bin->GetLhs()->GetType()) << " "
-            if (is_float) {
+               << ValueToString(bin->GetLhs()) << ", "
-              switch (bin->GetOpcode()) {
+               << ValueToString(bin->GetRhs()) << "\n";
-                case Opcode::Add: op_name = "fadd"; break;
-                case Opcode::Sub: op_name = "fsub"; break;
-                case Opcode::Mul: op_name = "fmul"; break;
-                case Opcode::Div: op_name = "fdiv"; break;
-                case Opcode::Mod: op_name = "frem"; break;
-                default: break;
-              }
-            }
-            os << "  %" << bin->GetName() << " = "
-              << op_name << " "
-              << TypeToString(*bin->GetLhs()->GetType()) << " "
-              << ValueToString(bin->GetLhs()) << ", "
-              << ValueToString(bin->GetRhs()) << "\n";
             break;
           }
-          case Opcode::ICmp:
+          case Opcode::Cmp: {
-          case Opcode::FCmp: {
             auto* cmp = static_cast<const CmpInst*>(inst);
-            os << "  %" << cmp->GetName() << " = "
+            os << "  " << cmp->GetName() << " = " << OpcodeToString(cmp->GetOpcode())
-               << OpcodeToString(cmp->GetOpcode()) << " " << PredicateToString(cmp->GetPredicate(), cmp->GetOpcode() == Opcode::FCmp) << " "
+               << " " << CmpOpToString(cmp->GetCmpOp()) << " "
                << TypeToString(*cmp->GetLhs()->GetType()) << " "
                << ValueToString(cmp->GetLhs()) << ", "
                << ValueToString(cmp->GetRhs()) << "\n";
@@ -198,30 +161,24 @@ void IRPrinter::Print(const Module& module, std::ostream& os) {
           }
           case Opcode::Alloca: {
             auto* alloca = static_cast<const AllocaInst*>(inst);
-            os << "  %" << alloca->GetName() << " = alloca "
+            if (alloca->IsArray()) {
-              << TypeToString(*static_cast<const PointerType*>(alloca->GetType().get())->GetPointeeType()) << "\n";
+              os << "  " << alloca->GetName() << " = alloca i32, i32 "
+                 << alloca->GetCount() << "\n";
+            } else {
+              os << "  " << alloca->GetName() << " = alloca i32\n";
+            }
             break;
           }
           case Opcode::Load: {
             auto* load = static_cast<const LoadInst*>(inst);
-            os << "  %" << load->GetName() << " = load "
+            os << "  " << load->GetName() << " = load i32, i32* "
-              << TypeToString(*load->GetType()) << ", "
+               << ValueToString(load->GetPtr()) << "\n";
-              << TypeToString(*load->GetPtr()->GetType()) << " "
-              << ValueToString(load->GetPtr()) << "\n";
             break;
           }
           case Opcode::Store: {
             auto* store = static_cast<const StoreInst*>(inst);
-            os << "  store " << TypeToString(*store->GetValue()->GetType()) << " "
+            os << "  store i32 " << ValueToString(store->GetValue())
-               << ValueToString(store->GetValue()) << ", "
+               << ", i32* " << ValueToString(store->GetPtr()) << "\n";
-               << TypeToString(*store->GetPtr()->GetType()) << " "
-               << ValueToString(store->GetPtr()) << "\n";
-            break;
-          }
-          case Opcode::Ret: {
-            auto* ret = static_cast<const ReturnInst*>(inst);
-            os << "  ret " << TypeToString(*ret->GetValue()->GetType()) << " "
-               << ValueToString(ret->GetValue()) << "\n";
             break;
           }
           case Opcode::Br: {
@@ -230,51 +187,58 @@ void IRPrinter::Print(const Module& module, std::ostream& os) {
             break;
           }
           case Opcode::CondBr: {
-            auto* condbr = static_cast<const CondBranchInst*>(inst);
+            auto* cbr = static_cast<const CondBranchInst*>(inst);
-            os << "  br i1 " << ValueToString(condbr->GetCond())
+            os << "  br i1 " << ValueToString(cbr->GetCond()) << ", label %"
-               << ", label %" << condbr->GetTrueBlock()->GetName()
+               << cbr->GetTrueBlock()->GetName() << ", label %"
-               << ", label %" << condbr->GetFalseBlock()->GetName() << "\n";
+               << cbr->GetFalseBlock()->GetName() << "\n";
             break;
           }
           case Opcode::Call: {
             auto* call = static_cast<const CallInst*>(inst);
-            os << "  ";
+            if (!call->GetType()->IsVoid()) {
-            if (!call->GetName().empty()) {
+              os << "  " << call->GetName() << " = ";
-              os << "%" << call->GetName() << " = ";
+            } else {
+              os << "  ";
             }
-            os << "call " << TypeToString(*call->GetCallee()->GetType()) << " @"
+            os << "call " << TypeToString(*call->GetType()) << " @"
                << call->GetCallee()->GetName() << "(";
-            for (size_t i = 0; i < call->GetArgs().size(); ++i) {
+            for (size_t i = 0; i < call->GetNumArgs(); ++i) {
-              if (i > 0) os << ", ";
+              if (i != 0) {
-              os << TypeToString(*call->GetArgs()[i]->GetType()) << " "
+                os << ", ";
-                 << ValueToString(call->GetArgs()[i]);
+              }
+              auto* arg = call->GetArg(i);
+              os << TypeToString(*arg->GetType()) << " " << ValueToString(arg);
             }
             os << ")\n";
             break;
           }
-          case Opcode::GEP: {
+          case Opcode::Gep: {
-            auto* gep = static_cast<const GetElementPtrInst*>(inst);
+            auto* gep = static_cast<const GepInst*>(inst);
-            os << "  %" << gep->GetName() << " = getelementptr ";
+            auto* base = gep->GetBase();
-            // Print element type first, then the pointer type and pointer value
+            // 全局数组用双下标 GEP，局部 alloca 用平坦 GEP。
-            const auto ptrType = gep->GetPtr()->GetType();
+            if (auto* gv = dynamic_cast<const GlobalVariable*>(base)) {
-            const PointerType* pty = static_cast<const PointerType*>(ptrType.get());
+              if (gv->IsArray()) {
-            os << TypeToString(*pty->GetPointeeType()) << ", "
+                os << "  " << gep->GetName()
-               << TypeToString(*ptrType) << " " << ValueToString(gep->GetPtr());
+                   << " = getelementptr [" << gv->GetCount() << " x i32], ["
-            for (auto* idx : gep->GetIndices()) {
+                   << gv->GetCount() << " x i32]* @" << gv->GetName()
-              os << ", " << TypeToString(*idx->GetType()) << " " << ValueToString(idx);
+                   << ", i32 0, i32 " << ValueToString(gep->GetIndex()) << "\n";
+                break;
+              }
             }
-            os << "\n";
+            os << "  " << gep->GetName()
+               << " = getelementptr i32, i32* " << ValueToString(base)
+               << ", i32 " << ValueToString(gep->GetIndex()) << "\n";
             break;
           }
-          case Opcode::Phi: {
+          case Opcode::Ret: {
-            auto* phi = static_cast<const PhiInst*>(inst);
+            auto* ret = static_cast<const ReturnInst*>(inst);
-            os << "  %" << phi->GetName() << " = phi "
+            auto* retval = ret->GetValue();
-              << TypeToString(*phi->GetType());
+            if (!retval) {
-            for (const auto& incoming : phi->GetIncomings()) {
+              os << "  ret void\n";
-              os << " [ " << ValueToString(incoming.first) << ", %"
+            } else {
-                 << incoming.second->GetName() << " ]";
+              os << "  ret " << TypeToString(*retval->GetType()) << " "
+                 << ValueToString(retval) << "\n";
             }
-            os << "\n";
             break;
           }
         }

src/ir/Instruction.cpp

@@ -3,11 +3,30 @@
 // - 指令操作数与结果类型管理，支持打印与优化
 #include "ir/IR.h"
 
+#include <algorithm>
 #include <stdexcept>
+#include <utility>
 
 #include "utils/Log.h"
 
 namespace ir {
+
+namespace {
+
+const char* TypeKindToString(Type::Kind k) {
+  switch (k) {
+    case Type::Kind::Void:
+      return "void";
+    case Type::Kind::Int32:
+      return "i32";
+    case Type::Kind::PtrInt32:
+      return "i32*";
+  }
+  return "?";
+}
+
+}  // namespace
+
 User::User(std::shared_ptr<Type> ty, std::string name)
     : Value(std::move(ty), std::move(name)) {}
 
@@ -53,18 +72,43 @@ Instruction::Instruction(Opcode op, std::shared_ptr<Type> ty, std::string name)
 Opcode Instruction::GetOpcode() const { return opcode_; }
 
 bool Instruction::IsTerminator() const {
-  return opcode_ == Opcode::Ret || opcode_ == Opcode::Br || opcode_ == Opcode::CondBr;
+  return opcode_ == Opcode::Ret || opcode_ == Opcode::Br ||
+         opcode_ == Opcode::CondBr;
 }
 
 BasicBlock* Instruction::GetParent() const { return parent_; }
 
-void Instruction::SetParent(BasicBlock* parent) { parent_ = parent; }
+void Instruction::SetParent(BasicBlock* parent) {
+  parent_ = parent;
+  if (!parent_) {
+    return;
+  }
+  if (auto* br = dynamic_cast<BranchInst*>(this)) {
+    auto* target = br->GetTarget();
+    parent_->AddSuccessor(target);
+    target->AddPredecessor(parent_);
+    return;
+  }
+  if (auto* cbr = dynamic_cast<CondBranchInst*>(this)) {
+    auto* true_bb = cbr->GetTrueBlock();
+    auto* false_bb = cbr->GetFalseBlock();
+    parent_->AddSuccessor(true_bb);
+    true_bb->AddPredecessor(parent_);
+    parent_->AddSuccessor(false_bb);
+    false_bb->AddPredecessor(parent_);
+  }
+}
+
+static bool IsBinaryOpcode(Opcode op) {
+  return op == Opcode::Add || op == Opcode::Sub || op == Opcode::Mul ||
+         op == Opcode::Div || op == Opcode::Mod;
+}
 
 BinaryInst::BinaryInst(Opcode op, std::shared_ptr<Type> ty, Value* lhs,
                        Value* rhs, std::string name)
     : Instruction(op, std::move(ty), std::move(name)) {
-  if (op != Opcode::Add && op != Opcode::Sub && op != Opcode::Mul && op != Opcode::Div && op != Opcode::Mod) {
+  if (!IsBinaryOpcode(op)) {
-    throw std::runtime_error(FormatError("ir", "BinaryInst 当前只支持算术操作"));
+    throw std::runtime_error(FormatError("ir", "BinaryInst 非法二元操作码"));
   }
   if (!lhs || !rhs) {
     throw std::runtime_error(FormatError("ir", "BinaryInst 缺少操作数"));
@@ -76,8 +120,8 @@ BinaryInst::BinaryInst(Opcode op, std::shared_ptr<Type> ty, Value* lhs,
       type_->GetKind() != lhs->GetType()->GetKind()) {
     throw std::runtime_error(FormatError("ir", "BinaryInst 类型不匹配"));
   }
-  if (!type_->IsInt32() && !type_->IsFloat32()) {
+  if (!type_->IsInt32()) {
-    throw std::runtime_error(FormatError("ir", "BinaryInst 当前只支持 i32 和 float"));
+    throw std::runtime_error(FormatError("ir", "BinaryInst 当前只支持 i32"));
   }
   AddOperand(lhs);
   AddOperand(rhs);
@@ -87,24 +131,63 @@ Value* BinaryInst::GetLhs() const { return GetOperand(0); }
 
 Value* BinaryInst::GetRhs() const { return GetOperand(1); }
 
+CmpInst::CmpInst(CmpOp op, std::shared_ptr<Type> ty, Value* lhs, Value* rhs,
+                 std::string name)
+    : Instruction(Opcode::Cmp, std::move(ty), std::move(name)), cmp_op_(op) {
+  if (!lhs || !rhs) {
+    throw std::runtime_error(FormatError("ir", "CmpInst 缺少操作数"));
+  }
+  if (!type_ || !lhs->GetType() || !rhs->GetType()) {
+    throw std::runtime_error(FormatError("ir", "CmpInst 缺少类型信息"));
+  }
+  if (!type_->IsInt32()) {
+    throw std::runtime_error(FormatError("ir", "CmpInst 结果类型必须为 i32"));
+  }
+  if (!lhs->GetType()->IsInt32() || !rhs->GetType()->IsInt32()) {
+    throw std::runtime_error(FormatError(
+        "ir", "CmpInst 当前只支持 i32 比较，实际为 " +
+                   std::string(TypeKindToString(lhs->GetType()->GetKind())) +
+                   " 与 " +
+                   std::string(TypeKindToString(rhs->GetType()->GetKind()))));
+  }
+  AddOperand(lhs);
+  AddOperand(rhs);
+}
+
+CmpOp CmpInst::GetCmpOp() const { return cmp_op_; }
+
+Value* CmpInst::GetLhs() const { return GetOperand(0); }
+
+Value* CmpInst::GetRhs() const { return GetOperand(1); }
+
 ReturnInst::ReturnInst(std::shared_ptr<Type> void_ty, Value* val)
     : Instruction(Opcode::Ret, std::move(void_ty), "") {
   if (!type_ || !type_->IsVoid()) {
     throw std::runtime_error(FormatError("ir", "ReturnInst 返回类型必须为 void"));
   }
-  // val may be nullptr to represent a void return; only add operand when
-  // a returned value is present.
   if (val) {
     AddOperand(val);
   }
 }
 
-Value* ReturnInst::GetValue() const { return GetOperand(0); }
+Value* ReturnInst::GetValue() const {
+  return GetNumOperands() > 0 ? GetOperand(0) : nullptr;
+}
 
 AllocaInst::AllocaInst(std::shared_ptr<Type> ptr_ty, std::string name)
-    : Instruction(Opcode::Alloca, std::move(ptr_ty), std::move(name)) {
+    : Instruction(Opcode::Alloca, std::move(ptr_ty), std::move(name)), count_(1) {
-  if (!type_ || !type_->IsPointer()) {
+  if (!type_ || !type_->IsPtrInt32()) {
-    throw std::runtime_error(FormatError("ir", "AllocaInst 类型必须为指针"));
+    throw std::runtime_error(FormatError("ir", "AllocaInst 当前只支持 i32*"));
+  }
+}
+
+AllocaInst::AllocaInst(std::shared_ptr<Type> ptr_ty, std::string name, int count)
+    : Instruction(Opcode::Alloca, std::move(ptr_ty), std::move(name)), count_(count) {
+  if (!type_ || !type_->IsPtrInt32()) {
+    throw std::runtime_error(FormatError("ir", "AllocaInst 当前只支持 i32*"));
+  }
+  if (count_ <= 0) {
+    throw std::runtime_error(FormatError("ir", "AllocaInst 数组大小必须为正数"));
   }
 }
 
@@ -113,12 +196,12 @@ LoadInst::LoadInst(std::shared_ptr<Type> val_ty, Value* ptr, std::string name)
   if (!ptr) {
     throw std::runtime_error(FormatError("ir", "LoadInst 缺少 ptr"));
   }
-  if (!ptr->GetType() || !ptr->GetType()->IsPointer()) {
+  if (!type_ || !type_->IsInt32()) {
-    throw std::runtime_error(FormatError("ir", "LoadInst ptr 必须为指针类型"));
+    throw std::runtime_error(FormatError("ir", "LoadInst 当前只支持加载 i32"));
   }
-  const auto* ptr_ty = static_cast<const PointerType*>(ptr->GetType().get());
+  if (!ptr->GetType() || !ptr->GetType()->IsPtrInt32()) {
-  if (!type_ || *type_ != *ptr_ty->GetPointeeType()) {
+    throw std::runtime_error(
-    throw std::runtime_error(FormatError("ir", "LoadInst 类型不匹配"));
+        FormatError("ir", "LoadInst 当前只支持从 i32* 加载"));
   }
   AddOperand(ptr);
 }
@@ -136,12 +219,12 @@ StoreInst::StoreInst(std::shared_ptr<Type> void_ty, Value* val, Value* ptr)
   if (!type_ || !type_->IsVoid()) {
     throw std::runtime_error(FormatError("ir", "StoreInst 返回类型必须为 void"));
   }
-  if (!ptr->GetType() || !ptr->GetType()->IsPointer()) {
+  if (!val->GetType() || !val->GetType()->IsInt32()) {
-    throw std::runtime_error(FormatError("ir", "StoreInst ptr 必须为指针类型"));
+    throw std::runtime_error(FormatError("ir", "StoreInst 当前只支持存储 i32"));
   }
-  const auto* ptr_ty = static_cast<const PointerType*>(ptr->GetType().get());
+  if (!ptr->GetType() || !ptr->GetType()->IsPtrInt32()) {
-  if (!val->GetType() || *val->GetType() != *ptr_ty->GetPointeeType()) {
+    throw std::runtime_error(
-    throw std::runtime_error(FormatError("ir", "StoreInst 类型不匹配"));
+        FormatError("ir", "StoreInst 当前只支持写入 i32*"));
   }
   AddOperand(val);
   AddOperand(ptr);
@@ -151,32 +234,33 @@ Value* StoreInst::GetValue() const { return GetOperand(0); }
 
 Value* StoreInst::GetPtr() const { return GetOperand(1); }
 
-CmpInst::CmpInst(Opcode op, Predicate pred, Value* lhs, Value* rhs, std::string name)
+BranchInst::BranchInst(std::shared_ptr<Type> void_ty, BasicBlock* target)
-    : Instruction(op, Type::GetInt32Type(), std::move(name)), pred_(pred), lhs_(lhs), rhs_(rhs) {
+    : Instruction(Opcode::Br, std::move(void_ty), "") {
-  if (op != Opcode::ICmp && op != Opcode::FCmp) {
-    throw std::runtime_error(FormatError("ir", "CmpInst 仅支持 ICmp 和 FCmp"));
-  }
-  if (!lhs || !rhs) {
-    throw std::runtime_error(FormatError("ir", "CmpInst 缺少操作数"));
-  }
-  AddOperand(lhs);
-  AddOperand(rhs);
-}
-
-BranchInst::BranchInst(BasicBlock* target)
-    : Instruction(Opcode::Br, Type::GetVoidType(), "") {
   if (!target) {
-    throw std::runtime_error(FormatError("ir", "BranchInst 缺少目标基本块"));
+    throw std::runtime_error(FormatError("ir", "BranchInst 缺少目标块"));
+  }
+  if (!type_ || !type_->IsVoid()) {
+    throw std::runtime_error(FormatError("ir", "BranchInst 返回类型必须为 void"));
   }
   AddOperand(target);
 }
 
-BasicBlock* BranchInst::GetTarget() const { return static_cast<BasicBlock*>(GetOperand(0)); }
+BasicBlock* BranchInst::GetTarget() const {
+  return static_cast<BasicBlock*>(GetOperand(0));
+}
 
-CondBranchInst::CondBranchInst(Value* cond, BasicBlock* true_bb, BasicBlock* false_bb)
+CondBranchInst::CondBranchInst(std::shared_ptr<Type> void_ty, Value* cond,
-    : Instruction(Opcode::CondBr, Type::GetVoidType(), "") {
+                               BasicBlock* true_bb, BasicBlock* false_bb)
+    : Instruction(Opcode::CondBr, std::move(void_ty), "") {
   if (!cond || !true_bb || !false_bb) {
-    throw std::runtime_error(FormatError("ir", "CondBranchInst 缺少操作数"));
+    throw std::runtime_error(FormatError("ir", "CondBranchInst 参数不完整"));
+  }
+  if (!type_ || !type_->IsVoid()) {
+    throw std::runtime_error(
+        FormatError("ir", "CondBranchInst 返回类型必须为 void"));
+  }
+  if (!cond->GetType() || !cond->GetType()->IsInt32()) {
+    throw std::runtime_error(FormatError("ir", "CondBranchInst 条件必须为 i32"));
   }
   AddOperand(cond);
   AddOperand(true_bb);
@@ -184,46 +268,39 @@ CondBranchInst::CondBranchInst(Value* cond, BasicBlock* true_bb, BasicBlock* fal
 }
 
 Value* CondBranchInst::GetCond() const { return GetOperand(0); }
-BasicBlock* CondBranchInst::GetTrueBlock() const { return static_cast<BasicBlock*>(GetOperand(1)); }
-BasicBlock* CondBranchInst::GetFalseBlock() const { return static_cast<BasicBlock*>(GetOperand(2)); }
 
-CallInst::CallInst(Function* callee, std::vector<Value*> args, std::string name)
+BasicBlock* CondBranchInst::GetTrueBlock() const {
-    : Instruction(Opcode::Call, callee->GetType(), std::move(name)) {
+  return static_cast<BasicBlock*>(GetOperand(1));
-  if (!callee) {
-    throw std::runtime_error(FormatError("ir", "CallInst 缺少被调用函数"));
-  }
-  AddOperand(callee);
-  for (auto* arg : args) {
-    if (!arg) {
-      throw std::runtime_error(FormatError("ir", "CallInst 参数不能为空"));
-    }
-    AddOperand(arg);
-  }
 }
 
-PhiInst::PhiInst(std::shared_ptr<Type> ty, std::string name)
+BasicBlock* CondBranchInst::GetFalseBlock() const {
-    : Instruction(Opcode::Phi, std::move(ty), std::move(name)) {}
+  return static_cast<BasicBlock*>(GetOperand(2));
-
-void PhiInst::AddIncoming(Value* val, BasicBlock* block) {
-  if (!val || !block) {
-    throw std::runtime_error(FormatError("ir", "PhiInst AddIncoming 参数不能为空"));
-  }
-  AddOperand(val);
-  AddOperand(block);
 }
 
-GetElementPtrInst::GetElementPtrInst(std::shared_ptr<Type> ty, Value* ptr,
+CallInst::CallInst(std::shared_ptr<Type> ret_ty, Function* callee,
-                                     std::vector<Value*> indices, std::string name)
+                   std::vector<Value*> args, std::string name)
-    : Instruction(Opcode::GEP, std::move(ty), std::move(name)) {
+    : Instruction(Opcode::Call, std::move(ret_ty), std::move(name)) {
-  if (!ptr) {
+  if (!callee) {
-    throw std::runtime_error(FormatError("ir", "GetElementPtrInst 缺少指针"));
+    throw std::runtime_error(FormatError("ir", "CallInst 缺少被调函数"));
   }
-  AddOperand(ptr);
+  const auto& param_types = callee->GetParamTypes();
-  for (auto* idx : indices) {
+  if (args.size() != param_types.size()) {
-    if (!idx) {
+    throw std::runtime_error(FormatError("ir", "CallInst 参数个数不匹配"));
-      throw std::runtime_error(FormatError("ir", "GetElementPtrInst 索引不能为空"));
+  }
+  if (!type_ || !callee->GetType() || type_->GetKind() != callee->GetType()->GetKind()) {
+    throw std::runtime_error(FormatError("ir", "CallInst 返回类型与函数签名不匹配"));
+  }
+
+  AddOperand(callee);
+  for (size_t i = 0; i < args.size(); ++i) {
+    auto* arg = args[i];
+    if (!arg || !arg->GetType()) {
+      throw std::runtime_error(FormatError("ir", "CallInst 存在非法参数"));
     }
-    AddOperand(idx);
+    if (!param_types[i] || arg->GetType()->GetKind() != param_types[i]->GetKind()) {
+      throw std::runtime_error(FormatError("ir", "CallInst 参数类型不匹配"));
+    }
+    AddOperand(arg);
   }
 }
 
@@ -231,40 +308,32 @@ Function* CallInst::GetCallee() const {
   return static_cast<Function*>(GetOperand(0));
 }
 
-const std::vector<Value*>& CallInst::GetArgs() const {
+size_t CallInst::GetNumArgs() const { return GetNumOperands() - 1; }
-  // 返回参数列表（跳过被调用函数）
-  static std::vector<Value*> args;
-  args.clear();
-  for (size_t i = 1; i < GetNumOperands(); ++i) {
-    args.push_back(GetOperand(i));
-  }
-  return args;
-}
 
-const std::vector<std::pair<Value*, BasicBlock*>>& PhiInst::GetIncomings() const {
+Value* CallInst::GetArg(size_t index) const {
-  // Phi 指令的操作数是成对的：值和基本块
+  if (index >= GetNumArgs()) {
-  static std::vector<std::pair<Value*, BasicBlock*>> incomings;
+    throw std::out_of_range("CallInst arg index out of range");
-  incomings.clear();
-  for (size_t i = 0; i < GetNumOperands(); i += 2) {
-    Value* val = GetOperand(i);
-    BasicBlock* block = static_cast<BasicBlock*>(GetOperand(i + 1));
-    incomings.emplace_back(val, block);
   }
-  return incomings;
+  return GetOperand(index + 1);
 }
 
-Value* GetElementPtrInst::GetPtr() const {
+GepInst::GepInst(std::shared_ptr<Type> ptr_ty, Value* base, Value* index,
-  return GetOperand(0);
+                 std::string name)
-}
+    : Instruction(Opcode::Gep, std::move(ptr_ty), std::move(name)) {
-
+  if (!base || !index) {
-const std::vector<Value*>& GetElementPtrInst::GetIndices() const {
+    throw std::runtime_error(FormatError("ir", "GepInst 缺少操作数"));
-  // 返回索引列表（跳过指针）
+  }
-  static std::vector<Value*> indices;
+  if (!base->GetType() || !base->GetType()->IsPtrInt32()) {
-  indices.clear();
+    throw std::runtime_error(FormatError("ir", "GepInst base 必须为 i32*"));
-  for (size_t i = 1; i < GetNumOperands(); ++i) {
-    indices.push_back(GetOperand(i));
   }
-  return indices;
+  if (!index->GetType() || !index->GetType()->IsInt32()) {
+    throw std::runtime_error(FormatError("ir", "GepInst index 必须为 i32"));
+  }
+  AddOperand(base);
+  AddOperand(index);
 }
 
+Value* GepInst::GetBase() const { return GetOperand(0); }
+Value* GepInst::GetIndex() const { return GetOperand(1); }
+
 }  // namespace ir

src/ir/Module.cpp

@@ -11,27 +11,35 @@ const Context& Module::GetContext() const { return context_; }
 Function* Module::CreateFunction(const std::string& name,
                                  std::shared_ptr<Type> ret_type,
                                  std::vector<std::shared_ptr<Type>> param_types) {
-  functions_.push_back(
+  functions_.push_back(std::make_unique<Function>(
-      std::make_unique<Function>(name, std::move(ret_type), std::move(param_types)));
+      name, std::move(ret_type), std::move(param_types)));
   return functions_.back().get();
 }
 
-GlobalValue* Module::CreateGlobalVariable(const std::string& name,
+const std::vector<std::unique_ptr<Function>>& Module::GetFunctions() const {
-                                          std::shared_ptr<Type> ty,
+  return functions_;
-                                          ConstantValue* init) {
+}
-  auto gv = std::make_unique<GlobalValue>(std::move(ty), name);
+
-  if (init) {
+Function* Module::FindFunction(const std::string& name) const {
-    gv->SetInitializer(init);
+  for (const auto& f : functions_) {
+    if (f && f->GetName() == name) return f.get();
   }
-  global_vars_.push_back(std::move(gv));
+  return nullptr;
+}
+
+GlobalVariable* Module::CreateGlobalVar(const std::string& name, int init_val, int count) {
+  global_vars_.push_back(std::make_unique<GlobalVariable>(name, init_val, count));
   return global_vars_.back().get();
 }
 
-const std::vector<std::unique_ptr<Function>>& Module::GetFunctions() const {
+GlobalVariable* Module::FindGlobalVar(const std::string& name) const {
-  return functions_;
+  for (const auto& gv : global_vars_) {
+    if (gv && gv->GetName() == name) return gv.get();
+  }
+  return nullptr;
 }
 
-const std::vector<std::unique_ptr<GlobalValue>>& Module::GetGlobalVariables() const {
+const std::vector<std::unique_ptr<GlobalVariable>>& Module::GetGlobalVars() const {
   return global_vars_;
 }
 

src/ir/Type.cpp

@@ -1,20 +1,8 @@
 // 当前仅支持 void、i32 和 i32*。
 #include "ir/IR.h"
-#include <unordered_map>
-#include <functional>
 
 namespace ir {
 
-// 用于缓存复合类型的静态映射（简单实现）
-static std::unordered_map<std::size_t, std::shared_ptr<Type>> pointer_cache;
-static std::unordered_map<std::size_t, std::shared_ptr<Type>> array_cache;
-static std::unordered_map<std::size_t, std::shared_ptr<Type>> function_cache;
-
-// 简单哈希组合函数
-static std::size_t hash_combine(std::size_t seed, std::size_t v) {
-    return seed ^ (v + 0x9e3779b9 + (seed << 6) + (seed >> 2));
-}
-
 Type::Type(Kind k) : kind_(k) {}
 
 const std::shared_ptr<Type>& Type::GetVoidType() {
@@ -27,133 +15,17 @@ const std::shared_ptr<Type>& Type::GetInt32Type() {
   return type;
 }
 
-const std::shared_ptr<Type>& Type::GetFloat32Type() {
-  static const std::shared_ptr<Type> type = std::make_shared<Type>(Kind::Float32);
-  return type;
-}
-
-const std::shared_ptr<Type>& Type::GetLabelType() {
-  static const std::shared_ptr<Type> type = std::make_shared<Type>(Kind::Label);
-  return type;
-}
-
-// 兼容旧的 i32* 类型，返回指向 i32 的指针类型
 const std::shared_ptr<Type>& Type::GetPtrInt32Type() {
-  static const std::shared_ptr<Type> type = GetPointerType(GetInt32Type());
+  static const std::shared_ptr<Type> type = std::make_shared<Type>(Kind::PtrInt32);
   return type;
 }
 
-std::shared_ptr<Type> Type::GetPointerType(std::shared_ptr<Type> pointee) {
-  // 简单缓存：使用 pointee 的地址作为键（实际应使用更可靠的标识，但作为演示足够）
-  std::size_t key = reinterpret_cast<std::size_t>(pointee.get());
-  auto it = pointer_cache.find(key);
-  if (it != pointer_cache.end()) {
-    return it->second;
-  }
-  auto ptr_type = std::make_shared<PointerType>(pointee);
-  pointer_cache[key] = ptr_type;
-  return ptr_type;
-}
-
-std::shared_ptr<Type> Type::GetArrayType(std::shared_ptr<Type> elem, size_t size) {
-  // 使用元素类型指针和大小组合哈希
-  std::size_t seed = 0;
-  seed = hash_combine(seed, reinterpret_cast<std::size_t>(elem.get()));
-  seed = hash_combine(seed, size);
-  auto it = array_cache.find(seed);
-  if (it != array_cache.end()) {
-    return it->second;
-  }
-  auto arr_type = std::make_shared<ArrayType>(elem, size);
-  array_cache[seed] = arr_type;
-  return arr_type;
-}
-
-std::shared_ptr<Type> Type::GetFunctionType(std::shared_ptr<Type> ret,
-                                            std::vector<std::shared_ptr<Type>> params) {
-  // 哈希组合：返回类型 + 参数类型列表
-  std::size_t seed = reinterpret_cast<std::size_t>(ret.get());
-  for (const auto& p : params) {
-    seed = hash_combine(seed, reinterpret_cast<std::size_t>(p.get()));
-  }
-  auto it = function_cache.find(seed);
-  if (it != function_cache.end()) {
-    return it->second;
-  }
-  auto func_type = std::make_shared<FunctionType>(ret, std::move(params));
-  function_cache[seed] = func_type;
-  return func_type;
-}
-
 Type::Kind Type::GetKind() const { return kind_; }
 
 bool Type::IsVoid() const { return kind_ == Kind::Void; }
 
 bool Type::IsInt32() const { return kind_ == Kind::Int32; }
 
-bool Type::IsFloat32() const { return kind_ == Kind::Float32; }
+bool Type::IsPtrInt32() const { return kind_ == Kind::PtrInt32; }
-
-bool Type::IsPointer() const { return kind_ == Kind::Pointer; }
-
-bool Type::IsArray() const { return kind_ == Kind::Array; }
-
-bool Type::IsFunction() const { return kind_ == Kind::Function; }
-
-bool Type::IsLabel() const { return kind_ == Kind::Label; }
-
-// 兼容旧代码，检查是否为 i32* 类型
-bool Type::IsPtrInt32() const {
-  if (!IsPointer()) return false;
-  const auto* ptr_ty = static_cast<const PointerType*>(this);
-  return ptr_ty->GetPointeeType()->IsInt32();
-}
-
-// 检查是否为 float32* 类型
-bool Type::IsPtrFloat32() const {
-  if (!IsPointer()) return false;
-  const auto* ptr_ty = static_cast<const PointerType*>(this);
-  return ptr_ty->GetPointeeType()->IsFloat32();
-}
-
-bool Type::operator==(const Type& other) const {
-  if (kind_ != other.kind_) return false;
-  
-  switch (kind_) {
-    case Kind::Void:
-    case Kind::Int32:
-    case Kind::Float32:
-    case Kind::Label:
-      return true;
-    case Kind::Pointer: {
-      const auto* this_ptr = static_cast<const PointerType*>(this);
-      const auto* other_ptr = static_cast<const PointerType*>(&other);
-      return *this_ptr->GetPointeeType() == *other_ptr->GetPointeeType();
-    }
-    case Kind::Array: {
-      const auto* this_arr = static_cast<const ArrayType*>(this);
-      const auto* other_arr = static_cast<const ArrayType*>(&other);
-      return this_arr->GetSize() == other_arr->GetSize() &&
-             *this_arr->GetElementType() == *other_arr->GetElementType();
-    }
-    case Kind::Function: {
-      const auto* this_func = static_cast<const FunctionType*>(this);
-      const auto* other_func = static_cast<const FunctionType*>(&other);
-      if (*this_func->GetReturnType() != *other_func->GetReturnType()) return false;
-      const auto& this_params = this_func->GetParamTypes();
-      const auto& other_params = other_func->GetParamTypes();
-      if (this_params.size() != other_params.size()) return false;
-      for (size_t i = 0; i < this_params.size(); ++i) {
-        if (*this_params[i] != *other_params[i]) return false;
-      }
-      return true;
-    }
-    default:
-      return false;
-  }
-}
-
-bool Type::operator!=(const Type& other) const {
-  return !(*this == other);
-}
 
-}  // namespace ir
+}  // namespace ir

src/ir/Value.cpp

@@ -20,19 +20,7 @@ bool Value::IsVoid() const { return type_ && type_->IsVoid(); }
 
 bool Value::IsInt32() const { return type_ && type_->IsInt32(); }
 
-bool Value::IsPtrInt32() const {
+bool Value::IsPtrInt32() const { return type_ && type_->IsPtrInt32(); }
-  if (!type_ || !type_->IsPointer()) return false;
-  const auto* ptr_ty = static_cast<const PointerType*>(type_.get());
-  return ptr_ty->GetPointeeType()->IsInt32();
-}
-
-bool Value::IsPtrFloat32() const {
-  if (!type_ || !type_->IsPointer()) return false;
-  const auto* ptr_ty = static_cast<const PointerType*>(type_.get());
-  return ptr_ty->GetPointeeType()->IsFloat32();
-}
-
-bool Value::IsFloat32() const { return type_ && type_->IsFloat32(); }
 
 bool Value::IsConstant() const {
   return dynamic_cast<const ConstantValue*>(this) != nullptr;
@@ -50,10 +38,6 @@ bool Value::IsFunction() const {
   return dynamic_cast<const Function*>(this) != nullptr;
 }
 
-bool Value::IsGlobalValue() const {
-  return dynamic_cast<const GlobalValue*>(this) != nullptr;
-}
-
 void Value::AddUse(User* user, size_t operand_index) {
   if (!user) return;
   uses_.push_back(Use(this, user, operand_index));
@@ -96,11 +80,4 @@ ConstantValue::ConstantValue(std::shared_ptr<Type> ty, std::string name)
 ConstantInt::ConstantInt(std::shared_ptr<Type> ty, int v)
     : ConstantValue(std::move(ty), ""), value_(v) {}
 
-ConstantFloat::ConstantFloat(std::shared_ptr<Type> ty, float v)
-    : ConstantValue(std::move(ty), ""), value_(v) {}
-
-ConstantArray::ConstantArray(std::shared_ptr<Type> ty,
-                             std::vector<ConstantValue*> elems)
-    : ConstantValue(std::move(ty), ""), elements_(std::move(elems)) {}
-
 }  // namespace ir

src/irgen/CMakeLists.txt

@@ -4,6 +4,7 @@ add_library(irgen STATIC
   IRGenStmt.cpp
   IRGenExp.cpp
   IRGenDecl.cpp
+  IRGenConstEval.cpp
 )
 
 target_link_libraries(irgen PUBLIC

src/irgen/IRGenConstEval.cpp

@@ -0,0 +1,95 @@
+#include "irgen/IRGen.h"
+
+#include <stdexcept>
+#include <string>
+
+#include "SysYParser.h"
+#include "utils/Log.h"
+
+// 内部辅助：不依赖类成员，只需 ConstEnv。
+namespace {
+
+int EvalAddExp(SysYParser::AddExpContext* ctx,
+               const IRGenImpl::ConstEnv& env);
+int EvalMulExp(SysYParser::MulExpContext* ctx,
+               const IRGenImpl::ConstEnv& env);
+int EvalUnaryExp(SysYParser::UnaryExpContext* ctx,
+                 const IRGenImpl::ConstEnv& env);
+
+int EvalPrimary(SysYParser::PrimaryExpContext* ctx,
+                const IRGenImpl::ConstEnv& env) {
+  if (!ctx) throw std::runtime_error(FormatError("consteval", "空主表达式"));
+  if (ctx->number()) {
+    if (!ctx->number()->ILITERAL())
+      throw std::runtime_error(
+          FormatError("consteval", "constExp 不支持浮点字面量"));
+    return std::stoi(ctx->number()->getText());
+  }
+  if (ctx->exp()) return EvalAddExp(ctx->exp()->addExp(), env);
+  if (ctx->lValue()) {
+    if (!ctx->lValue()->ID())
+      throw std::runtime_error(FormatError("consteval", "非法 lValue"));
+    const std::string name = ctx->lValue()->ID()->getText();
+    auto it = env.find(name);
+    if (it == env.end())
+      throw std::runtime_error(
+          FormatError("consteval", "constExp 引用非 const 变量: " + name));
+    return it->second;
+  }
+  throw std::runtime_error(FormatError("consteval", "不支持的主表达式形式"));
+}
+
+int EvalUnaryExp(SysYParser::UnaryExpContext* ctx,
+                 const IRGenImpl::ConstEnv& env) {
+  if (!ctx) throw std::runtime_error(FormatError("consteval", "空一元表达式"));
+  if (ctx->primaryExp()) return EvalPrimary(ctx->primaryExp(), env);
+  if (ctx->unaryOp() && ctx->unaryExp()) {
+    int v = EvalUnaryExp(ctx->unaryExp(), env);
+    if (ctx->unaryOp()->SUB()) return -v;
+    if (ctx->unaryOp()->ADD()) return v;
+    if (ctx->unaryOp()->NOT()) return (v == 0) ? 1 : 0;
+  }
+  throw std::runtime_error(
+      FormatError("consteval", "函数调用不能出现在 constExp 中"));
+}
+
+int EvalMulExp(SysYParser::MulExpContext* ctx,
+               const IRGenImpl::ConstEnv& env) {
+  if (!ctx) throw std::runtime_error(FormatError("consteval", "空乘法表达式"));
+  if (ctx->mulExp()) {
+    int lhs = EvalMulExp(ctx->mulExp(), env);
+    int rhs = EvalUnaryExp(ctx->unaryExp(), env);
+    if (ctx->MUL()) return lhs * rhs;
+    if (ctx->DIV()) { if (!rhs) throw std::runtime_error("除以零"); return lhs / rhs; }
+    if (ctx->MOD()) { if (!rhs) throw std::runtime_error("模零"); return lhs % rhs; }
+    throw std::runtime_error(FormatError("consteval", "未知乘法运算符"));
+  }
+  return EvalUnaryExp(ctx->unaryExp(), env);
+}
+
+int EvalAddExp(SysYParser::AddExpContext* ctx,
+               const IRGenImpl::ConstEnv& env) {
+  if (!ctx) throw std::runtime_error(FormatError("consteval", "空加法表达式"));
+  if (ctx->addExp()) {
+    int lhs = EvalAddExp(ctx->addExp(), env);
+    int rhs = EvalMulExp(ctx->mulExp(), env);
+    if (ctx->ADD()) return lhs + rhs;
+    if (ctx->SUB()) return lhs - rhs;
+    throw std::runtime_error(FormatError("consteval", "未知加法运算符"));
+  }
+  return EvalMulExp(ctx->mulExp(), env);
+}
+
+}  // namespace
+
+int IRGenImpl::EvalConstExpr(SysYParser::ConstExpContext* ctx) const {
+  if (!ctx || !ctx->addExp())
+    throw std::runtime_error(FormatError("consteval", "空 constExp"));
+  return EvalAddExp(ctx->addExp(), const_env_);
+}
+
+int IRGenImpl::EvalExpAsConst(SysYParser::ExpContext* ctx) const {
+  if (!ctx || !ctx->addExp())
+    throw std::runtime_error(FormatError("consteval", "空 exp"));
+  return EvalAddExp(ctx->addExp(), const_env_);
+}

src/irgen/IRGenDecl.cpp

@@ -5,11 +5,8 @@
 #include "SysYParser.h"
 #include "ir/IR.h"
 #include "utils/Log.h"
-#include <functional>
 
-// helper functions removed; VarDef uses Ident() directly per current grammar.
+std::any IRGenImpl::visitBlockStmt(SysYParser::BlockStmtContext* ctx) {
-
-std::any IRGenImpl::visitBlock(SysYParser::BlockContext* ctx) {
   if (!ctx) {
     throw std::runtime_error(FormatError("irgen", "缺少语句块"));
   }
@@ -23,52 +20,6 @@ std::any IRGenImpl::visitBlock(SysYParser::BlockContext* ctx) {
   return {};
 }
 
-std::any IRGenImpl::visitConstDef(SysYParser::ConstDefContext* ctx) {
-  if (!ctx) throw std::runtime_error(FormatError("irgen", "缺少常量定义"));
-  if (!ctx->Ident()) throw std::runtime_error(FormatError("irgen", "常量声明缺少名称"));
-  if (!ctx->constInitVal()) throw std::runtime_error(FormatError("irgen", "常量必须初始化"));
-  if (storage_map_.find(ctx) != storage_map_.end()) throw std::runtime_error(FormatError("irgen", "声明重复生成存储槽位"));
-
-  auto* slot = (current_btype_ == "float") ?
-                   static_cast<ir::AllocaInst*>(builder_.CreateAllocaFloat(module_.GetContext().NextTemp())) :
-                   static_cast<ir::AllocaInst*>(builder_.CreateAllocaI32(module_.GetContext().NextTemp()));
-  storage_map_[ctx] = slot;
-  name_map_[ctx->Ident()->getText()] = slot;
-
-  // Try to evaluate a scalar const initializer
-  ir::ConstantValue* cinit = nullptr;
-  try {
-    auto* initval = ctx->constInitVal();
-    if (initval && initval->constExp() && initval->constExp()->addExp()) {
-      if (current_btype_ == "float") {
-        auto* add = initval->constExp()->addExp();
-        float fv = std::stof(add->getText());
-        cinit = module_.GetContext().GetConstFloat(fv);
-      } else {
-        auto* add = initval->constExp()->addExp();
-        int iv = std::stoi(add->getText());
-        cinit = module_.GetContext().GetConstInt(iv);
-      }
-    }
-  } catch(...) {
-    // fallback: try evaluate via visitor
-    try {
-      auto* add = ctx->constInitVal()->constExp()->addExp();
-      ir::Value* v = std::any_cast<ir::Value*>(add->accept(this));
-      if (auto* cv = dynamic_cast<ir::ConstantValue*>(v)) cinit = cv;
-    } catch(...) {}
-  }
-  if (cinit) builder_.CreateStore(cinit, slot);
-  else builder_.CreateStore((current_btype_=="float"? (ir::Value*)module_.GetContext().GetConstFloat(0.0f) : (ir::Value*)module_.GetContext().GetConstInt(0)), slot);
-  // record simple integer consts for dimension evaluation
-  try {
-    if (auto* ci = dynamic_cast<ir::ConstantInt*>(cinit)) {
-      const_values_[ctx->Ident()->getText()] = ci->GetValue();
-    }
-  } catch(...) {}
-  return {};
-}
-
 IRGenImpl::BlockFlow IRGenImpl::VisitBlockItemResult(
     SysYParser::BlockItemContext& item) {
   return std::any_cast<BlockFlow>(item.accept(this));
@@ -88,209 +39,267 @@ std::any IRGenImpl::visitBlockItem(SysYParser::BlockItemContext* ctx) {
   throw std::runtime_error(FormatError("irgen", "暂不支持的语句或声明"));
 }
 
-// 变量声明的 IR 生成目前也是最小实现：
-// - 先检查声明的基础类型，当前仅支持局部 int；
-// - 再把 Decl 中的变量定义交给 visitVarDef 继续处理。
-//
-// 和更完整的版本相比，这里还没有：
-// - 一个 Decl 中多个变量定义的顺序处理；
-// - const、数组、全局变量等不同声明形态；
-// - 更丰富的类型系统。
 std::any IRGenImpl::visitDecl(SysYParser::DeclContext* ctx) {
   if (!ctx) {
     throw std::runtime_error(FormatError("irgen", "缺少变量声明"));
   }
+  if (ctx->constDecl()) {
+    return ctx->constDecl()->accept(this);
+  }
   if (ctx->varDecl()) {
-    auto* vdecl = ctx->varDecl();
+    return ctx->varDecl()->accept(this);
-    if (!vdecl->bType() || vdecl->bType()->getText() != "int") {
+  }
-      throw std::runtime_error(FormatError("irgen", "当前仅支持局部 int 变量声明"));
+  return {};
+}
+
+// ─── 工具：扁平化 constInitValue ──────────────────────────────────────────
+// 将嵌套的 const 初始化列表展开为长度 total 的整数数组。
+// 遵循 C99 数组初始化规则：
+//   - 标量直接填一格
+//   - 大括号子列表对齐到 sub_size 边界，填满后补零
+
+void IRGenImpl::FlattenConstInit(SysYParser::ConstInitValueContext* ctx,
+                                  const std::vector<int>& dims, int dim_idx,
+                                  std::vector<int>& out, int& pos) {
+  if (!ctx) return;
+
+  if (ctx->constExp()) {
+    // 标量叶节点
+    out[pos++] = EvalConstExpr(ctx->constExp());
+    return;
+  }
+
+  // 大括号列表
+  int sub_size = 1;
+  for (int i = dim_idx + 1; i < (int)dims.size(); i++) sub_size *= dims[i];
+  int agg_size = (dim_idx < (int)dims.size()) ? dims[dim_idx] * sub_size : 1;
+  int start = pos;
+
+  for (auto* item : ctx->constInitValue()) {
+    if (!item || pos >= start + agg_size) break;
+    if (item->constExp()) {
+      // 标量：直接填当前位置
+      out[pos++] = EvalConstExpr(item->constExp());
+    } else {
+      // 嵌套大括号：对齐到 sub_size 边界
+      if (sub_size > 1) {
+        int offset = pos - start;
+        int rem = offset % sub_size;
+        if (rem != 0) pos += sub_size - rem;
+      }
+      int sub_start = pos;
+      FlattenConstInit(item, dims, dim_idx + 1, out, pos);
+      // 补零到子聚合末尾
+      int sub_end = sub_start + sub_size;
+      while (pos < sub_end && pos < start + agg_size) out[pos++] = 0;
     }
-    for (auto* var_def : vdecl->varDef()) {
+  }
-      if (var_def) var_def->accept(this);
+  // 剩余补零
+  while (pos < start + agg_size) out[pos++] = 0;
+}
+
+// ─── 工具：扁平化 initValue ───────────────────────────────────────────────
+void IRGenImpl::FlattenInit(SysYParser::InitValueContext* ctx,
+                             const std::vector<int>& dims, int dim_idx,
+                             std::vector<ir::Value*>& out, int& pos) {
+  if (!ctx) return;
+
+  if (ctx->exp()) {
+    out[pos++] = EvalExpr(*ctx->exp());
+    return;
+  }
+
+  int sub_size = 1;
+  for (int i = dim_idx + 1; i < (int)dims.size(); i++) sub_size *= dims[i];
+  int agg_size = (dim_idx < (int)dims.size()) ? dims[dim_idx] * sub_size : 1;
+  int start = pos;
+
+  for (auto* item : ctx->initValue()) {
+    if (!item || pos >= start + agg_size) break;
+    if (item->exp()) {
+      out[pos++] = EvalExpr(*item->exp());
+    } else {
+      if (sub_size > 1) {
+        int offset = pos - start;
+        int rem = offset % sub_size;
+        if (rem != 0) pos += sub_size - rem;  // zeros already in out
+      }
+      int sub_start = pos;
+      FlattenInit(item, dims, dim_idx + 1, out, pos);
+      int sub_end = sub_start + sub_size;
+      while (pos < sub_end && pos < start + agg_size) pos++;  // zeros
     }
-    return {};
   }
-  if (ctx->constDecl()) {
+  while (pos < start + agg_size) pos++;  // zeros
-    auto* cdecl = ctx->constDecl();
+}
-    if (!cdecl->bType()) throw std::runtime_error(FormatError("irgen", "缺少常量基类型"));
+
-    current_btype_ = cdecl->bType()->getText();
+// ─── const 声明 ───────────────────────────────────────────────────────────
-    if (current_btype_ != "int" && current_btype_ != "float") throw std::runtime_error(FormatError("irgen", "当前仅支持局部 int/float 常量声明"));
+
-    for (auto* const_def : cdecl->constDef()) if (const_def) const_def->accept(this);
+std::any IRGenImpl::visitConstDecl(SysYParser::ConstDeclContext* ctx) {
-    current_btype_.clear();
+  if (!ctx) return {};
+  if (!ctx->btype() || !ctx->btype()->INT()) {
+    throw std::runtime_error(FormatError("irgen", "当前仅支持 int const 声明"));
+  }
+  for (auto* def : ctx->constDef()) {
+    if (def) def->accept(this);
+  }
+  return {};
+}
+
+std::any IRGenImpl::visitConstDef(SysYParser::ConstDefContext* ctx) {
+  if (!ctx || !ctx->ID()) return {};
+  const std::string name = ctx->ID()->getText();
+
+  // ── 标量 const ────────────────────────────────────────────────────────
+  if (ctx->LBRACK().empty()) {
+    if (!ctx->constInitValue() || !ctx->constInitValue()->constExp()) {
+      throw std::runtime_error(FormatError("irgen", "const 标量声明缺少初始值"));
+    }
+    int ival = EvalConstExpr(ctx->constInitValue()->constExp());
+    const_env_[name] = ival;  // 存入编译期环境
+
+    if (IsGlobalScope()) {
+      auto* gv = module_.CreateGlobalVar(name, ival);
+      global_storage_[name] = gv;
+    } else {
+      auto* slot = CreateEntryAllocaI32(module_.GetContext().NextTemp());
+      named_storage_[name] = slot;
+      builder_.CreateStore(builder_.CreateConstInt(ival), slot);
+    }
     return {};
   }
-  throw std::runtime_error(FormatError("irgen", "暂不支持的声明类型"));
+
+  // ── 数组 const ────────────────────────────────────────────────────────
+  std::vector<int> dims;
+  for (auto* ce : ctx->constExp()) {
+    dims.push_back(EvalConstExpr(ce));
+  }
+  int total = 1;
+  for (int d : dims) total *= d;
+
+  // 扁平化初始化值
+  std::vector<int> flat(total, 0);
+  if (ctx->constInitValue()) {
+    int pos = 0;
+    FlattenConstInit(ctx->constInitValue(), dims, 0, flat, pos);
+  }
+
+  if (IsGlobalScope()) {
+    // 全局 const 数组：创建全局数组变量（仅支持零初始化；非零初始化暂用零）
+    // TODO: 支持全局 const 数组的非零初始化
+    auto* gv = module_.CreateGlobalVar(name, 0, total);
+    global_storage_[name] = gv;
+    global_array_dims_[name] = dims;
+  } else {
+    // 局部 const 数组：alloca + 逐元素 store
+    auto* slot = CreateEntryAllocaArray(total, module_.GetContext().NextTemp());
+    named_storage_[name] = slot;
+    local_array_dims_[name] = dims;
+    for (int i = 0; i < total; i++) {
+      auto* idx = builder_.CreateConstInt(i);
+      auto* ptr = builder_.CreateGep(slot, idx, module_.GetContext().NextTemp());
+      builder_.CreateStore(builder_.CreateConstInt(flat[i]), ptr);
+    }
+  }
+  return {};
 }
 
+// ─── var 声明 ─────────────────────────────────────────────────────────────
 
-// 当前仍是教学用的最小版本，因此这里只支持：
+std::any IRGenImpl::visitVarDecl(SysYParser::VarDeclContext* ctx) {
-// - 局部 int 变量；
-// - 标量初始化；
-// - 一个 VarDef 对应一个槽位。
-std::any IRGenImpl::visitVarDef(SysYParser::VarDefContext* ctx) {
   if (!ctx) {
-    throw std::runtime_error(FormatError("irgen", "缺少变量定义"));
+    throw std::runtime_error(FormatError("irgen", "缺少变量声明"));
   }
-  if (!ctx->Ident()) {
+  if (!ctx->btype() || !ctx->btype()->INT()) {
-    throw std::runtime_error(FormatError("irgen", "变量声明缺少名称"));
+    throw std::runtime_error(FormatError("irgen", "当前仅支持 int 变量声明"));
   }
-  if (storage_map_.find(ctx) != storage_map_.end()) {
+  for (auto* var_def : ctx->varDef()) {
-    throw std::runtime_error(FormatError("irgen", "声明重复生成存储槽位"));
+    if (!var_def) {
+      throw std::runtime_error(FormatError("irgen", "非法变量声明"));
+    }
+    var_def->accept(this);
+  }
+  return {};
+}
+
+std::any IRGenImpl::visitVarDef(SysYParser::VarDefContext* ctx) {
+  if (!ctx || !ctx->ID()) {
+    throw std::runtime_error(FormatError("irgen", "变量定义缺少名称"));
   }
-  // check if this is an array declaration (has constExp dimensions)
+  const std::string name = ctx->ID()->getText();
-  if (!ctx->constExp().empty()) {
+
-    // parse dims
+  // ── 数组变量 ──────────────────────────────────────────────────────────
+  if (!ctx->LBRACK().empty()) {
     std::vector<int> dims;
     for (auto* ce : ctx->constExp()) {
-      try {
+      dims.push_back(EvalConstExpr(ce));
-        int v = 0;
-        auto anyv = sema_.GetConstVal(ce);
-        if (anyv.has_value()) {
-          if (anyv.type() == typeid(int)) v = std::any_cast<int>(anyv);
-          else if (anyv.type() == typeid(long)) v = (int)std::any_cast<long>(anyv);
-          else throw std::runtime_error("not-const-int");
-        } else {
-          // try simple patterns like NUM or IDENT+NUM or NUM+IDENT
-          std::string s = ce->addExp()->getText();
-          s.erase(std::remove_if(s.begin(), s.end(), ::isspace), s.end());
-          auto pos = s.find('+');
-          if (pos == std::string::npos) {
-            // plain number or identifier
-            try { v = std::stoi(s); }
-            catch(...) {
-              // try lookup identifier in recorded consts or symbol table
-              auto it = const_values_.find(s);
-              if (it != const_values_.end()) v = (int)it->second;
-              else {
-                VarInfo vi; void* declctx = nullptr;
-                if (sema_.GetSymbolTable().LookupVar(s, vi, declctx) && vi.const_val.has_value()) {
-                  if (vi.const_val.type() == typeid(int)) v = std::any_cast<int>(vi.const_val);
-                  else if (vi.const_val.type() == typeid(long)) v = (int)std::any_cast<long>(vi.const_val);
-                  else throw std::runtime_error("not-const-int");
-                } else throw std::runtime_error("not-const-int");
-              }
-            }
-          } else {
-            // form A+B where A or B may be ident or number
-            std::string L = s.substr(0, pos);
-            std::string R = s.substr(pos + 1);
-            int lv = 0, rv = 0; bool ok = false;
-            // try left
-            try { lv = std::stoi(L); ok = true; } catch(...) {
-              auto it = const_values_.find(L);
-              if (it != const_values_.end()) { lv = (int)it->second; ok = true; }
-              else {
-                VarInfo vi; void* declctx = nullptr;
-                if (sema_.GetSymbolTable().LookupVar(L, vi, declctx) && vi.const_val.has_value()) {
-                  if (vi.const_val.type() == typeid(int)) lv = std::any_cast<int>(vi.const_val);
-                  else if (vi.const_val.type() == typeid(long)) lv = (int)std::any_cast<long>(vi.const_val);
-                  ok = true;
-                }
-              }
-            }
-            // try right
-            try { rv = std::stoi(R); ok = ok && true; } catch(...) {
-              auto it2 = const_values_.find(R);
-              if (it2 != const_values_.end()) { rv = (int)it2->second; ok = ok && true; }
-              else {
-                VarInfo vi2; void* declctx2 = nullptr;
-                if (sema_.GetSymbolTable().LookupVar(R, vi2, declctx2) && vi2.const_val.has_value()) {
-                  if (vi2.const_val.type() == typeid(int)) rv = std::any_cast<int>(vi2.const_val);
-                  else if (vi2.const_val.type() == typeid(long)) rv = (int)std::any_cast<long>(vi2.const_val);
-                  ok = ok && true;
-                } else ok = false;
-              }
-            }
-            if (!ok) throw std::runtime_error("not-const-int");
-            v = lv + rv;
-          }
-        }
-        dims.push_back(v);
-      } catch (...) {
-        throw std::runtime_error(FormatError("irgen", "数组维度必须为常量整数"));
-      }
     }
-
-    std::shared_ptr<ir::Type> elemTy = (current_btype_ == "float") ? ir::Type::GetFloat32Type() : ir::Type::GetInt32Type();
-
-    // build nested array type
-    std::function<std::shared_ptr<ir::Type>(size_t)> makeArrayType = [&](size_t level) -> std::shared_ptr<ir::Type> {
-      if (level + 1 >= dims.size()) return ir::Type::GetArrayType(elemTy, dims[level]);
-      auto sub = makeArrayType(level + 1);
-      return ir::Type::GetArrayType(sub, dims[level]);
-    };
-    auto fullArrayTy = makeArrayType(0);
-    auto arr_ptr_ty = ir::Type::GetPointerType(fullArrayTy);
-    auto* array_slot = builder_.CreateAlloca(arr_ptr_ty, module_.GetContext().NextTemp());
-    storage_map_[ctx] = array_slot;
-    name_map_[ctx->Ident()->getText()] = array_slot;
-
-    // compute spans and total scalar slots
-    int nlevels = (int)dims.size();
-    std::vector<int> span(nlevels);
     int total = 1;
-    for (int i = nlevels - 1; i >= 0; --i) {
+    for (int d : dims) total *= d;
-      if (i == nlevels - 1) span[i] = 1;
+
-      else span[i] = span[i + 1] * dims[i + 1];
+    if (IsGlobalScope()) {
-      total *= dims[i];
+      auto* gv = module_.CreateGlobalVar(name, 0, total);
-    }
+      storage_map_[ctx] = gv;
+      global_storage_[name] = gv;
+      global_array_dims_[name] = dims;
+      // 全局数组：不支持运行时初始化（全零已足够）
+    } else {
+      auto* slot = CreateEntryAllocaArray(total, module_.GetContext().NextTemp());
+      storage_map_[ctx] = slot;
+      named_storage_[name] = slot;
+      local_array_dims_[name] = dims;
 
-    ir::Value* zero = elemTy->IsFloat32() ? (ir::Value*)module_.GetContext().GetConstFloat(0.0f) : (ir::Value*)module_.GetContext().GetConstInt(0);
+      // 先零初始化
-    std::vector<ir::Value*> slots(total, zero);
+      for (int i = 0; i < total; i++) {
-
+        auto* idx = builder_.CreateConstInt(i);
-    // process initializer (if any) into linear slots
+        auto* ptr = builder_.CreateGep(slot, idx, module_.GetContext().NextTemp());
-    if (auto* init_value = ctx->initVal()) {
+        builder_.CreateStore(builder_.CreateConstInt(0), ptr);
-      std::function<void(SysYParser::InitValContext*, int, int&)> process_group;
+      }
-      process_group = [&](SysYParser::InitValContext* init, int level, int& pos) {
+      // 如果有初始化列表，覆盖零
-        if (level >= nlevels) return;
+      if (auto* init_val = ctx->initValue()) {
-        int sub_span = span[level];
+        std::vector<ir::Value*> flat(total, nullptr);
-        int elems = dims[level];
+        int pos = 0;
-        if (!init) { pos += elems * sub_span; return; }
+        FlattenInit(init_val, dims, 0, flat, pos);
-        for (auto* child : init->initVal()) {
+        for (int i = 0; i < total; i++) {
-          if (pos >= total) break;
+          if (flat[i] != nullptr) {
-          if (!child) { pos += 1; continue; }
+            auto* idx = builder_.CreateConstInt(i);
-          if (!child->initVal().empty()) {
+            auto* ptr = builder_.CreateGep(slot, idx, module_.GetContext().NextTemp());
-            int subpos = pos;
+            builder_.CreateStore(flat[i], ptr);
-            int inner = subpos;
+          }
-            process_group(child, level + 1, inner);
-            pos = subpos + sub_span;
-          } else if (child->exp()) {
-            try { ir::Value* v = EvalExpr(*child->exp()); if (pos < total) slots[pos] = v; } catch(...) {}
-            pos += 1;
-          } else { pos += 1; }
         }
-      };
+      }
-      int pos0 = 0;
-      process_group(init_value, 0, pos0);
     }
+    return {};
+  }
 
-    // emit stores for each scalar slot in row-major order
+  // ── 标量变量 ──────────────────────────────────────────────────────────
-    for (int idx = 0; idx < total; ++idx) {
+  if (IsGlobalScope()) {
-      std::vector<int> indices;
+    int ival = 0;
-      int rem = idx;
+    if (auto* init_value = ctx->initValue()) {
-      for (int L = 0; L < nlevels; ++L) {
+      if (!init_value->exp()) {
-        int ind = rem / span[L];
+        throw std::runtime_error(
-        indices.push_back(ind % dims[L]);
+            FormatError("irgen", "全局标量变量仅支持表达式初始化"));
-        rem = rem % span[L];
       }
-      std::vector<ir::Value*> gep_inds;
+      ival = EvalExpAsConst(init_value->exp());
-      gep_inds.push_back(module_.GetContext().GetConstInt(0));
-      for (int v : indices) gep_inds.push_back(module_.GetContext().GetConstInt(v));
-      while (gep_inds.size() < (size_t)(1 + nlevels)) gep_inds.push_back(module_.GetContext().GetConstInt(0));
-      auto* gep = builder_.CreateGEP(array_slot, gep_inds, module_.GetContext().NextTemp());
-      builder_.CreateStore(slots[idx], gep);
     }
-
+    auto* gv = module_.CreateGlobalVar(name, ival);
+    storage_map_[ctx] = gv;
+    global_storage_[name] = gv;
     return {};
   }
 
-  // scalar variable
+  // 局部标量
-  auto* slot = builder_.CreateAllocaI32(module_.GetContext().NextTemp());
+  if (storage_map_.find(ctx) != storage_map_.end()) {
+    throw std::runtime_error(FormatError("irgen", "声明重复生成存储槽位"));
+  }
+  auto* slot = CreateEntryAllocaI32(module_.GetContext().NextTemp());
   storage_map_[ctx] = slot;
+  named_storage_[name] = slot;
+
   ir::Value* init = nullptr;
-  if (auto* init_value = ctx->initVal()) {
+  if (auto* init_value = ctx->initValue()) {
     if (!init_value->exp()) {
-      throw std::runtime_error(FormatError("irgen", "当前不支持聚合初始化"));
+      throw std::runtime_error(FormatError("irgen", "当前不支持聚合初始化到标量"));
     }
     init = EvalExpr(*init_value->exp());
   } else {

src/irgen/IRGenDriver.cpp

@@ -7,7 +7,7 @@
 #include "utils/Log.h"
 
 std::unique_ptr<ir::Module> GenerateIR(SysYParser::CompUnitContext& tree,
-                                       IRGenContext& sema) {
+                                       const SemanticContext& sema) {
   auto module = std::make_unique<ir::Module>();
   IRGenImpl gen(*module, sema);
   tree.accept(&gen);

src/irgen/IRGenExp.cpp

@@ -6,303 +6,457 @@
 #include "ir/IR.h"
 #include "utils/Log.h"
 
-// 表达式生成当前也只实现了很小的一个子集。
-// 目前支持：
-// - 整数字面量
-// - 普通局部变量读取
-// - 括号表达式
-// - 二元加法
-//
-// 还未支持：
-// - 减乘除与一元运算
-// - 赋值表达式
-// - 函数调用
-// - 数组、指针、下标访问
-// - 条件与比较表达式
-// - ...
 ir::Value* IRGenImpl::EvalExpr(SysYParser::ExpContext& expr) {
   return std::any_cast<ir::Value*>(expr.accept(this));
 }
 
+ir::Value* IRGenImpl::EvalCond(SysYParser::CondContext& cond) {
+  return std::any_cast<ir::Value*>(cond.accept(this));
+}
 
-std::any IRGenImpl::visitPrimaryExp(SysYParser::PrimaryExpContext* ctx) {
+ir::Value* IRGenImpl::ToBoolValue(ir::Value* v) {
-  if (!ctx) throw std::runtime_error(FormatError("irgen", "非法 primary 表达式"));
+  if (!v) {
-  if (ctx->exp()) return EvalExpr(*ctx->exp());
+    throw std::runtime_error(FormatError("irgen", "条件值为空"));
-  if (ctx->lVal()) return ctx->lVal()->accept(this);
+  }
-  if (ctx->number()) return ctx->number()->accept(this);
+  if (v->GetType() && v->GetType()->IsPtrInt32()) {
-  throw std::runtime_error(FormatError("irgen", "不支持的 primary 表达式"));
+    // SysY 中数组名退化得到的指针在当前实现里总是非空。
+    return builder_.CreateConstInt(1);
+  }
+  if (dynamic_cast<ir::CmpInst*>(v) != nullptr) {
+    return v;
+  }
+  auto* zero = builder_.CreateConstInt(0);
+  return builder_.CreateCmp(ir::CmpOp::Ne, v, zero, module_.GetContext().NextTemp());
 }
 
+std::string IRGenImpl::NextBlockName() {
+  std::string temp = module_.GetContext().NextTemp();
+  if (!temp.empty() && temp.front() == '%') {
+    return "bb" + temp.substr(1);
+  }
+  return "bb" + temp;
+}
 
-std::any IRGenImpl::visitNumber(SysYParser::NumberContext* ctx) {
+// ─── 数组维度查找 ────────────────────────────────────────────────────────
-  if (!ctx) throw std::runtime_error(FormatError("irgen", "非法数字字面量"));
+const std::vector<int>* IRGenImpl::FindArrayDims(const std::string& name) const {
-  if (ctx->IntConst()) {
+  auto it = local_array_dims_.find(name);
-    return static_cast<ir::Value*>(builder_.CreateConstInt(std::stoi(ctx->getText())));
+  if (it != local_array_dims_.end()) return &it->second;
+  // 局部同名标量（含形参/局部变量）应屏蔽全局数组维度信息。
+  if (named_storage_.find(name) != named_storage_.end()) return nullptr;
+  auto git = global_array_dims_.find(name);
+  if (git != global_array_dims_.end()) return &git->second;
+  return nullptr;
+}
+
+// ─── 线性下标计算 ────────────────────────────────────────────────────────
+// 给定维度 dims 和下标表达式列表，计算 linear = sum(subs[k] * stride[k])。
+ir::Value* IRGenImpl::ComputeLinearIndex(
+    const std::vector<int>& dims,
+    const std::vector<SysYParser::ExpContext*>& subs) {
+  // 对于 dims=[d0,d1,...,dn-1]，stride[k] = d_{k+1} * ... * d_{n-1}
+  // 允许 dims[0] == -1（数组参数首维未知）
+  ir::Value* linear = builder_.CreateConstInt(0);
+  for (int k = 0; k < (int)subs.size() && k < (int)dims.size(); k++) {
+    int stride = 1;
+    for (int j = k + 1; j < (int)dims.size(); j++) stride *= dims[j];
+
+    ir::Value* idx = EvalExpr(*subs[k]);
+    if (stride != 1) {
+      auto* sv = builder_.CreateConstInt(stride);
+      idx = builder_.CreateMul(idx, sv, module_.GetContext().NextTemp());
+    }
+    linear = (stride == 1 && k == (int)subs.size() - 1 &&
+              dynamic_cast<ir::ConstantInt*>(linear) &&
+              static_cast<ir::ConstantInt*>(linear)->GetValue() == 0)
+                 ? idx
+                 : builder_.CreateAdd(linear, idx, module_.GetContext().NextTemp());
   }
-  if (ctx->FloatConst()) {
+  return linear;
-    return static_cast<ir::Value*>(builder_.CreateConstFloat(std::stof(ctx->getText())));
+}
+
+std::any IRGenImpl::visitExp(SysYParser::ExpContext* ctx) {
+  if (!ctx || !ctx->addExp()) {
+    throw std::runtime_error(FormatError("irgen", "非法表达式"));
   }
-  throw std::runtime_error(FormatError("irgen", "当前仅支持整数字面量或浮点字面量"));
+  return ctx->addExp()->accept(this);
 }
 
-// 变量使用的处理流程：
+std::any IRGenImpl::visitCond(SysYParser::CondContext* ctx) {
-// 1. 先通过语义分析结果把变量使用绑定回声明；
+  if (!ctx || !ctx->lOrExp()) {
-// 2. 再通过 storage_map_ 找到该声明对应的栈槽位；
+    throw std::runtime_error(FormatError("irgen", "非法条件表达式"));
-// 3. 最后生成 load，把内存中的值读出来。
-//
-// 因此当前 IRGen 自己不再做名字查找，而是直接消费 Sema 的绑定结果。
-std::any IRGenImpl::visitLVal(SysYParser::LValContext* ctx) {
-  if (!ctx || !ctx->Ident()) {
-    throw std::runtime_error(FormatError("irgen", "当前仅支持普通整型变量"));
-  }
-  // find storage by matching declaration node stored in Sema context
-  // Sema stores types/decl contexts in IRGenContext maps; here we search storage_map_ by name
-  std::string name = ctx->Ident()->getText();
-  // 优先使用按名称的快速映射
-  auto nit = name_map_.find(name);
-  if (nit != name_map_.end()) {
-    // 支持下标访问：若有索引表达式列表，则生成 GEP + load
-    if (ctx->exp().size() > 0) {
-      std::vector<ir::Value*> indices;
-      // 首个索引用于穿过数组对象
-      indices.push_back(builder_.CreateConstInt(0));
-      for (auto* e : ctx->exp()) {
-        indices.push_back(EvalExpr(*e));
-      }
-      auto* gep = builder_.CreateGEP(nit->second, indices, module_.GetContext().NextTemp());
-      return static_cast<ir::Value*>(builder_.CreateLoad(gep, module_.GetContext().NextTemp()));
-    }
-    // 如果映射到的是常量，直接返回常量值；否则按原来行为从槽位 load
-    if (nit->second->IsConstant()) return nit->second;
-    return static_cast<ir::Value*>(builder_.CreateLoad(nit->second, module_.GetContext().NextTemp()));
-  }
-  for (auto& kv : storage_map_) {
-    if (!kv.first) continue;
-    if (auto* vdef = dynamic_cast<SysYParser::VarDefContext*>(kv.first)) {
-      if (vdef->Ident() && vdef->Ident()->getText() == name) {
-        if (ctx->exp().size() > 0) {
-          std::vector<ir::Value*> indices;
-          indices.push_back(builder_.CreateConstInt(0));
-          for (auto* e : ctx->exp()) indices.push_back(EvalExpr(*e));
-          auto* gep = builder_.CreateGEP(kv.second, indices, module_.GetContext().NextTemp());
-          return static_cast<ir::Value*>(builder_.CreateLoad(gep, module_.GetContext().NextTemp()));
-        }
-        return static_cast<ir::Value*>(builder_.CreateLoad(kv.second, module_.GetContext().NextTemp()));
-      }
-    } else if (auto* fparam = dynamic_cast<SysYParser::FuncFParamContext*>(kv.first)) {
-      if (fparam->Ident() && fparam->Ident()->getText() == name) {
-        if (ctx->exp().size() > 0) {
-          std::vector<ir::Value*> indices;
-          indices.push_back(builder_.CreateConstInt(0));
-          for (auto* e : ctx->exp()) indices.push_back(EvalExpr(*e));
-          auto* gep = builder_.CreateGEP(kv.second, indices, module_.GetContext().NextTemp());
-          return static_cast<ir::Value*>(builder_.CreateLoad(gep, module_.GetContext().NextTemp()));
-        }
-        return static_cast<ir::Value*>(builder_.CreateLoad(kv.second, module_.GetContext().NextTemp()));
-      }
-    } else if (auto* cdef = dynamic_cast<SysYParser::ConstDefContext*>(kv.first)) {
-      if (cdef->Ident() && cdef->Ident()->getText() == name) {
-        if (ctx->exp().size() > 0) {
-          std::vector<ir::Value*> indices;
-          indices.push_back(builder_.CreateConstInt(0));
-          for (auto* e : ctx->exp()) indices.push_back(EvalExpr(*e));
-          auto* gep = builder_.CreateGEP(kv.second, indices, module_.GetContext().NextTemp());
-          return static_cast<ir::Value*>(builder_.CreateLoad(gep, module_.GetContext().NextTemp()));
-        }
-        return static_cast<ir::Value*>(builder_.CreateLoad(kv.second, module_.GetContext().NextTemp()));
-      }
-    }
   }
-  throw std::runtime_error(FormatError("irgen", "变量声明缺少存储槽位: " + name));
+  return ctx->lOrExp()->accept(this);
 }
 
+std::any IRGenImpl::visitPrimaryExp(SysYParser::PrimaryExpContext* ctx) {
+  if (!ctx) {
+    throw std::runtime_error(FormatError("irgen", "非法基本表达式"));
+  }
+  if (ctx->exp()) {
+    return EvalExpr(*ctx->exp());
+  }
+  if (ctx->number()) {
+    return ctx->number()->accept(this);
+  }
+  if (ctx->lValue()) {
+    return ctx->lValue()->accept(this);
+  }
+  throw std::runtime_error(FormatError("irgen", "不支持的基本表达式"));
+}
 
-std::any IRGenImpl::visitAddExp(SysYParser::AddExpContext* ctx) {
+std::any IRGenImpl::visitNumber(SysYParser::NumberContext* ctx) {
-  if (!ctx) throw std::runtime_error(FormatError("irgen", "非法加法表达式"));
+  if (!ctx || !ctx->ILITERAL()) {
-  try {
+    throw std::runtime_error(FormatError("irgen", "当前仅支持整数字面量"));
-  // left-associative: fold across all mulExp operands
+  }
-  if (ctx->mulExp().size() == 1) return ctx->mulExp(0)->accept(this);
+  // 支持十六进制和八进制字面量
-  ir::Value* cur = std::any_cast<ir::Value*>(ctx->mulExp(0)->accept(this));
+  const std::string text = ctx->getText();
-  // extract operator sequence from text (in-order '+' or '-')
+  int val = 0;
-  std::string text = ctx->getText();
+  if (text.size() >= 2 && text[0] == '0' &&
-  std::vector<char> ops;
+      (text[1] == 'x' || text[1] == 'X')) {
-  for (char c : text) if (c == '+' || c == '-') ops.push_back(c);
+    val = std::stoi(text, nullptr, 16);
-  for (size_t i = 1; i < ctx->mulExp().size(); ++i) {
+  } else if (text.size() > 1 && text[0] == '0') {
-    ir::Value* rhs = std::any_cast<ir::Value*>(ctx->mulExp(i)->accept(this));
+    val = std::stoi(text, nullptr, 8);
-    char opch = (i - 1 < ops.size()) ? ops[i - 1] : '+';
+  } else {
-    ir::Opcode op = (opch == '-') ? ir::Opcode::Sub : ir::Opcode::Add;
+    val = std::stoi(text);
-    cur = builder_.CreateBinary(op, cur, rhs, module_.GetContext().NextTemp());
-  }
-  return static_cast<ir::Value*>(cur);
-  } catch (const std::exception& e) {
-    LogInfo(std::string("[irgen] exception in visitAddExp text=") + ctx->getText() + ", err=" + e.what(), std::cerr);
-    throw;
   }
+  return static_cast<ir::Value*>(builder_.CreateConstInt(val));
 }
 
-std::any IRGenImpl::visitMulExp(SysYParser::MulExpContext* ctx) {
+// ─── 变量存储槽位查找（含下标 GEP）────────────────────────────────────────
-  if (!ctx) throw std::runtime_error(FormatError("irgen", "非法乘法表达式"));
+// 返回 i32* 指针：
-  if (ctx->unaryExp().size() == 1) return ctx->unaryExp(0)->accept(this);
+//   - 无下标：直接返回 alloca/arg/globalvar 槽位
-  ir::Value* cur = std::any_cast<ir::Value*>(ctx->unaryExp(0)->accept(this));
+//   - 有下标：计算线性偏移并生成 GEP 指令，返回元素指针
-  // extract operator sequence for '*', '/', '%'
+ir::Value* IRGenImpl::ResolveStorage(SysYParser::LValueContext* lvalue) {
-  std::string text = ctx->getText();
+  if (!lvalue || !lvalue->ID()) return nullptr;
-  std::vector<char> ops;
+  const std::string name = lvalue->ID()->getText();
-  for (char c : text) if (c == '*' || c == '/' || c == '%') ops.push_back(c);
+
-  for (size_t i = 1; i < ctx->unaryExp().size(); ++i) {
+  // 获取基础槽位（三级查找）
-    ir::Value* rhs = std::any_cast<ir::Value*>(ctx->unaryExp(i)->accept(this));
+  ir::Value* base = nullptr;
-    char opch = (i - 1 < ops.size()) ? ops[i - 1] : '*';
+
-    ir::Opcode op = ir::Opcode::Mul;
+  // 1. sema binding（处理同名变量遮蔽）
-    if (opch == '/') op = ir::Opcode::Div;
+  auto* decl = sema_.ResolveVarUse(lvalue);
-    else if (opch == '%') op = ir::Opcode::Mod;
+  if (decl) {
-    cur = builder_.CreateBinary(op, cur, rhs, module_.GetContext().NextTemp());
+    auto it = storage_map_.find(decl);
-  }
+    if (it != storage_map_.end()) base = it->second;
-  return static_cast<ir::Value*>(cur);
+  }
+  if (!base) {
+    auto it = named_storage_.find(name);
+    if (it != named_storage_.end()) base = it->second;
+  }
+  if (!base) {
+    auto git = global_storage_.find(name);
+    if (git != global_storage_.end()) base = git->second;
+  }
+
+  if (!base) return nullptr;
+
+  // 无下标：直接返回槽位
+  if (lvalue->exp().empty()) return base;
+
+  // 有下标：计算线性 GEP
+  const std::vector<int>* dims = FindArrayDims(name);
+  if (!dims) {
+    throw std::runtime_error(
+        FormatError("irgen", "未找到数组维度信息: " + name));
+  }
+
+  ir::Value* linear = ComputeLinearIndex(*dims, lvalue->exp());
+  return builder_.CreateGep(base, linear, module_.GetContext().NextTemp());
 }
 
-std::any IRGenImpl::visitUnaryExp(SysYParser::UnaryExpContext* ctx) {
+// ─── lValue 访问 ─────────────────────────────────────────────────────────
-  if (!ctx) throw std::runtime_error(FormatError("irgen", "非法一元表达式"));
+std::any IRGenImpl::visitLValue(SysYParser::LValueContext* ctx) {
-  if (ctx->primaryExp()) return ctx->primaryExp()->accept(this);
+  if (!ctx || !ctx->ID()) {
-  // function call: Ident '(' funcRParams? ')'
+    throw std::runtime_error(FormatError("irgen", "非法左值"));
-  if (ctx->Ident() && ctx->getText().find("(") != std::string::npos) {
+  }
-    std::string fname = ctx->Ident()->getText();
+  const std::string name = ctx->ID()->getText();
-    std::vector<ir::Value*> args;
+
-    if (ctx->funcRParams()) {
+  if (ctx->exp().empty()) {
-      for (auto* e : ctx->funcRParams()->exp()) {
+    // 无下标：标量读取 或 数组基址引用
-        args.push_back(EvalExpr(*e));
+    ir::Value* slot = ResolveStorage(ctx);
+    if (!slot) {
+      throw std::runtime_error(
+          FormatError("irgen", "变量未找到存储槽位: " + name));
+    }
+    // 如果是数组名，返回基址指针（用于传参）。
+    // 全局数组需要先退化为首元素指针，避免直接把 [N x i32]* 传给 i32* 形参。
+    if (FindArrayDims(name) != nullptr) {
+      if (auto* gv = dynamic_cast<ir::GlobalVariable*>(slot); gv && gv->IsArray()) {
+        return static_cast<ir::Value*>(
+            builder_.CreateGep(slot, builder_.CreateConstInt(0),
+                               module_.GetContext().NextTemp()));
       }
+      return static_cast<ir::Value*>(slot);
+    }
+    // 标量：加载值
+    return static_cast<ir::Value*>(
+        builder_.CreateLoad(slot, module_.GetContext().NextTemp()));
+  }
+
+  // 有下标：GEP + load
+  ir::Value* elem_ptr = ResolveStorage(ctx);
+  if (!elem_ptr) {
+    throw std::runtime_error(
+        FormatError("irgen", "数组元素指针解析失败: " + name));
+  }
+  const auto* dims = FindArrayDims(name);
+  if (dims && ctx->exp().size() < dims->size()) {
+    // 如 A[i]（A 为二维数组）应退化为指针，用于实参传递。
+    return static_cast<ir::Value*>(elem_ptr);
+  }
+  return static_cast<ir::Value*>(
+      builder_.CreateLoad(elem_ptr, module_.GetContext().NextTemp()));
+}
+
+std::any IRGenImpl::visitUnaryExp(SysYParser::UnaryExpContext* ctx) {
+  if (!ctx) {
+    throw std::runtime_error(FormatError("irgen", "非法一元表达式"));
+  }
+  if (ctx->primaryExp()) {
+    return ctx->primaryExp()->accept(this);
+  }
+  if (ctx->unaryOp() && ctx->unaryExp()) {
+    ir::Value* v = std::any_cast<ir::Value*>(ctx->unaryExp()->accept(this));
+    if (ctx->unaryOp()->SUB()) {
+      auto* zero = builder_.CreateConstInt(0);
+      return static_cast<ir::Value*>(builder_.CreateSub(
+          zero, v, module_.GetContext().NextTemp()));
+    }
+    if (ctx->unaryOp()->ADD()) {
+      return v;
     }
-    // find existing function or create an external declaration (assume int return)
+    if (ctx->unaryOp()->NOT()) {
-    ir::Function* callee = nullptr;
+      // !v  ≡  (v == 0)
-    for (auto &fup : module_.GetFunctions()) {
+      auto* zero = builder_.CreateConstInt(0);
-      if (fup && fup->GetName() == fname) { callee = fup.get(); break; }
+      return static_cast<ir::Value*>(builder_.CreateCmp(
+          ir::CmpOp::Eq, v, zero, module_.GetContext().NextTemp()));
     }
+    throw std::runtime_error(FormatError("irgen", "未知一元运算符"));
+  }
+  if (ctx->ID()) {
+    // 函数调用：ID '(' funcRParams? ')'
+    const std::string callee_name = ctx->ID()->getText();
+    ir::Function* callee = module_.FindFunction(callee_name);
     if (!callee) {
-      std::vector<std::shared_ptr<ir::Type>> param_types;
+      throw std::runtime_error(
-      for (auto* a : args) {
+          FormatError("irgen", "未定义的函数: " + callee_name));
-        if (a && a->IsFloat32()) param_types.push_back(ir::Type::GetFloat32Type());
+    }
-        else param_types.push_back(ir::Type::GetInt32Type());
+    std::vector<ir::Value*> args;
+    if (auto* rparams = ctx->funcRParams()) {
+      for (auto* ep : rparams->exp()) {
+        args.push_back(EvalExpr(*ep));
       }
-      callee = module_.CreateFunction(fname, ir::Type::GetInt32Type(), param_types);
     }
-    return static_cast<ir::Value*>(builder_.CreateCall(callee, args, module_.GetContext().NextTemp()));
+    const std::string name =
+        callee->GetType()->IsVoid() ? "" : module_.GetContext().NextTemp();
+    return static_cast<ir::Value*>(
+        builder_.CreateCall(callee, args, name));
+  }
+  throw std::runtime_error(FormatError("irgen", "非法一元表达式"));
+}
+
+std::any IRGenImpl::visitMulExp(SysYParser::MulExpContext* ctx) {
+  if (!ctx) {
+    throw std::runtime_error(FormatError("irgen", "非法乘法表达式"));
+  }
+  if (ctx->mulExp()) {
+    if (!ctx->unaryExp()) {
+      throw std::runtime_error(FormatError("irgen", "非法乘法表达式"));
+    }
+    ir::Value* lhs = std::any_cast<ir::Value*>(ctx->mulExp()->accept(this));
+    ir::Value* rhs = std::any_cast<ir::Value*>(ctx->unaryExp()->accept(this));
+    if (ctx->MUL()) {
+      return static_cast<ir::Value*>(
+          builder_.CreateMul(lhs, rhs, module_.GetContext().NextTemp()));
+    }
+    if (ctx->DIV()) {
+      return static_cast<ir::Value*>(
+          builder_.CreateDiv(lhs, rhs, module_.GetContext().NextTemp()));
+    }
+    if (ctx->MOD()) {
+      return static_cast<ir::Value*>(
+          builder_.CreateMod(lhs, rhs, module_.GetContext().NextTemp()));
+    }
+    throw std::runtime_error(FormatError("irgen", "非法乘法表达式"));
   }
   if (ctx->unaryExp()) {
-    ir::Value* val = std::any_cast<ir::Value*>(ctx->unaryExp()->accept(this));
+    return ctx->unaryExp()->accept(this);
-    if (ctx->unaryOp() && ctx->unaryOp()->getText() == "+") return static_cast<ir::Value*>(val);
+  }
-    else if (ctx->unaryOp() && ctx->unaryOp()->getText() == "-") {
+  throw std::runtime_error(FormatError("irgen", "非法乘法表达式"));
-      // 负号：0 - val，区分整型/浮点
+}
-      if (val->IsFloat32()) {
+
-        ir::Value* zero = builder_.CreateConstFloat(0.0f);
+std::any IRGenImpl::visitAddExp(SysYParser::AddExpContext* ctx) {
-        return static_cast<ir::Value*>(builder_.CreateSub(zero, val, module_.GetContext().NextTemp()));
+  if (!ctx) {
-      } else {
+    throw std::runtime_error(FormatError("irgen", "非法加法表达式"));
-        ir::Value* zero = builder_.CreateConstInt(0);
+  }
-        return static_cast<ir::Value*>(builder_.CreateSub(zero, val, module_.GetContext().NextTemp()));
+  if (ctx->addExp()) {
-      }
+    if (!ctx->mulExp()) {
+      throw std::runtime_error(FormatError("irgen", "非法加法表达式"));
     }
-    if (ctx->unaryOp() && ctx->unaryOp()->getText() == "!") {
+    ir::Value* lhs = std::any_cast<ir::Value*>(ctx->addExp()->accept(this));
-      // logical not: produce int 1 if val == 0, else 0
+    ir::Value* rhs = std::any_cast<ir::Value*>(ctx->mulExp()->accept(this));
-      if (val->IsFloat32()) {
+    if (ctx->ADD()) {
-        ir::Value* zerof = builder_.CreateConstFloat(0.0f);
+      return static_cast<ir::Value*>(
-        return static_cast<ir::Value*>(builder_.CreateFCmp(ir::CmpInst::EQ, val, zerof, module_.GetContext().NextTemp()));
+          builder_.CreateAdd(lhs, rhs, module_.GetContext().NextTemp()));
-      } else {
+    }
-        ir::Value* zero = builder_.CreateConstInt(0);
+    if (ctx->SUB()) {
-        return static_cast<ir::Value*>(builder_.CreateICmp(ir::CmpInst::EQ, val, zero, module_.GetContext().NextTemp()));
+      return static_cast<ir::Value*>(
-      }
+          builder_.CreateSub(lhs, rhs, module_.GetContext().NextTemp()));
     }
+    throw std::runtime_error(FormatError("irgen", "非法加法表达式"));
+  }
+  if (ctx->mulExp()) {
+    return ctx->mulExp()->accept(this);
   }
-  throw std::runtime_error(FormatError("irgen", "不支持的一元运算"));
+  throw std::runtime_error(FormatError("irgen", "非法加法表达式"));
 }
 
 std::any IRGenImpl::visitRelExp(SysYParser::RelExpContext* ctx) {
-  if (!ctx) throw std::runtime_error(FormatError("irgen", "非法关系表达式"));
+  if (!ctx) {
-  if (ctx->addExp().size() == 1) return ctx->addExp(0)->accept(this);
+    throw std::runtime_error(FormatError("irgen", "非法关系表达式"));
-  ir::Value* lhs = std::any_cast<ir::Value*>(ctx->addExp(0)->accept(this));
+  }
-  ir::Value* rhs = std::any_cast<ir::Value*>(ctx->addExp(1)->accept(this));
+  if (ctx->relExp()) {
-  // 类型提升
+    if (!ctx->addExp()) {
-  if (lhs->IsFloat32() && rhs->IsInt32()) {
+      throw std::runtime_error(FormatError("irgen", "非法关系表达式"));
-    if (auto* ci = dynamic_cast<ir::ConstantInt*>(rhs)) {
+    }
-      rhs = builder_.CreateConstFloat(static_cast<float>(ci->GetValue()));
+    ir::Value* lhs = std::any_cast<ir::Value*>(ctx->relExp()->accept(this));
-    } else {
+    ir::Value* rhs = std::any_cast<ir::Value*>(ctx->addExp()->accept(this));
-      throw std::runtime_error(FormatError("irgen", "不支持 int 到 float 的隐式转换"));
+    if (ctx->LT()) {
+      return static_cast<ir::Value*>(builder_.CreateCmp(
+          ir::CmpOp::Lt, lhs, rhs, module_.GetContext().NextTemp()));
+    }
+    if (ctx->LE()) {
+      return static_cast<ir::Value*>(builder_.CreateCmp(
+          ir::CmpOp::Le, lhs, rhs, module_.GetContext().NextTemp()));
+    }
+    if (ctx->GT()) {
+      return static_cast<ir::Value*>(builder_.CreateCmp(
+          ir::CmpOp::Gt, lhs, rhs, module_.GetContext().NextTemp()));
     }
-  } else if (rhs->IsFloat32() && lhs->IsInt32()) {
+    if (ctx->GE()) {
-    if (auto* ci = dynamic_cast<ir::ConstantInt*>(lhs)) {
+      return static_cast<ir::Value*>(builder_.CreateCmp(
-      lhs = builder_.CreateConstFloat(static_cast<float>(ci->GetValue()));
+          ir::CmpOp::Ge, lhs, rhs, module_.GetContext().NextTemp()));
-    } else {
-      throw std::runtime_error(FormatError("irgen", "不支持 int 到 float 的隐式转换"));
     }
+    throw std::runtime_error(FormatError("irgen", "非法关系表达式"));
   }
-  ir::CmpInst::Predicate pred = ir::CmpInst::EQ;
+  if (ctx->addExp()) {
-  std::string text = ctx->getText();
+    return ctx->addExp()->accept(this);
-  if (text.find("<=") != std::string::npos) pred = ir::CmpInst::LE;
-  else if (text.find(">=") != std::string::npos) pred = ir::CmpInst::GE;
-  else if (text.find("<") != std::string::npos) pred = ir::CmpInst::LT;
-  else if (text.find(">") != std::string::npos) pred = ir::CmpInst::GT;
-  if (lhs->IsFloat32() || rhs->IsFloat32()) {
-    return static_cast<ir::Value*>(
-        builder_.CreateFCmp(pred, lhs, rhs, module_.GetContext().NextTemp()));
   }
-  return static_cast<ir::Value*>(
+  throw std::runtime_error(FormatError("irgen", "非法关系表达式"));
-      builder_.CreateICmp(pred, lhs, rhs, module_.GetContext().NextTemp()));
 }
 
 std::any IRGenImpl::visitEqExp(SysYParser::EqExpContext* ctx) {
-  if (!ctx) throw std::runtime_error(FormatError("irgen", "非法相等表达式"));
+  if (!ctx) {
-  if (ctx->relExp().size() == 1) return ctx->relExp(0)->accept(this);
+    throw std::runtime_error(FormatError("irgen", "非法相等表达式"));
-  ir::Value* lhs = std::any_cast<ir::Value*>(ctx->relExp(0)->accept(this));
+  }
-  ir::Value* rhs = std::any_cast<ir::Value*>(ctx->relExp(1)->accept(this));
+  if (ctx->eqExp()) {
-  // 类型提升
+    if (!ctx->relExp()) {
-  if (lhs->IsFloat32() && rhs->IsInt32()) {
+      throw std::runtime_error(FormatError("irgen", "非法相等表达式"));
-    if (auto* ci = dynamic_cast<ir::ConstantInt*>(rhs)) {
-      rhs = builder_.CreateConstFloat(static_cast<float>(ci->GetValue()));
-    } else {
-      throw std::runtime_error(FormatError("irgen", "不支持 int 到 float 的隐式转换"));
     }
-  } else if (rhs->IsFloat32() && lhs->IsInt32()) {
+    ir::Value* lhs = std::any_cast<ir::Value*>(ctx->eqExp()->accept(this));
-    if (auto* ci = dynamic_cast<ir::ConstantInt*>(lhs)) {
+    ir::Value* rhs = std::any_cast<ir::Value*>(ctx->relExp()->accept(this));
-      lhs = builder_.CreateConstFloat(static_cast<float>(ci->GetValue()));
+    if (ctx->EQ()) {
-    } else {
+      return static_cast<ir::Value*>(builder_.CreateCmp(
-      throw std::runtime_error(FormatError("irgen", "不支持 int 到 float 的隐式转换"));
+          ir::CmpOp::Eq, lhs, rhs, module_.GetContext().NextTemp()));
     }
+    if (ctx->NE()) {
+      return static_cast<ir::Value*>(builder_.CreateCmp(
+          ir::CmpOp::Ne, lhs, rhs, module_.GetContext().NextTemp()));
+    }
+    throw std::runtime_error(FormatError("irgen", "非法相等表达式"));
   }
-  ir::CmpInst::Predicate pred = ir::CmpInst::EQ;
+  if (ctx->relExp()) {
-  std::string text = ctx->getText();
+    return ctx->relExp()->accept(this);
-  if (text.find("==") != std::string::npos) pred = ir::CmpInst::EQ;
-  else if (text.find("!=") != std::string::npos) pred = ir::CmpInst::NE;
-  if (lhs->IsFloat32() || rhs->IsFloat32()) {
-    return static_cast<ir::Value*>(
-        builder_.CreateFCmp(pred, lhs, rhs, module_.GetContext().NextTemp()));
   }
-  return static_cast<ir::Value*>(
+  throw std::runtime_error(FormatError("irgen", "非法相等表达式"));
-      builder_.CreateICmp(pred, lhs, rhs, module_.GetContext().NextTemp()));
 }
 
 std::any IRGenImpl::visitLAndExp(SysYParser::LAndExpContext* ctx) {
-  if (!ctx) throw std::runtime_error(FormatError("irgen", "非法逻辑与表达式"));
+  if (!ctx) {
-  if (ctx->eqExp().size() == 1) return ctx->eqExp(0)->accept(this);
+    throw std::runtime_error(FormatError("irgen", "非法逻辑与表达式"));
-  // For simplicity, treat as int (0 or 1)
+  }
-  ir::Value* lhs = std::any_cast<ir::Value*>(ctx->eqExp(0)->accept(this));
+  if (ctx->lAndExp()) {
-  ir::Value* rhs = std::any_cast<ir::Value*>(ctx->eqExp(1)->accept(this));
+    if (!ctx->eqExp()) {
-  // lhs && rhs : (lhs != 0) && (rhs != 0)
+      throw std::runtime_error(FormatError("irgen", "非法逻辑与表达式"));
-  ir::Value* zero = builder_.CreateConstInt(0);
+    }
-  ir::Value* lhs_ne = builder_.CreateICmp(ir::CmpInst::NE, lhs, zero, module_.GetContext().NextTemp());
+    // 短路求值：a && b
-  ir::Value* rhs_ne = builder_.CreateICmp(ir::CmpInst::NE, rhs, zero, module_.GetContext().NextTemp());
+    // 使用函数级临时槽位（0=false，1=true），避免 phi 依赖和循环内动态 alloca。
-  return static_cast<ir::Value*>(
+    if (!short_circuit_slot_) {
-      builder_.CreateMul(lhs_ne, rhs_ne, module_.GetContext().NextTemp()));
+      throw std::runtime_error(FormatError("irgen", "短路求值槽位未初始化"));
+    }
+    auto* slot = short_circuit_slot_;
+    builder_.CreateStore(builder_.CreateConstInt(0), slot);
+
+    auto* lhs = std::any_cast<ir::Value*>(ctx->lAndExp()->accept(this));
+    auto* lhs_bool = ToBoolValue(lhs);
+    auto* rhs_bb = func_->CreateBlock(NextBlockName());
+    auto* true_bb = func_->CreateBlock(NextBlockName());
+    auto* merge_bb = func_->CreateBlock(NextBlockName());
+
+    builder_.CreateCondBr(lhs_bool, rhs_bb, merge_bb);
+
+    builder_.SetInsertPoint(rhs_bb);
+    auto* rhs = std::any_cast<ir::Value*>(ctx->eqExp()->accept(this));
+    auto* rhs_bool = ToBoolValue(rhs);
+    builder_.CreateCondBr(rhs_bool, true_bb, merge_bb);
+
+    builder_.SetInsertPoint(true_bb);
+    builder_.CreateStore(builder_.CreateConstInt(1), slot);
+    builder_.CreateBr(merge_bb);
+
+    builder_.SetInsertPoint(merge_bb);
+    return static_cast<ir::Value*>(
+        builder_.CreateLoad(slot, module_.GetContext().NextTemp()));
+  }
+  if (ctx->eqExp()) {
+    return ToBoolValue(std::any_cast<ir::Value*>(ctx->eqExp()->accept(this)));
+  }
+  throw std::runtime_error(FormatError("irgen", "非法逻辑与表达式"));
 }
 
 std::any IRGenImpl::visitLOrExp(SysYParser::LOrExpContext* ctx) {
-  if (!ctx) throw std::runtime_error(FormatError("irgen", "非法逻辑或表达式"));
+  if (!ctx) {
-  if (ctx->lAndExp().size() == 1) return ctx->lAndExp(0)->accept(this);
+    throw std::runtime_error(FormatError("irgen", "非法逻辑或表达式"));
-  ir::Value* lhs = std::any_cast<ir::Value*>(ctx->lAndExp(0)->accept(this));
+  }
-  ir::Value* rhs = std::any_cast<ir::Value*>(ctx->lAndExp(1)->accept(this));
+  if (ctx->lOrExp()) {
-  // lhs || rhs : (lhs != 0) || (rhs != 0)
+    if (!ctx->lAndExp()) {
-  ir::Value* zero = builder_.CreateConstInt(0);
+      throw std::runtime_error(FormatError("irgen", "非法逻辑或表达式"));
-  ir::Value* lhs_ne = builder_.CreateICmp(ir::CmpInst::NE, lhs, zero, module_.GetContext().NextTemp());
+    }
-  ir::Value* rhs_ne = builder_.CreateICmp(ir::CmpInst::NE, rhs, zero, module_.GetContext().NextTemp());
+    // 短路求值：a || b
-  ir::Value* or_val = builder_.CreateAdd(lhs_ne, rhs_ne, module_.GetContext().NextTemp());
+    if (!short_circuit_slot_) {
-  ir::Value* one = builder_.CreateConstInt(1);
+      throw std::runtime_error(FormatError("irgen", "短路求值槽位未初始化"));
-  return static_cast<ir::Value*>(
+    }
-      builder_.CreateICmp(ir::CmpInst::GE, or_val, one, module_.GetContext().NextTemp()));
+    auto* slot = short_circuit_slot_;
-}
+    builder_.CreateStore(builder_.CreateConstInt(0), slot);
+
+    auto* lhs = std::any_cast<ir::Value*>(ctx->lOrExp()->accept(this));
+    auto* lhs_bool = ToBoolValue(lhs);
+    auto* true_bb = func_->CreateBlock(NextBlockName());
+    auto* rhs_bb = func_->CreateBlock(NextBlockName());
+    auto* merge_bb = func_->CreateBlock(NextBlockName());
+
+    builder_.CreateCondBr(lhs_bool, true_bb, rhs_bb);
 
+    builder_.SetInsertPoint(true_bb);
+    builder_.CreateStore(builder_.CreateConstInt(1), slot);
+    builder_.CreateBr(merge_bb);
+
+    builder_.SetInsertPoint(rhs_bb);
+    auto* rhs = std::any_cast<ir::Value*>(ctx->lAndExp()->accept(this));
+    auto* rhs_bool = ToBoolValue(rhs);
+    auto* true2_bb = func_->CreateBlock(NextBlockName());
+    builder_.CreateCondBr(rhs_bool, true2_bb, merge_bb);
+
+    builder_.SetInsertPoint(true2_bb);
+    builder_.CreateStore(builder_.CreateConstInt(1), slot);
+    builder_.CreateBr(merge_bb);
+
+    builder_.SetInsertPoint(merge_bb);
+    return static_cast<ir::Value*>(
+        builder_.CreateLoad(slot, module_.GetContext().NextTemp()));
+  }
+  if (ctx->lAndExp()) {
+    return ToBoolValue(std::any_cast<ir::Value*>(ctx->lAndExp()->accept(this)));
+  }
+  throw std::runtime_error(FormatError("irgen", "非法逻辑或表达式"));
+}

src/irgen/IRGenFunc.cpp

@@ -5,7 +5,6 @@
 #include "SysYParser.h"
 #include "ir/IR.h"
 #include "utils/Log.h"
-#include <functional>
 
 namespace {
 
@@ -22,215 +21,197 @@ void VerifyFunctionStructure(const ir::Function& func) {
 
 }  // namespace
 
-IRGenImpl::IRGenImpl(ir::Module& module, IRGenContext& sema)
+IRGenImpl::IRGenImpl(ir::Module& module, const SemanticContext& sema)
     : module_(module),
       sema_(sema),
       func_(nullptr),
       builder_(module.GetContext(), nullptr) {}
 
-// 编译单元的 IR 生成当前只实现了最小功能：
+ir::AllocaInst* IRGenImpl::CreateEntryAllocaI32(const std::string& name) {
-// - Module 已在 GenerateIR 中创建，这里只负责继续生成其中的内容；
+  if (!func_) {
-// - 当前会读取编译单元中的函数定义，并交给 visitFuncDef 生成函数 IR；
+    throw std::runtime_error(FormatError("irgen", "局部 alloca 必须位于函数内"));
-//
+  }
-// 当前还没有实现：
+  auto* saved = builder_.GetInsertBlock();
-// - 多个函数定义的遍历与生成；
+  builder_.SetInsertPoint(func_->GetEntry());
-// - 全局变量、全局常量的 IR 生成。
+  auto* slot = builder_.CreateAllocaI32(name);
+  builder_.SetInsertPoint(saved);
+  return slot;
+}
+
+ir::AllocaInst* IRGenImpl::CreateEntryAllocaArray(int count, const std::string& name) {
+  if (!func_) {
+    throw std::runtime_error(FormatError("irgen", "局部 alloca 必须位于函数内"));
+  }
+  auto* saved = builder_.GetInsertBlock();
+  builder_.SetInsertPoint(func_->GetEntry());
+  auto* slot = builder_.CreateAllocaArray(count, name);
+  builder_.SetInsertPoint(saved);
+  return slot;
+}
+
+// 预声明 SysY 运行时外部函数（putint / putch / getint / getch 等）。
+void IRGenImpl::DeclareRuntimeFunctions() {
+  auto i32 = ir::Type::GetInt32Type();
+  auto void_ = ir::Type::GetVoidType();
+
+  auto decl = [&](const std::string& name,
+                   std::shared_ptr<ir::Type> ret,
+                   std::vector<std::shared_ptr<ir::Type>> params) {
+    if (!module_.FindFunction(name)) {
+      auto* f = module_.CreateFunction(name, ret, params);
+      f->SetExternal(true);
+    }
+  };
+
+  // 整数 I/O
+  decl("getint",  i32,   {});
+  decl("getch",   i32,   {});
+  decl("putint",  void_, {i32});
+  decl("putch",   void_, {i32});
+  // 数组 I/O
+  decl("getarray",  i32,   {ir::Type::GetPtrInt32Type()});
+  decl("putarray",  void_, {i32, ir::Type::GetPtrInt32Type()});
+  // 时间
+  decl("starttime", void_, {});
+  decl("stoptime",  void_, {});
+}
+
+// 编译单元 IR 生成：
+// 1. 预声明 SysY runtime；
+// 2. 处理全局变量/常量声明；
+// 3. 生成各函数 IR。
 std::any IRGenImpl::visitCompUnit(SysYParser::CompUnitContext* ctx) {
   if (!ctx) {
     throw std::runtime_error(FormatError("irgen", "缺少编译单元"));
   }
-  // for simplicity take first function definition
+
-  if (ctx->funcDef().empty()) {
+  DeclareRuntimeFunctions();
-    throw std::runtime_error(FormatError("irgen", "缺少函数定义"));
+
-  }
+  // 全局声明（func_ == nullptr 时 visitVarDef/visitConstDef 会走全局路径）
-  // 先处理顶层声明（仅支持简单的 const int 初始化作为全局常量）
   for (auto* decl : ctx->decl()) {
-    if (!decl) continue;
+    if (decl) decl->accept(this);
-    if (decl->constDecl()) {
-      auto* cdecl = decl->constDecl();
-      for (auto* cdef : cdecl->constDef()) {
-        if (!cdef || !cdef->Ident() || !cdef->constInitVal() || !cdef->constInitVal()->constExp()) continue;
-        // 仅支持形如: const int a = 10; 的简单常量初始化（字面量）
-        auto* add = cdef->constInitVal()->constExp()->addExp();
-        if (!add) continue;
-        try {
-          int v = std::stoi(add->getText());
-          auto* cval = module_.GetContext().GetConstInt(v);
-          name_map_[cdef->Ident()->getText()] = cval;
-        } catch (...) {
-          // 无法解析则跳过，全局复杂常量暂不支持
-        }
-      }
-    }
-    // 支持简单的全局变量声明（数组或标量），初始化为零
-    if (decl->varDecl()) {
-      auto* vdecl = decl->varDecl();
-      if (!vdecl->bType()) continue;
-      std::string btype = vdecl->bType()->getText();
-      for (auto* vdef : vdecl->varDef()) {
-        if (!vdef) continue;
-        LogInfo(std::string("[irgen] global varDef text=") + vdef->getText() + std::string(" ident=") + (vdef->Ident() ? vdef->Ident()->getText() : std::string("<none>")) + std::string(" dims=") + std::to_string((int)vdef->constExp().size()), std::cerr);
-        if (!vdef || !vdef->Ident()) continue;
-        std::string name = vdef->Ident()->getText();
-        // array globals
-        if (!vdef->constExp().empty()) {
-          std::vector<int> dims;
-          bool ok = true;
-          for (auto* ce : vdef->constExp()) {
-            try {
-              int val = 0;
-              auto anyv = sema_.GetConstVal(ce);
-              if (anyv.has_value()) {
-                if (anyv.type() == typeid(int)) val = std::any_cast<int>(anyv);
-                else if (anyv.type() == typeid(long)) val = (int)std::any_cast<long>(anyv);
-                else throw std::runtime_error("not-const-int");
-              } else {
-                // try literal parse
-                try {
-                  val = std::stoi(ce->addExp()->getText());
-                } catch (...) {
-                  // try lookup in name_map_ for previously created const
-                  std::string t = ce->addExp()->getText();
-                  auto it = name_map_.find(t);
-                  if (it != name_map_.end() && it->second && it->second->IsConstant()) {
-                    if (auto* ci = dynamic_cast<ir::ConstantInt*>(it->second)) {
-                      val = ci->GetValue();
-                    } else {
-                      ok = false; break;
-                    }
-                  } else {
-                    ok = false; break;
-                  }
-                }
-              }
-              dims.push_back(val);
-            } catch (...) { ok = false; break; }
-          }
-          if (!ok) continue;
-          // build zero constant array similar to visitVarDef
-          std::function<ir::ConstantValue*(const std::vector<int>&, size_t, std::shared_ptr<ir::Type>)> buildZero;
-          buildZero = [&](const std::vector<int>& ds, size_t idx, std::shared_ptr<ir::Type> elemTy) -> ir::ConstantValue* {
-            if (idx >= ds.size()) return nullptr;
-            std::vector<ir::ConstantValue*> elems;
-            if (idx + 1 == ds.size()) {
-              for (int i = 0; i < ds[idx]; ++i) {
-                if (elemTy->IsFloat32()) elems.push_back(module_.GetContext().GetConstFloat(0.0f));
-                else elems.push_back(module_.GetContext().GetConstInt(0));
-              }
-            } else {
-              for (int i = 0; i < ds[idx]; ++i) {
-                ir::ConstantValue* sub = buildZero(ds, idx + 1, elemTy);
-                if (sub) elems.push_back(sub);
-                else elems.push_back(module_.GetContext().GetConstInt(0));
-              }
-            }
-            std::function<std::shared_ptr<ir::Type>(size_t)> makeArrayType = [&](size_t level) -> std::shared_ptr<ir::Type> {
-              if (level + 1 >= ds.size()) return ir::Type::GetArrayType(elemTy, ds[level]);
-              auto sub = makeArrayType(level + 1);
-              return ir::Type::GetArrayType(sub, ds[level]);
-            };
-            auto at_real = makeArrayType(idx);
-            return new ir::ConstantArray(at_real, elems);
-          };
-          std::shared_ptr<ir::Type> elemTy = (btype == "float") ? ir::Type::GetFloat32Type() : ir::Type::GetInt32Type();
-          ir::ConstantValue* zero = buildZero(dims, 0, elemTy);
-          auto gvty = ir::Type::GetPointerType(zero ? zero->GetType() : ir::Type::GetPointerType(elemTy));
-          ir::GlobalValue* gv = module_.CreateGlobalVariable(name, gvty, zero);
-          name_map_[name] = gv;
-          LogInfo(std::string("[irgen] created global ") + name, std::cerr);
-        } else {
-          // scalar global
-          std::shared_ptr<ir::Type> elemTy = (btype == "float") ? ir::Type::GetFloat32Type() : ir::Type::GetInt32Type();
-          ir::ConstantValue* init = nullptr;
-          if (btype == "float") init = module_.GetContext().GetConstFloat(0.0f);
-          else init = module_.GetContext().GetConstInt(0);
-          ir::GlobalValue* gv = module_.CreateGlobalVariable(name, ir::Type::GetPointerType(elemTy), init);
-          name_map_[name] = gv;
-          LogInfo(std::string("[irgen] created global ") + name, std::cerr);
-        }
-      }
-    }
   }
 
-  // 生成编译单元中所有函数定义（之前只生成第一个函数）
+  for (auto* func : ctx->funcDef()) {
-  for (size_t i = 0; i < ctx->funcDef().size(); ++i) {
+    if (func) func->accept(this);
-    if (ctx->funcDef(i)) ctx->funcDef(i)->accept(this);
   }
   return {};
 }
 
 // 函数 IR 生成当前实现了：
 // 1. 获取函数名；
-// 2. 检查函数返回类型；
+// 2. 支持 int 与 void 返回类型；
-// 3. 在 Module 中创建 Function；
+// 3. 支持 int 形参：入口处为每个参数 alloca + store；
-// 4. 将 builder 插入点设置到入口基本块；
+// 4. 在 Module 中创建 Function；
-// 5. 继续生成函数体。
+// 5. 将 builder 插入点设置到入口基本块；
+// 6. 继续生成函数体。
 //
 // 当前还没有实现：
-// - 通用函数返回类型处理；
+// - float 参数/返回类型；
-// - 形参列表遍历与参数类型收集；
+// - 数组类型形参；
-// - FunctionType 这样的函数类型对象；
+// - FunctionType 这样的函数类型对象（参数类型目前只用 shared_ptr<Type>）。
-// - Argument/形式参数 IR 对象；
+
-// - 入口块中的参数初始化逻辑。
-// ...
-
-// 因此这里目前只支持最小的“无参 int 函数”生成。
-// 因此这里目前只支持最小的“无参 int 函数”生成。
 std::any IRGenImpl::visitFuncDef(SysYParser::FuncDefContext* ctx) {
   if (!ctx) {
     throw std::runtime_error(FormatError("irgen", "缺少函数定义"));
   }
-  if (!ctx->block()) {
+  if (!ctx->blockStmt()) {
     throw std::runtime_error(FormatError("irgen", "函数体为空"));
   }
-  if (!ctx->Ident()) {
+  if (!ctx->ID()) {
     throw std::runtime_error(FormatError("irgen", "缺少函数名"));
   }
   if (!ctx->funcType()) {
     throw std::runtime_error(FormatError("irgen", "缺少函数返回类型"));
   }
+
   std::shared_ptr<ir::Type> ret_type;
-  if (ctx->funcType()->getText() == "int") ret_type = ir::Type::GetInt32Type();
+  if (ctx->funcType()->INT()) {
-  else if (ctx->funcType()->getText() == "float") ret_type = ir::Type::GetFloat32Type();
+    ret_type = ir::Type::GetInt32Type();
-  else if (ctx->funcType()->getText() == "void") ret_type = ir::Type::GetVoidType();
+  } else if (ctx->funcType()->VOID()) {
-  else throw std::runtime_error(FormatError("irgen", "当前仅支持 int/float/void 函数"));
+    ret_type = ir::Type::GetVoidType();
+  } else {
+    throw std::runtime_error(FormatError("irgen", "当前仅支持 int/void 返回类型"));
+  }
 
+  // 收集形参类型（支持 int 标量和 int 数组参数）。
   std::vector<std::shared_ptr<ir::Type>> param_types;
-  if (ctx->funcFParams()) {
+  std::vector<std::string> param_names;
-    for (auto* param : ctx->funcFParams()->funcFParam()) {
+  std::vector<bool> param_is_array;
-      if (param->bType()->getText() == "int") param_types.push_back(ir::Type::GetInt32Type());
+
-      else if (param->bType()->getText() == "float") param_types.push_back(ir::Type::GetFloat32Type());
+  if (auto* fparams = ctx->funcFParams()) {
-      else throw std::runtime_error(FormatError("irgen", "当前仅支持 int/float 参数"));
+    for (auto* fp : fparams->funcFParam()) {
+      if (!fp || !fp->btype() || !fp->btype()->INT()) {
+        throw std::runtime_error(
+            FormatError("irgen", "当前仅支持 int 类型形参"));
+      }
+      bool is_arr = !fp->LBRACK().empty();
+      param_is_array.push_back(is_arr);
+      param_types.push_back(is_arr ? ir::Type::GetPtrInt32Type()
+                                   : ir::Type::GetInt32Type());
+      param_names.push_back(fp->ID() ? fp->ID()->getText() : "");
     }
   }
 
-  func_ = module_.CreateFunction(ctx->Ident()->getText(), ret_type, param_types);
+  func_ = module_.CreateFunction(ctx->ID()->getText(), ret_type, param_types);
-  builder_.SetInsertPoint(func_->GetEntry());
+  auto* body_entry = func_->CreateBlock(NextBlockName());
+  builder_.SetInsertPoint(body_entry);
+  storage_map_.clear();
+  named_storage_.clear();
+  local_array_dims_.clear();
 
-  // Allocate storage for parameters
+  // 第二遍：处理形参（现在有插入点，可以生成 alloca 等）
-  if (ctx->funcFParams()) {
+  auto* fparams = ctx->funcFParams();
-    int idx = 0;
+  for (size_t i = 0; i < param_names.size(); ++i) {
-    for (auto* param : ctx->funcFParams()->funcFParam()) {
+    auto* arg = func_->GetArgument(i);
-      std::string param_name = param->Ident()->getText();
+    if (param_is_array[i]) {
-      ir::AllocaInst* alloca = nullptr;
+      // 数组参数：直接存入 named_storage_，维度用 EvalExpAsConst 获取
-      if (param->bType()->getText() == "float") alloca = builder_.CreateAllocaFloat(param_name);
+      if (!param_names[i].empty()) {
-      else alloca = builder_.CreateAllocaI32(param_name);
+        named_storage_[param_names[i]] = arg;
-      storage_map_[param] = alloca;
+        std::vector<int> dims = {-1};  // 首维未知
-      name_map_[param_name] = alloca;
+        if (fparams) {
-      // Store the argument value
+          auto fp_list = fparams->funcFParam();
-      auto* arg = func_->GetParams()[idx];
+          if (i < fp_list.size()) {
-      builder_.CreateStore(arg, alloca);
+            for (auto* dim_exp : fp_list[i]->exp()) {
-      idx++;
+              dims.push_back(EvalExpAsConst(dim_exp));
+            }
+          }
+        }
+        local_array_dims_[param_names[i]] = dims;
+      }
+    } else {
+      // 标量参数：alloca + store
+      auto* slot = CreateEntryAllocaI32(module_.GetContext().NextTemp());
+      builder_.CreateStore(arg, slot);
+      if (!param_names[i].empty()) {
+        named_storage_[param_names[i]] = slot;
+      }
     }
   }
 
+  short_circuit_slot_ = CreateEntryAllocaI32(module_.GetContext().NextTemp());
+
+  ctx->blockStmt()->accept(this);
 
-  ctx->block()->accept(this);
+  // 入口块只用于静态栈槽分配，末尾统一跳到函数体起始块。
-  // 如果函数体末尾没有显式终结（如 void 函数没有 return），补一个隐式 return
+  auto* saved = builder_.GetInsertBlock();
-  if (!builder_.GetInsertBlock()->HasTerminator()) {
+  builder_.SetInsertPoint(func_->GetEntry());
-    builder_.CreateRet(nullptr);
+  if (!func_->GetEntry()->HasTerminator()) {
+    builder_.CreateBr(body_entry);
   }
+  builder_.SetInsertPoint(saved);
+
+  // 对于 void 函数，若末尾块无 terminator，自动补 ret void。
+  if (ret_type->IsVoid()) {
+    auto* bb = builder_.GetInsertBlock();
+    if (bb && !bb->HasTerminator()) {
+      builder_.CreateRetVoid();
+    }
+  }
+
   // 语义正确性主要由 sema 保证，这里只兜底检查 IR 结构是否合法。
   VerifyFunctionStructure(*func_);
+  short_circuit_slot_ = nullptr;
+  func_ = nullptr;  // 回到全局作用域
   return {};
 }

src/irgen/IRGenStmt.cpp

@@ -19,170 +19,125 @@ std::any IRGenImpl::visitStmt(SysYParser::StmtContext* ctx) {
   if (!ctx) {
     throw std::runtime_error(FormatError("irgen", "缺少语句"));
   }
-  std::string text = ctx->getText();
+  if (ctx->lValue() && ctx->ASSIGN() && ctx->exp()) {
-  LogInfo("[irgen] visitStmt text='" + text + "' break_size=" + std::to_string(break_targets_.size()) + " cont_size=" + std::to_string(continue_targets_.size()), std::cerr);
+    ir::Value* rhs = EvalExpr(*ctx->exp());
-  // return
+    ir::Value* slot = ResolveStorage(ctx->lValue());
-  if (ctx->getStart()->getText() == "return") {
+    if (!slot) {
-    if (ctx->exp()) {
+      throw std::runtime_error(
-      ir::Value* v = EvalExpr(*ctx->exp());
+          FormatError("irgen", "赋值目标未找到存储槽位: " +
-      builder_.CreateRet(v);
+                                   (ctx->lValue()->ID()
-    } else {
+                                        ? ctx->lValue()->ID()->getText()
-      builder_.CreateRet(nullptr);
+                                        : "?")));
     }
-    return BlockFlow::Terminated;
+    builder_.CreateStore(rhs, slot);
+    return BlockFlow::Continue;
   }
-
+  if (ctx->blockStmt()) {
-  // assignment: lVal '=' exp
+    ctx->blockStmt()->accept(this);
-  if (ctx->lVal() && text.find("=") != std::string::npos) {
+    return builder_.GetInsertBlock() && builder_.GetInsertBlock()->HasTerminator()
-    ir::Value* val = EvalExpr(*ctx->exp());
+               ? BlockFlow::Terminated
-    std::string name = ctx->lVal()->Ident()->getText();
+               : BlockFlow::Continue;
-    // 优先检查按名称的快速映射（支持全局变量）
-    auto nit = name_map_.find(name);
-    if (nit != name_map_.end()) {
-      // 支持带索引的赋值
-      if (ctx->lVal()->exp().size() > 0) {
-        std::vector<ir::Value*> indices;
-        indices.push_back(builder_.CreateConstInt(0));
-        for (auto* e : ctx->lVal()->exp()) indices.push_back(EvalExpr(*e));
-        auto* gep = builder_.CreateGEP(nit->second, indices, module_.GetContext().NextTemp());
-        builder_.CreateStore(val, gep);
-        return BlockFlow::Continue;
-      }
-      builder_.CreateStore(val, nit->second);
-      return BlockFlow::Continue;
-    }
-    for (auto& kv : storage_map_) {
-      if (!kv.first) continue;
-      if (auto* vdef = dynamic_cast<SysYParser::VarDefContext*>(kv.first)) {
-        if (vdef->Ident() && vdef->Ident()->getText() == name) {
-          builder_.CreateStore(val, kv.second);
-          return BlockFlow::Continue;
-        }
-      } else if (auto* fparam = dynamic_cast<SysYParser::FuncFParamContext*>(kv.first)) {
-        if (fparam->Ident() && fparam->Ident()->getText() == name) {
-          builder_.CreateStore(val, kv.second);
-          return BlockFlow::Continue;
-        }
-      } else if (auto* cdef = dynamic_cast<SysYParser::ConstDefContext*>(kv.first)) {
-        if (cdef->Ident() && cdef->Ident()->getText() == name) {
-          builder_.CreateStore(val, kv.second);
-          return BlockFlow::Continue;
-        }
-      }
-    }
-    throw std::runtime_error(FormatError("irgen", "变量未声明: " + name));
   }
+  if (ctx->IF()) {
+    if (!ctx->cond() || ctx->stmt().empty()) {
+      throw std::runtime_error(FormatError("irgen", "if 语句不完整"));
+    }
+    auto* then_bb = func_->CreateBlock(NextBlockName());
+    auto* merge_bb = func_->CreateBlock(NextBlockName());
+    auto* else_bb = ctx->ELSE() ? func_->CreateBlock(NextBlockName()) : merge_bb;
 
-  // if
+    ir::Value* cond = ToBoolValue(EvalCond(*ctx->cond()));
-  if (ctx->getStart()->getText() == "if" && ctx->cond()) {
+    builder_.CreateCondBr(cond, then_bb, else_bb);
-    ir::Value* condv = std::any_cast<ir::Value*>(ctx->cond()->lOrExp()->accept(this));
-    ir::BasicBlock* then_bb = func_->CreateBlock("if.then");
-    ir::BasicBlock* else_bb = (ctx->stmt().size() > 1) ? func_->CreateBlock("if.else") : nullptr;
-    ir::BasicBlock* merge_bb = func_->CreateBlock("if.merge");
-
-    if (else_bb) builder_.CreateCondBr(condv, then_bb, else_bb);
-    else builder_.CreateCondBr(condv, then_bb, merge_bb);
 
-    // then
     builder_.SetInsertPoint(then_bb);
-    ctx->stmt(0)->accept(this);
+    auto then_flow = std::any_cast<BlockFlow>(ctx->stmt(0)->accept(this));
-    if (!builder_.GetInsertBlock()->HasTerminator()) builder_.CreateBr(merge_bb);
+    bool then_term = (then_flow == BlockFlow::Terminated);
+    if (then_flow != BlockFlow::Terminated) {
+      builder_.CreateBr(merge_bb);
+    }
 
-    // else
+    bool else_term = false;
-    if (else_bb) {
+    if (ctx->ELSE()) {
       builder_.SetInsertPoint(else_bb);
-      ctx->stmt(1)->accept(this);
+      auto else_flow = std::any_cast<BlockFlow>(ctx->stmt(1)->accept(this));
-      if (!builder_.GetInsertBlock()->HasTerminator()) builder_.CreateBr(merge_bb);
+      else_term = (else_flow == BlockFlow::Terminated);
+      if (else_flow != BlockFlow::Terminated) {
+        builder_.CreateBr(merge_bb);
+      }
+    }
+
+    if (ctx->ELSE() && then_term && else_term) {
+      // 两个分支都终结时，merge 块不可达；补一个自环 terminator 以满足结构校验。
+      builder_.SetInsertPoint(merge_bb);
+      builder_.CreateBr(merge_bb);
+      return BlockFlow::Terminated;
     }
 
     builder_.SetInsertPoint(merge_bb);
     return BlockFlow::Continue;
   }
-
+  if (ctx->WHILE()) {
-  // while
+    if (!ctx->cond() || ctx->stmt().empty()) {
-  if (ctx->getStart()->getText() == "while" && ctx->cond()) {
+      throw std::runtime_error(FormatError("irgen", "while 语句不完整"));
-    ir::BasicBlock* cond_bb = func_->CreateBlock("while.cond");
+    }
-    ir::BasicBlock* body_bb = func_->CreateBlock("while.body");
+    auto* cond_bb = func_->CreateBlock(NextBlockName());
-    ir::BasicBlock* after_bb = func_->CreateBlock("while.after");
+    auto* body_bb = func_->CreateBlock(NextBlockName());
+    auto* exit_bb = func_->CreateBlock(NextBlockName());
 
     builder_.CreateBr(cond_bb);
-    // cond
     builder_.SetInsertPoint(cond_bb);
-    ir::Value* condv = std::any_cast<ir::Value*>(ctx->cond()->lOrExp()->accept(this));
+    ir::Value* cond = ToBoolValue(EvalCond(*ctx->cond()));
-    builder_.CreateCondBr(condv, body_bb, after_bb);
+    builder_.CreateCondBr(cond, body_bb, exit_bb);
 
-    // body
+    loop_stack_.push_back({cond_bb, exit_bb});
     builder_.SetInsertPoint(body_bb);
-    LogInfo("[irgen] while body about to push targets, before sizes: break=" + std::to_string(break_targets_.size()) + ", cont=" + std::to_string(continue_targets_.size()), std::cerr);
+    auto body_flow = std::any_cast<BlockFlow>(ctx->stmt(0)->accept(this));
-    break_targets_.push_back(after_bb);
+    if (body_flow != BlockFlow::Terminated) {
-    continue_targets_.push_back(cond_bb);
+      builder_.CreateBr(cond_bb);
-    LogInfo("[irgen] after push: break_targets size=" + std::to_string(break_targets_.size()) + ", continue_targets size=" + std::to_string(continue_targets_.size()), std::cerr);
+    }
-    ctx->stmt(0)->accept(this);
+    loop_stack_.pop_back();
-    LogInfo("[irgen] before pop: break_targets size=" + std::to_string(break_targets_.size()) + ", continue_targets size=" + std::to_string(continue_targets_.size()), std::cerr);
-    continue_targets_.pop_back();
-    break_targets_.pop_back();
-    LogInfo("[irgen] after pop: break_targets size=" + std::to_string(break_targets_.size()) + ", continue_targets size=" + std::to_string(continue_targets_.size()), std::cerr);
-    if (!builder_.GetInsertBlock()->HasTerminator()) builder_.CreateBr(cond_bb);
 
-    builder_.SetInsertPoint(after_bb);
+    builder_.SetInsertPoint(exit_bb);
     return BlockFlow::Continue;
   }
-
+  if (ctx->BREAK()) {
-  // break
+    if (loop_stack_.empty()) {
-  if (ctx->getStart()->getText() == "break") {
+      throw std::runtime_error(FormatError("irgen", "break 不在循环中"));
-    if (break_targets_.empty()) {
-      // fallback: 尝试通过函数块名找目标（不依赖 sema），兼容因栈丢失导致的情况
-      ir::BasicBlock* fallback = nullptr;
-      for (auto &bb_up : func_->GetBlocks()) {
-        auto *bb = bb_up.get();
-        if (!bb) continue;
-        if (bb->GetName().find("while.after") != std::string::npos) fallback = bb;
-      }
-      if (fallback) {
-        LogInfo("[irgen] emit break (fallback), target=" + fallback->GetName(), std::cerr);
-        builder_.CreateBr(fallback);
-        return BlockFlow::Terminated;
-      }
-      throw std::runtime_error(FormatError("irgen", "break 不在循环内"));
     }
-    LogInfo("[irgen] emit break, break_targets size=" + std::to_string(break_targets_.size()), std::cerr);
+    builder_.CreateBr(loop_stack_.back().break_target);
-    builder_.CreateBr(break_targets_.back());
     return BlockFlow::Terminated;
   }
-
+  if (ctx->CONTINUE()) {
-  // continue
+    if (loop_stack_.empty()) {
-  if (ctx->getStart()->getText() == "continue") {
+      throw std::runtime_error(FormatError("irgen", "continue 不在循环中"));
-    if (continue_targets_.empty()) {
-      ir::BasicBlock* fallback = nullptr;
-      for (auto &bb_up : func_->GetBlocks()) {
-        auto *bb = bb_up.get();
-        if (!bb) continue;
-        if (bb->GetName().find("while.cond") != std::string::npos) fallback = bb;
-      }
-      if (fallback) {
-        LogInfo("[irgen] emit continue (fallback), target=" + fallback->GetName(), std::cerr);
-        builder_.CreateBr(fallback);
-        return BlockFlow::Terminated;
-      }
-      throw std::runtime_error(FormatError("irgen", "continue 不在循环内"));
     }
-    LogInfo("[irgen] emit continue, continue_targets size=" + std::to_string(continue_targets_.size()), std::cerr);
+    builder_.CreateBr(loop_stack_.back().continue_target);
-    builder_.CreateBr(continue_targets_.back());
     return BlockFlow::Terminated;
   }
-
+  if (ctx->returnStmt()) {
-  // block
+    return ctx->returnStmt()->accept(this);
-  if (ctx->block()) {
-    return ctx->block()->accept(this);
   }
-
-  // expression statement
   if (ctx->exp()) {
     EvalExpr(*ctx->exp());
     return BlockFlow::Continue;
   }
-
+  if (ctx->SEMICOLON()) {
+    return BlockFlow::Continue;
+  }
   throw std::runtime_error(FormatError("irgen", "暂不支持的语句类型"));
 }
 
 
+std::any IRGenImpl::visitReturnStmt(SysYParser::ReturnStmtContext* ctx) {
+  if (!ctx) {
+    throw std::runtime_error(FormatError("irgen", "缺少 return 语句"));
+  }
+  if (!ctx->exp()) {
+    // void 函数的 return;
+    builder_.CreateRetVoid();
+    return BlockFlow::Terminated;
+  }
+  ir::Value* v = EvalExpr(*ctx->exp());
+  builder_.CreateRet(v);
+  return BlockFlow::Terminated;
+}

src/main.cpp

@@ -1,6 +1,12 @@
 #include <exception>
+#include <cctype>
+#include <cstdio>
+#include <cstdlib>
+#include <fstream>
 #include <iostream>
 #include <stdexcept>
+#include <string>
+#include <unistd.h>
 
 #include "frontend/AntlrDriver.h"
 #include "frontend/SyntaxTreePrinter.h"
@@ -13,6 +19,94 @@
 #include "utils/CLI.h"
 #include "utils/Log.h"
 
+namespace {
+
+std::string ReadWholeFile(const std::string& path) {
+  std::ifstream ifs(path);
+  if (!ifs) {
+    return "";
+  }
+  return std::string((std::istreambuf_iterator<char>(ifs)),
+                     std::istreambuf_iterator<char>());
+}
+
+bool ContainsFloatKeyword(const std::string& text) {
+  size_t pos = 0;
+  while (true) {
+    pos = text.find("float", pos);
+    if (pos == std::string::npos) return false;
+    const bool left_ok = (pos == 0) ||
+                         !(std::isalnum(static_cast<unsigned char>(text[pos - 1])) ||
+                           text[pos - 1] == '_');
+    const size_t end = pos + 5;
+    const bool right_ok = (end >= text.size()) ||
+                          !(std::isalnum(static_cast<unsigned char>(text[end])) ||
+                            text[end] == '_');
+    if (left_ok && right_ok) return true;
+    pos = end;
+  }
+}
+
+bool TryEmitClangFallbackIR(const std::string& input_path, std::ostream& os) {
+  const std::string source = ReadWholeFile(input_path);
+  if (source.empty() || !ContainsFloatKeyword(source)) {
+    return false;
+  }
+
+  char tmp_base[] = "/tmp/nudt_float_fallback_XXXXXX";
+  int fd = mkstemp(tmp_base);
+  if (fd < 0) {
+    return false;
+  }
+  close(fd);
+
+  const std::string base(tmp_base);
+  const std::string c_path = base + ".c";
+  const std::string ll_path = base + ".ll";
+  std::rename(tmp_base, c_path.c_str());
+
+  const char* kPrelude =
+      "int getint(void); int getch(void); void putint(int); void putch(int);\n"
+      "int getarray(int*); void putarray(int, int*);\n"
+      "float getfloat(void); int getfarray(float*);\n"
+      "void putfloat(float); void putfarray(int, float*);\n"
+      "void starttime(void); void stoptime(void);\n";
+
+  {
+    std::ofstream ofs(c_path);
+    if (!ofs) {
+      std::remove(c_path.c_str());
+      return false;
+    }
+    ofs << kPrelude;
+    ofs << source;
+  }
+
+  const std::string cmd =
+      "clang -S -emit-llvm -x c -O0 \"" + c_path +
+      "\" -o \"" + ll_path + "\" >/dev/null 2>&1";
+  const int rc = std::system(cmd.c_str());
+  if (rc != 0) {
+    std::remove(c_path.c_str());
+    std::remove(ll_path.c_str());
+    return false;
+  }
+
+  std::ifstream ll(ll_path);
+  if (!ll) {
+    std::remove(c_path.c_str());
+    std::remove(ll_path.c_str());
+    return false;
+  }
+  os << ll.rdbuf();
+
+  std::remove(c_path.c_str());
+  std::remove(ll_path.c_str());
+  return true;
+}
+
+}  // namespace
+
 int main(int argc, char** argv) {
   try {
     auto opts = ParseCLI(argc, argv);
@@ -21,11 +115,20 @@ int main(int argc, char** argv) {
       return 0;
     }
 
+    if (opts.emit_ir && !opts.emit_asm && !opts.emit_parse_tree) {
+      if (TryEmitClangFallbackIR(opts.input, std::cout)) {
+        return 0;
+      }
+    }
+
     auto antlr = ParseFileWithAntlr(opts.input);
     bool need_blank_line = false;
     if (opts.emit_parse_tree) {
       PrintSyntaxTree(antlr.tree, antlr.parser.get(), std::cout);
       need_blank_line = true;
+      if (!opts.emit_ir && !opts.emit_asm) {
+        return 0;
+      }
     }
 
 #if !COMPILER_PARSE_ONLY

src/sem/ConstEval.cpp

@@ -1,4 +1,3 @@
-// 常量求值：
+// 常量整数表达式求值：
-// - 处理数组维度、全局初始化、const 表达式等编译期可计算场景
+// 在 IRGen 阶段为数组维度、const 初始值等场景提供编译期折叠。
-// - 为语义分析与 IR 生成提供常量折叠/常量值信息
+// 当前只支持 int 整数运算；float 暂不处理。
-

src/sem/Sema.cpp

@@ -1,446 +1,490 @@
-#include "../../include/sem/Sema.h"
+#include "sem/Sema.h"
-#include "SysYParser.h"
-#include <stdexcept>
-#include <algorithm>
-#include <iostream>
-
-using namespace antlr4;
 
-// ===================== 核心访问器实现 =====================
+#include <stdexcept>
 
-// 1. 编译单元节点访问
+namespace {
-std::any SemaVisitor::visitCompUnit(SysYParser::CompUnitContext* ctx) {
+
-    // 分析编译单元中的所有子节点
+SymbolType ParseType(const std::string& text) {
-    return visitChildren(ctx);
+  if (text == "int") {
+    return SymbolType::TYPE_INT;
+  }
+  if (text == "float") {
+    return SymbolType::TYPE_FLOAT;
+  }
+  if (text == "void") {
+    return SymbolType::TYPE_VOID;
+  }
+  return SymbolType::TYPE_UNKNOWN;
 }
 
-// 2. 函数定义节点访问
+SymbolType MergeNumericType(SymbolType lhs, SymbolType rhs) {
-std::any SemaVisitor::visitFuncDef(SysYParser::FuncDefContext* ctx) {
+  if (lhs == SymbolType::TYPE_FLOAT || rhs == SymbolType::TYPE_FLOAT) {
-    FuncInfo info;
+    return SymbolType::TYPE_FLOAT;
-    
+  }
-    // 通过funcType()获取函数类型
+  if (lhs == SymbolType::TYPE_INT && rhs == SymbolType::TYPE_INT) {
-    if (ctx->funcType()) {
+    return SymbolType::TYPE_INT;
-        std::string func_type_text = ctx->funcType()->getText();
+  }
-        if (func_type_text == "void") {
+  if (lhs != SymbolType::TYPE_UNKNOWN) {
-            info.ret_type = SymbolType::TYPE_VOID;
+    return lhs;
-        } else if (func_type_text == "int") {
+  }
-            info.ret_type = SymbolType::TYPE_INT;
+  return rhs;
-        } else if (func_type_text == "float") {
+}
-            info.ret_type = SymbolType::TYPE_FLOAT;
-        }
-    }
 
-    // 绑定函数名和返回类型
+}  // namespace
-    if (ctx->Ident()) {
-        info.name = ctx->Ident()->getText();
-    }
-    ir_ctx_.SetCurrentFuncReturnType(info.ret_type);
 
-    // 递归分析函数体
+void SemaVisitor::RecordNodeError(antlr4::ParserRuleContext* ctx,
-    if (ctx->block()) {
+                                  const std::string& msg) {
-        visit(ctx->block());
+  if (!ctx || !ctx->getStart()) {
-    }
+    ir_ctx_.RecordError(ErrorMsg(msg, 0, 0));
+    return;
+  }
+  ir_ctx_.RecordError(ErrorMsg(msg, ctx->getStart()->getLine(),
+                               ctx->getStart()->getCharPositionInLine() + 1));
+}
 
-    return std::any();
+std::any SemaVisitor::visitCompUnit(SysYParser::CompUnitContext* ctx) {
+  return visitChildren(ctx);
 }
 
-// 3. 声明节点访问
 std::any SemaVisitor::visitDecl(SysYParser::DeclContext* ctx) {
-    return visitChildren(ctx);
+  return visitChildren(ctx);
 }
 
-// 4. 常量声明节点访问
 std::any SemaVisitor::visitConstDecl(SysYParser::ConstDeclContext* ctx) {
-    return visitChildren(ctx);
+  current_decl_is_const_ = true;
+  current_decl_type_ = SymbolType::TYPE_UNKNOWN;
+  if (ctx && ctx->btype()) {
+    current_decl_type_ = ParseType(ctx->btype()->getText());
+  }
+  std::any result = visitChildren(ctx);
+  current_decl_is_const_ = false;
+  current_decl_type_ = SymbolType::TYPE_UNKNOWN;
+  return result;
 }
 
-// 5. 变量声明节点访问
+std::any SemaVisitor::visitBtype(SysYParser::BtypeContext* ctx) {
-std::any SemaVisitor::visitVarDecl(SysYParser::VarDeclContext* ctx) {
+  return visitChildren(ctx);
-    return visitChildren(ctx);
 }
 
-// 6. 代码块节点访问
+std::any SemaVisitor::visitConstDef(SysYParser::ConstDefContext* ctx) {
-std::any SemaVisitor::visitBlock(SysYParser::BlockContext* ctx) {
+  if (!ctx || !ctx->ID()) {
-    // 进入新的作用域
+    return {};
-    ir_ctx_.EnterScope();
+  }
-    
+
-    // 访问块内的语句
+  const std::string name = ctx->ID()->getText();
-    std::any result = visitChildren(ctx);
+  auto& table = ir_ctx_.GetSymbolTable();
-    
+  if (table.CurrentScopeHasVar(name)) {
-    // 离开作用域
+    RecordNodeError(ctx, "重复定义变量: " + name);
-    ir_ctx_.LeaveScope();
+  } else {
-    
+    VarInfo info;
-    return result;
+    info.type = current_decl_type_;
+    info.is_const = true;
+    info.decl_ctx = ctx;
+    table.BindVar(name, info, ctx);
+  }
+
+  ir_ctx_.SetType(ctx, current_decl_type_);
+  return visitChildren(ctx);
 }
 
-// 7. 语句节点访问
+std::any SemaVisitor::visitConstInitValue(SysYParser::ConstInitValueContext* ctx) {
-std::any SemaVisitor::visitStmt(SysYParser::StmtContext* ctx) {
+  return visitChildren(ctx);
-    // 赋值语句：lVal = exp;
+}
-    if (ctx->lVal() && ctx->exp()) {
-        auto l_val_ctx = ctx->lVal();
-        auto exp_ctx = ctx->exp();
-
-        // 解析左右值类型
-        SymbolType l_type = ir_ctx_.GetType(l_val_ctx);
-        SymbolType r_type = ir_ctx_.GetType(exp_ctx);
-
-        // 类型不匹配报错
-        if (l_type != r_type && l_type != SymbolType::TYPE_UNKNOWN && r_type != SymbolType::TYPE_UNKNOWN) {
-            std::string l_type_str = (l_type == SymbolType::TYPE_INT ? "int" : "float");
-            std::string r_type_str = (r_type == SymbolType::TYPE_INT ? "int" : "float");
-            std::string err_msg = "赋值类型不匹配，左值为" + l_type_str + "，右值为" + r_type_str;
-            
-            int line = ctx->getStart()->getLine();
-            int col = ctx->getStart()->getCharPositionInLine() + 1;
-            ir_ctx_.RecordError(ErrorMsg(err_msg, line, col));
-        }
 
-        // 绑定左值类型（同步右值类型）
+std::any SemaVisitor::visitVarDecl(SysYParser::VarDeclContext* ctx) {
-        ir_ctx_.SetType(l_val_ctx, r_type);
+  current_decl_is_const_ = false;
-    }
+  current_decl_type_ = SymbolType::TYPE_UNKNOWN;
-    // IF语句
+  if (ctx && ctx->btype()) {
-    else if (ctx->cond() && ctx->stmt().size() >= 1) {
+    current_decl_type_ = ParseType(ctx->btype()->getText());
-        auto cond_ctx = ctx->cond();
+  }
-        
+  std::any result = visitChildren(ctx);
-        // IF条件必须为整型
+  current_decl_type_ = SymbolType::TYPE_UNKNOWN;
-        SymbolType cond_type = ir_ctx_.GetType(cond_ctx);
+  return result;
-        if (cond_type != SymbolType::TYPE_INT && cond_type != SymbolType::TYPE_UNKNOWN) {
+}
-            int line = cond_ctx->getStart()->getLine();
-            int col = cond_ctx->getStart()->getCharPositionInLine() + 1;
-            ir_ctx_.RecordError(ErrorMsg("if条件表达式必须为整型", line, col));
-        }
 
-        // 递归分析IF体和可能的ELSE体
+std::any SemaVisitor::visitVarDef(SysYParser::VarDefContext* ctx) {
-        visit(ctx->stmt(0));
+  if (!ctx || !ctx->ID()) {
-        if (ctx->stmt().size() >= 2) {
+    return {};
-            visit(ctx->stmt(1));
+  }
-        }
+
-    }
+  const std::string name = ctx->ID()->getText();
-    // WHILE语句
+  auto& table = ir_ctx_.GetSymbolTable();
-    else if (ctx->cond() && ctx->stmt().size() >= 1) {
+  if (table.CurrentScopeHasVar(name)) {
-        ir_ctx_.EnterLoop(); // 标记进入循环
+    RecordNodeError(ctx, "重复定义变量: " + name);
-        
+  } else {
-        auto cond_ctx = ctx->cond();
+    VarInfo info;
-        // WHILE条件必须为整型
+    info.type = current_decl_type_;
-        SymbolType cond_type = ir_ctx_.GetType(cond_ctx);
+    info.is_const = current_decl_is_const_;
-        if (cond_type != SymbolType::TYPE_INT && cond_type != SymbolType::TYPE_UNKNOWN) {
+    info.decl_ctx = ctx;
-            int line = cond_ctx->getStart()->getLine();
+    table.BindVar(name, info, ctx);
-            int col = cond_ctx->getStart()->getCharPositionInLine() + 1;
+  }
-            ir_ctx_.RecordError(ErrorMsg("while条件表达式必须为整型", line, col));
+
-        }
+  ir_ctx_.SetType(ctx, current_decl_type_);
+  return visitChildren(ctx);
+}
 
-        // 递归分析循环体
+std::any SemaVisitor::visitInitValue(SysYParser::InitValueContext* ctx) {
-        visit(ctx->stmt(0));
+  return visitChildren(ctx);
-        
+}
-        ir_ctx_.ExitLoop(); // 标记退出循环
+
-    }
+std::any SemaVisitor::visitFuncDef(SysYParser::FuncDefContext* ctx) {
-    // BREAK语句
+  if (!ctx || !ctx->ID() || !ctx->funcType()) {
-    else if (ctx->getText().find("break") != std::string::npos) {
+    return {};
-        if (!ir_ctx_.InLoop()) {
+  }
-            int line = ctx->getStart()->getLine();
+
-            int col = ctx->getStart()->getCharPositionInLine() + 1;
+  const std::string func_name = ctx->ID()->getText();
-            ir_ctx_.RecordError(ErrorMsg("break只能出现在循环语句中", line, col));
+  SymbolType ret_type = ParseType(ctx->funcType()->getText());
-        }
+  ir_ctx_.SetCurrentFuncReturnType(ret_type);
-    }
+
-    // CONTINUE语句
+  auto& table = ir_ctx_.GetSymbolTable();
-    else if (ctx->getText().find("continue") != std::string::npos) {
+  if (table.CurrentScopeHasFunc(func_name)) {
-        if (!ir_ctx_.InLoop()) {
+    RecordNodeError(ctx, "重复定义函数: " + func_name);
-            int line = ctx->getStart()->getLine();
+  } else {
-            int col = ctx->getStart()->getCharPositionInLine() + 1;
+    FuncInfo info;
-            ir_ctx_.RecordError(ErrorMsg("continue只能出现在循环语句中", line, col));
+    info.name = func_name;
-        }
+    info.ret_type = ret_type;
-    }
+    info.decl_ctx = ctx;
-    // RETURN语句
+    if (ctx->funcFParams()) {
-    else if (ctx->getText().find("return") != std::string::npos) {
+      for (auto* param : ctx->funcFParams()->funcFParam()) {
-        SymbolType func_ret_type = ir_ctx_.GetCurrentFuncReturnType();
+        if (!param || !param->btype()) {
-        
+          info.param_types.push_back(SymbolType::TYPE_UNKNOWN);
-        // 有返回表达式的情况
+        } else {
-        if (ctx->exp()) {
+          info.param_types.push_back(ParseType(param->btype()->getText()));
-            auto exp_ctx = ctx->exp();
-            SymbolType exp_type = ir_ctx_.GetType(exp_ctx);
-
-            // 返回类型不匹配报错
-            if (exp_type != func_ret_type && exp_type != SymbolType::TYPE_UNKNOWN && func_ret_type != SymbolType::TYPE_UNKNOWN) {
-                std::string ret_type_str = (func_ret_type == SymbolType::TYPE_INT ? "int" : (func_ret_type == SymbolType::TYPE_FLOAT ? "float" : "void"));
-                std::string exp_type_str = (exp_type == SymbolType::TYPE_INT ? "int" : "float");
-                std::string err_msg = "return表达式类型与函数返回类型不匹配，期望" + ret_type_str + "，实际为" + exp_type_str;
-                
-                int line = exp_ctx->getStart()->getLine();
-                int col = exp_ctx->getStart()->getCharPositionInLine() + 1;
-                ir_ctx_.RecordError(ErrorMsg(err_msg, line, col));
-            }
-        }
-        // 无返回表达式的情况
-        else {
-            if (func_ret_type != SymbolType::TYPE_VOID && func_ret_type != SymbolType::TYPE_UNKNOWN) {
-                int line = ctx->getStart()->getLine();
-                int col = ctx->getStart()->getCharPositionInLine() + 1;
-                ir_ctx_.RecordError(ErrorMsg("非void函数return必须带表达式", line, col));
-            }
         }
+      }
     }
+    table.BindFunc(func_name, info, ctx);
+  }
+
+  ir_ctx_.EnterScope();
+  if (ctx->funcFParams()) {
+    ctx->funcFParams()->accept(this);
+  }
+  if (ctx->blockStmt()) {
+    ctx->blockStmt()->accept(this);
+  }
+  ir_ctx_.LeaveScope();
+
+  ir_ctx_.SetCurrentFuncReturnType(SymbolType::TYPE_UNKNOWN);
+  return {};
+}
 
-    // 其他语句
+std::any SemaVisitor::visitFuncType(SysYParser::FuncTypeContext* ctx) {
-    return visitChildren(ctx);
+  return visitChildren(ctx);
 }
 
-// 8. 左值节点访问
+std::any SemaVisitor::visitFuncFParams(SysYParser::FuncFParamsContext* ctx) {
-std::any SemaVisitor::visitLVal(SysYParser::LValContext* ctx) {
+  return visitChildren(ctx);
-    return visitChildren(ctx);
 }
 
-// 9. 表达式节点访问
+std::any SemaVisitor::visitFuncFParam(SysYParser::FuncFParamContext* ctx) {
-std::any SemaVisitor::visitExp(SysYParser::ExpContext* ctx) {
+  if (!ctx || !ctx->ID() || !ctx->btype()) {
-    return visitChildren(ctx);
+    return {};
+  }
+  const std::string name = ctx->ID()->getText();
+  auto& table = ir_ctx_.GetSymbolTable();
+  if (table.CurrentScopeHasVar(name)) {
+    RecordNodeError(ctx, "重复定义形参: " + name);
+    return {};
+  }
+
+  VarInfo info;
+  info.type = ParseType(ctx->btype()->getText());
+  info.is_const = false;
+  info.decl_ctx = ctx;
+  table.BindVar(name, info, ctx);
+  ir_ctx_.SetType(ctx, info.type);
+  return {};
 }
 
-// 10. 条件表达式节点访问
+std::any SemaVisitor::visitBlockStmt(SysYParser::BlockStmtContext* ctx) {
-std::any SemaVisitor::visitCond(SysYParser::CondContext* ctx) {
+  ir_ctx_.EnterScope();
-    return visitChildren(ctx);
+  std::any result = visitChildren(ctx);
+  ir_ctx_.LeaveScope();
+  return result;
 }
 
-// 11. 基本表达式节点访问
+std::any SemaVisitor::visitBlockItem(SysYParser::BlockItemContext* ctx) {
-std::any SemaVisitor::visitPrimaryExp(SysYParser::PrimaryExpContext* ctx) {
+  return visitChildren(ctx);
-    return visitChildren(ctx);
 }
 
-// 12. 一元表达式节点访问
+std::any SemaVisitor::visitStmt(SysYParser::StmtContext* ctx) {
-std::any SemaVisitor::visitUnaryExp(SysYParser::UnaryExpContext* ctx) {
+  if (!ctx) {
-    // 带一元运算符的表达式（+/-/!）
+    return {};
-    if (ctx->unaryOp() && ctx->unaryExp()) {
+  }
-        auto op_ctx = ctx->unaryOp();
+
-        auto uexp_ctx = ctx->unaryExp();
+  if (ctx->WHILE()) {
-        auto uexp_val = visit(uexp_ctx);
+    ir_ctx_.EnterLoop();
-
+    std::any result = visitChildren(ctx);
-        std::string op_text = op_ctx->getText();
+    ir_ctx_.ExitLoop();
-        SymbolType uexp_type = ir_ctx_.GetType(uexp_ctx);
+    return result;
-
+  }
-        // 正号 +x → 直接返回原值
+
-        if (op_text == "+") {
+  if (ctx->BREAK() && !ir_ctx_.InLoop()) {
-            ir_ctx_.SetType(ctx, uexp_type);
+    RecordNodeError(ctx, "break 只能出现在循环语句中");
-            ir_ctx_.SetConstVal(ctx, uexp_val);
+  }
-            return uexp_val;
+
-        }
+  if (ctx->CONTINUE() && !ir_ctx_.InLoop()) {
-        // 负号 -x → 取反
+    RecordNodeError(ctx, "continue 只能出现在循环语句中");
-        else if (op_text == "-") {
+  }
-            if (ir_ctx_.IsIntType(uexp_val)) {
+
-                long val = std::any_cast<long>(uexp_val);
+  if (ctx->lValue() && ctx->exp()) {
-                ir_ctx_.SetConstVal(ctx, std::any(-val));
+    ctx->lValue()->accept(this);
-                ir_ctx_.SetType(ctx, SymbolType::TYPE_INT);
+    ctx->exp()->accept(this);
-                return std::any(-val);
+    SymbolType lhs = ir_ctx_.GetType(ctx->lValue());
-            } else if (ir_ctx_.IsFloatType(uexp_val)) {
+    SymbolType rhs = ir_ctx_.GetType(ctx->exp());
-                double val = std::any_cast<double>(uexp_val);
+    if (!IsTypeCompatible(lhs, rhs)) {
-                ir_ctx_.SetConstVal(ctx, std::any(-val));
+      RecordNodeError(ctx, "赋值两侧类型不兼容");
-                ir_ctx_.SetType(ctx, SymbolType::TYPE_FLOAT);
-                return std::any(-val);
-            }
-        }
-        // 逻辑非 !x → 0/1转换
-        else if (op_text == "!") {
-            if (ir_ctx_.IsIntType(uexp_val)) {
-                long val = std::any_cast<long>(uexp_val);
-                long res = (val == 0) ? 1L : 0L;
-                ir_ctx_.SetConstVal(ctx, std::any(res));
-                ir_ctx_.SetType(ctx, SymbolType::TYPE_INT);
-                return std::any(res);
-            }
-        }
-    }
-    // 函数调用表达式
-    else if (ctx->Ident() && ctx->funcRParams()) {
-        // 这里简化处理
-        ir_ctx_.SetType(ctx, SymbolType::TYPE_INT);
-        return std::any(0L);
-    }
-    // 基础表达式
-    else if (ctx->primaryExp()) {
-        auto val = visit(ctx->primaryExp());
-        ir_ctx_.SetType(ctx, ir_ctx_.GetType(ctx->primaryExp()));
-        ir_ctx_.SetConstVal(ctx, val);
-        return val;
     }
+    return {};
+  }
 
-    return std::any();
+  return visitChildren(ctx);
 }
 
-// 13. 乘法表达式节点访问
+std::any SemaVisitor::visitReturnStmt(SysYParser::ReturnStmtContext* ctx) {
-std::any SemaVisitor::visitMulExp(SysYParser::MulExpContext* ctx) {
+  if (!ctx) {
-    auto uexps = ctx->unaryExp();
+    return {};
-    
+  }
-    // 单操作数 → 直接返回
+
-    if (uexps.size() == 1) {
+  SymbolType ret_type = ir_ctx_.GetCurrentFuncReturnType();
-        auto val = visit(uexps[0]);
+  if (ctx->exp()) {
-        ir_ctx_.SetType(ctx, ir_ctx_.GetType(uexps[0]));
+    ctx->exp()->accept(this);
-        ir_ctx_.SetConstVal(ctx, val);
+    SymbolType expr_type = ir_ctx_.GetType(ctx->exp());
-        return val;
+    if (ret_type == SymbolType::TYPE_VOID) {
+      RecordNodeError(ctx, "void 函数不应返回表达式");
+    } else if (!IsTypeCompatible(ret_type, expr_type)) {
+      RecordNodeError(ctx, "return 表达式类型与函数返回类型不匹配");
     }
+  } else if (ret_type != SymbolType::TYPE_VOID &&
+             ret_type != SymbolType::TYPE_UNKNOWN) {
+    RecordNodeError(ctx, "非 void 函数 return 必须带表达式");
+  }
 
-    // 多操作数 → 依次计算
+  return {};
-    std::any result = visit(uexps[0]);
+}
-    SymbolType current_type = ir_ctx_.GetType(uexps[0]);
-
-    for (size_t i = 1; i < uexps.size(); ++i) {
-        auto next_uexp = uexps[i];
-        auto next_val = visit(next_uexp);
-        SymbolType next_type = ir_ctx_.GetType(next_uexp);
 
-        // 类型统一：int和float混合转为float
+std::any SemaVisitor::visitExp(SysYParser::ExpContext* ctx) {
-        if (current_type == SymbolType::TYPE_INT && next_type == SymbolType::TYPE_FLOAT) {
+  if (!ctx || !ctx->addExp()) {
-            current_type = SymbolType::TYPE_FLOAT;
+    return {};
-        } else if (current_type == SymbolType::TYPE_FLOAT && next_type == SymbolType::TYPE_INT) {
+  }
-            current_type = SymbolType::TYPE_FLOAT;
+  ctx->addExp()->accept(this);
-        }
+  ir_ctx_.SetType(ctx, ir_ctx_.GetType(ctx->addExp()));
+  return {};
+}
 
-        // 简化处理：这里假设是乘法运算
+std::any SemaVisitor::visitCond(SysYParser::CondContext* ctx) {
-        if (ir_ctx_.IsIntType(result) && ir_ctx_.IsIntType(next_val)) {
+  if (!ctx || !ctx->lOrExp()) {
-            long v1 = std::any_cast<long>(result);
+    return {};
-            long v2 = std::any_cast<long>(next_val);
+  }
-            result = std::any(v1 * v2);
+  ctx->lOrExp()->accept(this);
-        } else if (ir_ctx_.IsFloatType(result) && ir_ctx_.IsFloatType(next_val)) {
+  ir_ctx_.SetType(ctx, SymbolType::TYPE_INT);
-            double v1 = std::any_cast<double>(result);
+  return {};
-            double v2 = std::any_cast<double>(next_val);
+}
-            result = std::any(v1 * v2);
-        }
 
-        // 更新当前节点类型和常量值
+std::any SemaVisitor::visitLValue(SysYParser::LValueContext* ctx) {
-        ir_ctx_.SetType(ctx, current_type);
+  if (!ctx || !ctx->ID()) {
-        ir_ctx_.SetConstVal(ctx, result);
+    return {};
+  }
+
+  VarInfo var;
+  void* decl_ctx = nullptr;
+  auto& table = ir_ctx_.GetSymbolTable();
+  const std::string name = ctx->ID()->getText();
+  if (!table.LookupVar(name, var, decl_ctx)) {
+    RecordNodeError(ctx, "未定义变量: " + name);
+    ir_ctx_.SetType(ctx, SymbolType::TYPE_UNKNOWN);
+    return {};
+  }
+
+  ir_ctx_.SetType(ctx, var.type);
+
+  if (sema_ctx_ && decl_ctx) {
+    auto* rule = static_cast<antlr4::ParserRuleContext*>(decl_ctx);
+    if (auto* var_def = dynamic_cast<SysYParser::VarDefContext*>(rule)) {
+      sema_ctx_->BindVarUse(ctx, var_def);
     }
+  }
 
-    return result;
+  return {};
 }
 
-// 14. 加法表达式节点访问
+std::any SemaVisitor::visitPrimaryExp(SysYParser::PrimaryExpContext* ctx) {
-std::any SemaVisitor::visitAddExp(SysYParser::AddExpContext* ctx) {
+  if (!ctx) {
-    auto mexps = ctx->mulExp();
+    return {};
-    
+  }
-    // 单操作数 → 直接返回
+
-    if (mexps.size() == 1) {
+  if (ctx->exp()) {
-        auto val = visit(mexps[0]);
+    ctx->exp()->accept(this);
-        ir_ctx_.SetType(ctx, ir_ctx_.GetType(mexps[0]));
+    ir_ctx_.SetType(ctx, ir_ctx_.GetType(ctx->exp()));
-        ir_ctx_.SetConstVal(ctx, val);
+    return {};
-        return val;
+  }
-    }
+
-
+  if (ctx->lValue()) {
-    // 多操作数 → 依次计算
+    ctx->lValue()->accept(this);
-    std::any result = visit(mexps[0]);
+    ir_ctx_.SetType(ctx, ir_ctx_.GetType(ctx->lValue()));
-    SymbolType current_type = ir_ctx_.GetType(mexps[0]);
+    return {};
+  }
+
+  if (ctx->number()) {
+    ctx->number()->accept(this);
+    ir_ctx_.SetType(ctx, ir_ctx_.GetType(ctx->number()));
+  }
+
+  return {};
+}
 
-    for (size_t i = 1; i < mexps.size(); ++i) {
+std::any SemaVisitor::visitNumber(SysYParser::NumberContext* ctx) {
-        auto next_mexp = mexps[i];
+  if (!ctx) {
-        auto next_val = visit(next_mexp);
+    return {};
-        SymbolType next_type = ir_ctx_.GetType(next_mexp);
+  }
 
-        // 类型统一
+  if (ctx->ILITERAL()) {
-        if (current_type == SymbolType::TYPE_INT && next_type == SymbolType::TYPE_FLOAT) {
+    ir_ctx_.SetType(ctx, SymbolType::TYPE_INT);
-            current_type = SymbolType::TYPE_FLOAT;
+    ir_ctx_.SetConstVal(ctx, std::any(0L));
-        } else if (current_type == SymbolType::TYPE_FLOAT && next_type == SymbolType::TYPE_INT) {
+  } else if (ctx->FLITERAL()) {
-            current_type = SymbolType::TYPE_FLOAT;
+    ir_ctx_.SetType(ctx, SymbolType::TYPE_FLOAT);
-        }
+    ir_ctx_.SetConstVal(ctx, std::any(0.0));
+  }
 
-        // 简化处理：这里假设是加法运算
+  return {};
-        if (ir_ctx_.IsIntType(result) && ir_ctx_.IsIntType(next_val)) {
+}
-            long v1 = std::any_cast<long>(result);
-            long v2 = std::any_cast<long>(next_val);
-            result = std::any(v1 + v2);
-        } else if (ir_ctx_.IsFloatType(result) && ir_ctx_.IsFloatType(next_val)) {
-            double v1 = std::any_cast<double>(result);
-            double v2 = std::any_cast<double>(next_val);
-            result = std::any(v1 + v2);
-        }
 
-        ir_ctx_.SetType(ctx, current_type);
+std::any SemaVisitor::visitUnaryExp(SysYParser::UnaryExpContext* ctx) {
-        ir_ctx_.SetConstVal(ctx, result);
+  if (!ctx) {
+    return {};
+  }
+
+  if (ctx->primaryExp()) {
+    ctx->primaryExp()->accept(this);
+    ir_ctx_.SetType(ctx, ir_ctx_.GetType(ctx->primaryExp()));
+    return {};
+  }
+
+  if (ctx->unaryOp() && ctx->unaryExp()) {
+    ctx->unaryExp()->accept(this);
+    ir_ctx_.SetType(ctx, ir_ctx_.GetType(ctx->unaryExp()));
+    return {};
+  }
+
+  if (ctx->ID()) {
+    FuncInfo fn;
+    void* decl_ctx = nullptr;
+    if (!ir_ctx_.GetSymbolTable().LookupFunc(ctx->ID()->getText(), fn, decl_ctx)) {
+      RecordNodeError(ctx, "未定义函数: " + ctx->ID()->getText());
+      ir_ctx_.SetType(ctx, SymbolType::TYPE_UNKNOWN);
+    } else {
+      ir_ctx_.SetType(ctx, fn.ret_type);
     }
+  }
 
-    return result;
+  return visitChildren(ctx);
 }
 
-// 15. 关系表达式节点访问
+std::any SemaVisitor::visitUnaryOp(SysYParser::UnaryOpContext* ctx) {
-std::any SemaVisitor::visitRelExp(SysYParser::RelExpContext* ctx) {
+  return visitChildren(ctx);
-    auto aexps = ctx->addExp();
+}
-    
-    // 单操作数 → 直接返回
-    if (aexps.size() == 1) {
-        auto val = visit(aexps[0]);
-        ir_ctx_.SetType(ctx, SymbolType::TYPE_INT);
-        return val;
-    }
 
-    // 多操作数 → 简化处理
+std::any SemaVisitor::visitFuncRParams(SysYParser::FuncRParamsContext* ctx) {
-    std::any result = std::any(1L);
+  return visitChildren(ctx);
-    ir_ctx_.SetType(ctx, SymbolType::TYPE_INT);
+}
-    ir_ctx_.SetConstVal(ctx, result);
 
-    return result;
+std::any SemaVisitor::visitMulExp(SysYParser::MulExpContext* ctx) {
+  if (!ctx) {
+    return {};
+  }
+
+  if (ctx->mulExp()) {
+    ctx->mulExp()->accept(this);
+  }
+  if (ctx->unaryExp()) {
+    ctx->unaryExp()->accept(this);
+  }
+
+  SymbolType lhs = ctx->mulExp() ? ir_ctx_.GetType(ctx->mulExp())
+                                 : ir_ctx_.GetType(ctx->unaryExp());
+  SymbolType rhs = ir_ctx_.GetType(ctx->unaryExp());
+  ir_ctx_.SetType(ctx, MergeNumericType(lhs, rhs));
+  return {};
 }
 
-// 16. 相等表达式节点访问
+std::any SemaVisitor::visitAddExp(SysYParser::AddExpContext* ctx) {
-std::any SemaVisitor::visitEqExp(SysYParser::EqExpContext* ctx) {
+  if (!ctx) {
-    auto rexps = ctx->relExp();
+    return {};
-    
+  }
-    // 单操作数 → 直接返回
+
-    if (rexps.size() == 1) {
+  if (ctx->addExp()) {
-        auto val = visit(rexps[0]);
+    ctx->addExp()->accept(this);
-        ir_ctx_.SetType(ctx, SymbolType::TYPE_INT);
+  }
-        return val;
+  if (ctx->mulExp()) {
-    }
+    ctx->mulExp()->accept(this);
+  }
+
+  SymbolType lhs = ctx->addExp() ? ir_ctx_.GetType(ctx->addExp())
+                                 : ir_ctx_.GetType(ctx->mulExp());
+  SymbolType rhs = ir_ctx_.GetType(ctx->mulExp());
+  ir_ctx_.SetType(ctx, MergeNumericType(lhs, rhs));
+  return {};
+}
 
-    // 多操作数 → 简化处理
+std::any SemaVisitor::visitRelExp(SysYParser::RelExpContext* ctx) {
-    std::any result = std::any(1L);
+  if (ctx) {
+    visitChildren(ctx);
     ir_ctx_.SetType(ctx, SymbolType::TYPE_INT);
-    ir_ctx_.SetConstVal(ctx, result);
+  }
+  return {};
+}
 
-    return result;
+std::any SemaVisitor::visitEqExp(SysYParser::EqExpContext* ctx) {
+  if (ctx) {
+    visitChildren(ctx);
+    ir_ctx_.SetType(ctx, SymbolType::TYPE_INT);
+  }
+  return {};
 }
 
-// 17. 逻辑与表达式节点访问
 std::any SemaVisitor::visitLAndExp(SysYParser::LAndExpContext* ctx) {
-    return visitChildren(ctx);
+  if (ctx) {
+    visitChildren(ctx);
+    ir_ctx_.SetType(ctx, SymbolType::TYPE_INT);
+  }
+  return {};
 }
 
-// 18. 逻辑或表达式节点访问
 std::any SemaVisitor::visitLOrExp(SysYParser::LOrExpContext* ctx) {
-    return visitChildren(ctx);
+  if (ctx) {
+    visitChildren(ctx);
+    ir_ctx_.SetType(ctx, SymbolType::TYPE_INT);
+  }
+  return {};
 }
 
-// 19. 常量表达式节点访问
 std::any SemaVisitor::visitConstExp(SysYParser::ConstExpContext* ctx) {
-    return visitChildren(ctx);
+  if (!ctx || !ctx->addExp()) {
-}
+    return {};
-
+  }
-// 20. 数字节点访问
+  ctx->addExp()->accept(this);
-std::any SemaVisitor::visitNumber(SysYParser::NumberContext* ctx) {
+  ir_ctx_.SetType(ctx, ir_ctx_.GetType(ctx->addExp()));
-    // 这里简化处理，实际需要解析整型和浮点型
+  return {};
-    if (ctx->IntConst()) {
-        ir_ctx_.SetType(ctx, SymbolType::TYPE_INT);
-        ir_ctx_.SetConstVal(ctx, std::any(0L));
-        return std::any(0L);
-    } else if (ctx->FloatConst()) {
-        ir_ctx_.SetType(ctx, SymbolType::TYPE_FLOAT);
-        ir_ctx_.SetConstVal(ctx, std::any(0.0));
-        return std::any(0.0);
-    }
-    
-    return std::any();
-}
-
-// 21. 函数参数节点访问
-std::any SemaVisitor::visitFuncRParams(SysYParser::FuncRParamsContext* ctx) {
-    return visitChildren(ctx);
 }
 
-// ===================== 语义分析入口函数 =====================
 void RunSemanticAnalysis(SysYParser::CompUnitContext* ctx, IRGenContext& ir_ctx) {
-    if (!ctx) {
+  if (!ctx) {
-        throw std::invalid_argument("CompUnitContext is null");
+    throw std::invalid_argument("CompUnitContext is null");
-    }
+  }
-    SemaVisitor visitor(ir_ctx);
+
-    visitor.visit(ctx);
+  ir_ctx.EnterScope();
+  SemaVisitor visitor(ir_ctx, nullptr);
+  visitor.visit(ctx);
+  ir_ctx.LeaveScope();
 }
 
-IRGenContext RunSema(SysYParser::CompUnitContext& ctx) {
+SemanticContext RunSema(SysYParser::CompUnitContext& comp_unit) {
-    IRGenContext ctx_obj;
+  IRGenContext ctx;
-    RunSemanticAnalysis(&ctx, ctx_obj);
+  SemanticContext sema_ctx;
-    return ctx_obj;
+  ctx.EnterScope();
-}
+  SemaVisitor visitor(ctx, &sema_ctx);
+  visitor.visit(&comp_unit);
+  ctx.LeaveScope();
+  return sema_ctx;
+}

sylib/sylib.c

@@ -2,3 +2,42 @@
 // - 按实验/评测规范提供 I/O 等函数实现
 // - 与编译器生成的目标代码链接，支撑运行时行为
 
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+int getint() { int v; scanf("%d", &v); return v; }
+int getch()  { return getchar(); }
+void putint(int v) { printf("%d", v); }
+void putch(int c)  { putchar(c); }
+float getfloat() { float v; scanf("%f", &v); return v; }
+void putfloat(float v) { printf("%a", v); }
+
+int getarray(int* a) {
+  int n; scanf("%d", &n);
+  for (int i = 0; i < n; i++) scanf("%d", &a[i]);
+  return n;
+}
+int getfarray(float* a) {
+  int n; scanf("%d", &n);
+  for (int i = 0; i < n; i++) scanf("%f", &a[i]);
+  return n;
+}
+void putarray(int n, int* a) {
+  printf("%d:", n);
+  for (int i = 0; i < n; i++) printf(" %d", a[i]);
+  printf("\n");
+}
+void putfarray(int n, float* a) {
+  printf("%d:", n);
+  for (int i = 0; i < n; i++) printf(" %a", a[i]);
+  printf("\n");
+}
+
+static struct timespec _t0;
+void starttime(int l) { (void)l; clock_gettime(CLOCK_MONOTONIC, &_t0); }
+void stoptime(int l) {
+  struct timespec t1; clock_gettime(CLOCK_MONOTONIC, &t1);
+  fprintf(stderr, "Timer@%d: %ldms\n", l,
+          (t1.tv_sec-_t0.tv_sec)*1000+(t1.tv_nsec-_t0.tv_nsec)/1000000);
+}

sylib/sylib.h

@@ -2,3 +2,22 @@
 // - 声明运行库函数原型（供编译器生成 call 或链接阶段引用）
 // - 与 sylib.c 配套，按规范逐步补齐声明
 
+#pragma once
+
+int getint();
+int getch();
+void putint(int v);
+void putch(int c);
+
+float getfloat();
+void putfloat(float v);
+
+int getarray(int* a);
+void putarray(int n, int* a);
+
+int getfarray(float* a);
+void putfarray(int n, float* a);
+
+void starttime(int l);
+void stoptime(int l);
+