irgen实现

CMakeLists.txt

@@ -1,3 +1,4 @@
+include_directories(${PROJECT_SOURCE_DIR}/src/antlr4)
 cmake_minimum_required(VERSION 3.20)
 
 project(compiler LANGUAGES C CXX)

include/frontend/AntlrDriver.h

@@ -4,8 +4,8 @@
 #include <memory>
 #include <string>
 
-#include "SysYLexer.h"
+#include "antlr4/SysYLexer.h"
-#include "SysYParser.h"
+#include "antlr4/SysYParser.h"
 #include "antlr4-runtime.h"
 
 struct AntlrResult {

include/irgen/IRGen.h

@@ -6,13 +6,18 @@
 #include <any>
 #include <memory>
 #include <string>
+#include <vector>
 #include <unordered_map>
 
-#include "SysYBaseVisitor.h"
+#include "antlr4/SysYBaseVisitor.h"
-#include "SysYParser.h"
+#include "antlr4/SysYParser.h"
 #include "ir/IR.h"
 #include "sem/Sema.h"
 
+// 前向声明：语义层可能在未来提供更明确的符号类型，用于把符号唯一标识映射到 IR 对象。
+struct SemanticVarSymbol;
+struct SemanticFuncSymbol;
+
 namespace ir {
 class Module;
 class Function;
@@ -46,6 +51,10 @@ class IRGenImpl final : public SysYBaseVisitor {
   std::any visitLAndExp(SysYParser::LAndExpContext* ctx) override;
   std::any visitLOrExp(SysYParser::LOrExpContext* ctx) override;
 
+  // 辅助接口：数组下标地址计算与全局变量生成
+  ir::Value* EmitArrayIndex(ir::Value* base_ptr, SysYParser::ExpContext* idx_expr);
+  void EmitGlobalVariable(SysYParser::VarDefContext* ctx);
+
  private:
   enum class BlockFlow {
     Continue,
@@ -61,14 +70,28 @@ class IRGenImpl final : public SysYBaseVisitor {
   ir::Value* EvalExpr(SysYParser::ExpContext& expr);
   ir::Value* EvalCond(SysYParser::CondContext& cond);
   ir::Value* ToBoolValue(ir::Value* v);
+  ir::Value* FindInScope(const std::string& name);
   std::string NextBlockName();
+  ir::Function* FindFunctionByName(const std::string& name);
+  ir::Value* ResolveLValueAddress(SysYParser::LValueContext* ctx);
 
   ir::Module& module_;
   const SemanticContext& sema_;
   ir::Function* func_;
   ir::IRBuilder builder_;
+  bool in_function_ = false;
+
+  // 当前函数的参数对应的栈槽位（在函数入口处为每个形参分配的 alloca）
+  std::vector<ir::Value*> param_slots_;
+  // 将 Sema 提供的变量符号映射到对应的存储槽位（避免仅按名字查找）
+  std::unordered_map<const SemanticVarSymbol*, ir::Value*> symbol_storage_map_;
+  // 将 Sema 提供的函数符号映射到已创建的 IR 函数对象
+  std::unordered_map<const SemanticFuncSymbol*, ir::Function*> func_symbol_map_;
+  // 作用域栈：每个作用域维护一个从名称到存储槽位的映射
+  std::vector<std::unordered_map<std::string, ir::Value*>> scope_storage_;
   // 名称绑定由 Sema 负责；IRGen 只维护“声明 -> 存储槽位”的代码生成状态。
   std::unordered_map<SysYParser::VarDefContext*, ir::Value*> storage_map_;
+  // 保留按名字的映射以兼容现有代码路径，但优先使用 symbol_storage_map_
   std::unordered_map<std::string, ir::Value*> named_storage_;
   std::vector<LoopTargets> loop_stack_;
 };

include/sem/Sema.h

@@ -2,8 +2,8 @@
 #define SEMANTIC_ANALYSIS_H
 
 #include "SymbolTable.h"
-#include "SysYBaseVisitor.h"
+#include "antlr4/SysYBaseVisitor.h"
-#include "SysYParser.h"
+#include "antlr4/SysYParser.h"
 #include <vector>
 #include <string>
 #include <sstream>

src/antlr4/SysYBaseVisitor.cpp

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

src/antlr4/SysYBaseVisitor.h

@@ -0,0 +1,148 @@
+
+// Generated from SysY.g4 by ANTLR 4.13.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 std::any visitCompUnit(SysYParser::CompUnitContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitDecl(SysYParser::DeclContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitConstDecl(SysYParser::ConstDeclContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitConstDef(SysYParser::ConstDefContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitConstInitValue(SysYParser::ConstInitValueContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitVarDecl(SysYParser::VarDeclContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitBtype(SysYParser::BtypeContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitVarDef(SysYParser::VarDefContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitInitValue(SysYParser::InitValueContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitFuncDef(SysYParser::FuncDefContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitFuncType(SysYParser::FuncTypeContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitFuncFParams(SysYParser::FuncFParamsContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitFuncFParam(SysYParser::FuncFParamContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitBlockStmt(SysYParser::BlockStmtContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitBlockItem(SysYParser::BlockItemContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitStmt(SysYParser::StmtContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitReturnStmt(SysYParser::ReturnStmtContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitExp(SysYParser::ExpContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitCond(SysYParser::CondContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitLValue(SysYParser::LValueContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitPrimaryExp(SysYParser::PrimaryExpContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitNumber(SysYParser::NumberContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitUnaryExp(SysYParser::UnaryExpContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitUnaryOp(SysYParser::UnaryOpContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitFuncRParams(SysYParser::FuncRParamsContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitMulExp(SysYParser::MulExpContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitAddExp(SysYParser::AddExpContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitRelExp(SysYParser::RelExpContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitEqExp(SysYParser::EqExpContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitLAndExp(SysYParser::LAndExpContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitLOrExp(SysYParser::LOrExpContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitConstExp(SysYParser::ConstExpContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+
+};
+

src/antlr4/SysYLexer.cpp

@@ -0,0 +1,271 @@
+
+// Generated from SysY.g4 by ANTLR 4.13.2
+
+
+#include "SysYLexer.h"
+
+
+using namespace antlr4;
+
+
+
+using namespace antlr4;
+
+namespace {
+
+struct SysYLexerStaticData final {
+  SysYLexerStaticData(std::vector<std::string> ruleNames,
+                          std::vector<std::string> channelNames,
+                          std::vector<std::string> modeNames,
+                          std::vector<std::string> literalNames,
+                          std::vector<std::string> symbolicNames)
+      : ruleNames(std::move(ruleNames)), channelNames(std::move(channelNames)),
+        modeNames(std::move(modeNames)), literalNames(std::move(literalNames)),
+        symbolicNames(std::move(symbolicNames)),
+        vocabulary(this->literalNames, this->symbolicNames) {}
+
+  SysYLexerStaticData(const SysYLexerStaticData&) = delete;
+  SysYLexerStaticData(SysYLexerStaticData&&) = delete;
+  SysYLexerStaticData& operator=(const SysYLexerStaticData&) = delete;
+  SysYLexerStaticData& operator=(SysYLexerStaticData&&) = delete;
+
+  std::vector<antlr4::dfa::DFA> decisionToDFA;
+  antlr4::atn::PredictionContextCache sharedContextCache;
+  const std::vector<std::string> ruleNames;
+  const std::vector<std::string> channelNames;
+  const std::vector<std::string> modeNames;
+  const std::vector<std::string> literalNames;
+  const std::vector<std::string> symbolicNames;
+  const antlr4::dfa::Vocabulary vocabulary;
+  antlr4::atn::SerializedATNView serializedATN;
+  std::unique_ptr<antlr4::atn::ATN> atn;
+};
+
+::antlr4::internal::OnceFlag sysylexerLexerOnceFlag;
+#if ANTLR4_USE_THREAD_LOCAL_CACHE
+static thread_local
+#endif
+std::unique_ptr<SysYLexerStaticData> sysylexerLexerStaticData = nullptr;
+
+void sysylexerLexerInitialize() {
+#if ANTLR4_USE_THREAD_LOCAL_CACHE
+  if (sysylexerLexerStaticData != nullptr) {
+    return;
+  }
+#else
+  assert(sysylexerLexerStaticData == nullptr);
+#endif
+  auto staticData = std::make_unique<SysYLexerStaticData>(
+    std::vector<std::string>{
+      "CONST", "INT", "FLOAT", "VOID", "IF", "ELSE", "WHILE", "BREAK", "CONTINUE", 
+      "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", "FLITERAL", 
+      "ILITERAL", "DEC_INT", "OCT_INT", "HEX_INT", "DECIMAL_FLOAT", "HEX_FLOAT", 
+      "EXP", "WS", "LINECOMMENT", "BLOCKCOMMENT"
+    },
+    std::vector<std::string>{
+      "DEFAULT_TOKEN_CHANNEL", "HIDDEN"
+    },
+    std::vector<std::string>{
+      "DEFAULT_MODE"
+    },
+    std::vector<std::string>{
+      "", "'const'", "'int'", "'float'", "'void'", "'if'", "'else'", "'while'", 
+      "'break'", "'continue'", "'return'", "'='", "'=='", "'!='", "'<'", 
+      "'>'", "'<='", "'>='", "'+'", "'-'", "'*'", "'/'", "'%'", "'!'", "'&&'", 
+      "'||'", "'('", "')'", "'['", "']'", "'{'", "'}'", "','", "';'"
+    },
+    std::vector<std::string>{
+      "", "CONST", "INT", "FLOAT", "VOID", "IF", "ELSE", "WHILE", "BREAK", 
+      "CONTINUE", "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", 
+      "FLITERAL", "ILITERAL", "WS", "LINECOMMENT", "BLOCKCOMMENT"
+    }
+  );
+  static const int32_t serializedATNSegment[] = {
+  	4,0,39,353,6,-1,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,7,
+  	6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,7,13,2,14,
+  	7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19,2,20,7,20,2,21,
+  	7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,26,7,26,2,27,7,27,2,28,
+  	7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7,32,2,33,7,33,2,34,7,34,2,35,
+  	7,35,2,36,7,36,2,37,7,37,2,38,7,38,2,39,7,39,2,40,7,40,2,41,7,41,2,42,
+  	7,42,2,43,7,43,2,44,7,44,1,0,1,0,1,0,1,0,1,0,1,0,1,1,1,1,1,1,1,1,1,2,
+  	1,2,1,2,1,2,1,2,1,2,1,3,1,3,1,3,1,3,1,3,1,4,1,4,1,4,1,5,1,5,1,5,1,5,1,
+  	5,1,6,1,6,1,6,1,6,1,6,1,6,1,7,1,7,1,7,1,7,1,7,1,7,1,8,1,8,1,8,1,8,1,8,
+  	1,8,1,8,1,8,1,8,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,10,1,10,1,11,1,11,1,11,
+  	1,12,1,12,1,12,1,13,1,13,1,14,1,14,1,15,1,15,1,15,1,16,1,16,1,16,1,17,
+  	1,17,1,18,1,18,1,19,1,19,1,20,1,20,1,21,1,21,1,22,1,22,1,23,1,23,1,23,
+  	1,24,1,24,1,24,1,25,1,25,1,26,1,26,1,27,1,27,1,28,1,28,1,29,1,29,1,30,
+  	1,30,1,31,1,31,1,32,1,32,1,33,1,33,5,33,203,8,33,10,33,12,33,206,9,33,
+  	1,34,1,34,3,34,210,8,34,1,35,1,35,1,35,3,35,215,8,35,1,36,1,36,1,36,5,
+  	36,220,8,36,10,36,12,36,223,9,36,3,36,225,8,36,1,37,1,37,4,37,229,8,37,
+  	11,37,12,37,230,1,38,1,38,1,38,4,38,236,8,38,11,38,12,38,237,1,39,4,39,
+  	241,8,39,11,39,12,39,242,1,39,1,39,5,39,247,8,39,10,39,12,39,250,9,39,
+  	1,39,3,39,253,8,39,1,39,1,39,4,39,257,8,39,11,39,12,39,258,1,39,3,39,
+  	262,8,39,1,39,4,39,265,8,39,11,39,12,39,266,1,39,3,39,270,8,39,1,40,1,
+  	40,1,40,4,40,275,8,40,11,40,12,40,276,1,40,1,40,5,40,281,8,40,10,40,12,
+  	40,284,9,40,3,40,286,8,40,1,40,1,40,3,40,290,8,40,1,40,4,40,293,8,40,
+  	11,40,12,40,294,1,40,1,40,1,40,1,40,4,40,301,8,40,11,40,12,40,302,1,40,
+  	1,40,3,40,307,8,40,1,40,4,40,310,8,40,11,40,12,40,311,3,40,314,8,40,1,
+  	41,1,41,3,41,318,8,41,1,41,4,41,321,8,41,11,41,12,41,322,1,42,1,42,1,
+  	42,1,42,1,43,1,43,1,43,1,43,5,43,333,8,43,10,43,12,43,336,9,43,1,43,1,
+  	43,1,44,1,44,1,44,1,44,5,44,344,8,44,10,44,12,44,347,9,44,1,44,1,44,1,
+  	44,1,44,1,44,1,345,0,45,1,1,3,2,5,3,7,4,9,5,11,6,13,7,15,8,17,9,19,10,
+  	21,11,23,12,25,13,27,14,29,15,31,16,33,17,35,18,37,19,39,20,41,21,43,
+  	22,45,23,47,24,49,25,51,26,53,27,55,28,57,29,59,30,61,31,63,32,65,33,
+  	67,34,69,35,71,36,73,0,75,0,77,0,79,0,81,0,83,0,85,37,87,38,89,39,1,0,
+  	12,3,0,65,90,95,95,97,122,4,0,48,57,65,90,95,95,97,122,1,0,49,57,1,0,
+  	48,57,1,0,48,55,2,0,88,88,120,120,3,0,48,57,65,70,97,102,2,0,80,80,112,
+  	112,2,0,43,43,45,45,2,0,69,69,101,101,3,0,9,10,13,13,32,32,2,0,10,10,
+  	13,13,375,0,1,1,0,0,0,0,3,1,0,0,0,0,5,1,0,0,0,0,7,1,0,0,0,0,9,1,0,0,0,
+  	0,11,1,0,0,0,0,13,1,0,0,0,0,15,1,0,0,0,0,17,1,0,0,0,0,19,1,0,0,0,0,21,
+  	1,0,0,0,0,23,1,0,0,0,0,25,1,0,0,0,0,27,1,0,0,0,0,29,1,0,0,0,0,31,1,0,
+  	0,0,0,33,1,0,0,0,0,35,1,0,0,0,0,37,1,0,0,0,0,39,1,0,0,0,0,41,1,0,0,0,
+  	0,43,1,0,0,0,0,45,1,0,0,0,0,47,1,0,0,0,0,49,1,0,0,0,0,51,1,0,0,0,0,53,
+  	1,0,0,0,0,55,1,0,0,0,0,57,1,0,0,0,0,59,1,0,0,0,0,61,1,0,0,0,0,63,1,0,
+  	0,0,0,65,1,0,0,0,0,67,1,0,0,0,0,69,1,0,0,0,0,71,1,0,0,0,0,85,1,0,0,0,
+  	0,87,1,0,0,0,0,89,1,0,0,0,1,91,1,0,0,0,3,97,1,0,0,0,5,101,1,0,0,0,7,107,
+  	1,0,0,0,9,112,1,0,0,0,11,115,1,0,0,0,13,120,1,0,0,0,15,126,1,0,0,0,17,
+  	132,1,0,0,0,19,141,1,0,0,0,21,148,1,0,0,0,23,150,1,0,0,0,25,153,1,0,0,
+  	0,27,156,1,0,0,0,29,158,1,0,0,0,31,160,1,0,0,0,33,163,1,0,0,0,35,166,
+  	1,0,0,0,37,168,1,0,0,0,39,170,1,0,0,0,41,172,1,0,0,0,43,174,1,0,0,0,45,
+  	176,1,0,0,0,47,178,1,0,0,0,49,181,1,0,0,0,51,184,1,0,0,0,53,186,1,0,0,
+  	0,55,188,1,0,0,0,57,190,1,0,0,0,59,192,1,0,0,0,61,194,1,0,0,0,63,196,
+  	1,0,0,0,65,198,1,0,0,0,67,200,1,0,0,0,69,209,1,0,0,0,71,214,1,0,0,0,73,
+  	224,1,0,0,0,75,226,1,0,0,0,77,232,1,0,0,0,79,269,1,0,0,0,81,313,1,0,0,
+  	0,83,315,1,0,0,0,85,324,1,0,0,0,87,328,1,0,0,0,89,339,1,0,0,0,91,92,5,
+  	99,0,0,92,93,5,111,0,0,93,94,5,110,0,0,94,95,5,115,0,0,95,96,5,116,0,
+  	0,96,2,1,0,0,0,97,98,5,105,0,0,98,99,5,110,0,0,99,100,5,116,0,0,100,4,
+  	1,0,0,0,101,102,5,102,0,0,102,103,5,108,0,0,103,104,5,111,0,0,104,105,
+  	5,97,0,0,105,106,5,116,0,0,106,6,1,0,0,0,107,108,5,118,0,0,108,109,5,
+  	111,0,0,109,110,5,105,0,0,110,111,5,100,0,0,111,8,1,0,0,0,112,113,5,105,
+  	0,0,113,114,5,102,0,0,114,10,1,0,0,0,115,116,5,101,0,0,116,117,5,108,
+  	0,0,117,118,5,115,0,0,118,119,5,101,0,0,119,12,1,0,0,0,120,121,5,119,
+  	0,0,121,122,5,104,0,0,122,123,5,105,0,0,123,124,5,108,0,0,124,125,5,101,
+  	0,0,125,14,1,0,0,0,126,127,5,98,0,0,127,128,5,114,0,0,128,129,5,101,0,
+  	0,129,130,5,97,0,0,130,131,5,107,0,0,131,16,1,0,0,0,132,133,5,99,0,0,
+  	133,134,5,111,0,0,134,135,5,110,0,0,135,136,5,116,0,0,136,137,5,105,0,
+  	0,137,138,5,110,0,0,138,139,5,117,0,0,139,140,5,101,0,0,140,18,1,0,0,
+  	0,141,142,5,114,0,0,142,143,5,101,0,0,143,144,5,116,0,0,144,145,5,117,
+  	0,0,145,146,5,114,0,0,146,147,5,110,0,0,147,20,1,0,0,0,148,149,5,61,0,
+  	0,149,22,1,0,0,0,150,151,5,61,0,0,151,152,5,61,0,0,152,24,1,0,0,0,153,
+  	154,5,33,0,0,154,155,5,61,0,0,155,26,1,0,0,0,156,157,5,60,0,0,157,28,
+  	1,0,0,0,158,159,5,62,0,0,159,30,1,0,0,0,160,161,5,60,0,0,161,162,5,61,
+  	0,0,162,32,1,0,0,0,163,164,5,62,0,0,164,165,5,61,0,0,165,34,1,0,0,0,166,
+  	167,5,43,0,0,167,36,1,0,0,0,168,169,5,45,0,0,169,38,1,0,0,0,170,171,5,
+  	42,0,0,171,40,1,0,0,0,172,173,5,47,0,0,173,42,1,0,0,0,174,175,5,37,0,
+  	0,175,44,1,0,0,0,176,177,5,33,0,0,177,46,1,0,0,0,178,179,5,38,0,0,179,
+  	180,5,38,0,0,180,48,1,0,0,0,181,182,5,124,0,0,182,183,5,124,0,0,183,50,
+  	1,0,0,0,184,185,5,40,0,0,185,52,1,0,0,0,186,187,5,41,0,0,187,54,1,0,0,
+  	0,188,189,5,91,0,0,189,56,1,0,0,0,190,191,5,93,0,0,191,58,1,0,0,0,192,
+  	193,5,123,0,0,193,60,1,0,0,0,194,195,5,125,0,0,195,62,1,0,0,0,196,197,
+  	5,44,0,0,197,64,1,0,0,0,198,199,5,59,0,0,199,66,1,0,0,0,200,204,7,0,0,
+  	0,201,203,7,1,0,0,202,201,1,0,0,0,203,206,1,0,0,0,204,202,1,0,0,0,204,
+  	205,1,0,0,0,205,68,1,0,0,0,206,204,1,0,0,0,207,210,3,79,39,0,208,210,
+  	3,81,40,0,209,207,1,0,0,0,209,208,1,0,0,0,210,70,1,0,0,0,211,215,3,77,
+  	38,0,212,215,3,75,37,0,213,215,3,73,36,0,214,211,1,0,0,0,214,212,1,0,
+  	0,0,214,213,1,0,0,0,215,72,1,0,0,0,216,225,5,48,0,0,217,221,7,2,0,0,218,
+  	220,7,3,0,0,219,218,1,0,0,0,220,223,1,0,0,0,221,219,1,0,0,0,221,222,1,
+  	0,0,0,222,225,1,0,0,0,223,221,1,0,0,0,224,216,1,0,0,0,224,217,1,0,0,0,
+  	225,74,1,0,0,0,226,228,5,48,0,0,227,229,7,4,0,0,228,227,1,0,0,0,229,230,
+  	1,0,0,0,230,228,1,0,0,0,230,231,1,0,0,0,231,76,1,0,0,0,232,233,5,48,0,
+  	0,233,235,7,5,0,0,234,236,7,6,0,0,235,234,1,0,0,0,236,237,1,0,0,0,237,
+  	235,1,0,0,0,237,238,1,0,0,0,238,78,1,0,0,0,239,241,7,3,0,0,240,239,1,
+  	0,0,0,241,242,1,0,0,0,242,240,1,0,0,0,242,243,1,0,0,0,243,244,1,0,0,0,
+  	244,248,5,46,0,0,245,247,7,3,0,0,246,245,1,0,0,0,247,250,1,0,0,0,248,
+  	246,1,0,0,0,248,249,1,0,0,0,249,252,1,0,0,0,250,248,1,0,0,0,251,253,3,
+  	83,41,0,252,251,1,0,0,0,252,253,1,0,0,0,253,270,1,0,0,0,254,256,5,46,
+  	0,0,255,257,7,3,0,0,256,255,1,0,0,0,257,258,1,0,0,0,258,256,1,0,0,0,258,
+  	259,1,0,0,0,259,261,1,0,0,0,260,262,3,83,41,0,261,260,1,0,0,0,261,262,
+  	1,0,0,0,262,270,1,0,0,0,263,265,7,3,0,0,264,263,1,0,0,0,265,266,1,0,0,
+  	0,266,264,1,0,0,0,266,267,1,0,0,0,267,268,1,0,0,0,268,270,3,83,41,0,269,
+  	240,1,0,0,0,269,254,1,0,0,0,269,264,1,0,0,0,270,80,1,0,0,0,271,272,5,
+  	48,0,0,272,274,7,5,0,0,273,275,7,6,0,0,274,273,1,0,0,0,275,276,1,0,0,
+  	0,276,274,1,0,0,0,276,277,1,0,0,0,277,285,1,0,0,0,278,282,5,46,0,0,279,
+  	281,7,6,0,0,280,279,1,0,0,0,281,284,1,0,0,0,282,280,1,0,0,0,282,283,1,
+  	0,0,0,283,286,1,0,0,0,284,282,1,0,0,0,285,278,1,0,0,0,285,286,1,0,0,0,
+  	286,287,1,0,0,0,287,289,7,7,0,0,288,290,7,8,0,0,289,288,1,0,0,0,289,290,
+  	1,0,0,0,290,292,1,0,0,0,291,293,7,3,0,0,292,291,1,0,0,0,293,294,1,0,0,
+  	0,294,292,1,0,0,0,294,295,1,0,0,0,295,314,1,0,0,0,296,297,5,48,0,0,297,
+  	298,7,5,0,0,298,300,5,46,0,0,299,301,7,6,0,0,300,299,1,0,0,0,301,302,
+  	1,0,0,0,302,300,1,0,0,0,302,303,1,0,0,0,303,304,1,0,0,0,304,306,7,7,0,
+  	0,305,307,7,8,0,0,306,305,1,0,0,0,306,307,1,0,0,0,307,309,1,0,0,0,308,
+  	310,7,3,0,0,309,308,1,0,0,0,310,311,1,0,0,0,311,309,1,0,0,0,311,312,1,
+  	0,0,0,312,314,1,0,0,0,313,271,1,0,0,0,313,296,1,0,0,0,314,82,1,0,0,0,
+  	315,317,7,9,0,0,316,318,7,8,0,0,317,316,1,0,0,0,317,318,1,0,0,0,318,320,
+  	1,0,0,0,319,321,7,3,0,0,320,319,1,0,0,0,321,322,1,0,0,0,322,320,1,0,0,
+  	0,322,323,1,0,0,0,323,84,1,0,0,0,324,325,7,10,0,0,325,326,1,0,0,0,326,
+  	327,6,42,0,0,327,86,1,0,0,0,328,329,5,47,0,0,329,330,5,47,0,0,330,334,
+  	1,0,0,0,331,333,8,11,0,0,332,331,1,0,0,0,333,336,1,0,0,0,334,332,1,0,
+  	0,0,334,335,1,0,0,0,335,337,1,0,0,0,336,334,1,0,0,0,337,338,6,43,0,0,
+  	338,88,1,0,0,0,339,340,5,47,0,0,340,341,5,42,0,0,341,345,1,0,0,0,342,
+  	344,9,0,0,0,343,342,1,0,0,0,344,347,1,0,0,0,345,346,1,0,0,0,345,343,1,
+  	0,0,0,346,348,1,0,0,0,347,345,1,0,0,0,348,349,5,42,0,0,349,350,5,47,0,
+  	0,350,351,1,0,0,0,351,352,6,44,0,0,352,90,1,0,0,0,28,0,204,209,214,221,
+  	224,230,237,242,248,252,258,261,266,269,276,282,285,289,294,302,306,311,
+  	313,317,322,334,345,1,6,0,0
+  };
+  staticData->serializedATN = antlr4::atn::SerializedATNView(serializedATNSegment, sizeof(serializedATNSegment) / sizeof(serializedATNSegment[0]));
+
+  antlr4::atn::ATNDeserializer deserializer;
+  staticData->atn = deserializer.deserialize(staticData->serializedATN);
+
+  const size_t count = staticData->atn->getNumberOfDecisions();
+  staticData->decisionToDFA.reserve(count);
+  for (size_t i = 0; i < count; i++) { 
+    staticData->decisionToDFA.emplace_back(staticData->atn->getDecisionState(i), i);
+  }
+  sysylexerLexerStaticData = std::move(staticData);
+}
+
+}
+
+SysYLexer::SysYLexer(CharStream *input) : Lexer(input) {
+  SysYLexer::initialize();
+  _interpreter = new atn::LexerATNSimulator(this, *sysylexerLexerStaticData->atn, sysylexerLexerStaticData->decisionToDFA, sysylexerLexerStaticData->sharedContextCache);
+}
+
+SysYLexer::~SysYLexer() {
+  delete _interpreter;
+}
+
+std::string SysYLexer::getGrammarFileName() const {
+  return "SysY.g4";
+}
+
+const std::vector<std::string>& SysYLexer::getRuleNames() const {
+  return sysylexerLexerStaticData->ruleNames;
+}
+
+const std::vector<std::string>& SysYLexer::getChannelNames() const {
+  return sysylexerLexerStaticData->channelNames;
+}
+
+const std::vector<std::string>& SysYLexer::getModeNames() const {
+  return sysylexerLexerStaticData->modeNames;
+}
+
+const dfa::Vocabulary& SysYLexer::getVocabulary() const {
+  return sysylexerLexerStaticData->vocabulary;
+}
+
+antlr4::atn::SerializedATNView SysYLexer::getSerializedATN() const {
+  return sysylexerLexerStaticData->serializedATN;
+}
+
+const atn::ATN& SysYLexer::getATN() const {
+  return *sysylexerLexerStaticData->atn;
+}
+
+
+
+
+void SysYLexer::initialize() {
+#if ANTLR4_USE_THREAD_LOCAL_CACHE
+  sysylexerLexerInitialize();
+#else
+  ::antlr4::internal::call_once(sysylexerLexerOnceFlag, sysylexerLexerInitialize);
+#endif
+}

src/antlr4/SysYLexer.h

@@ -0,0 +1,54 @@
+
+// Generated from SysY.g4 by ANTLR 4.13.2
+
+#pragma once
+
+
+#include "antlr4-runtime.h"
+
+
+
+
+class  SysYLexer : public antlr4::Lexer {
+public:
+  enum {
+    CONST = 1, INT = 2, FLOAT = 3, VOID = 4, IF = 5, ELSE = 6, WHILE = 7, 
+    BREAK = 8, CONTINUE = 9, RETURN = 10, ASSIGN = 11, EQ = 12, NE = 13, 
+    LT = 14, GT = 15, LE = 16, GE = 17, ADD = 18, SUB = 19, MUL = 20, DIV = 21, 
+    MOD = 22, NOT = 23, AND = 24, OR = 25, LPAREN = 26, RPAREN = 27, LBRACK = 28, 
+    RBRACK = 29, LBRACE = 30, RBRACE = 31, COMMA = 32, SEMICOLON = 33, ID = 34, 
+    FLITERAL = 35, ILITERAL = 36, WS = 37, LINECOMMENT = 38, BLOCKCOMMENT = 39
+  };
+
+  explicit SysYLexer(antlr4::CharStream *input);
+
+  ~SysYLexer() override;
+
+
+  std::string getGrammarFileName() const override;
+
+  const std::vector<std::string>& getRuleNames() const override;
+
+  const std::vector<std::string>& getChannelNames() const override;
+
+  const std::vector<std::string>& getModeNames() const override;
+
+  const antlr4::dfa::Vocabulary& getVocabulary() const override;
+
+  antlr4::atn::SerializedATNView getSerializedATN() const override;
+
+  const antlr4::atn::ATN& getATN() const override;
+
+  // By default the static state used to implement the lexer is lazily initialized during the first
+  // call to the constructor. You can call this function if you wish to initialize the static state
+  // ahead of time.
+  static void initialize();
+
+private:
+
+  // Individual action functions triggered by action() above.
+
+  // Individual semantic predicate functions triggered by sempred() above.
+
+};
+

src/antlr4/SysYParser.h

@@ -0,0 +1,641 @@
+
+// Generated from SysY.g4 by ANTLR 4.13.2
+
+#pragma once
+
+
+#include "antlr4-runtime.h"
+
+
+
+
+class  SysYParser : public antlr4::Parser {
+public:
+  enum {
+    CONST = 1, INT = 2, FLOAT = 3, VOID = 4, IF = 5, ELSE = 6, WHILE = 7, 
+    BREAK = 8, CONTINUE = 9, RETURN = 10, ASSIGN = 11, EQ = 12, NE = 13, 
+    LT = 14, GT = 15, LE = 16, GE = 17, ADD = 18, SUB = 19, MUL = 20, DIV = 21, 
+    MOD = 22, NOT = 23, AND = 24, OR = 25, LPAREN = 26, RPAREN = 27, LBRACK = 28, 
+    RBRACK = 29, LBRACE = 30, RBRACE = 31, COMMA = 32, SEMICOLON = 33, ID = 34, 
+    FLITERAL = 35, ILITERAL = 36, WS = 37, LINECOMMENT = 38, BLOCKCOMMENT = 39
+  };
+
+  enum {
+    RuleCompUnit = 0, RuleDecl = 1, RuleConstDecl = 2, RuleConstDef = 3, 
+    RuleConstInitValue = 4, RuleVarDecl = 5, RuleBtype = 6, RuleVarDef = 7, 
+    RuleInitValue = 8, RuleFuncDef = 9, RuleFuncType = 10, RuleFuncFParams = 11, 
+    RuleFuncFParam = 12, RuleBlockStmt = 13, RuleBlockItem = 14, RuleStmt = 15, 
+    RuleReturnStmt = 16, RuleExp = 17, RuleCond = 18, RuleLValue = 19, RulePrimaryExp = 20, 
+    RuleNumber = 21, RuleUnaryExp = 22, RuleUnaryOp = 23, RuleFuncRParams = 24, 
+    RuleMulExp = 25, RuleAddExp = 26, RuleRelExp = 27, RuleEqExp = 28, RuleLAndExp = 29, 
+    RuleLOrExp = 30, RuleConstExp = 31
+  };
+
+  explicit SysYParser(antlr4::TokenStream *input);
+
+  SysYParser(antlr4::TokenStream *input, const antlr4::atn::ParserATNSimulatorOptions &options);
+
+  ~SysYParser() override;
+
+  std::string getGrammarFileName() const override;
+
+  const antlr4::atn::ATN& getATN() const override;
+
+  const std::vector<std::string>& getRuleNames() const override;
+
+  const antlr4::dfa::Vocabulary& getVocabulary() const override;
+
+  antlr4::atn::SerializedATNView getSerializedATN() const override;
+
+
+  class CompUnitContext;
+  class DeclContext;
+  class ConstDeclContext;
+  class ConstDefContext;
+  class ConstInitValueContext;
+  class VarDeclContext;
+  class BtypeContext;
+  class VarDefContext;
+  class InitValueContext;
+  class FuncDefContext;
+  class FuncTypeContext;
+  class FuncFParamsContext;
+  class FuncFParamContext;
+  class BlockStmtContext;
+  class BlockItemContext;
+  class StmtContext;
+  class ReturnStmtContext;
+  class ExpContext;
+  class CondContext;
+  class LValueContext;
+  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;
+    antlr4::tree::TerminalNode *EOF();
+    std::vector<DeclContext *> decl();
+    DeclContext* decl(size_t i);
+    std::vector<FuncDefContext *> funcDef();
+    FuncDefContext* funcDef(size_t i);
+
+
+    virtual std::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 std::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;
+    antlr4::tree::TerminalNode *CONST();
+    BtypeContext *btype();
+    std::vector<ConstDefContext *> constDef();
+    ConstDefContext* constDef(size_t i);
+    antlr4::tree::TerminalNode *SEMICOLON();
+    std::vector<antlr4::tree::TerminalNode *> COMMA();
+    antlr4::tree::TerminalNode* COMMA(size_t i);
+
+
+    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
+   
+  };
+
+  ConstDeclContext* constDecl();
+
+  class  ConstDefContext : public antlr4::ParserRuleContext {
+  public:
+    ConstDefContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    antlr4::tree::TerminalNode *ID();
+    antlr4::tree::TerminalNode *ASSIGN();
+    ConstInitValueContext *constInitValue();
+    std::vector<antlr4::tree::TerminalNode *> LBRACK();
+    antlr4::tree::TerminalNode* LBRACK(size_t i);
+    std::vector<ConstExpContext *> constExp();
+    ConstExpContext* constExp(size_t i);
+    std::vector<antlr4::tree::TerminalNode *> RBRACK();
+    antlr4::tree::TerminalNode* RBRACK(size_t i);
+
+
+    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
+   
+  };
+
+  ConstDefContext* constDef();
+
+  class  ConstInitValueContext : public antlr4::ParserRuleContext {
+  public:
+    ConstInitValueContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    ConstExpContext *constExp();
+    antlr4::tree::TerminalNode *LBRACE();
+    antlr4::tree::TerminalNode *RBRACE();
+    std::vector<ConstInitValueContext *> constInitValue();
+    ConstInitValueContext* constInitValue(size_t i);
+    std::vector<antlr4::tree::TerminalNode *> COMMA();
+    antlr4::tree::TerminalNode* COMMA(size_t i);
+
+
+    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
+   
+  };
+
+  ConstInitValueContext* constInitValue();
+
+  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);
+    antlr4::tree::TerminalNode *SEMICOLON();
+    std::vector<antlr4::tree::TerminalNode *> COMMA();
+    antlr4::tree::TerminalNode* COMMA(size_t i);
+
+
+    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
+   
+  };
+
+  VarDeclContext* varDecl();
+
+  class  BtypeContext : public antlr4::ParserRuleContext {
+  public:
+    BtypeContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    antlr4::tree::TerminalNode *INT();
+    antlr4::tree::TerminalNode *FLOAT();
+
+
+    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
+   
+  };
+
+  BtypeContext* btype();
+
+  class  VarDefContext : public antlr4::ParserRuleContext {
+  public:
+    VarDefContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    antlr4::tree::TerminalNode *ID();
+    std::vector<antlr4::tree::TerminalNode *> LBRACK();
+    antlr4::tree::TerminalNode* LBRACK(size_t i);
+    std::vector<ConstExpContext *> constExp();
+    ConstExpContext* constExp(size_t i);
+    std::vector<antlr4::tree::TerminalNode *> RBRACK();
+    antlr4::tree::TerminalNode* RBRACK(size_t i);
+    antlr4::tree::TerminalNode *ASSIGN();
+    InitValueContext *initValue();
+
+
+    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
+   
+  };
+
+  VarDefContext* varDef();
+
+  class  InitValueContext : public antlr4::ParserRuleContext {
+  public:
+    InitValueContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    ExpContext *exp();
+    antlr4::tree::TerminalNode *LBRACE();
+    antlr4::tree::TerminalNode *RBRACE();
+    std::vector<InitValueContext *> initValue();
+    InitValueContext* initValue(size_t i);
+    std::vector<antlr4::tree::TerminalNode *> COMMA();
+    antlr4::tree::TerminalNode* COMMA(size_t i);
+
+
+    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
+   
+  };
+
+  InitValueContext* initValue();
+
+  class  FuncDefContext : public antlr4::ParserRuleContext {
+  public:
+    FuncDefContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    FuncTypeContext *funcType();
+    antlr4::tree::TerminalNode *ID();
+    antlr4::tree::TerminalNode *LPAREN();
+    antlr4::tree::TerminalNode *RPAREN();
+    BlockStmtContext *blockStmt();
+    FuncFParamsContext *funcFParams();
+
+
+    virtual std::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;
+    antlr4::tree::TerminalNode *INT();
+    antlr4::tree::TerminalNode *FLOAT();
+    antlr4::tree::TerminalNode *VOID();
+
+
+    virtual std::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);
+    std::vector<antlr4::tree::TerminalNode *> COMMA();
+    antlr4::tree::TerminalNode* COMMA(size_t i);
+
+
+    virtual std::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 *ID();
+    std::vector<antlr4::tree::TerminalNode *> LBRACK();
+    antlr4::tree::TerminalNode* LBRACK(size_t i);
+    std::vector<antlr4::tree::TerminalNode *> RBRACK();
+    antlr4::tree::TerminalNode* RBRACK(size_t i);
+    std::vector<ExpContext *> exp();
+    ExpContext* exp(size_t i);
+
+
+    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
+   
+  };
+
+  FuncFParamContext* funcFParam();
+
+  class  BlockStmtContext : public antlr4::ParserRuleContext {
+  public:
+    BlockStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    antlr4::tree::TerminalNode *LBRACE();
+    antlr4::tree::TerminalNode *RBRACE();
+    std::vector<BlockItemContext *> blockItem();
+    BlockItemContext* blockItem(size_t i);
+
+
+    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
+   
+  };
+
+  BlockStmtContext* blockStmt();
+
+  class  BlockItemContext : public antlr4::ParserRuleContext {
+  public:
+    BlockItemContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    DeclContext *decl();
+    StmtContext *stmt();
+
+
+    virtual std::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;
+    LValueContext *lValue();
+    antlr4::tree::TerminalNode *ASSIGN();
+    ExpContext *exp();
+    antlr4::tree::TerminalNode *SEMICOLON();
+    BlockStmtContext *blockStmt();
+    antlr4::tree::TerminalNode *IF();
+    antlr4::tree::TerminalNode *LPAREN();
+    CondContext *cond();
+    antlr4::tree::TerminalNode *RPAREN();
+    std::vector<StmtContext *> stmt();
+    StmtContext* stmt(size_t i);
+    antlr4::tree::TerminalNode *ELSE();
+    antlr4::tree::TerminalNode *WHILE();
+    antlr4::tree::TerminalNode *BREAK();
+    antlr4::tree::TerminalNode *CONTINUE();
+    ReturnStmtContext *returnStmt();
+
+
+    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
+   
+  };
+
+  StmtContext* stmt();
+
+  class  ReturnStmtContext : public antlr4::ParserRuleContext {
+  public:
+    ReturnStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    antlr4::tree::TerminalNode *RETURN();
+    antlr4::tree::TerminalNode *SEMICOLON();
+    ExpContext *exp();
+
+
+    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
+   
+  };
+
+  ReturnStmtContext* returnStmt();
+
+  class  ExpContext : public antlr4::ParserRuleContext {
+  public:
+    ExpContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    AddExpContext *addExp();
+
+
+    virtual std::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 std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
+   
+  };
+
+  CondContext* cond();
+
+  class  LValueContext : public antlr4::ParserRuleContext {
+  public:
+    LValueContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    antlr4::tree::TerminalNode *ID();
+    std::vector<antlr4::tree::TerminalNode *> LBRACK();
+    antlr4::tree::TerminalNode* LBRACK(size_t i);
+    std::vector<ExpContext *> exp();
+    ExpContext* exp(size_t i);
+    std::vector<antlr4::tree::TerminalNode *> RBRACK();
+    antlr4::tree::TerminalNode* RBRACK(size_t i);
+
+
+    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
+   
+  };
+
+  LValueContext* lValue();
+
+  class  PrimaryExpContext : public antlr4::ParserRuleContext {
+  public:
+    PrimaryExpContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    antlr4::tree::TerminalNode *LPAREN();
+    ExpContext *exp();
+    antlr4::tree::TerminalNode *RPAREN();
+    LValueContext *lValue();
+    NumberContext *number();
+
+
+    virtual std::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 *ILITERAL();
+    antlr4::tree::TerminalNode *FLITERAL();
+
+
+    virtual std::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 *ID();
+    antlr4::tree::TerminalNode *LPAREN();
+    antlr4::tree::TerminalNode *RPAREN();
+    FuncRParamsContext *funcRParams();
+    UnaryOpContext *unaryOp();
+    UnaryExpContext *unaryExp();
+
+
+    virtual std::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;
+    antlr4::tree::TerminalNode *ADD();
+    antlr4::tree::TerminalNode *SUB();
+    antlr4::tree::TerminalNode *NOT();
+
+
+    virtual std::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);
+    std::vector<antlr4::tree::TerminalNode *> COMMA();
+    antlr4::tree::TerminalNode* COMMA(size_t i);
+
+
+    virtual std::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;
+    UnaryExpContext *unaryExp();
+    MulExpContext *mulExp();
+    antlr4::tree::TerminalNode *MUL();
+    antlr4::tree::TerminalNode *DIV();
+    antlr4::tree::TerminalNode *MOD();
+
+
+    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
+   
+  };
+
+  MulExpContext* mulExp();
+  MulExpContext* mulExp(int precedence);
+  class  AddExpContext : public antlr4::ParserRuleContext {
+  public:
+    AddExpContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    MulExpContext *mulExp();
+    AddExpContext *addExp();
+    antlr4::tree::TerminalNode *ADD();
+    antlr4::tree::TerminalNode *SUB();
+
+
+    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
+   
+  };
+
+  AddExpContext* addExp();
+  AddExpContext* addExp(int precedence);
+  class  RelExpContext : public antlr4::ParserRuleContext {
+  public:
+    RelExpContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    AddExpContext *addExp();
+    RelExpContext *relExp();
+    antlr4::tree::TerminalNode *LT();
+    antlr4::tree::TerminalNode *GT();
+    antlr4::tree::TerminalNode *LE();
+    antlr4::tree::TerminalNode *GE();
+
+
+    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
+   
+  };
+
+  RelExpContext* relExp();
+  RelExpContext* relExp(int precedence);
+  class  EqExpContext : public antlr4::ParserRuleContext {
+  public:
+    EqExpContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    RelExpContext *relExp();
+    EqExpContext *eqExp();
+    antlr4::tree::TerminalNode *EQ();
+    antlr4::tree::TerminalNode *NE();
+
+
+    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
+   
+  };
+
+  EqExpContext* eqExp();
+  EqExpContext* eqExp(int precedence);
+  class  LAndExpContext : public antlr4::ParserRuleContext {
+  public:
+    LAndExpContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    EqExpContext *eqExp();
+    LAndExpContext *lAndExp();
+    antlr4::tree::TerminalNode *AND();
+
+
+    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
+   
+  };
+
+  LAndExpContext* lAndExp();
+  LAndExpContext* lAndExp(int precedence);
+  class  LOrExpContext : public antlr4::ParserRuleContext {
+  public:
+    LOrExpContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    LAndExpContext *lAndExp();
+    LOrExpContext *lOrExp();
+    antlr4::tree::TerminalNode *OR();
+
+
+    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
+   
+  };
+
+  LOrExpContext* lOrExp();
+  LOrExpContext* lOrExp(int precedence);
+  class  ConstExpContext : public antlr4::ParserRuleContext {
+  public:
+    ConstExpContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    AddExpContext *addExp();
+
+
+    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
+   
+  };
+
+  ConstExpContext* constExp();
+
+
+  bool sempred(antlr4::RuleContext *_localctx, size_t ruleIndex, size_t predicateIndex) override;
+
+  bool mulExpSempred(MulExpContext *_localctx, size_t predicateIndex);
+  bool addExpSempred(AddExpContext *_localctx, size_t predicateIndex);
+  bool relExpSempred(RelExpContext *_localctx, size_t predicateIndex);
+  bool eqExpSempred(EqExpContext *_localctx, size_t predicateIndex);
+  bool lAndExpSempred(LAndExpContext *_localctx, size_t predicateIndex);
+  bool lOrExpSempred(LOrExpContext *_localctx, size_t predicateIndex);
+
+  // By default the static state used to implement the parser is lazily initialized during the first
+  // call to the constructor. You can call this function if you wish to initialize the static state
+  // ahead of time.
+  static void initialize();
+
+private:
+};
+

src/antlr4/SysYVisitor.cpp

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

src/antlr4/SysYVisitor.h

@@ -0,0 +1,88 @@
+
+// Generated from SysY.g4 by ANTLR 4.13.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 std::any visitCompUnit(SysYParser::CompUnitContext *context) = 0;
+
+    virtual std::any visitDecl(SysYParser::DeclContext *context) = 0;
+
+    virtual std::any visitConstDecl(SysYParser::ConstDeclContext *context) = 0;
+
+    virtual std::any visitConstDef(SysYParser::ConstDefContext *context) = 0;
+
+    virtual std::any visitConstInitValue(SysYParser::ConstInitValueContext *context) = 0;
+
+    virtual std::any visitVarDecl(SysYParser::VarDeclContext *context) = 0;
+
+    virtual std::any visitBtype(SysYParser::BtypeContext *context) = 0;
+
+    virtual std::any visitVarDef(SysYParser::VarDefContext *context) = 0;
+
+    virtual std::any visitInitValue(SysYParser::InitValueContext *context) = 0;
+
+    virtual std::any visitFuncDef(SysYParser::FuncDefContext *context) = 0;
+
+    virtual std::any visitFuncType(SysYParser::FuncTypeContext *context) = 0;
+
+    virtual std::any visitFuncFParams(SysYParser::FuncFParamsContext *context) = 0;
+
+    virtual std::any visitFuncFParam(SysYParser::FuncFParamContext *context) = 0;
+
+    virtual std::any visitBlockStmt(SysYParser::BlockStmtContext *context) = 0;
+
+    virtual std::any visitBlockItem(SysYParser::BlockItemContext *context) = 0;
+
+    virtual std::any visitStmt(SysYParser::StmtContext *context) = 0;
+
+    virtual std::any visitReturnStmt(SysYParser::ReturnStmtContext *context) = 0;
+
+    virtual std::any visitExp(SysYParser::ExpContext *context) = 0;
+
+    virtual std::any visitCond(SysYParser::CondContext *context) = 0;
+
+    virtual std::any visitLValue(SysYParser::LValueContext *context) = 0;
+
+    virtual std::any visitPrimaryExp(SysYParser::PrimaryExpContext *context) = 0;
+
+    virtual std::any visitNumber(SysYParser::NumberContext *context) = 0;
+
+    virtual std::any visitUnaryExp(SysYParser::UnaryExpContext *context) = 0;
+
+    virtual std::any visitUnaryOp(SysYParser::UnaryOpContext *context) = 0;
+
+    virtual std::any visitFuncRParams(SysYParser::FuncRParamsContext *context) = 0;
+
+    virtual std::any visitMulExp(SysYParser::MulExpContext *context) = 0;
+
+    virtual std::any visitAddExp(SysYParser::AddExpContext *context) = 0;
+
+    virtual std::any visitRelExp(SysYParser::RelExpContext *context) = 0;
+
+    virtual std::any visitEqExp(SysYParser::EqExpContext *context) = 0;
+
+    virtual std::any visitLAndExp(SysYParser::LAndExpContext *context) = 0;
+
+    virtual std::any visitLOrExp(SysYParser::LOrExpContext *context) = 0;
+
+    virtual std::any visitConstExp(SysYParser::ConstExpContext *context) = 0;
+
+
+};
+

src/frontend/AntlrDriver.cpp

@@ -6,8 +6,8 @@
 #include <stdexcept>
 #include <string>
 
-#include "SysYLexer.h"
+#include "antlr4/SysYLexer.h"
-#include "SysYParser.h"
+#include "antlr4/SysYParser.h"
 #include "antlr4-runtime.h"
 #include "utils/Log.h"
 

src/frontend/CMakeLists.txt

@@ -8,9 +8,10 @@ target_link_libraries(frontend PUBLIC
   ${ANTLR4_RUNTIME_TARGET}
 )
 
-# 自动纳入构建目录中的 Lexer/Parser 生成源码（若存在）
+# 自动纳入构建目录中的 Lexer/Parser 生成源码（若存在），同时兼容存储在 src/antlr4 中的已生成代码
 file(GLOB_RECURSE ANTLR4_GENERATED_SOURCES CONFIGURE_DEPENDS
   "${ANTLR4_GENERATED_DIR}/*.cpp"
+  "${PROJECT_SOURCE_DIR}/src/antlr4/*.cpp"
 )
 if(ANTLR4_GENERATED_SOURCES)
   target_sources(frontend PRIVATE ${ANTLR4_GENERATED_SOURCES})

src/irgen/IRGenDecl.cpp

@@ -2,7 +2,7 @@
 
 #include <stdexcept>
 
-#include "SysYParser.h"
+#include "antlr4/SysYParser.h"
 #include "ir/IR.h"
 #include "utils/Log.h"
 
@@ -21,6 +21,8 @@ std::any IRGenImpl::visitBlockStmt(SysYParser::BlockStmtContext* ctx) {
   if (!ctx) {
     throw std::runtime_error(FormatError("irgen", "缺少语句块"));
   }
+  // 进入新作用域
+  scope_storage_.emplace_back();
   for (auto* item : ctx->blockItem()) {
     if (item) {
       if (VisitBlockItemResult(*item) == BlockFlow::Terminated) {
@@ -29,6 +31,8 @@ std::any IRGenImpl::visitBlockStmt(SysYParser::BlockStmtContext* ctx) {
       }
     }
   }
+  // 退出作用域
+  scope_storage_.pop_back();
   return {};
 }
 
@@ -67,6 +71,18 @@ std::any IRGenImpl::visitDecl(SysYParser::DeclContext* ctx) {
     // 当前先忽略 constDecl 与其它声明形态。
     return {};
   }
+
+  if (!in_function_) {
+    // 全局变量处理路径
+    for (auto* var_def : ctx->varDecl()->varDef()) {
+      if (!var_def) {
+        throw std::runtime_error(FormatError("irgen", "非法变量声明"));
+      }
+      EmitGlobalVariable(var_def);
+    }
+    return {};
+  }
+
   return ctx->varDecl()->accept(this);
 }
 
@@ -75,13 +91,18 @@ std::any IRGenImpl::visitVarDecl(SysYParser::VarDeclContext* ctx) {
     throw std::runtime_error(FormatError("irgen", "缺少变量声明"));
   }
   if (!ctx->btype() || !ctx->btype()->INT()) {
-    throw std::runtime_error(FormatError("irgen", "当前仅支持局部 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);
+    if (in_function_) {
+      var_def->accept(this);
+    } else {
+      EmitGlobalVariable(var_def);
+    }
   }
   return {};
 }
@@ -99,11 +120,23 @@ std::any IRGenImpl::visitVarDef(SysYParser::VarDefContext* ctx) {
     throw std::runtime_error(FormatError("irgen", "变量声明缺少名称"));
   }
   const std::string name = ctx->ID()->getText();
+
+  // 数组语义暂时不支持，先提示
+  if (!ctx->LBRACK().empty()) {
+    throw std::runtime_error(FormatError("irgen", "暂不支持数组声明和初始化"));
+  }
+
   if (storage_map_.find(ctx) != storage_map_.end()) {
     throw std::runtime_error(FormatError("irgen", "声明重复生成存储槽位"));
   }
+
+  // const 变量在 Sema 中可扩展为常量折叠，当前暂时和普通变量一样处理
   auto* slot = builder_.CreateAllocaI32(module_.GetContext().NextTemp());
   storage_map_[ctx] = slot;
+  // 添加到当前作用域
+  if (!scope_storage_.empty()) {
+    scope_storage_.back()[name] = slot;
+  }
   named_storage_[name] = slot;
 
   ir::Value* init = nullptr;

src/irgen/IRGenDriver.cpp

@@ -2,7 +2,7 @@
 
 #include <memory>
 
-#include "SysYParser.h"
+#include "antlr4/SysYParser.h"
 #include "ir/IR.h"
 #include "utils/Log.h"
 

src/irgen/IRGenExp.cpp

@@ -2,7 +2,7 @@
 
 #include <stdexcept>
 
-#include "SysYParser.h"
+#include "antlr4/SysYParser.h"
 #include "ir/IR.h"
 #include "utils/Log.h"
 
@@ -36,6 +36,14 @@ ir::Value* IRGenImpl::ToBoolValue(ir::Value* v) {
   return builder_.CreateCmp(ir::CmpOp::Ne, v, zero, module_.GetContext().NextTemp());
 }
 
+ir::Value* IRGenImpl::FindInScope(const std::string& name) {
+  for (auto it = scope_storage_.rbegin(); it != scope_storage_.rend(); ++it) {
+    auto found = it->find(name);
+    if (found != it->end()) return found->second;
+  }
+  return nullptr;
+}
+
 std::string IRGenImpl::NextBlockName() {
   std::string temp = module_.GetContext().NextTemp();
   if (!temp.empty() && temp.front() == '%') {
@@ -89,26 +97,48 @@ std::any IRGenImpl::visitNumber(SysYParser::NumberContext* ctx) {
 //
 // 因此当前 IRGen 自己不再做名字查找，而是直接消费 Sema 的绑定结果。
 std::any IRGenImpl::visitLValue(SysYParser::LValueContext* ctx) {
-  if (!ctx || !ctx->ID()) {
+  auto* addr = ResolveLValueAddress(ctx);
-    throw std::runtime_error(FormatError("irgen", "当前仅支持普通整型变量"));
+  if (!addr) {
-  }
+    throw std::runtime_error(FormatError("irgen", "变量地址解析失败"));
-  const std::string name = ctx->ID()->getText();
-  auto it = named_storage_.find(name);
-  if (it == named_storage_.end()) {
-    throw std::runtime_error(
-        FormatError("irgen", "变量声明缺少存储槽位: " + name));
   }
   return static_cast<ir::Value*>(
-      builder_.CreateLoad(it->second, module_.GetContext().NextTemp()));
+      builder_.CreateLoad(addr, 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->ID() && ctx->LPAREN()) {
+    auto func_name = ctx->ID()->getText();
+    ir::Function* callee = FindFunctionByName(func_name);
+    if (!callee) {
+      throw std::runtime_error(FormatError("irgen", "函数未定义: " + func_name));
+    }
+
+    std::vector<ir::Value*> args;
+    if (ctx->funcRParams()) {
+      for (auto* exp : ctx->funcRParams()->exp()) {
+        if (!exp) {
+          throw std::runtime_error(FormatError("irgen", "函数参数缺失"));
+        }
+        args.push_back(EvalExpr(*exp));
+      }
+    }
+
+    auto* call = builder_.CreateCall(callee, args, module_.GetContext().NextTemp());
+    if (callee->GetType()->IsVoid()) {
+      // void 类型调用表达式在值上下文下暂时返回 0。
+      return static_cast<ir::Value*>(builder_.CreateConstInt(0));
+    }
+    return static_cast<ir::Value*>(call);
+  }
+
   if (ctx->unaryOp() && ctx->unaryExp()) {
     ir::Value* v = std::any_cast<ir::Value*>(ctx->unaryExp()->accept(this));
     if (ctx->unaryOp()->SUB()) {
@@ -119,9 +149,24 @@ std::any IRGenImpl::visitUnaryExp(SysYParser::UnaryExpContext* ctx) {
     if (ctx->unaryOp()->ADD()) {
       return v;
     }
-    throw std::runtime_error(FormatError("irgen", "当前不支持逻辑非运算"));
+    if (ctx->unaryOp()->NOT()) {
+      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", "非法一元运算符"));
+  }
+
+  throw std::runtime_error(FormatError("irgen", "非法一元表达式"));
+}
+
+ir::Function* IRGenImpl::FindFunctionByName(const std::string& name) {
+  for (const auto& func : module_.GetFunctions()) {
+    if (func && func->GetName() == name) {
+      return func.get();
+    }
   }
-  throw std::runtime_error(FormatError("irgen", "当前不支持函数调用表达式"));
+  return nullptr;
 }
 
 std::any IRGenImpl::visitMulExp(SysYParser::MulExpContext* ctx) {
@@ -244,36 +289,84 @@ std::any IRGenImpl::visitLAndExp(SysYParser::LAndExpContext* ctx) {
   if (!ctx) {
     throw std::runtime_error(FormatError("irgen", "非法逻辑与表达式"));
   }
-  if (ctx->lAndExp()) {
+
-    if (!ctx->eqExp()) {
+  if (!ctx->lAndExp()) {
-      throw std::runtime_error(FormatError("irgen", "非法逻辑与表达式"));
+    if (ctx->eqExp()) {
+      return ToBoolValue(std::any_cast<ir::Value*>(ctx->eqExp()->accept(this)));
     }
-    auto* lhs = ToBoolValue(std::any_cast<ir::Value*>(ctx->lAndExp()->accept(this)));
+    throw std::runtime_error(FormatError("irgen", "非法逻辑与表达式"));
-    auto* rhs = ToBoolValue(std::any_cast<ir::Value*>(ctx->eqExp()->accept(this)));
-    return static_cast<ir::Value*>(
-        builder_.CreateMul(lhs, rhs, module_.GetContext().NextTemp()));
   }
-  if (ctx->eqExp()) {
+
-    return ToBoolValue(std::any_cast<ir::Value*>(ctx->eqExp()->accept(this)));
+  if (!ctx->eqExp()) {
+    throw std::runtime_error(FormatError("irgen", "非法逻辑与表达式"));
+  }
+
+  auto* lhs = ToBoolValue(std::any_cast<ir::Value*>(ctx->lAndExp()->accept(this)));
+
+  auto* result_slot = builder_.CreateAllocaI32(module_.GetContext().NextTemp());
+  auto* rhs_bb = func_->CreateBlock(NextBlockName());
+  auto* false_bb = func_->CreateBlock(NextBlockName());
+  auto* merge_bb = func_->CreateBlock(NextBlockName());
+
+  builder_.CreateCondBr(lhs, rhs_bb, false_bb);
+
+  builder_.SetInsertPoint(rhs_bb);
+  auto* rhs = ToBoolValue(std::any_cast<ir::Value*>(ctx->eqExp()->accept(this)));
+  builder_.CreateStore(rhs, result_slot);
+  if (!rhs_bb->HasTerminator()) {
+    builder_.CreateBr(merge_bb);
+  }
+
+  builder_.SetInsertPoint(false_bb);
+  builder_.CreateStore(builder_.CreateConstInt(0), result_slot);
+  if (!false_bb->HasTerminator()) {
+    builder_.CreateBr(merge_bb);
   }
-  throw std::runtime_error(FormatError("irgen", "非法逻辑与表达式"));
+
+  builder_.SetInsertPoint(merge_bb);
+  return static_cast<ir::Value*>(
+      builder_.CreateLoad(result_slot, module_.GetContext().NextTemp()));
 }
 
 std::any IRGenImpl::visitLOrExp(SysYParser::LOrExpContext* ctx) {
   if (!ctx) {
     throw std::runtime_error(FormatError("irgen", "非法逻辑或表达式"));
   }
-  if (ctx->lOrExp()) {
+
-    if (!ctx->lAndExp()) {
+  if (!ctx->lOrExp()) {
-      throw std::runtime_error(FormatError("irgen", "非法逻辑或表达式"));
+    if (ctx->lAndExp()) {
+      return ToBoolValue(std::any_cast<ir::Value*>(ctx->lAndExp()->accept(this)));
     }
-    auto* lhs = ToBoolValue(std::any_cast<ir::Value*>(ctx->lOrExp()->accept(this)));
+    throw std::runtime_error(FormatError("irgen", "非法逻辑或表达式"));
-    auto* rhs = ToBoolValue(std::any_cast<ir::Value*>(ctx->lAndExp()->accept(this)));
+  }
-    auto* sum = builder_.CreateAdd(lhs, rhs, module_.GetContext().NextTemp());
+
-    return static_cast<ir::Value*>(ToBoolValue(sum));
+  if (!ctx->lAndExp()) {
+    throw std::runtime_error(FormatError("irgen", "非法逻辑或表达式"));
+  }
+
+  auto* lhs = ToBoolValue(std::any_cast<ir::Value*>(ctx->lOrExp()->accept(this)));
+
+  auto* result_slot = builder_.CreateAllocaI32(module_.GetContext().NextTemp());
+  auto* true_bb = func_->CreateBlock(NextBlockName());
+  auto* rhs_bb = func_->CreateBlock(NextBlockName());
+  auto* merge_bb = func_->CreateBlock(NextBlockName());
+
+  builder_.CreateCondBr(lhs, true_bb, rhs_bb);
+
+  builder_.SetInsertPoint(true_bb);
+  builder_.CreateStore(builder_.CreateConstInt(1), result_slot);
+  if (!true_bb->HasTerminator()) {
+    builder_.CreateBr(merge_bb);
   }
-  if (ctx->lAndExp()) {
+
-    return ToBoolValue(std::any_cast<ir::Value*>(ctx->lAndExp()->accept(this)));
+  builder_.SetInsertPoint(rhs_bb);
+  auto* rhs = ToBoolValue(std::any_cast<ir::Value*>(ctx->lAndExp()->accept(this)));
+  builder_.CreateStore(rhs, result_slot);
+  if (!rhs_bb->HasTerminator()) {
+    builder_.CreateBr(merge_bb);
   }
-  throw std::runtime_error(FormatError("irgen", "非法逻辑或表达式"));
+
+  builder_.SetInsertPoint(merge_bb);
+  return static_cast<ir::Value*>(
+      builder_.CreateLoad(result_slot, module_.GetContext().NextTemp()));
 }

src/irgen/IRGenFunc.cpp

@@ -2,7 +2,7 @@
 
 #include <stdexcept>
 
-#include "SysYParser.h"
+#include "antlr4/SysYParser.h"
 #include "ir/IR.h"
 #include "utils/Log.h"
 
@@ -25,7 +25,10 @@ IRGenImpl::IRGenImpl(ir::Module& module, const SemanticContext& sema)
     : module_(module),
       sema_(sema),
       func_(nullptr),
-      builder_(module.GetContext(), nullptr) {}
+      builder_(module.GetContext(), nullptr) {
+  // 初始化作用域栈，至少有一个全局作用域（但当前未使用全局变量）
+  scope_storage_.emplace_back();
+}
 
 // 编译单元的 IR 生成当前只实现了最小功能：
 // - Module 已在 GenerateIR 中创建，这里只负责继续生成其中的内容；
@@ -38,6 +41,17 @@ std::any IRGenImpl::visitCompUnit(SysYParser::CompUnitContext* ctx) {
   if (!ctx) {
     throw std::runtime_error(FormatError("irgen", "缺少编译单元"));
   }
+
+  // 先处理全局变量声明
+  for (auto* decl : ctx->decl()) {
+    if (!decl) continue;
+    // 如果当前还未进入函数，则这些为全局变量声明
+    if (!in_function_) {
+      decl->accept(this);
+    }
+  }
+
+  // 再处理函数定义
   if (ctx->funcDef().empty()) {
     throw std::runtime_error(FormatError("irgen", "缺少函数定义"));
   }
@@ -64,7 +78,7 @@ std::any IRGenImpl::visitCompUnit(SysYParser::CompUnitContext* ctx) {
 // - 入口块中的参数初始化逻辑。
 // ...
 
-// 因此这里目前只支持最小的“无参 int 函数”生成。
+// 因此这里目前只支持最小的“带参 int 函数”生成。
 std::any IRGenImpl::visitFuncDef(SysYParser::FuncDefContext* ctx) {
   if (!ctx) {
     throw std::runtime_error(FormatError("irgen", "缺少函数定义"));
@@ -76,16 +90,66 @@ std::any IRGenImpl::visitFuncDef(SysYParser::FuncDefContext* ctx) {
     throw std::runtime_error(FormatError("irgen", "缺少函数名"));
   }
   if (!ctx->funcType() || !ctx->funcType()->INT()) {
-    throw std::runtime_error(FormatError("irgen", "当前仅支持无参 int 函数"));
+    throw std::runtime_error(FormatError("irgen", "当前仅支持 int 返回类型函数"));
   }
 
-  func_ = module_.CreateFunction(ctx->ID()->getText(), ir::Type::GetInt32Type());
+  // 解析返回类型（当前仅 int）
+  auto ret_type = ir::Type::GetInt32Type();
+
+  // 解析参数类型列表
+  std::vector<std::shared_ptr<ir::Type>> param_types;
+  std::vector<std::string> param_names;
+  if (ctx->funcFParams()) {
+    for (auto* param : ctx->funcFParams()->funcFParam()) {
+      if (!param || !param->btype() || !param->btype()->INT() || !param->ID()) {
+        throw std::runtime_error(FormatError("irgen", "当前仅支持 int 类型参数"));
+      }
+      param_types.push_back(ir::Type::GetInt32Type());
+      param_names.push_back(param->ID()->getText());
+    }
+  }
+
+  in_function_ = true;
+
+  // 创建 IR 函数（假设 CreateFunction 支持参数类型列表）
+  func_ = module_.CreateFunction(ctx->ID()->getText(), ret_type, param_types);
   builder_.SetInsertPoint(func_->GetEntry());
+
+  // 清空当前函数的状态
   storage_map_.clear();
   named_storage_.clear();
+  param_slots_.clear();
+
+  // 进入函数参数作用域
+  scope_storage_.emplace_back();
 
+  // 处理参数：为每个参数创建 alloca 并放入符号表
+  for (const auto& param_name : param_names) {
+    auto* alloca = builder_.CreateAllocaI32(module_.GetContext().NextTemp());
+    param_slots_.push_back(alloca);
+    scope_storage_.back()[param_name] = alloca;
+    named_storage_[param_name] = alloca;
+  }
+
+  // 生成函数体
   ctx->blockStmt()->accept(this);
-  // 语义正确性主要由 sema 保证，这里只兜底检查 IR 结构是否合法。
+
+  // 退出函数参数作用域
+  scope_storage_.pop_back();
+  in_function_ = false;
+
+  // 如果函数最后一个基本块没有终结指令，添加默认返回
+  const auto& blocks = func_->GetBlocks();
+  if (!blocks.empty()) {
+    auto* last_bb = blocks.back().get();
+    if (last_bb && !last_bb->HasTerminator()) {
+      builder_.SetInsertPoint(last_bb);
+      builder_.CreateRet(builder_.CreateConstInt(0));
+    }
+  }
+
+  // 校验函数结构
   VerifyFunctionStructure(*func_);
+
   return {};
 }

src/irgen/IRGenStmt.cpp

@@ -2,10 +2,20 @@
 
 #include <stdexcept>
 
-#include "SysYParser.h"
+#include "antlr4/SysYParser.h"
 #include "ir/IR.h"
 #include "utils/Log.h"
 
+static std::string FormatErrorCtx(antlr4::ParserRuleContext* ctx,
+                                  const std::string& msg) {
+  if (ctx && ctx->getStart()) {
+    return FormatErrorAt("irgen", ctx->getStart()->getLine(),
+                         ctx->getStart()->getCharPositionInLine() + 1, msg);
+  }
+  return FormatError("irgen", msg);
+}
+
+
 // 语句生成当前只实现了最小子集。
 // 目前支持：
 // - return <exp>;
@@ -23,13 +33,13 @@ std::any IRGenImpl::visitStmt(SysYParser::StmtContext* ctx) {
     if (!ctx->lValue()->ID()) {
       throw std::runtime_error(FormatError("irgen", "赋值语句左值非法"));
     }
-    const std::string name = ctx->lValue()->ID()->getText();
+    ir::Value* dest = ResolveLValueAddress(ctx->lValue());
-    auto slot_it = named_storage_.find(name);
+    if (!dest) {
-    if (slot_it == named_storage_.end()) {
+      throw std::runtime_error(
-      throw std::runtime_error(FormatError("irgen", "赋值目标未声明: " + name));
+          FormatError("irgen", "赋值目标地址解析失败"));
     }
     ir::Value* rhs = EvalExpr(*ctx->exp());
-    builder_.CreateStore(rhs, slot_it->second);
+    builder_.CreateStore(rhs, dest);
     return BlockFlow::Continue;
   }
   if (ctx->blockStmt()) {
@@ -117,6 +127,27 @@ std::any IRGenImpl::visitStmt(SysYParser::StmtContext* ctx) {
   throw std::runtime_error(FormatError("irgen", "暂不支持的语句类型"));
 }
 
+ir::Value* IRGenImpl::ResolveLValueAddress(SysYParser::LValueContext* ctx) {
+  if (!ctx || !ctx->ID()) {
+    throw std::runtime_error(FormatError("irgen", "非法左值"));
+  }
+  const std::string name = ctx->ID()->getText();
+  ir::Value* base = FindInScope(name);
+  if (!base) {
+    throw std::runtime_error(FormatError("irgen", "变量未声明: " + name));
+  }
+
+  if (ctx->LBRACK().empty()) {
+    return base;
+  }
+
+  // 到目前为止只支持一维数组，占位实现
+  if (ctx->exp().empty()) {
+    throw std::runtime_error(FormatError("irgen", "数组下标缺失"));
+  }
+  return EmitArrayIndex(base, ctx->exp(0));
+}
+
 
 std::any IRGenImpl::visitReturnStmt(SysYParser::ReturnStmtContext* ctx) {
   if (!ctx) {
@@ -129,3 +160,32 @@ std::any IRGenImpl::visitReturnStmt(SysYParser::ReturnStmtContext* ctx) {
   builder_.CreateRet(v);
   return BlockFlow::Terminated;
 }
+
+ir::Value* IRGenImpl::EmitArrayIndex(ir::Value* base_ptr,
+                                     SysYParser::ExpContext* idx_expr) {
+  if (!base_ptr) {
+    throw std::runtime_error(FormatError("irgen", "数组基址为空"));
+  }
+  if (!idx_expr) {
+    throw std::runtime_error(FormatError("irgen", "缺少数组下标表达式"));
+  }
+  ir::Value* idx = EvalExpr(*idx_expr);
+  if (!idx) {
+    throw std::runtime_error(FormatError("irgen", "数组下标计算失败"));
+  }
+  // 当前 IR 仍只支持 i32 / i32*，还未实现真正的 GEP。
+  // 这里提供一个占位：直接将基址作为元素地址返回（仅用于结构化接口），
+  // 具体语义需在后续 IR 指令集扩展后完成。
+  // TODO: 实现指针加法/GEP，以支持数组下标访问
+  (void)idx;
+  return base_ptr;
+}
+
+void IRGenImpl::EmitGlobalVariable(SysYParser::VarDefContext* ctx) {
+  if (!ctx) {
+    throw std::runtime_error(FormatError("irgen", "缺少全局变量定义"));
+  }
+  // GlobalValue 还未完成，暂时抛异常以提醒后续实现。
+  throw std::runtime_error(FormatError("irgen", "全局变量生成未实现"));
+}
+