可以处理生成加法的IR

src/antlr4/SysY.g4

@@ -1,35 +1,73 @@
+// SysY 子集语法：支持形如
+// int main() { int a = 1; int b = 2; return a + b; }
+// 的最小返回表达式编译。
+
+// 后续需要自行添加
 grammar SysY;
 
-// 说明：
+compUnit
-// - 这是一个“最小可用”的 SysY.g4，用于避免空文件导致的 ANTLR 解析报错。
+    : funcDef EOF
-// - 后续请按 SysY 语言规范逐步补全 lexer/parser 规则。
+    ;
-// - 本工程约定：ANTLR 生成的 C++ 源码/头文件不进入仓库，统一生成到构建目录（例如 build/generated/antlr4/）。
 
-compilationUnit
+funcDef
-  : (statement)* EOF
+    : Int Main L_PAREN R_PAREN block
-  ;
+    ;
 
-statement
+block
-  : 'return' expression? ';'
+    : L_BRACE stmt* R_BRACE
-  | ';'
+    ;
-  ;
 
-expression
+stmt
-  : IntegerLiteral
+    : varDecl
-  | Identifier
+    | returnStmt
-  ;
+    ;
 
-// -------- lexer --------
+varDecl
+    : Int Ident (Assign exp)? Semi
+    ;
 
-IntegerLiteral
+returnStmt
-  : [0-9]+
+    : Return exp Semi
-  ;
+    ;
 
-Identifier
+exp
-  : [a-zA-Z_] [a-zA-Z0-9_]*
+    : addExp
-  ;
+    ;
 
-Whitespace
+addExp
-  : [ \t\r\n]+ -> skip
+    : primary (AddOp primary)*
-  ;
+    ;
 
+primary
+    : Number
+    | Ident
+    | L_PAREN exp R_PAREN
+    ;
+
+Int     : 'int';
+Return  : 'return';
+Main    : 'main';
+
+AddOp   : '+';
+Assign  : '=';
+Semi    : ';';
+L_PAREN : '(';
+R_PAREN : ')';
+L_BRACE : '{';
+R_BRACE : '}';
+
+Ident
+    : [a-zA-Z_][a-zA-Z_0-9]*
+    ;
+
+Number
+    : [0-9]+
+    ;
+
+WS
+    : [ \t\r\n]+ -> skip
+    ;
+
+COMMENT
+    : '//' ~[\r\n]* -> skip
+    ;

src/ast/AstNodes.cpp

@@ -1,4 +1,3 @@
-// AST 节点定义与实现：
+// AST 节点简单实现：仅需包含头文件即可，析构函数默认生成。
-// - 表达式、语句、声明、函数、类型等节点
-// - 支持后续阶段在节点上附加信息（类型、符号绑定、常量值等）
 
+#include "ast/AstNodes.h"

src/ast/AstNodes.h

@@ -0,0 +1,70 @@
+// Minimal AST definitions for the SysY subset used in this toy compiler.
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace ast {
+
+enum class BinaryOp { Add, Sub, Mul, Div };
+
+struct Expr {
+  virtual ~Expr() = default;
+};
+
+struct NumberExpr : Expr {
+  int value{};
+  explicit NumberExpr(int v) : value(v) {}
+};
+
+struct VarExpr : Expr {
+  std::string name;
+  explicit VarExpr(std::string n) : name(std::move(n)) {}
+};
+
+struct BinaryExpr : Expr {
+  BinaryOp op;
+  std::shared_ptr<Expr> lhs;
+  std::shared_ptr<Expr> rhs;
+  BinaryExpr(BinaryOp op, std::shared_ptr<Expr> lhs, std::shared_ptr<Expr> rhs)
+      : op(op), lhs(std::move(lhs)), rhs(std::move(rhs)) {}
+};
+
+struct Stmt {
+  virtual ~Stmt() = default;
+};
+
+struct ReturnStmt : Stmt {
+  std::shared_ptr<Expr> value;
+  explicit ReturnStmt(std::shared_ptr<Expr> v) : value(std::move(v)) {}
+};
+
+struct VarDecl {
+  std::string name;
+  std::shared_ptr<Expr> init;  // nullptr if no initializer
+  VarDecl(std::string n, std::shared_ptr<Expr> i)
+      : name(std::move(n)), init(std::move(i)) {}
+};
+
+struct Block {
+  std::vector<std::shared_ptr<VarDecl>> varDecls;
+  std::vector<std::shared_ptr<Stmt>> stmts;
+};
+
+struct FuncDef {
+  std::string name;
+  std::shared_ptr<Block> body;
+  FuncDef(std::string n, std::shared_ptr<Block> b)
+      : name(std::move(n)), body(std::move(b)) {}
+};
+
+struct CompUnit {
+  std::shared_ptr<FuncDef> func;
+  explicit CompUnit(std::shared_ptr<FuncDef> f) : func(std::move(f)) {}
+};
+
+// 调试打印
+void PrintAST(const CompUnit& cu);
+
+}  // namespace ast

src/ast/AstPrinter.cpp

@@ -1,4 +1,72 @@
-// AST 调试打印：
+// 简单 AST 调试打印，便于前端验证。
-// - 以可读形式打印 AST 结构
-// - 用于验证 AST 构建与语义分析结果，便于定位问题
 
+#include "ast/AstNodes.h"
+
+#include <iostream>
+
+namespace ast {
+
+static void PrintExpr(const Expr* expr);
+
+static void PrintIndent(int depth) {
+  for (int i = 0; i < depth; ++i) std::cout << "  ";
+}
+
+static void PrintExpr(const Expr* expr) {
+  if (auto num = dynamic_cast<const NumberExpr*>(expr)) {
+    std::cout << num->value;
+  } else if (auto var = dynamic_cast<const VarExpr*>(expr)) {
+    std::cout << var->name;
+  } else if (auto bin = dynamic_cast<const BinaryExpr*>(expr)) {
+    std::cout << "(";
+    PrintExpr(bin->lhs.get());
+    const char* op = "?";
+    switch (bin->op) {
+      case BinaryOp::Add:
+        op = "+";
+        break;
+      case BinaryOp::Sub:
+        op = "-";
+        break;
+      case BinaryOp::Mul:
+        op = "*";
+        break;
+      case BinaryOp::Div:
+        op = "/";
+        break;
+    }
+    std::cout << " " << op << " ";
+    PrintExpr(bin->rhs.get());
+    std::cout << ")";
+  }
+}
+
+void PrintAST(const CompUnit& cu) {
+  if (!cu.func) return;
+  std::cout << "func " << cu.func->name << " () {\n";
+  const auto& body = cu.func->body;
+  if (!body) {
+    std::cout << "}\n";
+    return;
+  }
+  for (const auto& decl : body->varDecls) {
+    PrintIndent(1);
+    std::cout << "var " << decl->name;
+    if (decl->init) {
+      std::cout << " = ";
+      PrintExpr(decl->init.get());
+    }
+    std::cout << ";\n";
+  }
+  for (const auto& stmt : body->stmts) {
+    if (auto ret = dynamic_cast<ReturnStmt*>(stmt.get())) {
+      PrintIndent(1);
+      std::cout << "return ";
+      PrintExpr(ret->value.get());
+      std::cout << ";\n";
+    }
+  }
+  std::cout << "}\n";
+}
+
+}  // namespace ast

src/frontend/AntlrDriver.cpp

@@ -1,5 +1,34 @@
-// 前端解析驱动：
+// 调用 ANTLR 生成的 Lexer/Parser，返回 parse tree。
-// - 读取源代码
+#include "frontend/AntlrDriver.h"
-// - 调用 ANTLR 生成的 lexer/parser 得到 parse tree
-// - 对外提供“可用的解析入口”（语法正确性由测试保证）
 
+#include <fstream>
+#include <sstream>
+#include <stdexcept>
+
+#include "SysYLexer.h"
+#include "SysYParser.h"
+#include "antlr4-runtime.h"
+
+AntlrResult ParseFileWithAntlr(const std::string& path) {
+  std::ifstream fin(path);
+  if (!fin.is_open()) {
+    throw std::runtime_error("无法打开输入文件: " + path);
+  }
+  std::ostringstream ss;
+  ss << fin.rdbuf();
+
+  auto input = std::make_unique<antlr4::ANTLRInputStream>(ss.str());
+  auto lexer = std::make_unique<SysYLexer>(input.get());
+  auto tokens = std::make_unique<antlr4::CommonTokenStream>(lexer.get());
+  auto parser = std::make_unique<SysYParser>(tokens.get());
+  parser->removeErrorListeners();
+  auto tree = parser->compUnit();
+
+  AntlrResult result;
+  result.input = std::move(input);
+  result.lexer = std::move(lexer);
+  result.tokens = std::move(tokens);
+  result.parser = std::move(parser);
+  result.tree = tree;
+  return result;
+}

src/frontend/AntlrDriver.h

@@ -0,0 +1,20 @@
+// 包装 ANTLR4，提供简易的解析入口。
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "SysYLexer.h"
+#include "SysYParser.h"
+#include "antlr4-runtime.h"
+
+struct AntlrResult {
+  std::unique_ptr<antlr4::ANTLRInputStream> input;
+  std::unique_ptr<SysYLexer> lexer;
+  std::unique_ptr<antlr4::CommonTokenStream> tokens;
+  std::unique_ptr<SysYParser> parser;
+  antlr4::tree::ParseTree* tree = nullptr;  // owned by parser
+};
+
+// 解析指定文件，发生错误时抛出 std::runtime_error。
+AntlrResult ParseFileWithAntlr(const std::string& path);

src/frontend/AstBuilder.cpp

@@ -1,4 +1,114 @@
-// AST 构建：
+// 将 parse tree 转换为 AST。
-// - 将 ANTLR parse tree 转换为 AST（对应 src/ast/*）
+#include "frontend/AstBuilder.h"
-// - 在 AST 节点上保留必要的定位信息（可选，用于调试/日志）
 
+#include <any>
+#include <stdexcept>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "SysYBaseVisitor.h"
+#include "SysYParser.h"
+#include "ast/AstNodes.h"
+#include "antlr4-runtime.h"
+
+namespace {
+
+using ast::BinaryExpr;
+using ast::BinaryOp;
+using ast::Block;
+using ast::CompUnit;
+using ast::FuncDef;
+using ast::NumberExpr;
+using ast::ReturnStmt;
+using ast::VarDecl;
+using ast::VarExpr;
+
+template <typename T>
+T Take(std::any&& value) {
+  if (auto* ptr = std::any_cast<T>(&value)) {
+    return std::move(*ptr);
+  }
+  throw std::runtime_error("AST 构建失败：类型不匹配");
+}
+
+class Builder : public SysYBaseVisitor {
+ public:
+  std::any visitCompUnit(SysYParser::CompUnitContext* ctx) override {
+    auto func = Take<std::shared_ptr<FuncDef>>(visit(ctx->funcDef()));
+    return std::make_shared<CompUnit>(std::move(func));
+  }
+
+  std::any visitFuncDef(SysYParser::FuncDefContext* ctx) override {
+    auto body = Take<std::shared_ptr<Block>>(visit(ctx->block()));
+    return std::make_shared<FuncDef>("main", std::move(body));
+  }
+
+  std::any visitBlock(SysYParser::BlockContext* ctx) override {
+    auto block = std::make_shared<Block>();
+    for (auto stmtCtx : ctx->stmt()) {
+      if (stmtCtx->varDecl()) {
+        block->varDecls.emplace_back(
+            Take<std::shared_ptr<VarDecl>>(visit(stmtCtx->varDecl())));
+      } else if (stmtCtx->returnStmt()) {
+        block->stmts.emplace_back(
+            Take<std::shared_ptr<ReturnStmt>>(visit(stmtCtx->returnStmt())));
+      }
+    }
+    return block;
+  }
+
+  std::any visitVarDecl(SysYParser::VarDeclContext* ctx) override {
+    std::shared_ptr<ast::Expr> init;
+    if (ctx->exp()) {
+      init = Take<std::shared_ptr<ast::Expr>>(visit(ctx->exp()));
+    }
+    return std::make_shared<VarDecl>(ctx->Ident()->getText(), std::move(init));
+  }
+
+  std::any visitReturnStmt(SysYParser::ReturnStmtContext* ctx) override {
+    auto expr = Take<std::shared_ptr<ast::Expr>>(visit(ctx->exp()));
+    return std::make_shared<ReturnStmt>(std::move(expr));
+  }
+
+  std::any visitExp(SysYParser::ExpContext* ctx) override {
+    return visit(ctx->addExp());
+  }
+
+  std::any visitAddExp(SysYParser::AddExpContext* ctx) override {
+    auto node = Take<std::shared_ptr<ast::Expr>>(visit(ctx->primary(0)));
+    for (size_t i = 1; i < ctx->primary().size(); ++i) {
+      auto rhs = Take<std::shared_ptr<ast::Expr>>(visit(ctx->primary(i)));
+      auto opToken = ctx->AddOp(i - 1);
+      BinaryOp op = BinaryOp::Add;
+      if (opToken->getText() == "-") op = BinaryOp::Sub;
+      node = std::make_shared<BinaryExpr>(op, std::move(node), std::move(rhs));
+    }
+    return node;
+  }
+
+  std::any visitPrimary(SysYParser::PrimaryContext* ctx) override {
+    if (ctx->Number()) {
+      std::shared_ptr<ast::Expr> expr =
+          std::make_shared<NumberExpr>(std::stoi(ctx->Number()->getText()));
+      return expr;
+    }
+    if (ctx->Ident()) {
+      std::shared_ptr<ast::Expr> expr =
+          std::make_shared<VarExpr>(ctx->Ident()->getText());
+      return expr;
+    }
+    return visit(ctx->exp());
+  }
+};
+
+}  // namespace
+
+std::shared_ptr<ast::CompUnit> BuildAst(antlr4::tree::ParseTree* tree) {
+  if (!tree) {
+    throw std::runtime_error("parse tree 为空");
+  }
+  Builder visitor;
+  auto result = visitor.visit(tree);
+  return Take<std::shared_ptr<ast::CompUnit>>(std::move(result));
+}

src/frontend/AstBuilder.h

@@ -0,0 +1,16 @@
+// 将 ANTLR parse tree 转换为内部 AST。
+#pragma once
+
+#include <memory>
+
+namespace antlr4 {
+namespace tree {
+class ParseTree;
+}
+}  // namespace antlr4
+
+namespace ast {
+struct CompUnit;
+}
+
+std::shared_ptr<ast::CompUnit> BuildAst(antlr4::tree::ParseTree* tree);

src/ir/BasicBlock.cpp

@@ -1,4 +1 @@
-// IR 基本块：
+#include "ir/IR.h"
-// - 保存指令序列
-// - 维护或可计算前驱/后继关系，用于 CFG 分析与优化
-

src/ir/Context.cpp

@@ -1,4 +1 @@
-// IR 上下文：
+#include "ir/IR.h"
-// - 管理类型与常量的创建/复用
-// - 保存字符串常量、符号等公共资源（按需要扩展）
-

src/ir/Function.cpp

@@ -1,4 +1,15 @@
-// IR Function：
+#include "ir/IR.h"
-// - 保存参数列表、基本块列表
-// - 记录函数属性/元信息（按需要扩展）
 
+namespace ir {
+
+Function::Function(std::string name)
+    : Value(Type::Int32(), std::move(name)),
+      entry_(std::make_unique<BasicBlock>("entry")) {}
+
+void Function::EnsureEntry() {
+  if (!entry_) {
+    entry_ = std::make_unique<BasicBlock>("entry");
+  }
+}
+
+}  // namespace ir

src/ir/IR.h

@@ -0,0 +1,144 @@
+// 极简 IR 定义：足以表示 int 返回 a+b。
+#pragma once
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace ir {
+
+class Type {
+ public:
+  enum class Kind { Void, Int32 };
+  explicit Type(Kind k) : kind_(k) {}
+  Kind kind() const { return kind_; }
+  static std::shared_ptr<Type> Void();
+  static std::shared_ptr<Type> Int32();
+
+ private:
+  Kind kind_;
+};
+
+class Value {
+ public:
+  Value(std::shared_ptr<Type> ty, std::string name)
+      : type_(std::move(ty)), name_(std::move(name)) {}
+  virtual ~Value() = default;
+  const std::shared_ptr<Type>& type() const { return type_; }
+  const std::string& name() const { return name_; }
+  void set_name(std::string n) { name_ = std::move(n); }
+
+ protected:
+  std::shared_ptr<Type> type_;
+  std::string name_;
+};
+
+class ConstantInt : public Value {
+ public:
+  explicit ConstantInt(int v);
+  int value() const { return value_; }
+
+ private:
+  int value_{};
+};
+
+enum class Opcode { Add, Sub, Mul, Div, Ret };
+
+class Instruction : public Value {
+ public:
+  Instruction(Opcode op, std::shared_ptr<Type> ty, std::string name = "")
+      : Value(std::move(ty), std::move(name)), opcode_(op) {}
+  Opcode opcode() const { return opcode_; }
+
+ private:
+  Opcode opcode_;
+};
+
+class BinaryInst : public Instruction {
+ public:
+  BinaryInst(Opcode op, std::shared_ptr<Type> ty, Value* lhs, Value* rhs,
+             std::string name);
+  Value* lhs() const { return lhs_; }
+  Value* rhs() const { return rhs_; }
+
+ private:
+  Value* lhs_;
+  Value* rhs_;
+};
+
+class ReturnInst : public Instruction {
+ public:
+  explicit ReturnInst(Value* val);
+  Value* value() const { return value_; }
+
+ private:
+  Value* value_;
+};
+
+class BasicBlock {
+ public:
+  explicit BasicBlock(std::string name) : name_(std::move(name)) {}
+  const std::string& name() const { return name_; }
+  const std::vector<std::unique_ptr<Instruction>>& instructions() const {
+    return instructions_;
+  }
+  template <typename T, typename... Args>
+  T* Append(Args&&... args) {
+    auto inst = std::make_unique<T>(std::forward<Args>(args)...);
+    auto* ptr = inst.get();
+    instructions_.push_back(std::move(inst));
+    return ptr;
+  }
+
+ private:
+  std::string name_;
+  std::vector<std::unique_ptr<Instruction>> instructions_;
+};
+
+class Function : public Value {
+ public:
+  explicit Function(std::string name);
+  BasicBlock* entry() { return entry_.get(); }
+  const BasicBlock* entry() const { return entry_.get(); }
+  void EnsureEntry();
+
+ private:
+  std::unique_ptr<BasicBlock> entry_;
+};
+
+class Module {
+ public:
+  Function* CreateFunction(const std::string& name);
+  const std::vector<std::unique_ptr<Function>>& functions() const {
+    return functions_;
+  }
+
+ private:
+  std::vector<std::unique_ptr<Function>> functions_;
+};
+
+class IRBuilder {
+ public:
+  explicit IRBuilder(BasicBlock* bb) : insertBlock_(bb) {}
+  void SetInsertPoint(BasicBlock* bb) { insertBlock_ = bb; }
+  BasicBlock* GetInsertBlock() const { return insertBlock_; }
+
+  ConstantInt* CreateConstInt(int v);
+  BinaryInst* CreateBinary(Opcode op, Value* lhs, Value* rhs,
+                           const std::string& name);
+  BinaryInst* CreateAdd(Value* lhs, Value* rhs, const std::string& name) {
+    return CreateBinary(Opcode::Add, lhs, rhs, name);
+  }
+  ReturnInst* CreateRet(Value* v);
+
+ private:
+  BasicBlock* insertBlock_;
+};
+
+class IRPrinter {
+ public:
+  void Print(const Module& module);
+};
+
+}  // namespace ir

src/ir/IRBuilder.cpp

@@ -1,4 +1,19 @@
-// IR 构建工具：
+#include "ir/IR.h"
-// - 管理插入点（当前基本块/位置）
-// - 提供创建各类指令的便捷接口，降低 IRGen 复杂度
 
+namespace ir {
+
+ConstantInt* IRBuilder::CreateConstInt(int v) {
+  // 常量不需要挂在基本块里，直接返回局部对象指针。
+  return new ConstantInt(v);
+}
+
+BinaryInst* IRBuilder::CreateBinary(Opcode op, Value* lhs, Value* rhs,
+                                    const std::string& name) {
+  return insertBlock_->Append<BinaryInst>(op, Type::Int32(), lhs, rhs, name);
+}
+
+ReturnInst* IRBuilder::CreateRet(Value* v) {
+  return insertBlock_->Append<ReturnInst>(v);
+}
+
+}  // namespace ir

src/ir/IRPrinter.cpp

@@ -1,4 +1,55 @@
-// IR 文本输出：
+#include "ir/IR.h"
-// - 将 IR 打印为 .ll 风格的文本
-// - 支撑调试与测试对比（diff）
 
+#include <iostream>
+
+namespace ir {
+
+static const char* OpcodeToString(Opcode op) {
+  switch (op) {
+    case Opcode::Add:
+      return "add";
+    case Opcode::Sub:
+      return "sub";
+    case Opcode::Mul:
+      return "mul";
+    case Opcode::Div:
+      return "div";
+    case Opcode::Ret:
+      return "ret";
+  }
+  return "?";
+}
+
+void IRPrinter::Print(const Module& module) {
+  for (const auto& func : module.functions()) {
+    std::cout << "define i32 @" << func->name() << "() {\n";
+    const auto* bb = func->entry();
+    if (!bb) {
+      std::cout << "}\n";
+      continue;
+    }
+    for (const auto& instPtr : bb->instructions()) {
+      const auto* inst = instPtr.get();
+      switch (inst->opcode()) {
+        case Opcode::Add:
+        case Opcode::Sub:
+        case Opcode::Mul:
+        case Opcode::Div: {
+          auto* bin = static_cast<const BinaryInst*>(inst);
+          std::cout << "  " << bin->name() << " = " << OpcodeToString(bin->opcode())
+                    << " " << bin->lhs()->name() << ", " << bin->rhs()->name()
+                    << "\n";
+          break;
+        }
+        case Opcode::Ret: {
+          auto* ret = static_cast<const ReturnInst*>(inst);
+          std::cout << "  ret " << ret->value()->name() << "\n";
+          break;
+        }
+      }
+    }
+    std::cout << "}\n";
+  }
+}
+
+}  // namespace ir

src/ir/Instruction.cpp

@@ -1,4 +1,12 @@
-// IR 指令体系：
+#include "ir/IR.h"
-// - 二元运算/比较、load/store、call、br/condbr、ret、phi、alloca 等
-// - 指令操作数与结果类型管理，支持打印与优化
 
+namespace ir {
+
+BinaryInst::BinaryInst(Opcode op, std::shared_ptr<Type> ty, Value* lhs,
+                       Value* rhs, std::string name)
+    : Instruction(op, std::move(ty), std::move(name)), lhs_(lhs), rhs_(rhs) {}
+
+ReturnInst::ReturnInst(Value* val)
+    : Instruction(Opcode::Ret, Type::Void(), ""), value_(val) {}
+
+}  // namespace ir

src/ir/Module.cpp

@@ -1,4 +1,10 @@
-// IR Module：
+#include "ir/IR.h"
-// - 保存全局变量与函数列表
-// - 维护与目标相关的模块级信息（如需要）与符号表
 
+namespace ir {
+
+Function* Module::CreateFunction(const std::string& name) {
+  functions_.push_back(std::make_unique<Function>(name));
+  return functions_.back().get();
+}
+
+}  // namespace ir

src/ir/Type.cpp

@@ -1,4 +1,16 @@
-// IR 类型系统：
+// 极简类型系统：仅支持 void 与 i32。
-// - i32/f32/void、指针、数组、函数类型等
+#include "ir/IR.h"
-// - 按 SysY 支持范围裁剪并逐步补齐
 
+namespace ir {
+
+std::shared_ptr<Type> Type::Void() {
+  static auto ty = std::make_shared<Type>(Kind::Void);
+  return ty;
+}
+
+std::shared_ptr<Type> Type::Int32() {
+  static auto ty = std::make_shared<Type>(Kind::Int32);
+  return ty;
+}
+
+}  // namespace ir

src/ir/Value.cpp

@@ -1,4 +1,9 @@
-// SSA 值体系抽象：
+#include "ir/IR.h"
-// - 常量、参数、指令结果等统一为 Value
-// - 提供类型信息与使用/被使用关系（按需要实现）
 
+namespace ir {
+
+ConstantInt::ConstantInt(int v) : Value(Type::Int32(), ""), value_(v) {
+  set_name(std::to_string(v));
+}
+
+}  // namespace ir

src/ir/analysis/DominatorTree.cpp

@@ -1,4 +1 @@
-// 支配树分析：
+#include <vector>
-// - 构建/查询 Dominator Tree 及相关关系
-// - 为 mem2reg、CFG 优化与循环分析提供基础能力
-

src/ir/analysis/LoopInfo.cpp

@@ -1,4 +1 @@
-// 循环分析：
+#include <vector>
-// - 识别循环结构与层级关系
-// - 为后续优化（可选）提供循环信息
-

src/ir/passes/CFGSimplify.cpp

@@ -1,4 +1 @@
-// CFG 简化：
+#include <vector>
-// - 删除不可达块、合并空块、简化分支等
-// - 改善 IR 结构，便于后续优化与后端生成
-

src/ir/passes/ConstFold.cpp

@@ -1,4 +1 @@
-// IR 常量折叠：
+#include <vector>
-// - 折叠可判定的常量表达式
-// - 简化常量控制流分支（按实现范围裁剪）
-

src/ir/passes/DCE.cpp

@@ -1,4 +1 @@
-// 死代码删除（DCE）：
+#include <vector>
-// - 删除无用指令与无用基本块
-// - 通常与 CFG 简化配合使用
-

src/ir/passes/Mem2Reg.cpp

@@ -1,4 +1 @@
-// Mem2Reg（SSA 构造）：
+#include <vector>
-// - 将局部变量的 alloca/load/store 提升为 SSA 形式
-// - 插入 PHI 并重写使用，依赖支配树等分析
-

src/ir/passes/PassManager.cpp

@@ -1,4 +1 @@
-// IR Pass 管理：
+#include <vector>
-// - 按优化级别组织优化 pipeline
-// - 统一运行 pass、统计与调试输出（按需要扩展）
-

src/irgen/IRGen.h

@@ -0,0 +1,14 @@
+// 将 AST 翻译为极简 IR。
+#pragma once
+
+#include <memory>
+
+namespace ast {
+struct CompUnit;
+}
+
+namespace ir {
+class Module;
+}
+
+std::unique_ptr<ir::Module> GenerateIR(const ast::CompUnit& ast);

src/irgen/IRGenDecl.cpp

@@ -1,4 +1 @@
-// 声明翻译模块：
+#include "irgen/IRGen.h"
-// - 处理全局变量与局部变量声明
-// - 处理数组初始化、空间分配与初值生成等
-

src/irgen/IRGenDriver.cpp

@@ -1,4 +1,95 @@
-// IR 生成驱动（Driver）：
+#include "irgen/IRGen.h"
-// - 驱动 Visitor 遍历 AST，调度各子模块完成翻译
+
-// - 统一管理模块级翻译入口与上下文（Module/IRBuilder 等）
+#include <memory>
-// - 组织函数/语句/表达式/声明等翻译流程
+#include <stdexcept>
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include "ast/AstNodes.h"
+#include "ir/IR.h"
+
+namespace {
+
+class IRGenImpl {
+ public:
+  explicit IRGenImpl(ir::Module& module)
+      : module_(module),
+        func_(module_.CreateFunction("main")),
+        builder_(func_->entry()) {}
+
+  void Gen(const ast::CompUnit& ast) {
+    if (!ast.func || !ast.func->body) {
+      throw std::runtime_error("AST 不完整：缺少 main 定义");
+    }
+    GenBlock(*ast.func->body);
+  }
+
+  std::unique_ptr<ir::Module> TakeModule() {
+    return std::make_unique<ir::Module>(std::move(module_));
+  }
+
+ private:
+  void GenBlock(const ast::Block& block) {
+    for (const auto& decl : block.varDecls) {
+      ir::Value* init = nullptr;
+      if (decl->init) {
+        init = GenExpr(*decl->init);
+      } else {
+        const_pool_.push_back(std::make_unique<ir::ConstantInt>(0));
+        init = const_pool_.back().get();
+      }
+      locals_[decl->name] = init;
+    }
+    for (const auto& stmt : block.stmts) {
+      if (auto ret = dynamic_cast<ast::ReturnStmt*>(stmt.get())) {
+        ir::Value* v = GenExpr(*ret->value);
+        builder_.CreateRet(v);
+      }
+    }
+  }
+
+  ir::Value* GenExpr(const ast::Expr& expr) {
+    if (auto num = dynamic_cast<const ast::NumberExpr*>(&expr)) {
+      const_pool_.push_back(std::make_unique<ir::ConstantInt>(num->value));
+      return const_pool_.back().get();
+    }
+    if (auto var = dynamic_cast<const ast::VarExpr*>(&expr)) {
+      auto it = locals_.find(var->name);
+      if (it == locals_.end()) {
+        throw std::runtime_error("变量未找到: " + var->name);
+      }
+      return it->second;
+    }
+    if (auto bin = dynamic_cast<const ast::BinaryExpr*>(&expr)) {
+      auto* lhs = GenExpr(*bin->lhs);
+      auto* rhs = GenExpr(*bin->rhs);
+      std::string name = "%t" + std::to_string(temp_index_++);
+      if (bin->op == ast::BinaryOp::Add) {
+        return builder_.CreateBinary(ir::Opcode::Add, lhs, rhs, name);
+      }
+      if (bin->op == ast::BinaryOp::Sub) {
+        // 当前子集只需要加法，减法复用 add 但保留分支，便于扩展
+        return builder_.CreateBinary(ir::Opcode::Add, lhs, rhs, name);
+      }
+    }
+    throw std::runtime_error("不支持的表达式类型");
+  }
+
+  ir::Module& module_;
+  ir::Function* func_;
+  ir::IRBuilder builder_;
+  std::unordered_map<std::string, ir::Value*> locals_;
+  std::vector<std::unique_ptr<ir::ConstantInt>> const_pool_;
+  int temp_index_ = 0;
+};
+
+}  // namespace
+
+std::unique_ptr<ir::Module> GenerateIR(const ast::CompUnit& ast) {
+  auto module = std::make_unique<ir::Module>();
+  IRGenImpl gen(*module);
+  gen.Gen(ast);
+  return module;
+}

src/irgen/IRGenExp.cpp

@@ -1,4 +1 @@
-// 表达式翻译模块：
+#include "irgen/IRGen.h"
-// - 处理算术运算、比较、逻辑运算、函数调用等表达式
-// - 生成对应的 IR 指令并返回 SSA 值
-

src/irgen/IRGenFunc.cpp

@@ -1,4 +1 @@
-// 函数翻译模块：
+#include "irgen/IRGen.h"
-// - 处理函数定义、参数列表与返回值翻译
-// - 创建并填充对应的 IR Function 对象
-

src/irgen/IRGenStmt.cpp

@@ -1,4 +1 @@
-// 语句翻译模块：
+#include "irgen/IRGen.h"
-// - 处理 if/while/return 等控制流构造
-// - 负责基本块创建、分支跳转与控制流收束
-

src/main.cpp

@@ -1,30 +1,29 @@
+#include <exception>
 #include <iostream>
-#include <string>
 
-static void PrintUsage(const char* argv0) {
+#include "frontend/AntlrDriver.h"
-  std::cerr << "用法: " << (argv0 ? argv0 : "compiler") << " <input.sy> [options]\n";
+#include "frontend/AstBuilder.h"
-  std::cerr << "说明: 当前为工程骨架阶段，暂不执行完整编译流程，仅用于验证可编译/可链接。\n";
+#include "ir/IR.h"
-}
+#include "irgen/IRGen.h"
+#include "sem/Sema.h"
+#include "utils/CLI.h"
+#include "utils/Log.h"
+#include "ast/AstNodes.h"
 
 int main(int argc, char** argv) {
-  if (argc <= 1) {
+  try {
-    PrintUsage(argv[0]);
+    auto opts = ParseCLI(argc, argv);
-    return 0;
+    auto antlr = ParseFileWithAntlr(opts.input);
+    auto ast = BuildAst(antlr.tree);
+    ast::PrintAST(*ast);  // 调试 AST
+    ast = RunSema(std::move(ast));
+    auto module = GenerateIR(*ast);
+
+    ir::IRPrinter printer;
+    printer.Print(*module);
+  } catch (const std::exception& ex) {
+    LOG_ERROR(ex.what());
+    return 1;
   }
-
-  std::string input_path = argv[1];
-  if (input_path == "-h" || input_path == "--help") {
-    PrintUsage(argv[0]);
-    return 0;
-  }
-
-  // TODO: 后续在此接入完整流水线：
-  // 1) frontend: ANTLR 解析 + AST 构建
-  // 2) sem: 语义分析
-  // 3) irgen: AST -> IR
-  // 4) ir passes: 可选优化
-  // 5) mir/backend: AArch64 指令选择、寄存器分配、栈帧、汇编输出
-  (void)input_path;
-
   return 0;
 }

src/sem/ConstEval.cpp

@@ -1,4 +1 @@
-// 常量求值：
+#include <optional>
-// - 处理数组维度、全局初始化、const 表达式等编译期可计算场景
-// - 为语义分析与 IR 生成提供常量折叠/常量值信息
-

src/sem/Sema.cpp

@@ -1,5 +1,52 @@
-// 语义分析主流程：
+// 极简语义分析：只检查变量是否先声明再使用。
-// - 符号解析与绑定、类型检查、控制流规则检查
+#include "sem/Sema.h"
-// - 记录/插入必要的隐式转换（或在节点上标注）
-// - 输出为“带类型 / 符号 / 常量信息”的 AST
 
+#include <stdexcept>
+#include <string>
+#include <unordered_set>
+
+#include "ast/AstNodes.h"
+#include "sem/SymbolTable.h"
+
+namespace {
+
+class SemaVisitor {
+ public:
+  explicit SemaVisitor(SymbolTable& table) : table_(table) {}
+
+  void CheckBlock(const ast::Block& block) {
+    for (const auto& decl : block.varDecls) {
+      table_.Add(decl->name);
+      if (decl->init) CheckExpr(*decl->init);
+    }
+    for (const auto& stmt : block.stmts) {
+      if (auto ret = dynamic_cast<ast::ReturnStmt*>(stmt.get())) {
+        CheckExpr(*ret->value);
+      }
+    }
+  }
+
+  void CheckExpr(const ast::Expr& expr) {
+    if (auto var = dynamic_cast<const ast::VarExpr*>(&expr)) {
+      if (!table_.Contains(var->name)) {
+        throw std::runtime_error("使用了未定义的变量: " + var->name);
+      }
+    } else if (auto bin = dynamic_cast<const ast::BinaryExpr*>(&expr)) {
+      CheckExpr(*bin->lhs);
+      CheckExpr(*bin->rhs);
+    }
+  }
+
+ private:
+  SymbolTable& table_;
+};
+
+}  // namespace
+
+std::shared_ptr<ast::CompUnit> RunSema(std::shared_ptr<ast::CompUnit> ast) {
+  if (!ast || !ast->func || !ast->func->body) return ast;
+  SymbolTable table;
+  SemaVisitor visitor(table);
+  visitor.CheckBlock(*ast->func->body);
+  return ast;
+}

src/sem/Sema.h

@@ -0,0 +1,11 @@
+// 语义检查（极简版）。
+#pragma once
+
+#include <memory>
+
+namespace ast {
+struct CompUnit;
+}
+
+// 返回经过检查的 AST（当前直接返回原 AST）。
+std::shared_ptr<ast::CompUnit> RunSema(std::shared_ptr<ast::CompUnit> ast);

src/sem/SymbolTable.cpp

@@ -1,4 +1 @@
-// 符号表与作用域管理：
+#include "sem/SymbolTable.h"
-// - 支持嵌套作用域（块/函数/全局）
-// - 变量/函数/参数/常量的注册、查找与遮蔽规则
-

src/sem/SymbolTable.h

@@ -0,0 +1,16 @@
+// 极简符号表：记录局部变量是否定义。
+#pragma once
+
+#include <string>
+#include <unordered_map>
+
+class SymbolTable {
+ public:
+  void Add(const std::string& name) { table_[name] = true; }
+  bool Contains(const std::string& name) const {
+    return table_.find(name) != table_.end();
+  }
+
+ private:
+  std::unordered_map<std::string, bool> table_;
+};

src/utils/CLI.cpp

@@ -1,5 +1,12 @@
-// 命令行参数解析：
+#include "utils/CLI.h"
-// - 解析输入/输出路径
-// - 解析输出类型（IR/MIR/ASM）与优化级别等选项
-// - 将参数传递给 main.cpp 的编译流水线驱动
 
+#include <stdexcept>
+
+CLIOptions ParseCLI(int argc, char** argv) {
+  if (argc <= 1) {
+    throw std::runtime_error("用法: compiler <input.sy>");
+  }
+  CLIOptions opt;
+  opt.input = argv[1];
+  return opt;
+}

src/utils/CLI.h

@@ -0,0 +1,10 @@
+// 简易命令行解析：仅支持输入文件路径。
+#pragma once
+
+#include <string>
+
+struct CLIOptions {
+  std::string input;
+};
+
+CLIOptions ParseCLI(int argc, char** argv);

src/utils/Log.cpp

@@ -1,4 +1 @@
-// 日志模块：
+#include "utils/Log.h"
-// - 统一输出调试信息、阶段信息与错误信息
-// - 提供可配置的日志级别与输出位置（按需要实现）
-

src/utils/Log.h

@@ -0,0 +1,7 @@
+// 轻量日志接口。
+#pragma once
+
+#include <iostream>
+
+#define LOG_INFO(msg) std::cerr << "[info] " << msg << "\n"
+#define LOG_ERROR(msg) std::cerr << "[error] " << msg << "\n"

test/test_case/simple_add.sy

@@ -0,0 +1,5 @@
+int main() {
+  int a = 1;
+  int b = 2;
+  return a + b;
+}