command.md

@@ -1,78 +0,0 @@
-## 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,8 +20,6 @@ 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

@@ -1,353 +0,0 @@
-# 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

@@ -1,108 +0,0 @@
-我先快速读取当前 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

@@ -151,35 +151,8 @@ class ConstantInt : public ConstantValue {
   int value_{};
 };
 
-// Argument 表示函数的形式参数，作为 Value 在函数体内直接被引用。
-class Argument : public Value {
- public:
-  Argument(std::shared_ptr<Type> ty, std::string name, size_t index);
-  size_t GetArgIndex() const { return arg_index_; }
-
- private:
-  size_t arg_index_;
-};
-
-// 第一版 Lab2 需要的指令集合。
-enum class Opcode {
-  Add,
-  Sub,
-  Mul,
-  Div,
-  Mod,
-  Cmp,
-  Br,
-  CondBr,
-  Call,
-  Alloca,
-  Load,
-  Store,
-  Ret,
-  Gep,  // getelementptr：数组元素地址计算
-};
-
-enum class CmpOp { Eq, Ne, Lt, Le, Gt, Ge };
+// 后续还需要扩展更多指令类型。
+enum class Opcode { Add, Sub, Mul, Alloca, Load, Store, Ret };
 
 // User 是所有“会使用其他 Value 作为输入”的 IR 对象的抽象基类。
 // 当前实现中只有 Instruction 继承自 User。
@@ -205,21 +178,6 @@ class GlobalValue : public User {
   GlobalValue(std::shared_ptr<Type> ty, std::string name);
 };
 
-// GlobalVariable 代表一个全局整型变量、常量或数组。
-// 标量：打印为 @name = global i32 N。
-// 数组：打印为 @name = global [count x i32] zeroinitializer。
-class GlobalVariable : public GlobalValue {
- public:
-  GlobalVariable(std::string name, int init_val = 0, int count = 1);
-  int GetInitValue() const { return init_val_; }
-  int GetCount() const { return count_; }
-  bool IsArray() const { return count_ > 1; }
-
- private:
-  int init_val_;
-  int count_;
-};
-
 class Instruction : public User {
  public:
   Instruction(Opcode op, std::shared_ptr<Type> ty, std::string name = "");
@@ -238,19 +196,7 @@ class BinaryInst : public Instruction {
   BinaryInst(Opcode op, std::shared_ptr<Type> ty, Value* lhs, Value* rhs,
              std::string name);
   Value* GetLhs() const;
-  Value* GetRhs() const;
-};
-
-class CmpInst : public Instruction {
- public:
-  CmpInst(CmpOp op, std::shared_ptr<Type> ty, Value* lhs, Value* rhs,
-          std::string name);
-  CmpOp GetCmpOp() const;
-  Value* GetLhs() const;
-  Value* GetRhs() const;
-
- private:
-  CmpOp cmp_op_;
+ Value* GetRhs() const;
 };
 
 class ReturnInst : public Instruction {
@@ -261,15 +207,7 @@ class ReturnInst : public Instruction {
 
 class AllocaInst : public Instruction {
  public:
-  // 标量 alloca（分配 1 个 i32）
   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:
-  int count_ = 1;
 };
 
 class LoadInst : public Instruction {
@@ -285,40 +223,6 @@ class StoreInst : public Instruction {
   Value* GetPtr() const;
 };
 
-class BranchInst : public Instruction {
- public:
-  BranchInst(std::shared_ptr<Type> void_ty, BasicBlock* target);
-  BasicBlock* GetTarget() const;
-};
-
-class CondBranchInst : public Instruction {
- public:
-  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 {
- public:
-  CallInst(std::shared_ptr<Type> ret_ty, Function* callee,
-           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 GepInst : public Instruction {
- public:
-  GepInst(std::shared_ptr<Type> ptr_ty, Value* base, Value* index,
-          std::string name);
-  Value* GetBase() const;
-  Value* GetIndex() const;
-};
-
 // BasicBlock 已纳入 Value 体系，便于后续向更完整 IR 类图靠拢。
 // 当前其类型仍使用 void 作为占位，后续可替换为专门的 label type。
 class BasicBlock : public Value {
@@ -330,8 +234,6 @@ class BasicBlock : public Value {
   const std::vector<std::unique_ptr<Instruction>>& GetInstructions() const;
   const std::vector<BasicBlock*>& GetPredecessors() const;
   const std::vector<BasicBlock*>& GetSuccessors() const;
-  void AddPredecessor(BasicBlock* pred);
-  void AddSuccessor(BasicBlock* succ);
   template <typename T, typename... Args>
   T* Append(Args&&... args) {
     if (HasTerminator()) {
@@ -354,30 +256,22 @@ class BasicBlock : public Value {
 
 // Function 当前也采用了最小实现。
 // 需要特别注意：由于项目里还没有单独的 FunctionType，
-// Function 继承自 Value 后，其 type_ 目前只保存”返回类型”，
-// 并不能完整表达”返回类型 + 形参列表”这一整套函数签名。
+// Function 继承自 Value 后，其 type_ 目前只保存“返回类型”，
+// 并不能完整表达“返回类型 + 形参列表”这一整套函数签名。
+// 这对当前只支持 int main() 的最小 IR 足够，但后续若补普通函数、
+// 形参和调用，通常需要引入专门的函数类型表示。
 class Function : public Value {
  public:
-  Function(std::string name, std::shared_ptr<Type> ret_type,
-           std::vector<std::shared_ptr<Type>> param_types = {});
+  // 当前构造函数接收的也是返回类型，而不是完整函数类型。
+  Function(std::string name, std::shared_ptr<Type> ret_type);
   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）。
-  void SetExternal(bool v) { is_external_ = v; }
-  bool IsExternal() const { return is_external_; }
-
  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_;
-  bool is_external_ = false;
 };
 
 class Module {
@@ -385,19 +279,13 @@ class Module {
   Module() = default;
   Context& GetContext();
   const Context& GetContext() const;
+  // 创建函数时当前只显式传入返回类型，尚未接入完整的 FunctionType。
   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;
+                           std::shared_ptr<Type> ret_type);
   const std::vector<std::unique_ptr<Function>>& GetFunctions() 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_;
 };
 
@@ -412,23 +300,10 @@ class IRBuilder {
   BinaryInst* CreateBinary(Opcode op, Value* lhs, Value* rhs,
                            const std::string& name);
   BinaryInst* CreateAdd(Value* lhs, Value* rhs, const std::string& name);
-  BinaryInst* CreateSub(Value* lhs, Value* rhs, const std::string& name);
-  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);
   AllocaInst* CreateAllocaI32(const std::string& name);
-  AllocaInst* CreateAllocaArray(int count, const std::string& name);
   LoadInst* CreateLoad(Value* ptr, const std::string& name);
   StoreInst* CreateStore(Value* val, Value* ptr);
-  BranchInst* CreateBr(BasicBlock* target);
-  CondBranchInst* CreateCondBr(Value* cond, BasicBlock* true_bb,
-                               BasicBlock* false_bb);
-  CallInst* CreateCall(Function* callee, const std::vector<Value*>& args,
-                       const std::string& name);
-  GepInst* CreateGep(Value* base, Value* index, const std::string& name);
   ReturnInst* CreateRet(Value* v);
-  ReturnInst* CreateRetVoid();
 
  private:
   Context& ctx_;

include/irgen/IRGen.h

@@ -7,7 +7,6 @@
 #include <memory>
 #include <string>
 #include <unordered_map>
-#include <vector>
 
 #include "SysYBaseVisitor.h"
 #include "SysYParser.h"
@@ -23,9 +22,6 @@ class Value;
 
 class IRGenImpl final : public SysYBaseVisitor {
  public:
-  // const 变量名 -> 编译期整数值，用于数组维度折叠。
-  using ConstEnv = std::unordered_map<std::string, int>;
-
   IRGenImpl(ir::Module& module, const SemanticContext& sema);
 
   std::any visitCompUnit(SysYParser::CompUnitContext* ctx) override;
@@ -33,24 +29,13 @@ class IRGenImpl final : public SysYBaseVisitor {
   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 visitLValue(SysYParser::LValueContext* 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 visitParenExp(SysYParser::ParenExpContext* ctx) override;
+  std::any visitNumberExp(SysYParser::NumberExpContext* ctx) override;
+  std::any visitVarExp(SysYParser::VarExpContext* ctx) override;
+  std::any visitAdditiveExp(SysYParser::AdditiveExpContext* ctx) override;
 
  private:
   enum class BlockFlow {
@@ -58,71 +43,15 @@ 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_;
   const SemanticContext& sema_;
   ir::Function* func_;
   ir::IRBuilder builder_;
-  // 声明 -> 存储槽位（局部 alloca 或全局变量，均为 i32*）。
+  // 名称绑定由 Sema 负责；IRGen 只维护“声明 -> 存储槽位”的代码生成状态。
   std::unordered_map<SysYParser::VarDefContext*, ir::Value*> storage_map_;
-  // 名称 -> 槽位（参数、const 变量等不经 sema binding 的后备查找）。
-  std::unordered_map<std::string, ir::Value*> named_storage_;
-  // 全局变量名 -> GlobalVariable*（跨函数持久）。
-  std::unordered_map<std::string, ir::Value*> global_storage_;
-  // 编译期 const 整数环境（全局 + 当前函数）。
-  ConstEnv const_env_;
-  // 数组维度信息：全局数组（跨函数持久）。
-  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,

include/sem/Sema.h

@@ -1,151 +1,30 @@
-#ifndef SEMANTIC_ANALYSIS_H
-#define SEMANTIC_ANALYSIS_H
+// 基于语法树的语义检查与名称绑定。
+#pragma once
 
-#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;
-  int line;
-  int column;
-
-  ErrorMsg(std::string m, int l, int c) : msg(std::move(m)), line(l), column(c) {}
-};
-
-class IRGenContext {
- public:
-  void RecordError(const ErrorMsg& err) { errors_.push_back(err); }
-  const std::vector<ErrorMsg>& GetErrors() const { return errors_; }
-  bool HasError() const { return !errors_.empty(); }
-  void ClearErrors() { errors_.clear(); }
-
-  void SetType(void* ctx, SymbolType type) { node_type_map_[ctx] = type; }
-
-  SymbolType GetType(void* ctx) const {
-    auto it = node_type_map_.find(ctx);
-    return it == node_type_map_.end() ? SymbolType::TYPE_UNKNOWN : it->second;
-  }
-
-  void SetConstVal(void* ctx, const std::any& val) { const_val_map_[ctx] = val; }
-
-  std::any GetConstVal(void* ctx) const {
-    auto it = const_val_map_.find(ctx);
-    return it == const_val_map_.end() ? std::any() : it->second;
-  }
-
-  void EnterLoop() { sym_table_.EnterLoop(); }
-  void ExitLoop() { sym_table_.ExitLoop(); }
-  bool InLoop() const { return sym_table_.InLoop(); }
-
-  bool IsIntType(const std::any& val) const {
-    return val.type() == typeid(long) || val.type() == typeid(int);
-  }
-
-  bool IsFloatType(const std::any& val) const {
-    return val.type() == typeid(double) || val.type() == typeid(float);
-  }
-
-  SymbolType GetCurrentFuncReturnType() const { return current_func_ret_type_; }
-  void SetCurrentFuncReturnType(SymbolType type) { current_func_ret_type_ = type; }
-
-  SymbolTable& GetSymbolTable() { return sym_table_; }
-  const SymbolTable& GetSymbolTable() const { return sym_table_; }
-
-  void EnterScope() { sym_table_.EnterScope(); }
-  void LeaveScope() { sym_table_.LeaveScope(); }
-  size_t GetScopeDepth() const { return sym_table_.GetScopeDepth(); }
-
- private:
-  SymbolTable sym_table_;
-  std::unordered_map<void*, SymbolType> node_type_map_;
-  std::unordered_map<void*, std::any> const_val_map_;
-  std::vector<ErrorMsg> errors_;
-  SymbolType current_func_ret_type_ = SymbolType::TYPE_UNKNOWN;
-};
-
 class SemanticContext {
  public:
-  void BindVarUse(const SysYParser::LValueContext* use,
+  void BindVarUse(SysYParser::VarContext* use,
                   SysYParser::VarDefContext* decl) {
     var_uses_[use] = decl;
   }
 
   SysYParser::VarDefContext* ResolveVarUse(
-      const SysYParser::LValueContext* use) const {
+      const SysYParser::VarContext* use) const {
     auto it = var_uses_.find(use);
     return it == var_uses_.end() ? nullptr : it->second;
   }
 
  private:
-  std::unordered_map<const SysYParser::LValueContext*, SysYParser::VarDefContext*>
+  std::unordered_map<const SysYParser::VarContext*,
+                     SysYParser::VarDefContext*>
       var_uses_;
 };
 
-inline std::string FormatErrMsg(const std::string& msg, int line, int col) {
-  std::ostringstream oss;
-  oss << "[行:" << line << ",列:" << col << "] " << msg;
-  return oss.str();
-}
-
-class SemaVisitor : public SysYBaseVisitor {
- public:
-  explicit SemaVisitor(IRGenContext& ctx, SemanticContext* sema_ctx = nullptr)
-      : ir_ctx_(ctx), sema_ctx_(sema_ctx) {}
-
-  std::any visitCompUnit(SysYParser::CompUnitContext* ctx) override;
-  std::any visitDecl(SysYParser::DeclContext* ctx) override;
-  std::any visitConstDecl(SysYParser::ConstDeclContext* ctx) override;
-  std::any visitBtype(SysYParser::BtypeContext* ctx) override;
-  std::any visitConstDef(SysYParser::ConstDefContext* ctx) override;
-  std::any visitConstInitValue(SysYParser::ConstInitValueContext* ctx) override;
-  std::any visitVarDecl(SysYParser::VarDeclContext* ctx) override;
-  std::any visitVarDef(SysYParser::VarDefContext* ctx) override;
-  std::any visitInitValue(SysYParser::InitValueContext* ctx) override;
-  std::any visitFuncDef(SysYParser::FuncDefContext* ctx) override;
-  std::any visitFuncType(SysYParser::FuncTypeContext* ctx) override;
-  std::any visitFuncFParams(SysYParser::FuncFParamsContext* ctx) override;
-  std::any visitFuncFParam(SysYParser::FuncFParamContext* ctx) override;
-  std::any visitBlockStmt(SysYParser::BlockStmtContext* ctx) override;
-  std::any visitBlockItem(SysYParser::BlockItemContext* ctx) override;
-  std::any visitStmt(SysYParser::StmtContext* 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 visitLValue(SysYParser::LValueContext* ctx) override;
-  std::any visitPrimaryExp(SysYParser::PrimaryExpContext* ctx) override;
-  std::any visitNumber(SysYParser::NumberContext* ctx) override;
-  std::any visitUnaryExp(SysYParser::UnaryExpContext* ctx) override;
-  std::any visitUnaryOp(SysYParser::UnaryOpContext* ctx) override;
-  std::any visitFuncRParams(SysYParser::FuncRParamsContext* 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 visitConstExp(SysYParser::ConstExpContext* ctx) override;
-
-  IRGenContext& GetContext() { return ir_ctx_; }
-  const IRGenContext& GetContext() const { return ir_ctx_; }
-
- private:
-  void RecordNodeError(antlr4::ParserRuleContext* ctx, const std::string& msg);
-
-  IRGenContext& ir_ctx_;
-  SemanticContext* sema_ctx_ = nullptr;
-  SymbolType current_decl_type_ = SymbolType::TYPE_UNKNOWN;
-  bool current_decl_is_const_ = false;
-};
-
-void RunSemanticAnalysis(SysYParser::CompUnitContext* ctx, IRGenContext& ir_ctx);
+// 目前仅检查：
+// - 变量先声明后使用
+// - 局部变量不允许重复定义
 SemanticContext RunSema(SysYParser::CompUnitContext& comp_unit);
-
-#endif  // SEMANTIC_ANALYSIS_H

include/sem/SymbolTable.h

@@ -1,201 +1,17 @@
-#ifndef SYMBOL_TABLE_H
-#define SYMBOL_TABLE_H
+// 极简符号表：记录局部变量定义点。
+#pragma once
 
-#include <any>
 #include <string>
-#include <vector>
 #include <unordered_map>
-#include <stack>
-#include <utility>
 
-// 核心类型枚举
-enum class SymbolType {
-    TYPE_UNKNOWN,   // 未知类型
-    TYPE_INT,       // 整型
-    TYPE_FLOAT,     // 浮点型
-    TYPE_VOID,      // 空类型
-    TYPE_ARRAY,     // 数组类型
-    TYPE_FUNCTION   // 函数类型
-};
-
-// 获取类型名称字符串
-inline const char* SymbolTypeToString(SymbolType type) {
-    switch (type) {
-        case SymbolType::TYPE_INT: return "int";
-        case SymbolType::TYPE_FLOAT: return "float";
-        case SymbolType::TYPE_VOID: return "void";
-        case SymbolType::TYPE_ARRAY: return "array";
-        case SymbolType::TYPE_FUNCTION: return "function";
-        default: return "unknown";
-    }
-}
-
-// 变量信息结构体
-struct VarInfo {
-    SymbolType type = SymbolType::TYPE_UNKNOWN;
-    bool is_const = false;
-    std::any const_val;
-    std::vector<int> array_dims;  // 数组维度，空表示非数组
-    void* decl_ctx = nullptr;     // 关联的语法节点
-    
-    // 检查是否为数组类型
-    bool IsArray() const { return !array_dims.empty(); }
-    
-    // 获取数组元素总数
-    int GetArrayElementCount() const {
-        int count = 1;
-        for (int dim : array_dims) {
-            count *= dim;
-        }
-        return count;
-    }
-};
-
-// 函数信息结构体
-struct FuncInfo {
-    SymbolType ret_type = SymbolType::TYPE_UNKNOWN;
-    std::string name;
-    std::vector<SymbolType> param_types;  // 参数类型列表
-    void* decl_ctx = nullptr;             // 关联的语法节点
-    
-    // 检查参数匹配
-    bool CheckParams(const std::vector<SymbolType>& actual_params) const {
-        if (actual_params.size() != param_types.size()) {
-            return false;
-        }
-        
-        for (size_t i = 0; i < param_types.size(); ++i) {
-            if (param_types[i] != actual_params[i] && 
-                param_types[i] != SymbolType::TYPE_UNKNOWN && 
-                actual_params[i] != SymbolType::TYPE_UNKNOWN) {
-                return false;
-            }
-        }
-        return true;
-    }
-};
-
-// 作用域条目结构体
-struct ScopeEntry {
-    // 变量符号表：符号名 -> (符号信息, 声明节点)
-    std::unordered_map<std::string, std::pair<VarInfo, void*>> var_symbols;
-    
-    // 函数符号表：符号名 -> (函数信息, 声明节点)
-    std::unordered_map<std::string, std::pair<FuncInfo, void*>> func_symbols;
-    
-    // 清空作用域
-    void Clear() {
-        var_symbols.clear();
-        func_symbols.clear();
-    }
-};
+#include "SysYParser.h"
 
-// 符号表核心类
 class SymbolTable {
-public:
-    // ========== 作用域管理 ==========
-    
-    // 进入新作用域
-    void EnterScope();
-    
-    // 离开当前作用域
-    void LeaveScope();
-    
-    // 获取当前作用域深度
-    size_t GetScopeDepth() const { return scopes_.size(); }
-    
-    // 检查作用域栈是否为空
-    bool IsEmpty() const { return scopes_.empty(); }
-    
-    // ========== 变量符号管理 ==========
-    
-    // 检查当前作用域是否包含指定变量
-    bool CurrentScopeHasVar(const std::string& name) const;
-    
-    // 绑定变量到当前作用域
-    void BindVar(const std::string& name, const VarInfo& info, void* decl_ctx);
-    
-    // 查找变量（从当前作用域向上遍历）
-    bool LookupVar(const std::string& name, VarInfo& out_info, void*& out_decl_ctx) const;
-    
-    // 快速查找变量（不获取详细信息）
-    bool HasVar(const std::string& name) const {
-        VarInfo info;
-        void* ctx;
-        return LookupVar(name, info, ctx);
-    }
-    
-    // ========== 函数符号管理 ==========
-    
-    // 检查当前作用域是否包含指定函数
-    bool CurrentScopeHasFunc(const std::string& name) const;
-    
-    // 绑定函数到当前作用域
-    void BindFunc(const std::string& name, const FuncInfo& info, void* decl_ctx);
-    
-    // 查找函数（从当前作用域向上遍历）
-    bool LookupFunc(const std::string& name, FuncInfo& out_info, void*& out_decl_ctx) const;
-    
-    // 快速查找函数（不获取详细信息）
-    bool HasFunc(const std::string& name) const {
-        FuncInfo info;
-        void* ctx;
-        return LookupFunc(name, info, ctx);
-    }
-    
-    // ========== 循环状态管理 ==========
-    
-    // 进入循环
-    void EnterLoop();
-    
-    // 离开循环
-    void ExitLoop();
-    
-    // 检查是否在循环内
-    bool InLoop() const;
-    
-    // 获取循环嵌套深度
-    int GetLoopDepth() const { return loop_depth_; }
-    
-    // ========== 辅助功能 ==========
-    
-    // 清空所有作用域和状态
-    void Clear();
-    
-    // 获取当前作用域中所有变量名
-    std::vector<std::string> GetCurrentScopeVarNames() const;
-    
-    // 获取当前作用域中所有函数名
-    std::vector<std::string> GetCurrentScopeFuncNames() const;
-    
-    // 调试：打印符号表内容
-    void Dump() const;
+ public:
+  void Add(const std::string& name, SysYParser::VarDefContext* decl);
+  bool Contains(const std::string& name) const;
+  SysYParser::VarDefContext* Lookup(const std::string& name) const;
 
-private:
-    // 作用域栈
-    std::stack<ScopeEntry> scopes_;
-    
-    // 循环嵌套深度
-    int loop_depth_ = 0;
+ private:
+  std::unordered_map<std::string, SysYParser::VarDefContext*> table_;
 };
-
-// 类型兼容性检查函数
-inline bool IsTypeCompatible(SymbolType expected, SymbolType actual) {
-    if (expected == SymbolType::TYPE_UNKNOWN || actual == SymbolType::TYPE_UNKNOWN) {
-        return true;  // 未知类型视为兼容
-    }
-    
-    // 基本类型兼容规则
-    if (expected == actual) {
-        return true;
-    }
-    
-    // int 可以隐式转换为 float
-    if (expected == SymbolType::TYPE_FLOAT && actual == SymbolType::TYPE_INT) {
-        return true;
-    }
-    
-    return false;
-}
-
-#endif // SYMBOL_TABLE_H

node_modules/.package-lock.json

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

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

@@ -1,3 +0,0 @@
-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

@@ -1,46 +0,0 @@
-# `@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

@@ -1,221 +0,0 @@
-/* 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

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

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

@@ -1,42 +0,0 @@
-{
-  "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

@@ -1,30 +0,0 @@
-{
-  "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

@@ -1,46 +0,0 @@
-# `@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

@@ -1,221 +0,0 @@
-/* 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

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

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

@@ -1,42 +0,0 @@
-{
-  "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

@@ -1,30 +0,0 @@
-{
-  "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

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

package.json

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

report.md

@@ -1,97 +0,0 @@
-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，补循环优化和并行化探索。

run_tests.py

@@ -1,39 +0,0 @@
-import os
-import subprocess
-
-COMPILER = "./build/bin/compiler"
-TEST_DIR = "./test/test_case/functional"
-
-pass_cnt = 0
-fail_cnt = 0
-
-print("===== SysY Batch Test Start =====")
-
-for file in os.listdir(TEST_DIR):
-    if not file.endswith(".sy"):
-        continue
-
-    path = os.path.join(TEST_DIR, file)
-    print(f"[TEST] {file} ... ", end="")
-
-    result = subprocess.run(
-        [COMPILER, "--emit-parse-tree", path],
-        stdout=subprocess.DEVNULL,
-        stderr=subprocess.PIPE
-    )
-
-    if result.returncode == 0:
-        print("PASS")
-        pass_cnt += 1
-    else:
-        print("FAIL")
-        fail_cnt += 1
-        print("---- Error ----")
-        print(result.stderr.decode())
-        print("---------------")
-
-print("===============================")
-print(f"Total: {pass_cnt + fail_cnt}")
-print(f"PASS : {pass_cnt}")
-print(f"FAIL : {fail_cnt}")
-print("===============================")

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 -no-pie "$obj" sylib/sylib.c -o "$exe" -lm
+  clang "$obj" -o "$exe"
   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 <(sed -e 's/\r$//' -e '$a\\' "$expected_file") <(sed -e 's/\r$//' -e '$a\\' "$actual_file"); then
+    if diff -u "$expected_file" "$actual_file"; then
       echo "输出匹配: $expected_file"
     else
       echo "输出不匹配: $expected_file" >&2

src/antlr4/SysY.g4

@@ -1,4 +1,8 @@
-// SysY Lab1 语法：覆盖常见声明、控制流、数组、函数与表达式优先级。
+// SysY 子集语法：支持形如
+// int main() { int a = 1; int b = 2; return a + b; }
+// 的最小返回表达式编译。
+
+// 后续需要自行添加
 
 grammar SysY;
 
@@ -6,72 +10,20 @@ grammar SysY;
 /* 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]+;
+ILITERAL: [0-9]+;
 
 WS: [ \t\r\n] -> skip;
 LINECOMMENT: '//' ~[\r\n]* -> skip;
@@ -82,61 +34,31 @@ BLOCKCOMMENT: '/*' .*? '*/' -> skip;
 /*===-------------------------------------------===*/
 
 compUnit
-    : (decl | funcDef)+ EOF
+    : funcDef EOF
     ;
 
 decl
-    : constDecl
-    | varDecl
-    ;
-
-constDecl
-    : CONST btype constDef (COMMA constDef)* SEMICOLON
-    ;
-
-constDef
-    : ID (LBRACK constExp RBRACK)* ASSIGN constInitValue
-    ;
-
-constInitValue
-    : constExp
-    | LBRACE (constInitValue (COMMA constInitValue)*)? RBRACE
-    ;
-
-varDecl
-    : btype varDef (COMMA varDef)* SEMICOLON
+    : btype varDef SEMICOLON
     ;
 
 btype
     : INT
-    | FLOAT
     ;
 
 varDef
-    : ID (LBRACK constExp RBRACK)* (ASSIGN initValue)?
+    : lValue (ASSIGN initValue)?
     ;
 
 initValue
     : exp
-    | LBRACE (initValue (COMMA initValue)*)? RBRACE
     ;
 
 funcDef
-    : funcType ID LPAREN (funcFParams)? RPAREN blockStmt
+    : funcType ID LPAREN RPAREN blockStmt
     ;
 
 funcType
     : INT
-    | FLOAT
-    | VOID
-    ;
-
-funcFParams
-    : funcFParam (COMMA funcFParam)*
-    ;
-
-funcFParam
-    : btype ID (LBRACK RBRACK (LBRACK exp RBRACK)*)?
     ;
 
 blockStmt
@@ -149,89 +71,28 @@ blockItem
     ;
 
 stmt
-    : lValue ASSIGN exp SEMICOLON
-    | (exp)? SEMICOLON
-    | blockStmt
-    | IF LPAREN cond RPAREN stmt (ELSE stmt)?
-    | WHILE LPAREN cond RPAREN stmt
-    | BREAK SEMICOLON
-    | CONTINUE SEMICOLON
-    | returnStmt
+    : returnStmt
     ;
 
 returnStmt
-    : RETURN (exp)? SEMICOLON
+    : RETURN exp SEMICOLON
     ;
 
 exp
-    : addExp
+    : LPAREN exp RPAREN          # parenExp
+    | var                        # varExp
+    | number                     # numberExp
+    | exp ADD exp                # additiveExp
     ;
 
-cond
-    : lOrExp
+var
+    : ID
     ;
 
 lValue
-    : ID (LBRACK exp RBRACK)*
-    ;
-
-primaryExp
-    : LPAREN exp RPAREN
-    | lValue
-    | number
+    : ID
     ;
 
 number
     : ILITERAL
-    | FLITERAL
-    ;
-
-unaryExp
-    : primaryExp
-    | ID LPAREN (funcRParams)? RPAREN
-    | unaryOp unaryExp
-    ;
-
-unaryOp
-    : ADD
-    | SUB
-    | NOT
-    ;
-
-funcRParams
-    : exp (COMMA exp)*
-    ;
-
-mulExp
-    : unaryExp
-    | mulExp (MUL | DIV | MOD) unaryExp
-    ;
-    
-addExp
-    : mulExp
-    | addExp (ADD | SUB) mulExp
-    ;
-
-relExp
-    : addExp
-    | relExp (LT | GT | LE | GE) addExp
-    ;
-
-eqExp
-    : relExp
-    | eqExp (EQ | NE) relExp
-    ;
-
-lAndExp
-    : eqExp
-    | lAndExp AND eqExp
-    ;
-
-lOrExp
-    : lAndExp
-    | lOrExp OR lAndExp
-    ;
-
-constExp
-    : addExp
     ;

src/antlr4/SysYBaseVisitor.cpp

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

src/antlr4/SysYBaseVisitor.h

@@ -1,144 +0,0 @@
-
-// 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

@@ -1,377 +0,0 @@
-
-// 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

@@ -1,62 +0,0 @@
-
-// 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

@@ -1,513 +0,0 @@
-
-// 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

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

src/antlr4/SysYVisitor.h

@@ -1,86 +0,0 @@
-
-// 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,7 +9,6 @@
 
 #include "ir/IR.h"
 
-#include <algorithm>
 #include <utility>
 
 namespace ir {
@@ -43,26 +42,4 @@ const std::vector<BasicBlock*>& BasicBlock::GetSuccessors() const {
   return successors_;
 }
 
-void BasicBlock::AddPredecessor(BasicBlock* pred) {
-  if (!pred) {
-    return;
-  }
-  if (std::find(predecessors_.begin(), predecessors_.end(), pred) !=
-      predecessors_.end()) {
-    return;
-  }
-  predecessors_.push_back(pred);
-}
-
-void BasicBlock::AddSuccessor(BasicBlock* succ) {
-  if (!succ) {
-    return;
-  }
-  if (std::find(successors_.begin(), successors_.end(), succ) !=
-      successors_.end()) {
-    return;
-  }
-  successors_.push_back(succ);
-}
-
 }  // namespace ir

src/ir/Context.cpp

@@ -17,7 +17,7 @@ ConstantInt* Context::GetConstInt(int v) {
 
 std::string Context::NextTemp() {
   std::ostringstream oss;
-  oss << "%t" << ++temp_index_;
+  oss << "%" << ++temp_index_;
   return oss.str();
 }
 

src/ir/Function.cpp

@@ -3,23 +3,10 @@
 // - 记录函数属性/元信息（按需要扩展）
 #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)),
-      param_types_(std::move(param_types)) {
-  for (size_t i = 0; i < param_types_.size(); ++i) {
-    args_.push_back(std::make_unique<Argument>(
-        param_types_[i], "%arg" + std::to_string(i), i));
-  }
+Function::Function(std::string name, std::shared_ptr<Type> ret_type)
+    : Value(std::move(ret_type), std::move(name)) {
   entry_ = CreateBlock("entry");
 }
 
@@ -38,19 +25,6 @@ BasicBlock* Function::GetEntry() { return entry_; }
 
 const BasicBlock* Function::GetEntry() const { return entry_; }
 
-const std::vector<std::shared_ptr<Type>>& Function::GetParamTypes() const {
-  return param_types_;
-}
-
-size_t Function::GetNumParams() const { return param_types_.size(); }
-
-Argument* Function::GetArgument(size_t index) const {
-  if (index >= args_.size()) {
-    throw std::out_of_range(FormatError("ir", "Argument 索引越界"));
-  }
-  return args_[index].get();
-}
-
 const std::vector<std::unique_ptr<BasicBlock>>& Function::GetBlocks() const {
   return blocks_;
 }

src/ir/GlobalValue.cpp

@@ -1,4 +1,5 @@
-// GlobalValue / GlobalVariable 实现。
+// GlobalValue 占位实现：
+// - 具体的全局初始化器、打印和链接语义需要自行补全
 
 #include "ir/IR.h"
 
@@ -7,9 +8,4 @@ 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

@@ -42,39 +42,6 @@ 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_) {
     throw std::runtime_error(FormatError("ir", "IRBuilder 未设置插入点"));
@@ -82,26 +49,6 @@ AllocaInst* IRBuilder::CreateAllocaI32(const std::string& name) {
   return insert_block_->Append<AllocaInst>(Type::GetPtrInt32Type(), name);
 }
 
-AllocaInst* IRBuilder::CreateAllocaArray(int count, const std::string& name) {
-  if (!insert_block_) {
-    throw std::runtime_error(FormatError("ir", "IRBuilder 未设置插入点"));
-  }
-  if (count <= 0) {
-    throw std::runtime_error(FormatError("ir", "IRBuilder::CreateAllocaArray 数组大小必须为正数"));
-  }
-  return insert_block_->Append<AllocaInst>(Type::GetPtrInt32Type(), name, count);
-}
-
-GepInst* IRBuilder::CreateGep(Value* base, Value* index, const std::string& name) {
-  if (!insert_block_) {
-    throw std::runtime_error(FormatError("ir", "IRBuilder 未设置插入点"));
-  }
-  if (!base || !index) {
-    throw std::runtime_error(FormatError("ir", "IRBuilder::CreateGep 缺少操作数"));
-  }
-  return insert_block_->Append<GepInst>(Type::GetPtrInt32Type(), base, index, name);
-}
-
 LoadInst* IRBuilder::CreateLoad(Value* ptr, const std::string& name) {
   if (!insert_block_) {
     throw std::runtime_error(FormatError("ir", "IRBuilder 未设置插入点"));
@@ -128,43 +75,6 @@ StoreInst* IRBuilder::CreateStore(Value* val, Value* ptr) {
   return insert_block_->Append<StoreInst>(Type::GetVoidType(), val, ptr);
 }
 
-BranchInst* IRBuilder::CreateBr(BasicBlock* target) {
-  if (!insert_block_) {
-    throw std::runtime_error(FormatError("ir", "IRBuilder 未设置插入点"));
-  }
-  if (!target) {
-    throw std::runtime_error(
-        FormatError("ir", "IRBuilder::CreateBr 缺少目标块"));
-  }
-  return insert_block_->Append<BranchInst>(Type::GetVoidType(), target);
-}
-
-CondBranchInst* IRBuilder::CreateCondBr(Value* cond, BasicBlock* true_bb,
-                                        BasicBlock* false_bb) {
-  if (!insert_block_) {
-    throw std::runtime_error(FormatError("ir", "IRBuilder 未设置插入点"));
-  }
-  if (!cond || !true_bb || !false_bb) {
-    throw std::runtime_error(
-        FormatError("ir", "IRBuilder::CreateCondBr 参数不完整"));
-  }
-  return insert_block_->Append<CondBranchInst>(Type::GetVoidType(), cond,
-                                               true_bb, 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 未设置插入点"));
-  }
-  if (!callee) {
-    throw std::runtime_error(
-        FormatError("ir", "IRBuilder::CreateCall 缺少被调函数"));
-  }
-  return insert_block_->Append<CallInst>(callee->GetType(), callee, args, name);
-}
-
 ReturnInst* IRBuilder::CreateRet(Value* v) {
   if (!insert_block_) {
     throw std::runtime_error(FormatError("ir", "IRBuilder 未设置插入点"));
@@ -176,11 +86,4 @@ ReturnInst* IRBuilder::CreateRet(Value* v) {
   return insert_block_->Append<ReturnInst>(Type::GetVoidType(), v);
 }
 
-ReturnInst* IRBuilder::CreateRetVoid() {
-  if (!insert_block_) {
-    throw std::runtime_error(FormatError("ir", "IRBuilder 未设置插入点"));
-  }
-  return insert_block_->Append<ReturnInst>(Type::GetVoidType(), nullptr);
-}
-
 }  // namespace ir

src/ir/IRPrinter.cpp

@@ -32,18 +32,6 @@ static const char* OpcodeToString(Opcode op) {
       return "sub";
     case Opcode::Mul:
       return "mul";
-    case Opcode::Div:
-      return "sdiv";
-    case Opcode::Mod:
-      return "srem";
-    case Opcode::Cmp:
-      return "icmp";
-    case Opcode::Br:
-      return "br";
-    case Opcode::CondBr:
-      return "br";
-    case Opcode::Call:
-      return "call";
     case Opcode::Alloca:
       return "alloca";
     case Opcode::Load:
@@ -52,26 +40,6 @@ static const char* OpcodeToString(Opcode op) {
       return "store";
     case Opcode::Ret:
       return "ret";
-    case Opcode::Gep:
-      return "getelementptr";
-  }
-  return "?";
-}
-
-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 "?";
 }
@@ -80,55 +48,13 @@ static std::string ValueToString(const Value* v) {
   if (auto* ci = dynamic_cast<const ConstantInt*>(v)) {
     return std::to_string(ci->GetValue());
   }
-  if (auto* gv = dynamic_cast<const GlobalVariable*>(v)) {
-    return "@" + gv->GetName();
-  }
-  if (auto* func = dynamic_cast<const Function*>(v)) {
-    return "@" + func->GetName();
-  }
-  if (auto* arg = dynamic_cast<const Argument*>(v)) {
-    return arg->GetName();
-  }
   return v ? v->GetName() : "<null>";
 }
 
 void IRPrinter::Print(const Module& module, std::ostream& os) {
-  // 先打印全局变量
-  for (const auto& gv : module.GetGlobalVars()) {
-    if (!gv) continue;
-    if (gv->IsArray()) {
-      os << "@" << gv->GetName() << " = global [" << gv->GetCount()
-         << " x i32] zeroinitializer\n";
-    } else {
-      os << "@" << gv->GetName() << " = global i32 " << gv->GetInitValue() << "\n";
-    }
-  }
-  if (!module.GetGlobalVars().empty()) os << "\n";
-
   for (const auto& func : module.GetFunctions()) {
-    if (func->IsExternal()) {
-      // 外部函数声明：declare rettype @name(paramtypes)
-      os << "declare " << TypeToString(*func->GetType()) << " @" << func->GetName() << "(";
-      const auto& ptypes = func->GetParamTypes();
-      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 << "define " << TypeToString(*func->GetType()) << " @" << func->GetName()
-       << "(" << params << ") {\n";
+       << "() {\n";
     for (const auto& bb : func->GetBlocks()) {
       if (!bb) {
         continue;
@@ -139,9 +65,7 @@ void IRPrinter::Print(const Module& module, std::ostream& os) {
         switch (inst->GetOpcode()) {
           case Opcode::Add:
           case Opcode::Sub:
-          case Opcode::Mul:
-          case Opcode::Div:
-          case Opcode::Mod: {
+          case Opcode::Mul: {
             auto* bin = static_cast<const BinaryInst*>(inst);
             os << "  " << bin->GetName() << " = "
                << OpcodeToString(bin->GetOpcode()) << " "
@@ -150,23 +74,9 @@ void IRPrinter::Print(const Module& module, std::ostream& os) {
                << ValueToString(bin->GetRhs()) << "\n";
             break;
           }
-          case Opcode::Cmp: {
-            auto* cmp = static_cast<const CmpInst*>(inst);
-            os << "  " << cmp->GetName() << " = " << OpcodeToString(cmp->GetOpcode())
-               << " " << CmpOpToString(cmp->GetCmpOp()) << " "
-               << TypeToString(*cmp->GetLhs()->GetType()) << " "
-               << ValueToString(cmp->GetLhs()) << ", "
-               << ValueToString(cmp->GetRhs()) << "\n";
-            break;
-          }
           case Opcode::Alloca: {
             auto* alloca = static_cast<const AllocaInst*>(inst);
-            if (alloca->IsArray()) {
-              os << "  " << alloca->GetName() << " = alloca i32, i32 "
-                 << alloca->GetCount() << "\n";
-            } else {
-              os << "  " << alloca->GetName() << " = alloca i32\n";
-            }
+            os << "  " << alloca->GetName() << " = alloca i32\n";
             break;
           }
           case Opcode::Load: {
@@ -181,64 +91,10 @@ void IRPrinter::Print(const Module& module, std::ostream& os) {
                << ", i32* " << ValueToString(store->GetPtr()) << "\n";
             break;
           }
-          case Opcode::Br: {
-            auto* br = static_cast<const BranchInst*>(inst);
-            os << "  br label %" << br->GetTarget()->GetName() << "\n";
-            break;
-          }
-          case Opcode::CondBr: {
-            auto* cbr = static_cast<const CondBranchInst*>(inst);
-            os << "  br i1 " << ValueToString(cbr->GetCond()) << ", label %"
-               << cbr->GetTrueBlock()->GetName() << ", label %"
-               << cbr->GetFalseBlock()->GetName() << "\n";
-            break;
-          }
-          case Opcode::Call: {
-            auto* call = static_cast<const CallInst*>(inst);
-            if (!call->GetType()->IsVoid()) {
-              os << "  " << call->GetName() << " = ";
-            } else {
-              os << "  ";
-            }
-            os << "call " << TypeToString(*call->GetType()) << " @"
-               << call->GetCallee()->GetName() << "(";
-            for (size_t i = 0; i < call->GetNumArgs(); ++i) {
-              if (i != 0) {
-                os << ", ";
-              }
-              auto* arg = call->GetArg(i);
-              os << TypeToString(*arg->GetType()) << " " << ValueToString(arg);
-            }
-            os << ")\n";
-            break;
-          }
-          case Opcode::Gep: {
-            auto* gep = static_cast<const GepInst*>(inst);
-            auto* base = gep->GetBase();
-            // 全局数组用双下标 GEP，局部 alloca 用平坦 GEP。
-            if (auto* gv = dynamic_cast<const GlobalVariable*>(base)) {
-              if (gv->IsArray()) {
-                os << "  " << gep->GetName()
-                   << " = getelementptr [" << gv->GetCount() << " x i32], ["
-                   << gv->GetCount() << " x i32]* @" << gv->GetName()
-                   << ", i32 0, i32 " << ValueToString(gep->GetIndex()) << "\n";
-                break;
-              }
-            }
-            os << "  " << gep->GetName()
-               << " = getelementptr i32, i32* " << ValueToString(base)
-               << ", i32 " << ValueToString(gep->GetIndex()) << "\n";
-            break;
-          }
           case Opcode::Ret: {
             auto* ret = static_cast<const ReturnInst*>(inst);
-            auto* retval = ret->GetValue();
-            if (!retval) {
-              os << "  ret void\n";
-            } else {
-              os << "  ret " << TypeToString(*retval->GetType()) << " "
-                 << ValueToString(retval) << "\n";
-            }
+            os << "  ret " << TypeToString(*ret->GetValue()->GetType()) << " "
+               << ValueToString(ret->GetValue()) << "\n";
             break;
           }
         }

src/ir/Instruction.cpp

@@ -3,30 +3,11 @@
 // - 指令操作数与结果类型管理，支持打印与优化
 #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)) {}
 
@@ -71,44 +52,17 @@ 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;
-}
+bool Instruction::IsTerminator() const { return opcode_ == Opcode::Ret; }
 
 BasicBlock* Instruction::GetParent() const { return 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;
-}
+void Instruction::SetParent(BasicBlock* parent) { parent_ = parent; }
 
 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 (!IsBinaryOpcode(op)) {
-    throw std::runtime_error(FormatError("ir", "BinaryInst 非法二元操作码"));
+  if (op != Opcode::Add) {
+    throw std::runtime_error(FormatError("ir", "BinaryInst 当前只支持 Add"));
   }
   if (!lhs || !rhs) {
     throw std::runtime_error(FormatError("ir", "BinaryInst 缺少操作数"));
@@ -131,64 +85,24 @@ 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 (!val) {
+    throw std::runtime_error(FormatError("ir", "ReturnInst 缺少返回值"));
+  }
   if (!type_ || !type_->IsVoid()) {
     throw std::runtime_error(FormatError("ir", "ReturnInst 返回类型必须为 void"));
   }
-  if (val) {
-    AddOperand(val);
-  }
+  AddOperand(val);
 }
 
-Value* ReturnInst::GetValue() const {
-  return GetNumOperands() > 0 ? GetOperand(0) : nullptr;
-}
+Value* ReturnInst::GetValue() const { return GetOperand(0); }
 
 AllocaInst::AllocaInst(std::shared_ptr<Type> ptr_ty, std::string name)
-    : Instruction(Opcode::Alloca, std::move(ptr_ty), std::move(name)), count_(1) {
-  if (!type_ || !type_->IsPtrInt32()) {
-    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) {
+    : Instruction(Opcode::Alloca, std::move(ptr_ty), std::move(name)) {
   if (!type_ || !type_->IsPtrInt32()) {
     throw std::runtime_error(FormatError("ir", "AllocaInst 当前只支持 i32*"));
   }
-  if (count_ <= 0) {
-    throw std::runtime_error(FormatError("ir", "AllocaInst 数组大小必须为正数"));
-  }
 }
 
 LoadInst::LoadInst(std::shared_ptr<Type> val_ty, Value* ptr, std::string name)
@@ -234,106 +148,4 @@ Value* StoreInst::GetValue() const { return GetOperand(0); }
 
 Value* StoreInst::GetPtr() const { return GetOperand(1); }
 
-BranchInst::BranchInst(std::shared_ptr<Type> void_ty, BasicBlock* target)
-    : Instruction(Opcode::Br, std::move(void_ty), "") {
-  if (!target) {
-    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));
-}
-
-CondBranchInst::CondBranchInst(std::shared_ptr<Type> void_ty, Value* cond,
-                               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 参数不完整"));
-  }
-  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);
-  AddOperand(false_bb);
-}
-
-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(std::shared_ptr<Type> ret_ty, Function* callee,
-                   std::vector<Value*> args, std::string name)
-    : Instruction(Opcode::Call, std::move(ret_ty), std::move(name)) {
-  if (!callee) {
-    throw std::runtime_error(FormatError("ir", "CallInst 缺少被调函数"));
-  }
-  const auto& param_types = callee->GetParamTypes();
-  if (args.size() != param_types.size()) {
-    throw std::runtime_error(FormatError("ir", "CallInst 参数个数不匹配"));
-  }
-  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 存在非法参数"));
-    }
-    if (!param_types[i] || arg->GetType()->GetKind() != param_types[i]->GetKind()) {
-      throw std::runtime_error(FormatError("ir", "CallInst 参数类型不匹配"));
-    }
-    AddOperand(arg);
-  }
-}
-
-Function* CallInst::GetCallee() const {
-  return static_cast<Function*>(GetOperand(0));
-}
-
-size_t CallInst::GetNumArgs() const { return GetNumOperands() - 1; }
-
-Value* CallInst::GetArg(size_t index) const {
-  if (index >= GetNumArgs()) {
-    throw std::out_of_range("CallInst arg index out of range");
-  }
-  return GetOperand(index + 1);
-}
-
-GepInst::GepInst(std::shared_ptr<Type> ptr_ty, Value* base, Value* index,
-                 std::string name)
-    : Instruction(Opcode::Gep, std::move(ptr_ty), std::move(name)) {
-  if (!base || !index) {
-    throw std::runtime_error(FormatError("ir", "GepInst 缺少操作数"));
-  }
-  if (!base->GetType() || !base->GetType()->IsPtrInt32()) {
-    throw std::runtime_error(FormatError("ir", "GepInst base 必须为 i32*"));
-  }
-  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

@@ -9,10 +9,8 @@ Context& Module::GetContext() { return context_; }
 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(std::make_unique<Function>(
-      name, std::move(ret_type), std::move(param_types)));
+                                 std::shared_ptr<Type> ret_type) {
+  functions_.push_back(std::make_unique<Function>(name, std::move(ret_type)));
   return functions_.back().get();
 }
 
@@ -20,27 +18,4 @@ const std::vector<std::unique_ptr<Function>>& Module::GetFunctions() const {
   return functions_;
 }
 
-Function* Module::FindFunction(const std::string& name) const {
-  for (const auto& f : functions_) {
-    if (f && f->GetName() == name) return f.get();
-  }
-  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();
-}
-
-GlobalVariable* Module::FindGlobalVar(const std::string& name) const {
-  for (const auto& gv : global_vars_) {
-    if (gv && gv->GetName() == name) return gv.get();
-  }
-  return nullptr;
-}
-
-const std::vector<std::unique_ptr<GlobalVariable>>& Module::GetGlobalVars() const {
-  return global_vars_;
-}
-
 }  // namespace ir

src/irgen/CMakeLists.txt

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

src/irgen/IRGenConstEval.cpp

@@ -1,95 +0,0 @@
-#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

@@ -6,6 +6,17 @@
 #include "ir/IR.h"
 #include "utils/Log.h"
 
+namespace {
+
+std::string GetLValueName(SysYParser::LValueContext& lvalue) {
+  if (!lvalue.ID()) {
+    throw std::runtime_error(FormatError("irgen", "非法左值"));
+  }
+  return lvalue.ID()->getText();
+}
+
+}  // namespace
+
 std::any IRGenImpl::visitBlockStmt(SysYParser::BlockStmtContext* ctx) {
   if (!ctx) {
     throw std::runtime_error(FormatError("irgen", "缺少语句块"));
@@ -13,6 +24,7 @@ std::any IRGenImpl::visitBlockStmt(SysYParser::BlockStmtContext* ctx) {
   for (auto* item : ctx->blockItem()) {
     if (item) {
       if (VisitBlockItemResult(*item) == BlockFlow::Terminated) {
+        // 当前语法要求 return 为块内最后一条语句；命中后可停止生成。
         break;
       }
     }
@@ -39,267 +51,52 @@ 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()) {
-    return ctx->varDecl()->accept(this);
-  }
-  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;
-    }
-  }
-  // 剩余补零
-  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
-    }
-  }
-  while (pos < start + agg_size) pos++;  // zeros
-}
-
-// ─── const 声明 ───────────────────────────────────────────────────────────
-
-std::any IRGenImpl::visitConstDecl(SysYParser::ConstDeclContext* ctx) {
-  if (!ctx) return {};
   if (!ctx->btype() || !ctx->btype()->INT()) {
-    throw std::runtime_error(FormatError("irgen", "当前仅支持 int const 声明"));
+    throw std::runtime_error(FormatError("irgen", "当前仅支持局部 int 变量声明"));
   }
-  for (auto* def : ctx->constDef()) {
-    if (def) def->accept(this);
+  auto* var_def = ctx->varDef();
+  if (!var_def) {
+    throw std::runtime_error(FormatError("irgen", "非法变量声明"));
   }
+  var_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 {};
-  }
-
-  // ── 数组 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) {
-  if (!ctx) {
-    throw std::runtime_error(FormatError("irgen", "缺少变量声明"));
-  }
-  if (!ctx->btype() || !ctx->btype()->INT()) {
-    throw std::runtime_error(FormatError("irgen", "当前仅支持 int 变量声明"));
-  }
-  for (auto* var_def : ctx->varDef()) {
-    if (!var_def) {
-      throw std::runtime_error(FormatError("irgen", "非法变量声明"));
-    }
-    var_def->accept(this);
-  }
-  return {};
-}
 
+// 当前仍是教学用的最小版本，因此这里只支持：
+// - 局部 int 变量；
+// - 标量初始化；
+// - 一个 VarDef 对应一个槽位。
 std::any IRGenImpl::visitVarDef(SysYParser::VarDefContext* ctx) {
-  if (!ctx || !ctx->ID()) {
-    throw std::runtime_error(FormatError("irgen", "变量定义缺少名称"));
-  }
-  const std::string name = ctx->ID()->getText();
-
-  // ── 数组变量 ──────────────────────────────────────────────────────────
-  if (!ctx->LBRACK().empty()) {
-    std::vector<int> dims;
-    for (auto* ce : ctx->constExp()) {
-      dims.push_back(EvalConstExpr(ce));
-    }
-    int total = 1;
-    for (int d : dims) total *= d;
-
-    if (IsGlobalScope()) {
-      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;
-
-      // 先零初始化
-      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(0), ptr);
-      }
-      // 如果有初始化列表，覆盖零
-      if (auto* init_val = ctx->initValue()) {
-        std::vector<ir::Value*> flat(total, nullptr);
-        int pos = 0;
-        FlattenInit(init_val, dims, 0, flat, pos);
-        for (int i = 0; i < total; i++) {
-          if (flat[i] != nullptr) {
-            auto* idx = builder_.CreateConstInt(i);
-            auto* ptr = builder_.CreateGep(slot, idx, module_.GetContext().NextTemp());
-            builder_.CreateStore(flat[i], ptr);
-          }
-        }
-      }
-    }
-    return {};
+  if (!ctx) {
+    throw std::runtime_error(FormatError("irgen", "缺少变量定义"));
   }
-
-  // ── 标量变量 ──────────────────────────────────────────────────────────
-  if (IsGlobalScope()) {
-    int ival = 0;
-    if (auto* init_value = ctx->initValue()) {
-      if (!init_value->exp()) {
-        throw std::runtime_error(
-            FormatError("irgen", "全局标量变量仅支持表达式初始化"));
-      }
-      ival = EvalExpAsConst(init_value->exp());
-    }
-    auto* gv = module_.CreateGlobalVar(name, ival);
-    storage_map_[ctx] = gv;
-    global_storage_[name] = gv;
-    return {};
+  if (!ctx->lValue()) {
+    throw std::runtime_error(FormatError("irgen", "变量声明缺少名称"));
   }
-
-  // 局部标量
+  GetLValueName(*ctx->lValue());
   if (storage_map_.find(ctx) != storage_map_.end()) {
     throw std::runtime_error(FormatError("irgen", "声明重复生成存储槽位"));
   }
-  auto* slot = CreateEntryAllocaI32(module_.GetContext().NextTemp());
+  auto* slot = builder_.CreateAllocaI32(module_.GetContext().NextTemp());
   storage_map_[ctx] = slot;
-  named_storage_[name] = slot;
 
   ir::Value* init = nullptr;
   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/IRGenExp.cpp

@@ -6,457 +6,75 @@
 #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));
-}
-
-ir::Value* IRGenImpl::ToBoolValue(ir::Value* v) {
-  if (!v) {
-    throw std::runtime_error(FormatError("irgen", "条件值为空"));
-  }
-  if (v->GetType() && v->GetType()->IsPtrInt32()) {
-    // 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;
-}
-
-// ─── 数组维度查找 ────────────────────────────────────────────────────────
-const std::vector<int>* IRGenImpl::FindArrayDims(const std::string& name) const {
-  auto it = local_array_dims_.find(name);
-  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());
-  }
-  return linear;
-}
-
-std::any IRGenImpl::visitExp(SysYParser::ExpContext* ctx) {
-  if (!ctx || !ctx->addExp()) {
-    throw std::runtime_error(FormatError("irgen", "非法表达式"));
+std::any IRGenImpl::visitParenExp(SysYParser::ParenExpContext* ctx) {
+  if (!ctx || !ctx->exp()) {
+    throw std::runtime_error(FormatError("irgen", "非法括号表达式"));
   }
-  return ctx->addExp()->accept(this);
+  return EvalExpr(*ctx->exp());
 }
 
-std::any IRGenImpl::visitCond(SysYParser::CondContext* ctx) {
-  if (!ctx || !ctx->lOrExp()) {
-    throw std::runtime_error(FormatError("irgen", "非法条件表达式"));
-  }
-  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::visitNumber(SysYParser::NumberContext* ctx) {
-  if (!ctx || !ctx->ILITERAL()) {
+std::any IRGenImpl::visitNumberExp(SysYParser::NumberExpContext* ctx) {
+  if (!ctx || !ctx->number() || !ctx->number()->ILITERAL()) {
     throw std::runtime_error(FormatError("irgen", "当前仅支持整数字面量"));
   }
-  // 支持十六进制和八进制字面量
-  const std::string text = ctx->getText();
-  int val = 0;
-  if (text.size() >= 2 && text[0] == '0' &&
-      (text[1] == 'x' || text[1] == 'X')) {
-    val = std::stoi(text, nullptr, 16);
-  } else if (text.size() > 1 && text[0] == '0') {
-    val = std::stoi(text, nullptr, 8);
-  } else {
-    val = std::stoi(text);
-  }
-  return static_cast<ir::Value*>(builder_.CreateConstInt(val));
+  return static_cast<ir::Value*>(
+      builder_.CreateConstInt(std::stoi(ctx->number()->getText())));
 }
 
-// ─── 变量存储槽位查找（含下标 GEP）────────────────────────────────────────
-// 返回 i32* 指针：
-//   - 无下标：直接返回 alloca/arg/globalvar 槽位
-//   - 有下标：计算线性偏移并生成 GEP 指令，返回元素指针
-ir::Value* IRGenImpl::ResolveStorage(SysYParser::LValueContext* lvalue) {
-  if (!lvalue || !lvalue->ID()) return nullptr;
-  const std::string name = lvalue->ID()->getText();
-
-  // 获取基础槽位（三级查找）
-  ir::Value* base = nullptr;
-
-  // 1. sema binding（处理同名变量遮蔽）
-  auto* decl = sema_.ResolveVarUse(lvalue);
-  if (decl) {
-    auto it = storage_map_.find(decl);
-    if (it != storage_map_.end()) base = it->second;
-  }
-  if (!base) {
-    auto it = named_storage_.find(name);
-    if (it != named_storage_.end()) base = it->second;
+// 变量使用的处理流程：
+// 1. 先通过语义分析结果把变量使用绑定回声明；
+// 2. 再通过 storage_map_ 找到该声明对应的栈槽位；
+// 3. 最后生成 load，把内存中的值读出来。
+//
+// 因此当前 IRGen 自己不再做名字查找，而是直接消费 Sema 的绑定结果。
+std::any IRGenImpl::visitVarExp(SysYParser::VarExpContext* ctx) {
+  if (!ctx || !ctx->var() || !ctx->var()->ID()) {
+    throw std::runtime_error(FormatError("irgen", "当前仅支持普通整型变量"));
   }
-  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) {
+  auto* decl = sema_.ResolveVarUse(ctx->var());
+  if (!decl) {
     throw std::runtime_error(
-        FormatError("irgen", "未找到数组维度信息: " + name));
+        FormatError("irgen",
+                    "变量使用缺少语义绑定: " + ctx->var()->ID()->getText()));
   }
-
-  ir::Value* linear = ComputeLinearIndex(*dims, lvalue->exp());
-  return builder_.CreateGep(base, linear, module_.GetContext().NextTemp());
-}
-
-// ─── lValue 访问 ─────────────────────────────────────────────────────────
-std::any IRGenImpl::visitLValue(SysYParser::LValueContext* ctx) {
-  if (!ctx || !ctx->ID()) {
-    throw std::runtime_error(FormatError("irgen", "非法左值"));
-  }
-  const std::string name = ctx->ID()->getText();
-
-  if (ctx->exp().empty()) {
-    // 无下标：标量读取 或 数组基址引用
-    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) {
+  auto it = storage_map_.find(decl);
+  if (it == storage_map_.end()) {
     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);
+        FormatError("irgen",
+                    "变量声明缺少存储槽位: " + ctx->var()->ID()->getText()));
   }
   return static_cast<ir::Value*>(
-      builder_.CreateLoad(elem_ptr, module_.GetContext().NextTemp()));
+      builder_.CreateLoad(it->second, 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;
-    }
-    if (ctx->unaryOp()->NOT()) {
-      // !v  ≡  (v == 0)
-      auto* zero = builder_.CreateConstInt(0);
-      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) {
-      throw std::runtime_error(
-          FormatError("irgen", "未定义的函数: " + callee_name));
-    }
-    std::vector<ir::Value*> args;
-    if (auto* rparams = ctx->funcRParams()) {
-      for (auto* ep : rparams->exp()) {
-        args.push_back(EvalExpr(*ep));
-      }
-    }
-    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()) {
-    return ctx->unaryExp()->accept(this);
-  }
-  throw std::runtime_error(FormatError("irgen", "非法乘法表达式"));
-}
-
-std::any IRGenImpl::visitAddExp(SysYParser::AddExpContext* ctx) {
-  if (!ctx) {
-    throw std::runtime_error(FormatError("irgen", "非法加法表达式"));
-  }
-  if (ctx->addExp()) {
-    if (!ctx->mulExp()) {
-      throw std::runtime_error(FormatError("irgen", "非法加法表达式"));
-    }
-    ir::Value* lhs = std::any_cast<ir::Value*>(ctx->addExp()->accept(this));
-    ir::Value* rhs = std::any_cast<ir::Value*>(ctx->mulExp()->accept(this));
-    if (ctx->ADD()) {
-      return static_cast<ir::Value*>(
-          builder_.CreateAdd(lhs, rhs, module_.GetContext().NextTemp()));
-    }
-    if (ctx->SUB()) {
-      return static_cast<ir::Value*>(
-          builder_.CreateSub(lhs, rhs, module_.GetContext().NextTemp()));
-    }
+std::any IRGenImpl::visitAdditiveExp(SysYParser::AdditiveExpContext* ctx) {
+  if (!ctx || !ctx->exp(0) || !ctx->exp(1)) {
     throw std::runtime_error(FormatError("irgen", "非法加法表达式"));
   }
-  if (ctx->mulExp()) {
-    return ctx->mulExp()->accept(this);
-  }
-  throw std::runtime_error(FormatError("irgen", "非法加法表达式"));
-}
-
-std::any IRGenImpl::visitRelExp(SysYParser::RelExpContext* ctx) {
-  if (!ctx) {
-    throw std::runtime_error(FormatError("irgen", "非法关系表达式"));
-  }
-  if (ctx->relExp()) {
-    if (!ctx->addExp()) {
-      throw std::runtime_error(FormatError("irgen", "非法关系表达式"));
-    }
-    ir::Value* lhs = std::any_cast<ir::Value*>(ctx->relExp()->accept(this));
-    ir::Value* rhs = std::any_cast<ir::Value*>(ctx->addExp()->accept(this));
-    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()));
-    }
-    if (ctx->GE()) {
-      return static_cast<ir::Value*>(builder_.CreateCmp(
-          ir::CmpOp::Ge, lhs, rhs, module_.GetContext().NextTemp()));
-    }
-    throw std::runtime_error(FormatError("irgen", "非法关系表达式"));
-  }
-  if (ctx->addExp()) {
-    return ctx->addExp()->accept(this);
-  }
-  throw std::runtime_error(FormatError("irgen", "非法关系表达式"));
-}
-
-std::any IRGenImpl::visitEqExp(SysYParser::EqExpContext* ctx) {
-  if (!ctx) {
-    throw std::runtime_error(FormatError("irgen", "非法相等表达式"));
-  }
-  if (ctx->eqExp()) {
-    if (!ctx->relExp()) {
-      throw std::runtime_error(FormatError("irgen", "非法相等表达式"));
-    }
-    ir::Value* lhs = std::any_cast<ir::Value*>(ctx->eqExp()->accept(this));
-    ir::Value* rhs = std::any_cast<ir::Value*>(ctx->relExp()->accept(this));
-    if (ctx->EQ()) {
-      return static_cast<ir::Value*>(builder_.CreateCmp(
-          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", "非法相等表达式"));
-  }
-  if (ctx->relExp()) {
-    return ctx->relExp()->accept(this);
-  }
-  throw std::runtime_error(FormatError("irgen", "非法相等表达式"));
-}
-
-std::any IRGenImpl::visitLAndExp(SysYParser::LAndExpContext* ctx) {
-  if (!ctx) {
-    throw std::runtime_error(FormatError("irgen", "非法逻辑与表达式"));
-  }
-  if (ctx->lAndExp()) {
-    if (!ctx->eqExp()) {
-      throw std::runtime_error(FormatError("irgen", "非法逻辑与表达式"));
-    }
-    // 短路求值：a && b
-    // 使用函数级临时槽位（0=false，1=true），避免 phi 依赖和循环内动态 alloca。
-    if (!short_circuit_slot_) {
-      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->lOrExp()) {
-    if (!ctx->lAndExp()) {
-      throw std::runtime_error(FormatError("irgen", "非法逻辑或表达式"));
-    }
-    // 短路求值：a || b
-    if (!short_circuit_slot_) {
-      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->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", "非法逻辑或表达式"));
+  ir::Value* lhs = EvalExpr(*ctx->exp(0));
+  ir::Value* rhs = EvalExpr(*ctx->exp(1));
+  return static_cast<ir::Value*>(
+      builder_.CreateBinary(ir::Opcode::Add, lhs, rhs,
+                            module_.GetContext().NextTemp()));
 }

src/irgen/IRGenFunc.cpp

@@ -27,90 +27,41 @@ IRGenImpl::IRGenImpl(ir::Module& module, const SemanticContext& sema)
       func_(nullptr),
       builder_(module.GetContext(), nullptr) {}
 
-ir::AllocaInst* IRGenImpl::CreateEntryAllocaI32(const std::string& name) {
-  if (!func_) {
-    throw std::runtime_error(FormatError("irgen", "局部 alloca 必须位于函数内"));
-  }
-  auto* saved = builder_.GetInsertBlock();
-  builder_.SetInsertPoint(func_->GetEntry());
-  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。
+// 编译单元的 IR 生成当前只实现了最小功能：
+// - Module 已在 GenerateIR 中创建，这里只负责继续生成其中的内容；
+// - 当前会读取编译单元中的函数定义，并交给 visitFuncDef 生成函数 IR；
+//
+// 当前还没有实现：
+// - 多个函数定义的遍历与生成；
+// - 全局变量、全局常量的 IR 生成。
 std::any IRGenImpl::visitCompUnit(SysYParser::CompUnitContext* ctx) {
   if (!ctx) {
     throw std::runtime_error(FormatError("irgen", "缺少编译单元"));
   }
-
-  DeclareRuntimeFunctions();
-
-  // 全局声明（func_ == nullptr 时 visitVarDef/visitConstDef 会走全局路径）
-  for (auto* decl : ctx->decl()) {
-    if (decl) decl->accept(this);
-  }
-
-  for (auto* func : ctx->funcDef()) {
-    if (func) func->accept(this);
+  auto* func = ctx->funcDef();
+  if (!func) {
+    throw std::runtime_error(FormatError("irgen", "缺少函数定义"));
   }
+  func->accept(this);
   return {};
 }
 
 // 函数 IR 生成当前实现了：
 // 1. 获取函数名；
-// 2. 支持 int 与 void 返回类型；
-// 3. 支持 int 形参：入口处为每个参数 alloca + store；
-// 4. 在 Module 中创建 Function；
-// 5. 将 builder 插入点设置到入口基本块；
-// 6. 继续生成函数体。
+// 2. 检查函数返回类型；
+// 3. 在 Module 中创建 Function；
+// 4. 将 builder 插入点设置到入口基本块；
+// 5. 继续生成函数体。
 //
 // 当前还没有实现：
-// - float 参数/返回类型；
-// - 数组类型形参；
-// - FunctionType 这样的函数类型对象（参数类型目前只用 shared_ptr<Type>）。
-
+// - 通用函数返回类型处理；
+// - 形参列表遍历与参数类型收集；
+// - FunctionType 这样的函数类型对象；
+// - Argument/形式参数 IR 对象；
+// - 入口块中的参数初始化逻辑。
+// ...
+
+// 因此这里目前只支持最小的“无参 int 函数”生成。
 std::any IRGenImpl::visitFuncDef(SysYParser::FuncDefContext* ctx) {
   if (!ctx) {
     throw std::runtime_error(FormatError("irgen", "缺少函数定义"));
@@ -121,97 +72,16 @@ std::any IRGenImpl::visitFuncDef(SysYParser::FuncDefContext* ctx) {
   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()->INT()) {
-    ret_type = ir::Type::GetInt32Type();
-  } else if (ctx->funcType()->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;
-  std::vector<std::string> param_names;
-  std::vector<bool> param_is_array;
-
-  if (auto* fparams = ctx->funcFParams()) {
-    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() : "");
-    }
+  if (!ctx->funcType() || !ctx->funcType()->INT()) {
+    throw std::runtime_error(FormatError("irgen", "当前仅支持无参 int 函数"));
   }
 
-  func_ = module_.CreateFunction(ctx->ID()->getText(), ret_type, param_types);
-  auto* body_entry = func_->CreateBlock(NextBlockName());
-  builder_.SetInsertPoint(body_entry);
+  func_ = module_.CreateFunction(ctx->ID()->getText(), ir::Type::GetInt32Type());
+  builder_.SetInsertPoint(func_->GetEntry());
   storage_map_.clear();
-  named_storage_.clear();
-  local_array_dims_.clear();
-
-  // 第二遍：处理形参（现在有插入点，可以生成 alloca 等）
-  auto* fparams = ctx->funcFParams();
-  for (size_t i = 0; i < param_names.size(); ++i) {
-    auto* arg = func_->GetArgument(i);
-    if (param_is_array[i]) {
-      // 数组参数：直接存入 named_storage_，维度用 EvalExpAsConst 获取
-      if (!param_names[i].empty()) {
-        named_storage_[param_names[i]] = arg;
-        std::vector<int> dims = {-1};  // 首维未知
-        if (fparams) {
-          auto fp_list = fparams->funcFParam();
-          if (i < fp_list.size()) {
-            for (auto* dim_exp : fp_list[i]->exp()) {
-              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);
-
-  // 入口块只用于静态栈槽分配，末尾统一跳到函数体起始块。
-  auto* saved = builder_.GetInsertBlock();
-  builder_.SetInsertPoint(func_->GetEntry());
-  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,111 +19,9 @@ std::any IRGenImpl::visitStmt(SysYParser::StmtContext* ctx) {
   if (!ctx) {
     throw std::runtime_error(FormatError("irgen", "缺少语句"));
   }
-  if (ctx->lValue() && ctx->ASSIGN() && ctx->exp()) {
-    ir::Value* rhs = EvalExpr(*ctx->exp());
-    ir::Value* slot = ResolveStorage(ctx->lValue());
-    if (!slot) {
-      throw std::runtime_error(
-          FormatError("irgen", "赋值目标未找到存储槽位: " +
-                                   (ctx->lValue()->ID()
-                                        ? ctx->lValue()->ID()->getText()
-                                        : "?")));
-    }
-    builder_.CreateStore(rhs, slot);
-    return BlockFlow::Continue;
-  }
-  if (ctx->blockStmt()) {
-    ctx->blockStmt()->accept(this);
-    return builder_.GetInsertBlock() && builder_.GetInsertBlock()->HasTerminator()
-               ? BlockFlow::Terminated
-               : BlockFlow::Continue;
-  }
-  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;
-
-    ir::Value* cond = ToBoolValue(EvalCond(*ctx->cond()));
-    builder_.CreateCondBr(cond, then_bb, else_bb);
-
-    builder_.SetInsertPoint(then_bb);
-    auto then_flow = std::any_cast<BlockFlow>(ctx->stmt(0)->accept(this));
-    bool then_term = (then_flow == BlockFlow::Terminated);
-    if (then_flow != BlockFlow::Terminated) {
-      builder_.CreateBr(merge_bb);
-    }
-
-    bool else_term = false;
-    if (ctx->ELSE()) {
-      builder_.SetInsertPoint(else_bb);
-      auto else_flow = std::any_cast<BlockFlow>(ctx->stmt(1)->accept(this));
-      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()) {
-    if (!ctx->cond() || ctx->stmt().empty()) {
-      throw std::runtime_error(FormatError("irgen", "while 语句不完整"));
-    }
-    auto* cond_bb = func_->CreateBlock(NextBlockName());
-    auto* body_bb = func_->CreateBlock(NextBlockName());
-    auto* exit_bb = func_->CreateBlock(NextBlockName());
-
-    builder_.CreateBr(cond_bb);
-    builder_.SetInsertPoint(cond_bb);
-    ir::Value* cond = ToBoolValue(EvalCond(*ctx->cond()));
-    builder_.CreateCondBr(cond, body_bb, exit_bb);
-
-    loop_stack_.push_back({cond_bb, exit_bb});
-    builder_.SetInsertPoint(body_bb);
-    auto body_flow = std::any_cast<BlockFlow>(ctx->stmt(0)->accept(this));
-    if (body_flow != BlockFlow::Terminated) {
-      builder_.CreateBr(cond_bb);
-    }
-    loop_stack_.pop_back();
-
-    builder_.SetInsertPoint(exit_bb);
-    return BlockFlow::Continue;
-  }
-  if (ctx->BREAK()) {
-    if (loop_stack_.empty()) {
-      throw std::runtime_error(FormatError("irgen", "break 不在循环中"));
-    }
-    builder_.CreateBr(loop_stack_.back().break_target);
-    return BlockFlow::Terminated;
-  }
-  if (ctx->CONTINUE()) {
-    if (loop_stack_.empty()) {
-      throw std::runtime_error(FormatError("irgen", "continue 不在循环中"));
-    }
-    builder_.CreateBr(loop_stack_.back().continue_target);
-    return BlockFlow::Terminated;
-  }
   if (ctx->returnStmt()) {
     return ctx->returnStmt()->accept(this);
   }
-  if (ctx->exp()) {
-    EvalExpr(*ctx->exp());
-    return BlockFlow::Continue;
-  }
-  if (ctx->SEMICOLON()) {
-    return BlockFlow::Continue;
-  }
   throw std::runtime_error(FormatError("irgen", "暂不支持的语句类型"));
 }
 
@@ -133,9 +31,7 @@ std::any IRGenImpl::visitReturnStmt(SysYParser::ReturnStmtContext* ctx) {
     throw std::runtime_error(FormatError("irgen", "缺少 return 语句"));
   }
   if (!ctx->exp()) {
-    // void 函数的 return;
-    builder_.CreateRetVoid();
-    return BlockFlow::Terminated;
+    throw std::runtime_error(FormatError("irgen", "return 缺少表达式"));
   }
   ir::Value* v = EvalExpr(*ctx->exp());
   builder_.CreateRet(v);

src/main.cpp

@@ -1,12 +1,6 @@
 #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"
@@ -19,94 +13,6 @@
 #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);
@@ -115,20 +21,11 @@ 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,3 +1,4 @@
-// 常量整数表达式求值：
-// 在 IRGen 阶段为数组维度、const 初始值等场景提供编译期折叠。
-// 当前只支持 int 整数运算；float 暂不处理。
+// 常量求值：
+// - 处理数组维度、全局初始化、const 表达式等编译期可计算场景
+// - 为语义分析与 IR 生成提供常量折叠/常量值信息
+

src/sem/Sema.cpp

@@ -1,490 +1,200 @@
 #include "sem/Sema.h"
 
+#include <any>
 #include <stdexcept>
+#include <string>
 
-namespace {
-
-SymbolType ParseType(const std::string& text) {
-  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;
-}
-
-SymbolType MergeNumericType(SymbolType lhs, SymbolType rhs) {
-  if (lhs == SymbolType::TYPE_FLOAT || rhs == SymbolType::TYPE_FLOAT) {
-    return SymbolType::TYPE_FLOAT;
-  }
-  if (lhs == SymbolType::TYPE_INT && rhs == SymbolType::TYPE_INT) {
-    return SymbolType::TYPE_INT;
-  }
-  if (lhs != SymbolType::TYPE_UNKNOWN) {
-    return lhs;
-  }
-  return rhs;
-}
+#include "SysYBaseVisitor.h"
+#include "sem/SymbolTable.h"
+#include "utils/Log.h"
 
-}  // namespace
-
-void SemaVisitor::RecordNodeError(antlr4::ParserRuleContext* ctx,
-                                  const std::string& msg) {
-  if (!ctx || !ctx->getStart()) {
-    ir_ctx_.RecordError(ErrorMsg(msg, 0, 0));
-    return;
-  }
-  ir_ctx_.RecordError(ErrorMsg(msg, ctx->getStart()->getLine(),
-                               ctx->getStart()->getCharPositionInLine() + 1));
-}
-
-std::any SemaVisitor::visitCompUnit(SysYParser::CompUnitContext* ctx) {
-  return visitChildren(ctx);
-}
-
-std::any SemaVisitor::visitDecl(SysYParser::DeclContext* ctx) {
-  return visitChildren(ctx);
-}
-
-std::any SemaVisitor::visitConstDecl(SysYParser::ConstDeclContext* 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;
-}
-
-std::any SemaVisitor::visitBtype(SysYParser::BtypeContext* ctx) {
-  return visitChildren(ctx);
-}
-
-std::any SemaVisitor::visitConstDef(SysYParser::ConstDefContext* ctx) {
-  if (!ctx || !ctx->ID()) {
-    return {};
-  }
-
-  const std::string name = ctx->ID()->getText();
-  auto& table = ir_ctx_.GetSymbolTable();
-  if (table.CurrentScopeHasVar(name)) {
-    RecordNodeError(ctx, "重复定义变量: " + name);
-  } else {
-    VarInfo info;
-    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);
-}
-
-std::any SemaVisitor::visitConstInitValue(SysYParser::ConstInitValueContext* ctx) {
-  return visitChildren(ctx);
-}
-
-std::any SemaVisitor::visitVarDecl(SysYParser::VarDeclContext* ctx) {
-  current_decl_is_const_ = false;
-  current_decl_type_ = SymbolType::TYPE_UNKNOWN;
-  if (ctx && ctx->btype()) {
-    current_decl_type_ = ParseType(ctx->btype()->getText());
-  }
-  std::any result = visitChildren(ctx);
-  current_decl_type_ = SymbolType::TYPE_UNKNOWN;
-  return result;
-}
-
-std::any SemaVisitor::visitVarDef(SysYParser::VarDefContext* ctx) {
-  if (!ctx || !ctx->ID()) {
-    return {};
-  }
+namespace {
 
-  const std::string name = ctx->ID()->getText();
-  auto& table = ir_ctx_.GetSymbolTable();
-  if (table.CurrentScopeHasVar(name)) {
-    RecordNodeError(ctx, "重复定义变量: " + name);
-  } else {
-    VarInfo info;
-    info.type = current_decl_type_;
-    info.is_const = current_decl_is_const_;
-    info.decl_ctx = ctx;
-    table.BindVar(name, info, ctx);
+std::string GetLValueName(SysYParser::LValueContext& lvalue) {
+  if (!lvalue.ID()) {
+    throw std::runtime_error(FormatError("sema", "非法左值"));
   }
-
-  ir_ctx_.SetType(ctx, current_decl_type_);
-  return visitChildren(ctx);
-}
-
-std::any SemaVisitor::visitInitValue(SysYParser::InitValueContext* ctx) {
-  return visitChildren(ctx);
+  return lvalue.ID()->getText();
 }
 
-std::any SemaVisitor::visitFuncDef(SysYParser::FuncDefContext* ctx) {
-  if (!ctx || !ctx->ID() || !ctx->funcType()) {
+class SemaVisitor final : public SysYBaseVisitor {
+ public:
+  std::any visitCompUnit(SysYParser::CompUnitContext* ctx) override {
+    if (!ctx) {
+      throw std::runtime_error(FormatError("sema", "缺少编译单元"));
+    }
+    auto* func = ctx->funcDef();
+    if (!func || !func->blockStmt()) {
+      throw std::runtime_error(FormatError("sema", "缺少 main 函数定义"));
+    }
+    if (!func->ID() || func->ID()->getText() != "main") {
+      throw std::runtime_error(FormatError("sema", "缺少 main 函数定义"));
+    }
+    func->accept(this);
+    if (!seen_return_) {
+      throw std::runtime_error(
+          FormatError("sema", "main 函数必须包含 return 语句"));
+    }
     return {};
   }
 
-  const std::string func_name = ctx->ID()->getText();
-  SymbolType ret_type = ParseType(ctx->funcType()->getText());
-  ir_ctx_.SetCurrentFuncReturnType(ret_type);
-
-  auto& table = ir_ctx_.GetSymbolTable();
-  if (table.CurrentScopeHasFunc(func_name)) {
-    RecordNodeError(ctx, "重复定义函数: " + func_name);
-  } else {
-    FuncInfo info;
-    info.name = func_name;
-    info.ret_type = ret_type;
-    info.decl_ctx = ctx;
-    if (ctx->funcFParams()) {
-      for (auto* param : ctx->funcFParams()->funcFParam()) {
-        if (!param || !param->btype()) {
-          info.param_types.push_back(SymbolType::TYPE_UNKNOWN);
-        } else {
-          info.param_types.push_back(ParseType(param->btype()->getText()));
-        }
-      }
+  std::any visitFuncDef(SysYParser::FuncDefContext* ctx) override {
+    if (!ctx || !ctx->blockStmt()) {
+      throw std::runtime_error(FormatError("sema", "缺少 main 函数定义"));
+    }
+    if (!ctx->funcType() || !ctx->funcType()->INT()) {
+      throw std::runtime_error(FormatError("sema", "当前仅支持 int main"));
+    }
+    const auto& items = ctx->blockStmt()->blockItem();
+    if (items.empty()) {
+      throw std::runtime_error(
+          FormatError("sema", "main 函数不能为空，且必须以 return 结束"));
     }
-    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);
-}
-
-std::any SemaVisitor::visitFuncFParams(SysYParser::FuncFParamsContext* ctx) {
-  return visitChildren(ctx);
-}
-
-std::any SemaVisitor::visitFuncFParam(SysYParser::FuncFParamContext* ctx) {
-  if (!ctx || !ctx->ID() || !ctx->btype()) {
-    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 {};
-}
-
-std::any SemaVisitor::visitBlockStmt(SysYParser::BlockStmtContext* ctx) {
-  ir_ctx_.EnterScope();
-  std::any result = visitChildren(ctx);
-  ir_ctx_.LeaveScope();
-  return result;
-}
-
-std::any SemaVisitor::visitBlockItem(SysYParser::BlockItemContext* ctx) {
-  return visitChildren(ctx);
-}
-
-std::any SemaVisitor::visitStmt(SysYParser::StmtContext* ctx) {
-  if (!ctx) {
+  std::any visitBlockStmt(SysYParser::BlockStmtContext* ctx) override {
+    if (!ctx) {
+      throw std::runtime_error(FormatError("sema", "缺少语句块"));
+    }
+    const auto& items = ctx->blockItem();
+    for (size_t i = 0; i < items.size(); ++i) {
+      auto* item = items[i];
+      if (!item) {
+        continue;
+      }
+      if (seen_return_) {
+        throw std::runtime_error(
+            FormatError("sema", "return 必须是 main 函数中的最后一条语句"));
+      }
+      current_item_index_ = i;
+      total_items_ = items.size();
+      item->accept(this);
+    }
     return {};
   }
 
-  if (ctx->WHILE()) {
-    ir_ctx_.EnterLoop();
-    std::any result = visitChildren(ctx);
-    ir_ctx_.ExitLoop();
-    return result;
-  }
-
-  if (ctx->BREAK() && !ir_ctx_.InLoop()) {
-    RecordNodeError(ctx, "break 只能出现在循环语句中");
-  }
-
-  if (ctx->CONTINUE() && !ir_ctx_.InLoop()) {
-    RecordNodeError(ctx, "continue 只能出现在循环语句中");
+  std::any visitBlockItem(SysYParser::BlockItemContext* ctx) override {
+    if (!ctx) {
+      throw std::runtime_error(FormatError("sema", "暂不支持的语句或声明"));
+    }
+    if (ctx->decl()) {
+      ctx->decl()->accept(this);
+      return {};
+    }
+    if (ctx->stmt()) {
+      ctx->stmt()->accept(this);
+      return {};
+    }
+    throw std::runtime_error(FormatError("sema", "暂不支持的语句或声明"));
   }
 
-  if (ctx->lValue() && ctx->exp()) {
-    ctx->lValue()->accept(this);
-    ctx->exp()->accept(this);
-    SymbolType lhs = ir_ctx_.GetType(ctx->lValue());
-    SymbolType rhs = ir_ctx_.GetType(ctx->exp());
-    if (!IsTypeCompatible(lhs, rhs)) {
-      RecordNodeError(ctx, "赋值两侧类型不兼容");
+  std::any visitDecl(SysYParser::DeclContext* ctx) override {
+    if (!ctx) {
+      throw std::runtime_error(FormatError("sema", "非法变量声明"));
+    }
+    if (!ctx->btype() || !ctx->btype()->INT()) {
+      throw std::runtime_error(FormatError("sema", "当前仅支持局部 int 变量声明"));
+    }
+    auto* var_def = ctx->varDef();
+    if (!var_def || !var_def->lValue()) {
+      throw std::runtime_error(FormatError("sema", "非法变量声明"));
     }
+    const std::string name = GetLValueName(*var_def->lValue());
+    if (table_.Contains(name)) {
+      throw std::runtime_error(FormatError("sema", "重复定义变量: " + name));
+    }
+    if (auto* init = var_def->initValue()) {
+      if (!init->exp()) {
+        throw std::runtime_error(FormatError("sema", "当前不支持聚合初始化"));
+      }
+      init->exp()->accept(this);
+    }
+    table_.Add(name, var_def);
     return {};
   }
 
-  return visitChildren(ctx);
-}
-
-std::any SemaVisitor::visitReturnStmt(SysYParser::ReturnStmtContext* ctx) {
-  if (!ctx) {
+  std::any visitStmt(SysYParser::StmtContext* ctx) override {
+    if (!ctx || !ctx->returnStmt()) {
+      throw std::runtime_error(FormatError("sema", "暂不支持的语句或声明"));
+    }
+    ctx->returnStmt()->accept(this);
     return {};
   }
 
-  SymbolType ret_type = ir_ctx_.GetCurrentFuncReturnType();
-  if (ctx->exp()) {
+  std::any visitReturnStmt(SysYParser::ReturnStmtContext* ctx) override {
+    if (!ctx || !ctx->exp()) {
+      throw std::runtime_error(FormatError("sema", "return 缺少表达式"));
+    }
     ctx->exp()->accept(this);
-    SymbolType expr_type = ir_ctx_.GetType(ctx->exp());
-    if (ret_type == SymbolType::TYPE_VOID) {
-      RecordNodeError(ctx, "void 函数不应返回表达式");
-    } else if (!IsTypeCompatible(ret_type, expr_type)) {
-      RecordNodeError(ctx, "return 表达式类型与函数返回类型不匹配");
+    seen_return_ = true;
+    if (current_item_index_ + 1 != total_items_) {
+      throw std::runtime_error(
+          FormatError("sema", "return 必须是 main 函数中的最后一条语句"));
     }
-  } else if (ret_type != SymbolType::TYPE_VOID &&
-             ret_type != SymbolType::TYPE_UNKNOWN) {
-    RecordNodeError(ctx, "非 void 函数 return 必须带表达式");
-  }
-
-  return {};
-}
-
-std::any SemaVisitor::visitExp(SysYParser::ExpContext* ctx) {
-  if (!ctx || !ctx->addExp()) {
-    return {};
-  }
-  ctx->addExp()->accept(this);
-  ir_ctx_.SetType(ctx, ir_ctx_.GetType(ctx->addExp()));
-  return {};
-}
-
-std::any SemaVisitor::visitCond(SysYParser::CondContext* ctx) {
-  if (!ctx || !ctx->lOrExp()) {
-    return {};
-  }
-  ctx->lOrExp()->accept(this);
-  ir_ctx_.SetType(ctx, SymbolType::TYPE_INT);
-  return {};
-}
-
-std::any SemaVisitor::visitLValue(SysYParser::LValueContext* ctx) {
-  if (!ctx || !ctx->ID()) {
     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);
+  std::any visitParenExp(SysYParser::ParenExpContext* ctx) override {
+    if (!ctx || !ctx->exp()) {
+      throw std::runtime_error(FormatError("sema", "非法括号表达式"));
     }
-  }
-
-  return {};
-}
-
-std::any SemaVisitor::visitPrimaryExp(SysYParser::PrimaryExpContext* ctx) {
-  if (!ctx) {
-    return {};
-  }
-
-  if (ctx->exp()) {
     ctx->exp()->accept(this);
-    ir_ctx_.SetType(ctx, ir_ctx_.GetType(ctx->exp()));
     return {};
   }
 
-  if (ctx->lValue()) {
-    ctx->lValue()->accept(this);
-    ir_ctx_.SetType(ctx, ir_ctx_.GetType(ctx->lValue()));
-    return {};
-  }
-
-  if (ctx->number()) {
-    ctx->number()->accept(this);
-    ir_ctx_.SetType(ctx, ir_ctx_.GetType(ctx->number()));
-  }
-
-  return {};
-}
-
-std::any SemaVisitor::visitNumber(SysYParser::NumberContext* ctx) {
-  if (!ctx) {
-    return {};
-  }
-
-  if (ctx->ILITERAL()) {
-    ir_ctx_.SetType(ctx, SymbolType::TYPE_INT);
-    ir_ctx_.SetConstVal(ctx, std::any(0L));
-  } else if (ctx->FLITERAL()) {
-    ir_ctx_.SetType(ctx, SymbolType::TYPE_FLOAT);
-    ir_ctx_.SetConstVal(ctx, std::any(0.0));
-  }
-
-  return {};
-}
-
-std::any SemaVisitor::visitUnaryExp(SysYParser::UnaryExpContext* ctx) {
-  if (!ctx) {
-    return {};
-  }
-
-  if (ctx->primaryExp()) {
-    ctx->primaryExp()->accept(this);
-    ir_ctx_.SetType(ctx, ir_ctx_.GetType(ctx->primaryExp()));
+  std::any visitVarExp(SysYParser::VarExpContext* ctx) override {
+    if (!ctx || !ctx->var()) {
+      throw std::runtime_error(FormatError("sema", "非法变量表达式"));
+    }
+    ctx->var()->accept(this);
     return {};
   }
 
-  if (ctx->unaryOp() && ctx->unaryExp()) {
-    ctx->unaryExp()->accept(this);
-    ir_ctx_.SetType(ctx, ir_ctx_.GetType(ctx->unaryExp()));
+  std::any visitNumberExp(SysYParser::NumberExpContext* ctx) override {
+    if (!ctx || !ctx->number() || !ctx->number()->ILITERAL()) {
+      throw std::runtime_error(FormatError("sema", "当前仅支持整数字面量"));
+    }
     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);
+  std::any visitAdditiveExp(SysYParser::AdditiveExpContext* ctx) override {
+    if (!ctx || !ctx->exp(0) || !ctx->exp(1)) {
+      throw std::runtime_error(FormatError("sema", "暂不支持的表达式形式"));
     }
-  }
-
-  return visitChildren(ctx);
-}
-
-std::any SemaVisitor::visitUnaryOp(SysYParser::UnaryOpContext* ctx) {
-  return visitChildren(ctx);
-}
-
-std::any SemaVisitor::visitFuncRParams(SysYParser::FuncRParamsContext* ctx) {
-  return visitChildren(ctx);
-}
-
-std::any SemaVisitor::visitMulExp(SysYParser::MulExpContext* ctx) {
-  if (!ctx) {
+    ctx->exp(0)->accept(this);
+    ctx->exp(1)->accept(this);
     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 {};
-}
-
-std::any SemaVisitor::visitAddExp(SysYParser::AddExpContext* ctx) {
-  if (!ctx) {
+  std::any visitVar(SysYParser::VarContext* ctx) override {
+    if (!ctx || !ctx->ID()) {
+      throw std::runtime_error(FormatError("sema", "非法变量引用"));
+    }
+    const std::string name = ctx->ID()->getText();
+    auto* decl = table_.Lookup(name);
+    if (!decl) {
+      throw std::runtime_error(FormatError("sema", "使用了未定义的变量: " + name));
+    }
+    sema_.BindVarUse(ctx, decl);
     return {};
   }
 
-  if (ctx->addExp()) {
-    ctx->addExp()->accept(this);
-  }
-  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 {};
-}
+  SemanticContext TakeSemanticContext() { return std::move(sema_); }
 
-std::any SemaVisitor::visitRelExp(SysYParser::RelExpContext* ctx) {
-  if (ctx) {
-    visitChildren(ctx);
-    ir_ctx_.SetType(ctx, SymbolType::TYPE_INT);
-  }
-  return {};
-}
+ private:
+  SymbolTable table_;
+  SemanticContext sema_;
+  bool seen_return_ = false;
+  size_t current_item_index_ = 0;
+  size_t total_items_ = 0;
+};
 
-std::any SemaVisitor::visitEqExp(SysYParser::EqExpContext* ctx) {
-  if (ctx) {
-    visitChildren(ctx);
-    ir_ctx_.SetType(ctx, SymbolType::TYPE_INT);
-  }
-  return {};
-}
-
-std::any SemaVisitor::visitLAndExp(SysYParser::LAndExpContext* ctx) {
-  if (ctx) {
-    visitChildren(ctx);
-    ir_ctx_.SetType(ctx, SymbolType::TYPE_INT);
-  }
-  return {};
-}
-
-std::any SemaVisitor::visitLOrExp(SysYParser::LOrExpContext* ctx) {
-  if (ctx) {
-    visitChildren(ctx);
-    ir_ctx_.SetType(ctx, SymbolType::TYPE_INT);
-  }
-  return {};
-}
-
-std::any SemaVisitor::visitConstExp(SysYParser::ConstExpContext* ctx) {
-  if (!ctx || !ctx->addExp()) {
-    return {};
-  }
-  ctx->addExp()->accept(this);
-  ir_ctx_.SetType(ctx, ir_ctx_.GetType(ctx->addExp()));
-  return {};
-}
-
-void RunSemanticAnalysis(SysYParser::CompUnitContext* ctx, IRGenContext& ir_ctx) {
-  if (!ctx) {
-    throw std::invalid_argument("CompUnitContext is null");
-  }
-
-  ir_ctx.EnterScope();
-  SemaVisitor visitor(ir_ctx, nullptr);
-  visitor.visit(ctx);
-  ir_ctx.LeaveScope();
-}
+}  // namespace
 
 SemanticContext RunSema(SysYParser::CompUnitContext& comp_unit) {
-  IRGenContext ctx;
-  SemanticContext sema_ctx;
-  ctx.EnterScope();
-  SemaVisitor visitor(ctx, &sema_ctx);
-  visitor.visit(&comp_unit);
-  ctx.LeaveScope();
-  return sema_ctx;
+  SemaVisitor visitor;
+  comp_unit.accept(&visitor);
+  return visitor.TakeSemanticContext();
 }

src/sem/SymbolTable.cpp

@@ -1,164 +1,17 @@
-#include "../../include/sem/SymbolTable.h"
-#include <stdexcept>
-#include <string>
-#include <iostream>
+// 维护局部变量声明的注册与查找。
 
-// 进入新作用域
-void SymbolTable::EnterScope() {
-    scopes_.push(ScopeEntry());
-}
-
-// 离开当前作用域
-void SymbolTable::LeaveScope() {
-    if (scopes_.empty()) {
-        throw std::runtime_error("SymbolTable Error: 作用域栈为空，无法退出");
-    }
-    scopes_.pop();
-}
-
-// 绑定变量到当前作用域
-void SymbolTable::BindVar(const std::string& name, const VarInfo& info, void* decl_ctx) {
-    if (CurrentScopeHasVar(name)) {
-        throw std::runtime_error("变量'" + name + "'在当前作用域重复定义");
-    }
-    scopes_.top().var_symbols[name] = {info, decl_ctx};
-}
-
-// 绑定函数到当前作用域
-void SymbolTable::BindFunc(const std::string& name, const FuncInfo& info, void* decl_ctx) {
-    if (CurrentScopeHasFunc(name)) {
-        throw std::runtime_error("函数'" + name + "'在当前作用域重复定义");
-    }
-    scopes_.top().func_symbols[name] = {info, decl_ctx};
-}
-
-// 查找变量（从当前作用域向上遍历）
-bool SymbolTable::LookupVar(const std::string& name, VarInfo& out_info, void*& out_decl_ctx) const {
-    if (scopes_.empty()) {
-        return false;
-    }
-    auto temp_stack = scopes_;
-    while (!temp_stack.empty()) {
-        auto& scope = temp_stack.top();
-        auto it = scope.var_symbols.find(name);
-        if (it != scope.var_symbols.end()) {
-            out_info = it->second.first;
-            out_decl_ctx = it->second.second;
-            return true;
-        }
-        temp_stack.pop();
-    }
-    return false;
-}
-
-// 查找函数（从当前作用域向上遍历，通常函数在全局作用域）
-bool SymbolTable::LookupFunc(const std::string& name, FuncInfo& out_info, void*& out_decl_ctx) const {
-    if (scopes_.empty()) {
-        return false;
-    }
-    auto temp_stack = scopes_;
-    while (!temp_stack.empty()) {
-        auto& scope = temp_stack.top();
-        auto it = scope.func_symbols.find(name);
-        if (it != scope.func_symbols.end()) {
-            out_info = it->second.first;
-            out_decl_ctx = it->second.second;
-            return true;
-        }
-        temp_stack.pop();
-    }
-    return false;
-}
+#include "sem/SymbolTable.h"
 
-// 检查当前作用域是否包含指定变量
-bool SymbolTable::CurrentScopeHasVar(const std::string& name) const {
-    if (scopes_.empty()) {
-        return false;
-    }
-    return scopes_.top().var_symbols.count(name) > 0;
+void SymbolTable::Add(const std::string& name,
+                      SysYParser::VarDefContext* decl) {
+  table_[name] = decl;
 }
 
-// 检查当前作用域是否包含指定函数
-bool SymbolTable::CurrentScopeHasFunc(const std::string& name) const {
-    if (scopes_.empty()) {
-        return false;
-    }
-    return scopes_.top().func_symbols.count(name) > 0;
+bool SymbolTable::Contains(const std::string& name) const {
+  return table_.find(name) != table_.end();
 }
 
-// 进入循环
-void SymbolTable::EnterLoop() { 
-    loop_depth_++; 
+SysYParser::VarDefContext* SymbolTable::Lookup(const std::string& name) const {
+  auto it = table_.find(name);
+  return it == table_.end() ? nullptr : it->second;
 }
-
-// 离开循环
-void SymbolTable::ExitLoop() { 
-    if (loop_depth_ > 0) loop_depth_--;
-}
-
-// 检查是否在循环内
-bool SymbolTable::InLoop() const { 
-    return loop_depth_ > 0; 
-}
-
-// 清空所有作用域和状态
-void SymbolTable::Clear() {
-    while (!scopes_.empty()) {
-        scopes_.pop();
-    }
-    loop_depth_ = 0;
-}
-
-// 获取当前作用域中所有变量名
-std::vector<std::string> SymbolTable::GetCurrentScopeVarNames() const {
-    std::vector<std::string> names;
-    if (!scopes_.empty()) {
-        for (const auto& pair : scopes_.top().var_symbols) {
-            names.push_back(pair.first);
-        }
-    }
-    return names;
-}
-
-// 获取当前作用域中所有函数名
-std::vector<std::string> SymbolTable::GetCurrentScopeFuncNames() const {
-    std::vector<std::string> names;
-    if (!scopes_.empty()) {
-        for (const auto& pair : scopes_.top().func_symbols) {
-            names.push_back(pair.first);
-        }
-    }
-    return names;
-}
-
-// 调试：打印符号表内容
-void SymbolTable::Dump() const {
-    std::cout << "符号表内容 (作用域深度: " << scopes_.size() << "):\n";
-    int scope_idx = 0;
-    auto temp_stack = scopes_;
-    
-    while (!temp_stack.empty()) {
-        std::cout << "\n作用域 " << scope_idx++ << ":\n";
-        auto& scope = temp_stack.top();
-        
-        std::cout << "  变量:\n";
-        for (const auto& var_pair : scope.var_symbols) {
-            const VarInfo& info = var_pair.second.first;
-            std::cout << "    " << var_pair.first << ": "
-                      << SymbolTypeToString(info.type)
-                      << (info.is_const ? " (const)" : "")
-                      << (info.IsArray() ? " [数组]" : "")
-                      << "\n";
-        }
-        
-        std::cout << "  函数:\n";
-        for (const auto& func_pair : scope.func_symbols) {
-            const FuncInfo& info = func_pair.second.first;
-            std::cout << "    " << func_pair.first << ": "
-                      << SymbolTypeToString(info.ret_type) << " ("
-                      << info.param_types.size() << " 个参数)\n";
-        }
-        
-        temp_stack.pop();
-    }
-}

sylib/sylib.c

@@ -2,42 +2,3 @@
 // - 按实验/评测规范提供 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,22 +2,3 @@
 // - 声明运行库函数原型（供编译器生成 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);
-