From c0a4de925f71a086ba858c191232b02a16e7f4b4 Mon Sep 17 00:00:00 2001 From: Pomelo <1807773939@qq.com> Date: Wed, 25 Mar 2026 17:28:42 +0800 Subject: [PATCH] =?UTF-8?q?irgen=E5=AE=9E=E7=8E=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- CMakeLists.txt | 1 + include/frontend/AntlrDriver.h | 4 +- include/irgen/IRGen.h | 27 +- include/sem/Sema.h | 4 +- src/antlr4/SysYBaseVisitor.cpp | 7 + src/antlr4/SysYBaseVisitor.h | 148 ++ src/antlr4/SysYLexer.cpp | 271 +++ src/antlr4/SysYLexer.h | 54 + src/antlr4/SysYParser.cpp | 3208 ++++++++++++++++++++++++++++++++ src/antlr4/SysYParser.h | 641 +++++++ src/antlr4/SysYVisitor.cpp | 7 + src/antlr4/SysYVisitor.h | 88 + src/frontend/AntlrDriver.cpp | 4 +- src/frontend/CMakeLists.txt | 3 +- src/irgen/IRGenDecl.cpp | 39 +- src/irgen/IRGenDriver.cpp | 2 +- src/irgen/IRGenExp.cpp | 157 +- src/irgen/IRGenFunc.cpp | 76 +- src/irgen/IRGenStmt.cpp | 72 +- 19 files changed, 4756 insertions(+), 57 deletions(-) create mode 100644 src/antlr4/SysYBaseVisitor.cpp create mode 100644 src/antlr4/SysYBaseVisitor.h create mode 100644 src/antlr4/SysYLexer.cpp create mode 100644 src/antlr4/SysYLexer.h create mode 100644 src/antlr4/SysYParser.cpp create mode 100644 src/antlr4/SysYParser.h create mode 100644 src/antlr4/SysYVisitor.cpp create mode 100644 src/antlr4/SysYVisitor.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 74dcb27..4e8c257 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,3 +1,4 @@ +include_directories(${PROJECT_SOURCE_DIR}/src/antlr4) cmake_minimum_required(VERSION 3.20) project(compiler LANGUAGES C CXX) diff --git a/include/frontend/AntlrDriver.h b/include/frontend/AntlrDriver.h index ee22da9..5403e14 100644 --- a/include/frontend/AntlrDriver.h +++ b/include/frontend/AntlrDriver.h @@ -4,8 +4,8 @@ #include #include -#include "SysYLexer.h" -#include "SysYParser.h" +#include "antlr4/SysYLexer.h" +#include "antlr4/SysYParser.h" #include "antlr4-runtime.h" struct AntlrResult { diff --git a/include/irgen/IRGen.h b/include/irgen/IRGen.h index 53eb24d..9083d27 100644 --- a/include/irgen/IRGen.h +++ b/include/irgen/IRGen.h @@ -6,13 +6,18 @@ #include #include #include +#include #include -#include "SysYBaseVisitor.h" -#include "SysYParser.h" +#include "antlr4/SysYBaseVisitor.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 param_slots_; + // 将 Sema 提供的变量符号映射到对应的存储槽位（避免仅按名字查找） + std::unordered_map symbol_storage_map_; + // 将 Sema 提供的函数符号映射到已创建的 IR 函数对象 + std::unordered_map func_symbol_map_; + // 作用域栈：每个作用域维护一个从名称到存储槽位的映射 + std::vector> scope_storage_; // 名称绑定由 Sema 负责；IRGen 只维护“声明 -> 存储槽位”的代码生成状态。 std::unordered_map storage_map_; + // 保留按名字的映射以兼容现有代码路径，但优先使用 symbol_storage_map_ std::unordered_map named_storage_; std::vector loop_stack_; }; diff --git a/include/sem/Sema.h b/include/sem/Sema.h index b684a41..2ba1d59 100644 --- a/include/sem/Sema.h +++ b/include/sem/Sema.h @@ -2,8 +2,8 @@ #define SEMANTIC_ANALYSIS_H #include "SymbolTable.h" -#include "SysYBaseVisitor.h" -#include "SysYParser.h" +#include "antlr4/SysYBaseVisitor.h" +#include "antlr4/SysYParser.h" #include #include #include diff --git a/src/antlr4/SysYBaseVisitor.cpp b/src/antlr4/SysYBaseVisitor.cpp new file mode 100644 index 0000000..b70482b --- /dev/null +++ b/src/antlr4/SysYBaseVisitor.cpp @@ -0,0 +1,7 @@ + +// Generated from SysY.g4 by ANTLR 4.13.2 + + +#include "SysYBaseVisitor.h" + + diff --git a/src/antlr4/SysYBaseVisitor.h b/src/antlr4/SysYBaseVisitor.h new file mode 100644 index 0000000..7f91aac --- /dev/null +++ b/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); + } + + +}; + diff --git a/src/antlr4/SysYLexer.cpp b/src/antlr4/SysYLexer.cpp new file mode 100644 index 0000000..86c4f9f --- /dev/null +++ b/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 ruleNames, + std::vector channelNames, + std::vector modeNames, + std::vector literalNames, + std::vector 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 decisionToDFA; + antlr4::atn::PredictionContextCache sharedContextCache; + const std::vector ruleNames; + const std::vector channelNames; + const std::vector modeNames; + const std::vector literalNames; + const std::vector symbolicNames; + const antlr4::dfa::Vocabulary vocabulary; + antlr4::atn::SerializedATNView serializedATN; + std::unique_ptr atn; +}; + +::antlr4::internal::OnceFlag sysylexerLexerOnceFlag; +#if ANTLR4_USE_THREAD_LOCAL_CACHE +static thread_local +#endif +std::unique_ptr sysylexerLexerStaticData = nullptr; + +void sysylexerLexerInitialize() { +#if ANTLR4_USE_THREAD_LOCAL_CACHE + if (sysylexerLexerStaticData != nullptr) { + return; + } +#else + assert(sysylexerLexerStaticData == nullptr); +#endif + auto staticData = std::make_unique( + std::vector{ + "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{ + "DEFAULT_TOKEN_CHANNEL", "HIDDEN" + }, + std::vector{ + "DEFAULT_MODE" + }, + std::vector{ + "", "'const'", "'int'", "'float'", "'void'", "'if'", "'else'", "'while'", + "'break'", "'continue'", "'return'", "'='", "'=='", "'!='", "'<'", + "'>'", "'<='", "'>='", "'+'", "'-'", "'*'", "'/'", "'%'", "'!'", "'&&'", + "'||'", "'('", "')'", "'['", "']'", "'{'", "'}'", "','", "';'" + }, + std::vector{ + "", "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& SysYLexer::getRuleNames() const { + return sysylexerLexerStaticData->ruleNames; +} + +const std::vector& SysYLexer::getChannelNames() const { + return sysylexerLexerStaticData->channelNames; +} + +const std::vector& 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 +} diff --git a/src/antlr4/SysYLexer.h b/src/antlr4/SysYLexer.h new file mode 100644 index 0000000..6138f59 --- /dev/null +++ b/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& getRuleNames() const override; + + const std::vector& getChannelNames() const override; + + const std::vector& 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. + +}; + diff --git a/src/antlr4/SysYParser.cpp b/src/antlr4/SysYParser.cpp new file mode 100644 index 0000000..7ce5a49 --- /dev/null +++ b/src/antlr4/SysYParser.cpp @@ -0,0 +1,3208 @@ + +// Generated from SysY.g4 by ANTLR 4.13.2 + + +#include "SysYVisitor.h" + +#include "SysYParser.h" + + +using namespace antlrcpp; + +using namespace antlr4; + +namespace { + +struct SysYParserStaticData final { + SysYParserStaticData(std::vector ruleNames, + std::vector literalNames, + std::vector symbolicNames) + : ruleNames(std::move(ruleNames)), literalNames(std::move(literalNames)), + symbolicNames(std::move(symbolicNames)), + vocabulary(this->literalNames, this->symbolicNames) {} + + SysYParserStaticData(const SysYParserStaticData&) = delete; + SysYParserStaticData(SysYParserStaticData&&) = delete; + SysYParserStaticData& operator=(const SysYParserStaticData&) = delete; + SysYParserStaticData& operator=(SysYParserStaticData&&) = delete; + + std::vector decisionToDFA; + antlr4::atn::PredictionContextCache sharedContextCache; + const std::vector ruleNames; + const std::vector literalNames; + const std::vector symbolicNames; + const antlr4::dfa::Vocabulary vocabulary; + antlr4::atn::SerializedATNView serializedATN; + std::unique_ptr atn; +}; + +::antlr4::internal::OnceFlag sysyParserOnceFlag; +#if ANTLR4_USE_THREAD_LOCAL_CACHE +static thread_local +#endif +std::unique_ptr sysyParserStaticData = nullptr; + +void sysyParserInitialize() { +#if ANTLR4_USE_THREAD_LOCAL_CACHE + if (sysyParserStaticData != nullptr) { + return; + } +#else + assert(sysyParserStaticData == nullptr); +#endif + auto staticData = std::make_unique( + std::vector{ + "compUnit", "decl", "constDecl", "constDef", "constInitValue", "varDecl", + "btype", "varDef", "initValue", "funcDef", "funcType", "funcFParams", + "funcFParam", "blockStmt", "blockItem", "stmt", "returnStmt", "exp", + "cond", "lValue", "primaryExp", "number", "unaryExp", "unaryOp", "funcRParams", + "mulExp", "addExp", "relExp", "eqExp", "lAndExp", "lOrExp", "constExp" + }, + std::vector{ + "", "'const'", "'int'", "'float'", "'void'", "'if'", "'else'", "'while'", + "'break'", "'continue'", "'return'", "'='", "'=='", "'!='", "'<'", + "'>'", "'<='", "'>='", "'+'", "'-'", "'*'", "'/'", "'%'", "'!'", "'&&'", + "'||'", "'('", "')'", "'['", "']'", "'{'", "'}'", "','", "';'" + }, + std::vector{ + "", "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,1,39,358,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,1,0,1,0,4,0,67,8,0,11,0,12,0,68,1,0, + 1,0,1,1,1,1,3,1,75,8,1,1,2,1,2,1,2,1,2,1,2,5,2,82,8,2,10,2,12,2,85,9, + 2,1,2,1,2,1,3,1,3,1,3,1,3,1,3,5,3,94,8,3,10,3,12,3,97,9,3,1,3,1,3,1,3, + 1,4,1,4,1,4,1,4,1,4,5,4,107,8,4,10,4,12,4,110,9,4,3,4,112,8,4,1,4,3,4, + 115,8,4,1,5,1,5,1,5,1,5,5,5,121,8,5,10,5,12,5,124,9,5,1,5,1,5,1,6,1,6, + 1,7,1,7,1,7,1,7,1,7,5,7,135,8,7,10,7,12,7,138,9,7,1,7,1,7,3,7,142,8,7, + 1,8,1,8,1,8,1,8,1,8,5,8,149,8,8,10,8,12,8,152,9,8,3,8,154,8,8,1,8,3,8, + 157,8,8,1,9,1,9,1,9,1,9,3,9,163,8,9,1,9,1,9,1,9,1,10,1,10,1,11,1,11,1, + 11,5,11,173,8,11,10,11,12,11,176,9,11,1,12,1,12,1,12,1,12,1,12,1,12,1, + 12,1,12,5,12,186,8,12,10,12,12,12,189,9,12,3,12,191,8,12,1,13,1,13,5, + 13,195,8,13,10,13,12,13,198,9,13,1,13,1,13,1,14,1,14,3,14,204,8,14,1, + 15,1,15,1,15,1,15,1,15,1,15,3,15,212,8,15,1,15,1,15,1,15,1,15,1,15,1, + 15,1,15,1,15,1,15,3,15,223,8,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1, + 15,1,15,1,15,1,15,3,15,236,8,15,1,16,1,16,3,16,240,8,16,1,16,1,16,1,17, + 1,17,1,18,1,18,1,19,1,19,1,19,1,19,1,19,5,19,253,8,19,10,19,12,19,256, + 9,19,1,20,1,20,1,20,1,20,1,20,1,20,3,20,264,8,20,1,21,1,21,1,22,1,22, + 1,22,1,22,3,22,272,8,22,1,22,1,22,1,22,1,22,3,22,278,8,22,1,23,1,23,1, + 24,1,24,1,24,5,24,285,8,24,10,24,12,24,288,9,24,1,25,1,25,1,25,1,25,1, + 25,1,25,5,25,296,8,25,10,25,12,25,299,9,25,1,26,1,26,1,26,1,26,1,26,1, + 26,5,26,307,8,26,10,26,12,26,310,9,26,1,27,1,27,1,27,1,27,1,27,1,27,5, + 27,318,8,27,10,27,12,27,321,9,27,1,28,1,28,1,28,1,28,1,28,1,28,5,28,329, + 8,28,10,28,12,28,332,9,28,1,29,1,29,1,29,1,29,1,29,1,29,5,29,340,8,29, + 10,29,12,29,343,9,29,1,30,1,30,1,30,1,30,1,30,1,30,5,30,351,8,30,10,30, + 12,30,354,9,30,1,31,1,31,1,31,0,6,50,52,54,56,58,60,32,0,2,4,6,8,10,12, + 14,16,18,20,22,24,26,28,30,32,34,36,38,40,42,44,46,48,50,52,54,56,58, + 60,62,0,8,1,0,2,3,1,0,2,4,1,0,35,36,2,0,18,19,23,23,1,0,20,22,1,0,18, + 19,1,0,14,17,1,0,12,13,368,0,66,1,0,0,0,2,74,1,0,0,0,4,76,1,0,0,0,6,88, + 1,0,0,0,8,114,1,0,0,0,10,116,1,0,0,0,12,127,1,0,0,0,14,129,1,0,0,0,16, + 156,1,0,0,0,18,158,1,0,0,0,20,167,1,0,0,0,22,169,1,0,0,0,24,177,1,0,0, + 0,26,192,1,0,0,0,28,203,1,0,0,0,30,235,1,0,0,0,32,237,1,0,0,0,34,243, + 1,0,0,0,36,245,1,0,0,0,38,247,1,0,0,0,40,263,1,0,0,0,42,265,1,0,0,0,44, + 277,1,0,0,0,46,279,1,0,0,0,48,281,1,0,0,0,50,289,1,0,0,0,52,300,1,0,0, + 0,54,311,1,0,0,0,56,322,1,0,0,0,58,333,1,0,0,0,60,344,1,0,0,0,62,355, + 1,0,0,0,64,67,3,2,1,0,65,67,3,18,9,0,66,64,1,0,0,0,66,65,1,0,0,0,67,68, + 1,0,0,0,68,66,1,0,0,0,68,69,1,0,0,0,69,70,1,0,0,0,70,71,5,0,0,1,71,1, + 1,0,0,0,72,75,3,4,2,0,73,75,3,10,5,0,74,72,1,0,0,0,74,73,1,0,0,0,75,3, + 1,0,0,0,76,77,5,1,0,0,77,78,3,12,6,0,78,83,3,6,3,0,79,80,5,32,0,0,80, + 82,3,6,3,0,81,79,1,0,0,0,82,85,1,0,0,0,83,81,1,0,0,0,83,84,1,0,0,0,84, + 86,1,0,0,0,85,83,1,0,0,0,86,87,5,33,0,0,87,5,1,0,0,0,88,95,5,34,0,0,89, + 90,5,28,0,0,90,91,3,62,31,0,91,92,5,29,0,0,92,94,1,0,0,0,93,89,1,0,0, + 0,94,97,1,0,0,0,95,93,1,0,0,0,95,96,1,0,0,0,96,98,1,0,0,0,97,95,1,0,0, + 0,98,99,5,11,0,0,99,100,3,8,4,0,100,7,1,0,0,0,101,115,3,62,31,0,102,111, + 5,30,0,0,103,108,3,8,4,0,104,105,5,32,0,0,105,107,3,8,4,0,106,104,1,0, + 0,0,107,110,1,0,0,0,108,106,1,0,0,0,108,109,1,0,0,0,109,112,1,0,0,0,110, + 108,1,0,0,0,111,103,1,0,0,0,111,112,1,0,0,0,112,113,1,0,0,0,113,115,5, + 31,0,0,114,101,1,0,0,0,114,102,1,0,0,0,115,9,1,0,0,0,116,117,3,12,6,0, + 117,122,3,14,7,0,118,119,5,32,0,0,119,121,3,14,7,0,120,118,1,0,0,0,121, + 124,1,0,0,0,122,120,1,0,0,0,122,123,1,0,0,0,123,125,1,0,0,0,124,122,1, + 0,0,0,125,126,5,33,0,0,126,11,1,0,0,0,127,128,7,0,0,0,128,13,1,0,0,0, + 129,136,5,34,0,0,130,131,5,28,0,0,131,132,3,62,31,0,132,133,5,29,0,0, + 133,135,1,0,0,0,134,130,1,0,0,0,135,138,1,0,0,0,136,134,1,0,0,0,136,137, + 1,0,0,0,137,141,1,0,0,0,138,136,1,0,0,0,139,140,5,11,0,0,140,142,3,16, + 8,0,141,139,1,0,0,0,141,142,1,0,0,0,142,15,1,0,0,0,143,157,3,34,17,0, + 144,153,5,30,0,0,145,150,3,16,8,0,146,147,5,32,0,0,147,149,3,16,8,0,148, + 146,1,0,0,0,149,152,1,0,0,0,150,148,1,0,0,0,150,151,1,0,0,0,151,154,1, + 0,0,0,152,150,1,0,0,0,153,145,1,0,0,0,153,154,1,0,0,0,154,155,1,0,0,0, + 155,157,5,31,0,0,156,143,1,0,0,0,156,144,1,0,0,0,157,17,1,0,0,0,158,159, + 3,20,10,0,159,160,5,34,0,0,160,162,5,26,0,0,161,163,3,22,11,0,162,161, + 1,0,0,0,162,163,1,0,0,0,163,164,1,0,0,0,164,165,5,27,0,0,165,166,3,26, + 13,0,166,19,1,0,0,0,167,168,7,1,0,0,168,21,1,0,0,0,169,174,3,24,12,0, + 170,171,5,32,0,0,171,173,3,24,12,0,172,170,1,0,0,0,173,176,1,0,0,0,174, + 172,1,0,0,0,174,175,1,0,0,0,175,23,1,0,0,0,176,174,1,0,0,0,177,178,3, + 12,6,0,178,190,5,34,0,0,179,180,5,28,0,0,180,187,5,29,0,0,181,182,5,28, + 0,0,182,183,3,34,17,0,183,184,5,29,0,0,184,186,1,0,0,0,185,181,1,0,0, + 0,186,189,1,0,0,0,187,185,1,0,0,0,187,188,1,0,0,0,188,191,1,0,0,0,189, + 187,1,0,0,0,190,179,1,0,0,0,190,191,1,0,0,0,191,25,1,0,0,0,192,196,5, + 30,0,0,193,195,3,28,14,0,194,193,1,0,0,0,195,198,1,0,0,0,196,194,1,0, + 0,0,196,197,1,0,0,0,197,199,1,0,0,0,198,196,1,0,0,0,199,200,5,31,0,0, + 200,27,1,0,0,0,201,204,3,2,1,0,202,204,3,30,15,0,203,201,1,0,0,0,203, + 202,1,0,0,0,204,29,1,0,0,0,205,206,3,38,19,0,206,207,5,11,0,0,207,208, + 3,34,17,0,208,209,5,33,0,0,209,236,1,0,0,0,210,212,3,34,17,0,211,210, + 1,0,0,0,211,212,1,0,0,0,212,213,1,0,0,0,213,236,5,33,0,0,214,236,3,26, + 13,0,215,216,5,5,0,0,216,217,5,26,0,0,217,218,3,36,18,0,218,219,5,27, + 0,0,219,222,3,30,15,0,220,221,5,6,0,0,221,223,3,30,15,0,222,220,1,0,0, + 0,222,223,1,0,0,0,223,236,1,0,0,0,224,225,5,7,0,0,225,226,5,26,0,0,226, + 227,3,36,18,0,227,228,5,27,0,0,228,229,3,30,15,0,229,236,1,0,0,0,230, + 231,5,8,0,0,231,236,5,33,0,0,232,233,5,9,0,0,233,236,5,33,0,0,234,236, + 3,32,16,0,235,205,1,0,0,0,235,211,1,0,0,0,235,214,1,0,0,0,235,215,1,0, + 0,0,235,224,1,0,0,0,235,230,1,0,0,0,235,232,1,0,0,0,235,234,1,0,0,0,236, + 31,1,0,0,0,237,239,5,10,0,0,238,240,3,34,17,0,239,238,1,0,0,0,239,240, + 1,0,0,0,240,241,1,0,0,0,241,242,5,33,0,0,242,33,1,0,0,0,243,244,3,52, + 26,0,244,35,1,0,0,0,245,246,3,60,30,0,246,37,1,0,0,0,247,254,5,34,0,0, + 248,249,5,28,0,0,249,250,3,34,17,0,250,251,5,29,0,0,251,253,1,0,0,0,252, + 248,1,0,0,0,253,256,1,0,0,0,254,252,1,0,0,0,254,255,1,0,0,0,255,39,1, + 0,0,0,256,254,1,0,0,0,257,258,5,26,0,0,258,259,3,34,17,0,259,260,5,27, + 0,0,260,264,1,0,0,0,261,264,3,38,19,0,262,264,3,42,21,0,263,257,1,0,0, + 0,263,261,1,0,0,0,263,262,1,0,0,0,264,41,1,0,0,0,265,266,7,2,0,0,266, + 43,1,0,0,0,267,278,3,40,20,0,268,269,5,34,0,0,269,271,5,26,0,0,270,272, + 3,48,24,0,271,270,1,0,0,0,271,272,1,0,0,0,272,273,1,0,0,0,273,278,5,27, + 0,0,274,275,3,46,23,0,275,276,3,44,22,0,276,278,1,0,0,0,277,267,1,0,0, + 0,277,268,1,0,0,0,277,274,1,0,0,0,278,45,1,0,0,0,279,280,7,3,0,0,280, + 47,1,0,0,0,281,286,3,34,17,0,282,283,5,32,0,0,283,285,3,34,17,0,284,282, + 1,0,0,0,285,288,1,0,0,0,286,284,1,0,0,0,286,287,1,0,0,0,287,49,1,0,0, + 0,288,286,1,0,0,0,289,290,6,25,-1,0,290,291,3,44,22,0,291,297,1,0,0,0, + 292,293,10,1,0,0,293,294,7,4,0,0,294,296,3,44,22,0,295,292,1,0,0,0,296, + 299,1,0,0,0,297,295,1,0,0,0,297,298,1,0,0,0,298,51,1,0,0,0,299,297,1, + 0,0,0,300,301,6,26,-1,0,301,302,3,50,25,0,302,308,1,0,0,0,303,304,10, + 1,0,0,304,305,7,5,0,0,305,307,3,50,25,0,306,303,1,0,0,0,307,310,1,0,0, + 0,308,306,1,0,0,0,308,309,1,0,0,0,309,53,1,0,0,0,310,308,1,0,0,0,311, + 312,6,27,-1,0,312,313,3,52,26,0,313,319,1,0,0,0,314,315,10,1,0,0,315, + 316,7,6,0,0,316,318,3,52,26,0,317,314,1,0,0,0,318,321,1,0,0,0,319,317, + 1,0,0,0,319,320,1,0,0,0,320,55,1,0,0,0,321,319,1,0,0,0,322,323,6,28,-1, + 0,323,324,3,54,27,0,324,330,1,0,0,0,325,326,10,1,0,0,326,327,7,7,0,0, + 327,329,3,54,27,0,328,325,1,0,0,0,329,332,1,0,0,0,330,328,1,0,0,0,330, + 331,1,0,0,0,331,57,1,0,0,0,332,330,1,0,0,0,333,334,6,29,-1,0,334,335, + 3,56,28,0,335,341,1,0,0,0,336,337,10,1,0,0,337,338,5,24,0,0,338,340,3, + 56,28,0,339,336,1,0,0,0,340,343,1,0,0,0,341,339,1,0,0,0,341,342,1,0,0, + 0,342,59,1,0,0,0,343,341,1,0,0,0,344,345,6,30,-1,0,345,346,3,58,29,0, + 346,352,1,0,0,0,347,348,10,1,0,0,348,349,5,25,0,0,349,351,3,58,29,0,350, + 347,1,0,0,0,351,354,1,0,0,0,352,350,1,0,0,0,352,353,1,0,0,0,353,61,1, + 0,0,0,354,352,1,0,0,0,355,356,3,52,26,0,356,63,1,0,0,0,35,66,68,74,83, + 95,108,111,114,122,136,141,150,153,156,162,174,187,190,196,203,211,222, + 235,239,254,263,271,277,286,297,308,319,330,341,352 + }; + 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); + } + sysyParserStaticData = std::move(staticData); +} + +} + +SysYParser::SysYParser(TokenStream *input) : SysYParser(input, antlr4::atn::ParserATNSimulatorOptions()) {} + +SysYParser::SysYParser(TokenStream *input, const antlr4::atn::ParserATNSimulatorOptions &options) : Parser(input) { + SysYParser::initialize(); + _interpreter = new atn::ParserATNSimulator(this, *sysyParserStaticData->atn, sysyParserStaticData->decisionToDFA, sysyParserStaticData->sharedContextCache, options); +} + +SysYParser::~SysYParser() { + delete _interpreter; +} + +const atn::ATN& SysYParser::getATN() const { + return *sysyParserStaticData->atn; +} + +std::string SysYParser::getGrammarFileName() const { + return "SysY.g4"; +} + +const std::vector& SysYParser::getRuleNames() const { + return sysyParserStaticData->ruleNames; +} + +const dfa::Vocabulary& SysYParser::getVocabulary() const { + return sysyParserStaticData->vocabulary; +} + +antlr4::atn::SerializedATNView SysYParser::getSerializedATN() const { + return sysyParserStaticData->serializedATN; +} + + +//----------------- CompUnitContext ------------------------------------------------------------------ + +SysYParser::CompUnitContext::CompUnitContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SysYParser::CompUnitContext::EOF() { + return getToken(SysYParser::EOF, 0); +} + +std::vector SysYParser::CompUnitContext::decl() { + return getRuleContexts(); +} + +SysYParser::DeclContext* SysYParser::CompUnitContext::decl(size_t i) { + return getRuleContext(i); +} + +std::vector SysYParser::CompUnitContext::funcDef() { + return getRuleContexts(); +} + +SysYParser::FuncDefContext* SysYParser::CompUnitContext::funcDef(size_t i) { + return getRuleContext(i); +} + + +size_t SysYParser::CompUnitContext::getRuleIndex() const { + return SysYParser::RuleCompUnit; +} + + +std::any SysYParser::CompUnitContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitCompUnit(this); + else + return visitor->visitChildren(this); +} + +SysYParser::CompUnitContext* SysYParser::compUnit() { + CompUnitContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 0, SysYParser::RuleCompUnit); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(66); + _errHandler->sync(this); + _la = _input->LA(1); + do { + setState(66); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 0, _ctx)) { + case 1: { + setState(64); + decl(); + break; + } + + case 2: { + setState(65); + funcDef(); + break; + } + + default: + break; + } + setState(68); + _errHandler->sync(this); + _la = _input->LA(1); + } while ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 30) != 0)); + setState(70); + match(SysYParser::EOF); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- DeclContext ------------------------------------------------------------------ + +SysYParser::DeclContext::DeclContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +SysYParser::ConstDeclContext* SysYParser::DeclContext::constDecl() { + return getRuleContext(0); +} + +SysYParser::VarDeclContext* SysYParser::DeclContext::varDecl() { + return getRuleContext(0); +} + + +size_t SysYParser::DeclContext::getRuleIndex() const { + return SysYParser::RuleDecl; +} + + +std::any SysYParser::DeclContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitDecl(this); + else + return visitor->visitChildren(this); +} + +SysYParser::DeclContext* SysYParser::decl() { + DeclContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 2, SysYParser::RuleDecl); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(74); + _errHandler->sync(this); + switch (_input->LA(1)) { + case SysYParser::CONST: { + enterOuterAlt(_localctx, 1); + setState(72); + constDecl(); + break; + } + + case SysYParser::INT: + case SysYParser::FLOAT: { + enterOuterAlt(_localctx, 2); + setState(73); + varDecl(); + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ConstDeclContext ------------------------------------------------------------------ + +SysYParser::ConstDeclContext::ConstDeclContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SysYParser::ConstDeclContext::CONST() { + return getToken(SysYParser::CONST, 0); +} + +SysYParser::BtypeContext* SysYParser::ConstDeclContext::btype() { + return getRuleContext(0); +} + +std::vector SysYParser::ConstDeclContext::constDef() { + return getRuleContexts(); +} + +SysYParser::ConstDefContext* SysYParser::ConstDeclContext::constDef(size_t i) { + return getRuleContext(i); +} + +tree::TerminalNode* SysYParser::ConstDeclContext::SEMICOLON() { + return getToken(SysYParser::SEMICOLON, 0); +} + +std::vector SysYParser::ConstDeclContext::COMMA() { + return getTokens(SysYParser::COMMA); +} + +tree::TerminalNode* SysYParser::ConstDeclContext::COMMA(size_t i) { + return getToken(SysYParser::COMMA, i); +} + + +size_t SysYParser::ConstDeclContext::getRuleIndex() const { + return SysYParser::RuleConstDecl; +} + + +std::any SysYParser::ConstDeclContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitConstDecl(this); + else + return visitor->visitChildren(this); +} + +SysYParser::ConstDeclContext* SysYParser::constDecl() { + ConstDeclContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 4, SysYParser::RuleConstDecl); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(76); + match(SysYParser::CONST); + setState(77); + btype(); + setState(78); + constDef(); + setState(83); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysYParser::COMMA) { + setState(79); + match(SysYParser::COMMA); + setState(80); + constDef(); + setState(85); + _errHandler->sync(this); + _la = _input->LA(1); + } + setState(86); + match(SysYParser::SEMICOLON); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ConstDefContext ------------------------------------------------------------------ + +SysYParser::ConstDefContext::ConstDefContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SysYParser::ConstDefContext::ID() { + return getToken(SysYParser::ID, 0); +} + +tree::TerminalNode* SysYParser::ConstDefContext::ASSIGN() { + return getToken(SysYParser::ASSIGN, 0); +} + +SysYParser::ConstInitValueContext* SysYParser::ConstDefContext::constInitValue() { + return getRuleContext(0); +} + +std::vector SysYParser::ConstDefContext::LBRACK() { + return getTokens(SysYParser::LBRACK); +} + +tree::TerminalNode* SysYParser::ConstDefContext::LBRACK(size_t i) { + return getToken(SysYParser::LBRACK, i); +} + +std::vector SysYParser::ConstDefContext::constExp() { + return getRuleContexts(); +} + +SysYParser::ConstExpContext* SysYParser::ConstDefContext::constExp(size_t i) { + return getRuleContext(i); +} + +std::vector SysYParser::ConstDefContext::RBRACK() { + return getTokens(SysYParser::RBRACK); +} + +tree::TerminalNode* SysYParser::ConstDefContext::RBRACK(size_t i) { + return getToken(SysYParser::RBRACK, i); +} + + +size_t SysYParser::ConstDefContext::getRuleIndex() const { + return SysYParser::RuleConstDef; +} + + +std::any SysYParser::ConstDefContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitConstDef(this); + else + return visitor->visitChildren(this); +} + +SysYParser::ConstDefContext* SysYParser::constDef() { + ConstDefContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 6, SysYParser::RuleConstDef); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(88); + match(SysYParser::ID); + setState(95); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysYParser::LBRACK) { + setState(89); + match(SysYParser::LBRACK); + setState(90); + constExp(); + setState(91); + match(SysYParser::RBRACK); + setState(97); + _errHandler->sync(this); + _la = _input->LA(1); + } + setState(98); + match(SysYParser::ASSIGN); + setState(99); + constInitValue(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ConstInitValueContext ------------------------------------------------------------------ + +SysYParser::ConstInitValueContext::ConstInitValueContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +SysYParser::ConstExpContext* SysYParser::ConstInitValueContext::constExp() { + return getRuleContext(0); +} + +tree::TerminalNode* SysYParser::ConstInitValueContext::LBRACE() { + return getToken(SysYParser::LBRACE, 0); +} + +tree::TerminalNode* SysYParser::ConstInitValueContext::RBRACE() { + return getToken(SysYParser::RBRACE, 0); +} + +std::vector SysYParser::ConstInitValueContext::constInitValue() { + return getRuleContexts(); +} + +SysYParser::ConstInitValueContext* SysYParser::ConstInitValueContext::constInitValue(size_t i) { + return getRuleContext(i); +} + +std::vector SysYParser::ConstInitValueContext::COMMA() { + return getTokens(SysYParser::COMMA); +} + +tree::TerminalNode* SysYParser::ConstInitValueContext::COMMA(size_t i) { + return getToken(SysYParser::COMMA, i); +} + + +size_t SysYParser::ConstInitValueContext::getRuleIndex() const { + return SysYParser::RuleConstInitValue; +} + + +std::any SysYParser::ConstInitValueContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitConstInitValue(this); + else + return visitor->visitChildren(this); +} + +SysYParser::ConstInitValueContext* SysYParser::constInitValue() { + ConstInitValueContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 8, SysYParser::RuleConstInitValue); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(114); + _errHandler->sync(this); + switch (_input->LA(1)) { + case SysYParser::ADD: + case SysYParser::SUB: + case SysYParser::NOT: + case SysYParser::LPAREN: + case SysYParser::ID: + case SysYParser::FLITERAL: + case SysYParser::ILITERAL: { + enterOuterAlt(_localctx, 1); + setState(101); + constExp(); + break; + } + + case SysYParser::LBRACE: { + enterOuterAlt(_localctx, 2); + setState(102); + match(SysYParser::LBRACE); + setState(111); + _errHandler->sync(this); + + _la = _input->LA(1); + if ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 121409110016) != 0)) { + setState(103); + constInitValue(); + setState(108); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysYParser::COMMA) { + setState(104); + match(SysYParser::COMMA); + setState(105); + constInitValue(); + setState(110); + _errHandler->sync(this); + _la = _input->LA(1); + } + } + setState(113); + match(SysYParser::RBRACE); + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- VarDeclContext ------------------------------------------------------------------ + +SysYParser::VarDeclContext::VarDeclContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +SysYParser::BtypeContext* SysYParser::VarDeclContext::btype() { + return getRuleContext(0); +} + +std::vector SysYParser::VarDeclContext::varDef() { + return getRuleContexts(); +} + +SysYParser::VarDefContext* SysYParser::VarDeclContext::varDef(size_t i) { + return getRuleContext(i); +} + +tree::TerminalNode* SysYParser::VarDeclContext::SEMICOLON() { + return getToken(SysYParser::SEMICOLON, 0); +} + +std::vector SysYParser::VarDeclContext::COMMA() { + return getTokens(SysYParser::COMMA); +} + +tree::TerminalNode* SysYParser::VarDeclContext::COMMA(size_t i) { + return getToken(SysYParser::COMMA, i); +} + + +size_t SysYParser::VarDeclContext::getRuleIndex() const { + return SysYParser::RuleVarDecl; +} + + +std::any SysYParser::VarDeclContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitVarDecl(this); + else + return visitor->visitChildren(this); +} + +SysYParser::VarDeclContext* SysYParser::varDecl() { + VarDeclContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 10, SysYParser::RuleVarDecl); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(116); + btype(); + setState(117); + varDef(); + setState(122); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysYParser::COMMA) { + setState(118); + match(SysYParser::COMMA); + setState(119); + varDef(); + setState(124); + _errHandler->sync(this); + _la = _input->LA(1); + } + setState(125); + match(SysYParser::SEMICOLON); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- BtypeContext ------------------------------------------------------------------ + +SysYParser::BtypeContext::BtypeContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SysYParser::BtypeContext::INT() { + return getToken(SysYParser::INT, 0); +} + +tree::TerminalNode* SysYParser::BtypeContext::FLOAT() { + return getToken(SysYParser::FLOAT, 0); +} + + +size_t SysYParser::BtypeContext::getRuleIndex() const { + return SysYParser::RuleBtype; +} + + +std::any SysYParser::BtypeContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitBtype(this); + else + return visitor->visitChildren(this); +} + +SysYParser::BtypeContext* SysYParser::btype() { + BtypeContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 12, SysYParser::RuleBtype); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(127); + _la = _input->LA(1); + if (!(_la == SysYParser::INT + + || _la == SysYParser::FLOAT)) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- VarDefContext ------------------------------------------------------------------ + +SysYParser::VarDefContext::VarDefContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SysYParser::VarDefContext::ID() { + return getToken(SysYParser::ID, 0); +} + +std::vector SysYParser::VarDefContext::LBRACK() { + return getTokens(SysYParser::LBRACK); +} + +tree::TerminalNode* SysYParser::VarDefContext::LBRACK(size_t i) { + return getToken(SysYParser::LBRACK, i); +} + +std::vector SysYParser::VarDefContext::constExp() { + return getRuleContexts(); +} + +SysYParser::ConstExpContext* SysYParser::VarDefContext::constExp(size_t i) { + return getRuleContext(i); +} + +std::vector SysYParser::VarDefContext::RBRACK() { + return getTokens(SysYParser::RBRACK); +} + +tree::TerminalNode* SysYParser::VarDefContext::RBRACK(size_t i) { + return getToken(SysYParser::RBRACK, i); +} + +tree::TerminalNode* SysYParser::VarDefContext::ASSIGN() { + return getToken(SysYParser::ASSIGN, 0); +} + +SysYParser::InitValueContext* SysYParser::VarDefContext::initValue() { + return getRuleContext(0); +} + + +size_t SysYParser::VarDefContext::getRuleIndex() const { + return SysYParser::RuleVarDef; +} + + +std::any SysYParser::VarDefContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitVarDef(this); + else + return visitor->visitChildren(this); +} + +SysYParser::VarDefContext* SysYParser::varDef() { + VarDefContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 14, SysYParser::RuleVarDef); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(129); + match(SysYParser::ID); + setState(136); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysYParser::LBRACK) { + setState(130); + match(SysYParser::LBRACK); + setState(131); + constExp(); + setState(132); + match(SysYParser::RBRACK); + setState(138); + _errHandler->sync(this); + _la = _input->LA(1); + } + setState(141); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == SysYParser::ASSIGN) { + setState(139); + match(SysYParser::ASSIGN); + setState(140); + initValue(); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- InitValueContext ------------------------------------------------------------------ + +SysYParser::InitValueContext::InitValueContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +SysYParser::ExpContext* SysYParser::InitValueContext::exp() { + return getRuleContext(0); +} + +tree::TerminalNode* SysYParser::InitValueContext::LBRACE() { + return getToken(SysYParser::LBRACE, 0); +} + +tree::TerminalNode* SysYParser::InitValueContext::RBRACE() { + return getToken(SysYParser::RBRACE, 0); +} + +std::vector SysYParser::InitValueContext::initValue() { + return getRuleContexts(); +} + +SysYParser::InitValueContext* SysYParser::InitValueContext::initValue(size_t i) { + return getRuleContext(i); +} + +std::vector SysYParser::InitValueContext::COMMA() { + return getTokens(SysYParser::COMMA); +} + +tree::TerminalNode* SysYParser::InitValueContext::COMMA(size_t i) { + return getToken(SysYParser::COMMA, i); +} + + +size_t SysYParser::InitValueContext::getRuleIndex() const { + return SysYParser::RuleInitValue; +} + + +std::any SysYParser::InitValueContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitInitValue(this); + else + return visitor->visitChildren(this); +} + +SysYParser::InitValueContext* SysYParser::initValue() { + InitValueContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 16, SysYParser::RuleInitValue); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(156); + _errHandler->sync(this); + switch (_input->LA(1)) { + case SysYParser::ADD: + case SysYParser::SUB: + case SysYParser::NOT: + case SysYParser::LPAREN: + case SysYParser::ID: + case SysYParser::FLITERAL: + case SysYParser::ILITERAL: { + enterOuterAlt(_localctx, 1); + setState(143); + exp(); + break; + } + + case SysYParser::LBRACE: { + enterOuterAlt(_localctx, 2); + setState(144); + match(SysYParser::LBRACE); + setState(153); + _errHandler->sync(this); + + _la = _input->LA(1); + if ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 121409110016) != 0)) { + setState(145); + initValue(); + setState(150); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysYParser::COMMA) { + setState(146); + match(SysYParser::COMMA); + setState(147); + initValue(); + setState(152); + _errHandler->sync(this); + _la = _input->LA(1); + } + } + setState(155); + match(SysYParser::RBRACE); + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- FuncDefContext ------------------------------------------------------------------ + +SysYParser::FuncDefContext::FuncDefContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +SysYParser::FuncTypeContext* SysYParser::FuncDefContext::funcType() { + return getRuleContext(0); +} + +tree::TerminalNode* SysYParser::FuncDefContext::ID() { + return getToken(SysYParser::ID, 0); +} + +tree::TerminalNode* SysYParser::FuncDefContext::LPAREN() { + return getToken(SysYParser::LPAREN, 0); +} + +tree::TerminalNode* SysYParser::FuncDefContext::RPAREN() { + return getToken(SysYParser::RPAREN, 0); +} + +SysYParser::BlockStmtContext* SysYParser::FuncDefContext::blockStmt() { + return getRuleContext(0); +} + +SysYParser::FuncFParamsContext* SysYParser::FuncDefContext::funcFParams() { + return getRuleContext(0); +} + + +size_t SysYParser::FuncDefContext::getRuleIndex() const { + return SysYParser::RuleFuncDef; +} + + +std::any SysYParser::FuncDefContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitFuncDef(this); + else + return visitor->visitChildren(this); +} + +SysYParser::FuncDefContext* SysYParser::funcDef() { + FuncDefContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 18, SysYParser::RuleFuncDef); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(158); + funcType(); + setState(159); + match(SysYParser::ID); + setState(160); + match(SysYParser::LPAREN); + setState(162); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == SysYParser::INT + + || _la == SysYParser::FLOAT) { + setState(161); + funcFParams(); + } + setState(164); + match(SysYParser::RPAREN); + setState(165); + blockStmt(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- FuncTypeContext ------------------------------------------------------------------ + +SysYParser::FuncTypeContext::FuncTypeContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SysYParser::FuncTypeContext::INT() { + return getToken(SysYParser::INT, 0); +} + +tree::TerminalNode* SysYParser::FuncTypeContext::FLOAT() { + return getToken(SysYParser::FLOAT, 0); +} + +tree::TerminalNode* SysYParser::FuncTypeContext::VOID() { + return getToken(SysYParser::VOID, 0); +} + + +size_t SysYParser::FuncTypeContext::getRuleIndex() const { + return SysYParser::RuleFuncType; +} + + +std::any SysYParser::FuncTypeContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitFuncType(this); + else + return visitor->visitChildren(this); +} + +SysYParser::FuncTypeContext* SysYParser::funcType() { + FuncTypeContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 20, SysYParser::RuleFuncType); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(167); + _la = _input->LA(1); + if (!((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 28) != 0))) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- FuncFParamsContext ------------------------------------------------------------------ + +SysYParser::FuncFParamsContext::FuncFParamsContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector SysYParser::FuncFParamsContext::funcFParam() { + return getRuleContexts(); +} + +SysYParser::FuncFParamContext* SysYParser::FuncFParamsContext::funcFParam(size_t i) { + return getRuleContext(i); +} + +std::vector SysYParser::FuncFParamsContext::COMMA() { + return getTokens(SysYParser::COMMA); +} + +tree::TerminalNode* SysYParser::FuncFParamsContext::COMMA(size_t i) { + return getToken(SysYParser::COMMA, i); +} + + +size_t SysYParser::FuncFParamsContext::getRuleIndex() const { + return SysYParser::RuleFuncFParams; +} + + +std::any SysYParser::FuncFParamsContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitFuncFParams(this); + else + return visitor->visitChildren(this); +} + +SysYParser::FuncFParamsContext* SysYParser::funcFParams() { + FuncFParamsContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 22, SysYParser::RuleFuncFParams); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(169); + funcFParam(); + setState(174); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysYParser::COMMA) { + setState(170); + match(SysYParser::COMMA); + setState(171); + funcFParam(); + setState(176); + _errHandler->sync(this); + _la = _input->LA(1); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- FuncFParamContext ------------------------------------------------------------------ + +SysYParser::FuncFParamContext::FuncFParamContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +SysYParser::BtypeContext* SysYParser::FuncFParamContext::btype() { + return getRuleContext(0); +} + +tree::TerminalNode* SysYParser::FuncFParamContext::ID() { + return getToken(SysYParser::ID, 0); +} + +std::vector SysYParser::FuncFParamContext::LBRACK() { + return getTokens(SysYParser::LBRACK); +} + +tree::TerminalNode* SysYParser::FuncFParamContext::LBRACK(size_t i) { + return getToken(SysYParser::LBRACK, i); +} + +std::vector SysYParser::FuncFParamContext::RBRACK() { + return getTokens(SysYParser::RBRACK); +} + +tree::TerminalNode* SysYParser::FuncFParamContext::RBRACK(size_t i) { + return getToken(SysYParser::RBRACK, i); +} + +std::vector SysYParser::FuncFParamContext::exp() { + return getRuleContexts(); +} + +SysYParser::ExpContext* SysYParser::FuncFParamContext::exp(size_t i) { + return getRuleContext(i); +} + + +size_t SysYParser::FuncFParamContext::getRuleIndex() const { + return SysYParser::RuleFuncFParam; +} + + +std::any SysYParser::FuncFParamContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitFuncFParam(this); + else + return visitor->visitChildren(this); +} + +SysYParser::FuncFParamContext* SysYParser::funcFParam() { + FuncFParamContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 24, SysYParser::RuleFuncFParam); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(177); + btype(); + setState(178); + match(SysYParser::ID); + setState(190); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == SysYParser::LBRACK) { + setState(179); + match(SysYParser::LBRACK); + setState(180); + match(SysYParser::RBRACK); + setState(187); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysYParser::LBRACK) { + setState(181); + match(SysYParser::LBRACK); + setState(182); + exp(); + setState(183); + match(SysYParser::RBRACK); + setState(189); + _errHandler->sync(this); + _la = _input->LA(1); + } + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- BlockStmtContext ------------------------------------------------------------------ + +SysYParser::BlockStmtContext::BlockStmtContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SysYParser::BlockStmtContext::LBRACE() { + return getToken(SysYParser::LBRACE, 0); +} + +tree::TerminalNode* SysYParser::BlockStmtContext::RBRACE() { + return getToken(SysYParser::RBRACE, 0); +} + +std::vector SysYParser::BlockStmtContext::blockItem() { + return getRuleContexts(); +} + +SysYParser::BlockItemContext* SysYParser::BlockStmtContext::blockItem(size_t i) { + return getRuleContext(i); +} + + +size_t SysYParser::BlockStmtContext::getRuleIndex() const { + return SysYParser::RuleBlockStmt; +} + + +std::any SysYParser::BlockStmtContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitBlockStmt(this); + else + return visitor->visitChildren(this); +} + +SysYParser::BlockStmtContext* SysYParser::blockStmt() { + BlockStmtContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 26, SysYParser::RuleBlockStmt); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(192); + match(SysYParser::LBRACE); + setState(196); + _errHandler->sync(this); + _la = _input->LA(1); + while ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 129999046574) != 0)) { + setState(193); + blockItem(); + setState(198); + _errHandler->sync(this); + _la = _input->LA(1); + } + setState(199); + match(SysYParser::RBRACE); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- BlockItemContext ------------------------------------------------------------------ + +SysYParser::BlockItemContext::BlockItemContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +SysYParser::DeclContext* SysYParser::BlockItemContext::decl() { + return getRuleContext(0); +} + +SysYParser::StmtContext* SysYParser::BlockItemContext::stmt() { + return getRuleContext(0); +} + + +size_t SysYParser::BlockItemContext::getRuleIndex() const { + return SysYParser::RuleBlockItem; +} + + +std::any SysYParser::BlockItemContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitBlockItem(this); + else + return visitor->visitChildren(this); +} + +SysYParser::BlockItemContext* SysYParser::blockItem() { + BlockItemContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 28, SysYParser::RuleBlockItem); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(203); + _errHandler->sync(this); + switch (_input->LA(1)) { + case SysYParser::CONST: + case SysYParser::INT: + case SysYParser::FLOAT: { + enterOuterAlt(_localctx, 1); + setState(201); + decl(); + break; + } + + case SysYParser::IF: + case SysYParser::WHILE: + case SysYParser::BREAK: + case SysYParser::CONTINUE: + case SysYParser::RETURN: + case SysYParser::ADD: + case SysYParser::SUB: + case SysYParser::NOT: + case SysYParser::LPAREN: + case SysYParser::LBRACE: + case SysYParser::SEMICOLON: + case SysYParser::ID: + case SysYParser::FLITERAL: + case SysYParser::ILITERAL: { + enterOuterAlt(_localctx, 2); + setState(202); + stmt(); + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- StmtContext ------------------------------------------------------------------ + +SysYParser::StmtContext::StmtContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +SysYParser::LValueContext* SysYParser::StmtContext::lValue() { + return getRuleContext(0); +} + +tree::TerminalNode* SysYParser::StmtContext::ASSIGN() { + return getToken(SysYParser::ASSIGN, 0); +} + +SysYParser::ExpContext* SysYParser::StmtContext::exp() { + return getRuleContext(0); +} + +tree::TerminalNode* SysYParser::StmtContext::SEMICOLON() { + return getToken(SysYParser::SEMICOLON, 0); +} + +SysYParser::BlockStmtContext* SysYParser::StmtContext::blockStmt() { + return getRuleContext(0); +} + +tree::TerminalNode* SysYParser::StmtContext::IF() { + return getToken(SysYParser::IF, 0); +} + +tree::TerminalNode* SysYParser::StmtContext::LPAREN() { + return getToken(SysYParser::LPAREN, 0); +} + +SysYParser::CondContext* SysYParser::StmtContext::cond() { + return getRuleContext(0); +} + +tree::TerminalNode* SysYParser::StmtContext::RPAREN() { + return getToken(SysYParser::RPAREN, 0); +} + +std::vector SysYParser::StmtContext::stmt() { + return getRuleContexts(); +} + +SysYParser::StmtContext* SysYParser::StmtContext::stmt(size_t i) { + return getRuleContext(i); +} + +tree::TerminalNode* SysYParser::StmtContext::ELSE() { + return getToken(SysYParser::ELSE, 0); +} + +tree::TerminalNode* SysYParser::StmtContext::WHILE() { + return getToken(SysYParser::WHILE, 0); +} + +tree::TerminalNode* SysYParser::StmtContext::BREAK() { + return getToken(SysYParser::BREAK, 0); +} + +tree::TerminalNode* SysYParser::StmtContext::CONTINUE() { + return getToken(SysYParser::CONTINUE, 0); +} + +SysYParser::ReturnStmtContext* SysYParser::StmtContext::returnStmt() { + return getRuleContext(0); +} + + +size_t SysYParser::StmtContext::getRuleIndex() const { + return SysYParser::RuleStmt; +} + + +std::any SysYParser::StmtContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitStmt(this); + else + return visitor->visitChildren(this); +} + +SysYParser::StmtContext* SysYParser::stmt() { + StmtContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 30, SysYParser::RuleStmt); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(235); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 22, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(205); + lValue(); + setState(206); + match(SysYParser::ASSIGN); + setState(207); + exp(); + setState(208); + match(SysYParser::SEMICOLON); + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(211); + _errHandler->sync(this); + + _la = _input->LA(1); + if ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 120335368192) != 0)) { + setState(210); + exp(); + } + setState(213); + match(SysYParser::SEMICOLON); + break; + } + + case 3: { + enterOuterAlt(_localctx, 3); + setState(214); + blockStmt(); + break; + } + + case 4: { + enterOuterAlt(_localctx, 4); + setState(215); + match(SysYParser::IF); + setState(216); + match(SysYParser::LPAREN); + setState(217); + cond(); + setState(218); + match(SysYParser::RPAREN); + setState(219); + stmt(); + setState(222); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 21, _ctx)) { + case 1: { + setState(220); + match(SysYParser::ELSE); + setState(221); + stmt(); + break; + } + + default: + break; + } + break; + } + + case 5: { + enterOuterAlt(_localctx, 5); + setState(224); + match(SysYParser::WHILE); + setState(225); + match(SysYParser::LPAREN); + setState(226); + cond(); + setState(227); + match(SysYParser::RPAREN); + setState(228); + stmt(); + break; + } + + case 6: { + enterOuterAlt(_localctx, 6); + setState(230); + match(SysYParser::BREAK); + setState(231); + match(SysYParser::SEMICOLON); + break; + } + + case 7: { + enterOuterAlt(_localctx, 7); + setState(232); + match(SysYParser::CONTINUE); + setState(233); + match(SysYParser::SEMICOLON); + break; + } + + case 8: { + enterOuterAlt(_localctx, 8); + setState(234); + returnStmt(); + break; + } + + default: + break; + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ReturnStmtContext ------------------------------------------------------------------ + +SysYParser::ReturnStmtContext::ReturnStmtContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SysYParser::ReturnStmtContext::RETURN() { + return getToken(SysYParser::RETURN, 0); +} + +tree::TerminalNode* SysYParser::ReturnStmtContext::SEMICOLON() { + return getToken(SysYParser::SEMICOLON, 0); +} + +SysYParser::ExpContext* SysYParser::ReturnStmtContext::exp() { + return getRuleContext(0); +} + + +size_t SysYParser::ReturnStmtContext::getRuleIndex() const { + return SysYParser::RuleReturnStmt; +} + + +std::any SysYParser::ReturnStmtContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitReturnStmt(this); + else + return visitor->visitChildren(this); +} + +SysYParser::ReturnStmtContext* SysYParser::returnStmt() { + ReturnStmtContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 32, SysYParser::RuleReturnStmt); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(237); + match(SysYParser::RETURN); + setState(239); + _errHandler->sync(this); + + _la = _input->LA(1); + if ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 120335368192) != 0)) { + setState(238); + exp(); + } + setState(241); + match(SysYParser::SEMICOLON); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ExpContext ------------------------------------------------------------------ + +SysYParser::ExpContext::ExpContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +SysYParser::AddExpContext* SysYParser::ExpContext::addExp() { + return getRuleContext(0); +} + + +size_t SysYParser::ExpContext::getRuleIndex() const { + return SysYParser::RuleExp; +} + + +std::any SysYParser::ExpContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitExp(this); + else + return visitor->visitChildren(this); +} + +SysYParser::ExpContext* SysYParser::exp() { + ExpContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 34, SysYParser::RuleExp); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(243); + addExp(0); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- CondContext ------------------------------------------------------------------ + +SysYParser::CondContext::CondContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +SysYParser::LOrExpContext* SysYParser::CondContext::lOrExp() { + return getRuleContext(0); +} + + +size_t SysYParser::CondContext::getRuleIndex() const { + return SysYParser::RuleCond; +} + + +std::any SysYParser::CondContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitCond(this); + else + return visitor->visitChildren(this); +} + +SysYParser::CondContext* SysYParser::cond() { + CondContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 36, SysYParser::RuleCond); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(245); + lOrExp(0); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- LValueContext ------------------------------------------------------------------ + +SysYParser::LValueContext::LValueContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SysYParser::LValueContext::ID() { + return getToken(SysYParser::ID, 0); +} + +std::vector SysYParser::LValueContext::LBRACK() { + return getTokens(SysYParser::LBRACK); +} + +tree::TerminalNode* SysYParser::LValueContext::LBRACK(size_t i) { + return getToken(SysYParser::LBRACK, i); +} + +std::vector SysYParser::LValueContext::exp() { + return getRuleContexts(); +} + +SysYParser::ExpContext* SysYParser::LValueContext::exp(size_t i) { + return getRuleContext(i); +} + +std::vector SysYParser::LValueContext::RBRACK() { + return getTokens(SysYParser::RBRACK); +} + +tree::TerminalNode* SysYParser::LValueContext::RBRACK(size_t i) { + return getToken(SysYParser::RBRACK, i); +} + + +size_t SysYParser::LValueContext::getRuleIndex() const { + return SysYParser::RuleLValue; +} + + +std::any SysYParser::LValueContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitLValue(this); + else + return visitor->visitChildren(this); +} + +SysYParser::LValueContext* SysYParser::lValue() { + LValueContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 38, SysYParser::RuleLValue); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(247); + match(SysYParser::ID); + setState(254); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 24, _ctx); + while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { + if (alt == 1) { + setState(248); + match(SysYParser::LBRACK); + setState(249); + exp(); + setState(250); + match(SysYParser::RBRACK); + } + setState(256); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 24, _ctx); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- PrimaryExpContext ------------------------------------------------------------------ + +SysYParser::PrimaryExpContext::PrimaryExpContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SysYParser::PrimaryExpContext::LPAREN() { + return getToken(SysYParser::LPAREN, 0); +} + +SysYParser::ExpContext* SysYParser::PrimaryExpContext::exp() { + return getRuleContext(0); +} + +tree::TerminalNode* SysYParser::PrimaryExpContext::RPAREN() { + return getToken(SysYParser::RPAREN, 0); +} + +SysYParser::LValueContext* SysYParser::PrimaryExpContext::lValue() { + return getRuleContext(0); +} + +SysYParser::NumberContext* SysYParser::PrimaryExpContext::number() { + return getRuleContext(0); +} + + +size_t SysYParser::PrimaryExpContext::getRuleIndex() const { + return SysYParser::RulePrimaryExp; +} + + +std::any SysYParser::PrimaryExpContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitPrimaryExp(this); + else + return visitor->visitChildren(this); +} + +SysYParser::PrimaryExpContext* SysYParser::primaryExp() { + PrimaryExpContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 40, SysYParser::RulePrimaryExp); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(263); + _errHandler->sync(this); + switch (_input->LA(1)) { + case SysYParser::LPAREN: { + enterOuterAlt(_localctx, 1); + setState(257); + match(SysYParser::LPAREN); + setState(258); + exp(); + setState(259); + match(SysYParser::RPAREN); + break; + } + + case SysYParser::ID: { + enterOuterAlt(_localctx, 2); + setState(261); + lValue(); + break; + } + + case SysYParser::FLITERAL: + case SysYParser::ILITERAL: { + enterOuterAlt(_localctx, 3); + setState(262); + number(); + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- NumberContext ------------------------------------------------------------------ + +SysYParser::NumberContext::NumberContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SysYParser::NumberContext::ILITERAL() { + return getToken(SysYParser::ILITERAL, 0); +} + +tree::TerminalNode* SysYParser::NumberContext::FLITERAL() { + return getToken(SysYParser::FLITERAL, 0); +} + + +size_t SysYParser::NumberContext::getRuleIndex() const { + return SysYParser::RuleNumber; +} + + +std::any SysYParser::NumberContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitNumber(this); + else + return visitor->visitChildren(this); +} + +SysYParser::NumberContext* SysYParser::number() { + NumberContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 42, SysYParser::RuleNumber); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(265); + _la = _input->LA(1); + if (!(_la == SysYParser::FLITERAL + + || _la == SysYParser::ILITERAL)) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- UnaryExpContext ------------------------------------------------------------------ + +SysYParser::UnaryExpContext::UnaryExpContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +SysYParser::PrimaryExpContext* SysYParser::UnaryExpContext::primaryExp() { + return getRuleContext(0); +} + +tree::TerminalNode* SysYParser::UnaryExpContext::ID() { + return getToken(SysYParser::ID, 0); +} + +tree::TerminalNode* SysYParser::UnaryExpContext::LPAREN() { + return getToken(SysYParser::LPAREN, 0); +} + +tree::TerminalNode* SysYParser::UnaryExpContext::RPAREN() { + return getToken(SysYParser::RPAREN, 0); +} + +SysYParser::FuncRParamsContext* SysYParser::UnaryExpContext::funcRParams() { + return getRuleContext(0); +} + +SysYParser::UnaryOpContext* SysYParser::UnaryExpContext::unaryOp() { + return getRuleContext(0); +} + +SysYParser::UnaryExpContext* SysYParser::UnaryExpContext::unaryExp() { + return getRuleContext(0); +} + + +size_t SysYParser::UnaryExpContext::getRuleIndex() const { + return SysYParser::RuleUnaryExp; +} + + +std::any SysYParser::UnaryExpContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitUnaryExp(this); + else + return visitor->visitChildren(this); +} + +SysYParser::UnaryExpContext* SysYParser::unaryExp() { + UnaryExpContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 44, SysYParser::RuleUnaryExp); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(277); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 27, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(267); + primaryExp(); + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(268); + match(SysYParser::ID); + setState(269); + match(SysYParser::LPAREN); + setState(271); + _errHandler->sync(this); + + _la = _input->LA(1); + if ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 120335368192) != 0)) { + setState(270); + funcRParams(); + } + setState(273); + match(SysYParser::RPAREN); + break; + } + + case 3: { + enterOuterAlt(_localctx, 3); + setState(274); + unaryOp(); + setState(275); + unaryExp(); + break; + } + + default: + break; + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- UnaryOpContext ------------------------------------------------------------------ + +SysYParser::UnaryOpContext::UnaryOpContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SysYParser::UnaryOpContext::ADD() { + return getToken(SysYParser::ADD, 0); +} + +tree::TerminalNode* SysYParser::UnaryOpContext::SUB() { + return getToken(SysYParser::SUB, 0); +} + +tree::TerminalNode* SysYParser::UnaryOpContext::NOT() { + return getToken(SysYParser::NOT, 0); +} + + +size_t SysYParser::UnaryOpContext::getRuleIndex() const { + return SysYParser::RuleUnaryOp; +} + + +std::any SysYParser::UnaryOpContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitUnaryOp(this); + else + return visitor->visitChildren(this); +} + +SysYParser::UnaryOpContext* SysYParser::unaryOp() { + UnaryOpContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 46, SysYParser::RuleUnaryOp); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(279); + _la = _input->LA(1); + if (!((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 9175040) != 0))) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- FuncRParamsContext ------------------------------------------------------------------ + +SysYParser::FuncRParamsContext::FuncRParamsContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector SysYParser::FuncRParamsContext::exp() { + return getRuleContexts(); +} + +SysYParser::ExpContext* SysYParser::FuncRParamsContext::exp(size_t i) { + return getRuleContext(i); +} + +std::vector SysYParser::FuncRParamsContext::COMMA() { + return getTokens(SysYParser::COMMA); +} + +tree::TerminalNode* SysYParser::FuncRParamsContext::COMMA(size_t i) { + return getToken(SysYParser::COMMA, i); +} + + +size_t SysYParser::FuncRParamsContext::getRuleIndex() const { + return SysYParser::RuleFuncRParams; +} + + +std::any SysYParser::FuncRParamsContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitFuncRParams(this); + else + return visitor->visitChildren(this); +} + +SysYParser::FuncRParamsContext* SysYParser::funcRParams() { + FuncRParamsContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 48, SysYParser::RuleFuncRParams); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(281); + exp(); + setState(286); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysYParser::COMMA) { + setState(282); + match(SysYParser::COMMA); + setState(283); + exp(); + setState(288); + _errHandler->sync(this); + _la = _input->LA(1); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- MulExpContext ------------------------------------------------------------------ + +SysYParser::MulExpContext::MulExpContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +SysYParser::UnaryExpContext* SysYParser::MulExpContext::unaryExp() { + return getRuleContext(0); +} + +SysYParser::MulExpContext* SysYParser::MulExpContext::mulExp() { + return getRuleContext(0); +} + +tree::TerminalNode* SysYParser::MulExpContext::MUL() { + return getToken(SysYParser::MUL, 0); +} + +tree::TerminalNode* SysYParser::MulExpContext::DIV() { + return getToken(SysYParser::DIV, 0); +} + +tree::TerminalNode* SysYParser::MulExpContext::MOD() { + return getToken(SysYParser::MOD, 0); +} + + +size_t SysYParser::MulExpContext::getRuleIndex() const { + return SysYParser::RuleMulExp; +} + + +std::any SysYParser::MulExpContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitMulExp(this); + else + return visitor->visitChildren(this); +} + + +SysYParser::MulExpContext* SysYParser::mulExp() { + return mulExp(0); +} + +SysYParser::MulExpContext* SysYParser::mulExp(int precedence) { + ParserRuleContext *parentContext = _ctx; + size_t parentState = getState(); + SysYParser::MulExpContext *_localctx = _tracker.createInstance(_ctx, parentState); + SysYParser::MulExpContext *previousContext = _localctx; + (void)previousContext; // Silence compiler, in case the context is not used by generated code. + size_t startState = 50; + enterRecursionRule(_localctx, 50, SysYParser::RuleMulExp, precedence); + + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + unrollRecursionContexts(parentContext); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(290); + unaryExp(); + _ctx->stop = _input->LT(-1); + setState(297); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 29, _ctx); + while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { + if (alt == 1) { + if (!_parseListeners.empty()) + triggerExitRuleEvent(); + previousContext = _localctx; + _localctx = _tracker.createInstance(parentContext, parentState); + pushNewRecursionContext(_localctx, startState, RuleMulExp); + setState(292); + + if (!(precpred(_ctx, 1))) throw FailedPredicateException(this, "precpred(_ctx, 1)"); + setState(293); + _la = _input->LA(1); + if (!((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 7340032) != 0))) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + setState(294); + unaryExp(); + } + setState(299); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 29, _ctx); + } + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + return _localctx; +} + +//----------------- AddExpContext ------------------------------------------------------------------ + +SysYParser::AddExpContext::AddExpContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +SysYParser::MulExpContext* SysYParser::AddExpContext::mulExp() { + return getRuleContext(0); +} + +SysYParser::AddExpContext* SysYParser::AddExpContext::addExp() { + return getRuleContext(0); +} + +tree::TerminalNode* SysYParser::AddExpContext::ADD() { + return getToken(SysYParser::ADD, 0); +} + +tree::TerminalNode* SysYParser::AddExpContext::SUB() { + return getToken(SysYParser::SUB, 0); +} + + +size_t SysYParser::AddExpContext::getRuleIndex() const { + return SysYParser::RuleAddExp; +} + + +std::any SysYParser::AddExpContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitAddExp(this); + else + return visitor->visitChildren(this); +} + + +SysYParser::AddExpContext* SysYParser::addExp() { + return addExp(0); +} + +SysYParser::AddExpContext* SysYParser::addExp(int precedence) { + ParserRuleContext *parentContext = _ctx; + size_t parentState = getState(); + SysYParser::AddExpContext *_localctx = _tracker.createInstance(_ctx, parentState); + SysYParser::AddExpContext *previousContext = _localctx; + (void)previousContext; // Silence compiler, in case the context is not used by generated code. + size_t startState = 52; + enterRecursionRule(_localctx, 52, SysYParser::RuleAddExp, precedence); + + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + unrollRecursionContexts(parentContext); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(301); + mulExp(0); + _ctx->stop = _input->LT(-1); + setState(308); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 30, _ctx); + while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { + if (alt == 1) { + if (!_parseListeners.empty()) + triggerExitRuleEvent(); + previousContext = _localctx; + _localctx = _tracker.createInstance(parentContext, parentState); + pushNewRecursionContext(_localctx, startState, RuleAddExp); + setState(303); + + if (!(precpred(_ctx, 1))) throw FailedPredicateException(this, "precpred(_ctx, 1)"); + setState(304); + _la = _input->LA(1); + if (!(_la == SysYParser::ADD + + || _la == SysYParser::SUB)) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + setState(305); + mulExp(0); + } + setState(310); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 30, _ctx); + } + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + return _localctx; +} + +//----------------- RelExpContext ------------------------------------------------------------------ + +SysYParser::RelExpContext::RelExpContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +SysYParser::AddExpContext* SysYParser::RelExpContext::addExp() { + return getRuleContext(0); +} + +SysYParser::RelExpContext* SysYParser::RelExpContext::relExp() { + return getRuleContext(0); +} + +tree::TerminalNode* SysYParser::RelExpContext::LT() { + return getToken(SysYParser::LT, 0); +} + +tree::TerminalNode* SysYParser::RelExpContext::GT() { + return getToken(SysYParser::GT, 0); +} + +tree::TerminalNode* SysYParser::RelExpContext::LE() { + return getToken(SysYParser::LE, 0); +} + +tree::TerminalNode* SysYParser::RelExpContext::GE() { + return getToken(SysYParser::GE, 0); +} + + +size_t SysYParser::RelExpContext::getRuleIndex() const { + return SysYParser::RuleRelExp; +} + + +std::any SysYParser::RelExpContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitRelExp(this); + else + return visitor->visitChildren(this); +} + + +SysYParser::RelExpContext* SysYParser::relExp() { + return relExp(0); +} + +SysYParser::RelExpContext* SysYParser::relExp(int precedence) { + ParserRuleContext *parentContext = _ctx; + size_t parentState = getState(); + SysYParser::RelExpContext *_localctx = _tracker.createInstance(_ctx, parentState); + SysYParser::RelExpContext *previousContext = _localctx; + (void)previousContext; // Silence compiler, in case the context is not used by generated code. + size_t startState = 54; + enterRecursionRule(_localctx, 54, SysYParser::RuleRelExp, precedence); + + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + unrollRecursionContexts(parentContext); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(312); + addExp(0); + _ctx->stop = _input->LT(-1); + setState(319); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 31, _ctx); + while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { + if (alt == 1) { + if (!_parseListeners.empty()) + triggerExitRuleEvent(); + previousContext = _localctx; + _localctx = _tracker.createInstance(parentContext, parentState); + pushNewRecursionContext(_localctx, startState, RuleRelExp); + setState(314); + + if (!(precpred(_ctx, 1))) throw FailedPredicateException(this, "precpred(_ctx, 1)"); + setState(315); + _la = _input->LA(1); + if (!((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 245760) != 0))) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + setState(316); + addExp(0); + } + setState(321); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 31, _ctx); + } + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + return _localctx; +} + +//----------------- EqExpContext ------------------------------------------------------------------ + +SysYParser::EqExpContext::EqExpContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +SysYParser::RelExpContext* SysYParser::EqExpContext::relExp() { + return getRuleContext(0); +} + +SysYParser::EqExpContext* SysYParser::EqExpContext::eqExp() { + return getRuleContext(0); +} + +tree::TerminalNode* SysYParser::EqExpContext::EQ() { + return getToken(SysYParser::EQ, 0); +} + +tree::TerminalNode* SysYParser::EqExpContext::NE() { + return getToken(SysYParser::NE, 0); +} + + +size_t SysYParser::EqExpContext::getRuleIndex() const { + return SysYParser::RuleEqExp; +} + + +std::any SysYParser::EqExpContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitEqExp(this); + else + return visitor->visitChildren(this); +} + + +SysYParser::EqExpContext* SysYParser::eqExp() { + return eqExp(0); +} + +SysYParser::EqExpContext* SysYParser::eqExp(int precedence) { + ParserRuleContext *parentContext = _ctx; + size_t parentState = getState(); + SysYParser::EqExpContext *_localctx = _tracker.createInstance(_ctx, parentState); + SysYParser::EqExpContext *previousContext = _localctx; + (void)previousContext; // Silence compiler, in case the context is not used by generated code. + size_t startState = 56; + enterRecursionRule(_localctx, 56, SysYParser::RuleEqExp, precedence); + + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + unrollRecursionContexts(parentContext); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(323); + relExp(0); + _ctx->stop = _input->LT(-1); + setState(330); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 32, _ctx); + while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { + if (alt == 1) { + if (!_parseListeners.empty()) + triggerExitRuleEvent(); + previousContext = _localctx; + _localctx = _tracker.createInstance(parentContext, parentState); + pushNewRecursionContext(_localctx, startState, RuleEqExp); + setState(325); + + if (!(precpred(_ctx, 1))) throw FailedPredicateException(this, "precpred(_ctx, 1)"); + setState(326); + _la = _input->LA(1); + if (!(_la == SysYParser::EQ + + || _la == SysYParser::NE)) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + setState(327); + relExp(0); + } + setState(332); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 32, _ctx); + } + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + return _localctx; +} + +//----------------- LAndExpContext ------------------------------------------------------------------ + +SysYParser::LAndExpContext::LAndExpContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +SysYParser::EqExpContext* SysYParser::LAndExpContext::eqExp() { + return getRuleContext(0); +} + +SysYParser::LAndExpContext* SysYParser::LAndExpContext::lAndExp() { + return getRuleContext(0); +} + +tree::TerminalNode* SysYParser::LAndExpContext::AND() { + return getToken(SysYParser::AND, 0); +} + + +size_t SysYParser::LAndExpContext::getRuleIndex() const { + return SysYParser::RuleLAndExp; +} + + +std::any SysYParser::LAndExpContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitLAndExp(this); + else + return visitor->visitChildren(this); +} + + +SysYParser::LAndExpContext* SysYParser::lAndExp() { + return lAndExp(0); +} + +SysYParser::LAndExpContext* SysYParser::lAndExp(int precedence) { + ParserRuleContext *parentContext = _ctx; + size_t parentState = getState(); + SysYParser::LAndExpContext *_localctx = _tracker.createInstance(_ctx, parentState); + SysYParser::LAndExpContext *previousContext = _localctx; + (void)previousContext; // Silence compiler, in case the context is not used by generated code. + size_t startState = 58; + enterRecursionRule(_localctx, 58, SysYParser::RuleLAndExp, precedence); + + + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + unrollRecursionContexts(parentContext); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(334); + eqExp(0); + _ctx->stop = _input->LT(-1); + setState(341); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 33, _ctx); + while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { + if (alt == 1) { + if (!_parseListeners.empty()) + triggerExitRuleEvent(); + previousContext = _localctx; + _localctx = _tracker.createInstance(parentContext, parentState); + pushNewRecursionContext(_localctx, startState, RuleLAndExp); + setState(336); + + if (!(precpred(_ctx, 1))) throw FailedPredicateException(this, "precpred(_ctx, 1)"); + setState(337); + match(SysYParser::AND); + setState(338); + eqExp(0); + } + setState(343); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 33, _ctx); + } + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + return _localctx; +} + +//----------------- LOrExpContext ------------------------------------------------------------------ + +SysYParser::LOrExpContext::LOrExpContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +SysYParser::LAndExpContext* SysYParser::LOrExpContext::lAndExp() { + return getRuleContext(0); +} + +SysYParser::LOrExpContext* SysYParser::LOrExpContext::lOrExp() { + return getRuleContext(0); +} + +tree::TerminalNode* SysYParser::LOrExpContext::OR() { + return getToken(SysYParser::OR, 0); +} + + +size_t SysYParser::LOrExpContext::getRuleIndex() const { + return SysYParser::RuleLOrExp; +} + + +std::any SysYParser::LOrExpContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitLOrExp(this); + else + return visitor->visitChildren(this); +} + + +SysYParser::LOrExpContext* SysYParser::lOrExp() { + return lOrExp(0); +} + +SysYParser::LOrExpContext* SysYParser::lOrExp(int precedence) { + ParserRuleContext *parentContext = _ctx; + size_t parentState = getState(); + SysYParser::LOrExpContext *_localctx = _tracker.createInstance(_ctx, parentState); + SysYParser::LOrExpContext *previousContext = _localctx; + (void)previousContext; // Silence compiler, in case the context is not used by generated code. + size_t startState = 60; + enterRecursionRule(_localctx, 60, SysYParser::RuleLOrExp, precedence); + + + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + unrollRecursionContexts(parentContext); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(345); + lAndExp(0); + _ctx->stop = _input->LT(-1); + setState(352); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 34, _ctx); + while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { + if (alt == 1) { + if (!_parseListeners.empty()) + triggerExitRuleEvent(); + previousContext = _localctx; + _localctx = _tracker.createInstance(parentContext, parentState); + pushNewRecursionContext(_localctx, startState, RuleLOrExp); + setState(347); + + if (!(precpred(_ctx, 1))) throw FailedPredicateException(this, "precpred(_ctx, 1)"); + setState(348); + match(SysYParser::OR); + setState(349); + lAndExp(0); + } + setState(354); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 34, _ctx); + } + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + return _localctx; +} + +//----------------- ConstExpContext ------------------------------------------------------------------ + +SysYParser::ConstExpContext::ConstExpContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +SysYParser::AddExpContext* SysYParser::ConstExpContext::addExp() { + return getRuleContext(0); +} + + +size_t SysYParser::ConstExpContext::getRuleIndex() const { + return SysYParser::RuleConstExp; +} + + +std::any SysYParser::ConstExpContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitConstExp(this); + else + return visitor->visitChildren(this); +} + +SysYParser::ConstExpContext* SysYParser::constExp() { + ConstExpContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 62, SysYParser::RuleConstExp); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(355); + addExp(0); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +bool SysYParser::sempred(RuleContext *context, size_t ruleIndex, size_t predicateIndex) { + switch (ruleIndex) { + case 25: return mulExpSempred(antlrcpp::downCast(context), predicateIndex); + case 26: return addExpSempred(antlrcpp::downCast(context), predicateIndex); + case 27: return relExpSempred(antlrcpp::downCast(context), predicateIndex); + case 28: return eqExpSempred(antlrcpp::downCast(context), predicateIndex); + case 29: return lAndExpSempred(antlrcpp::downCast(context), predicateIndex); + case 30: return lOrExpSempred(antlrcpp::downCast(context), predicateIndex); + + default: + break; + } + return true; +} + +bool SysYParser::mulExpSempred(MulExpContext *_localctx, size_t predicateIndex) { + switch (predicateIndex) { + case 0: return precpred(_ctx, 1); + + default: + break; + } + return true; +} + +bool SysYParser::addExpSempred(AddExpContext *_localctx, size_t predicateIndex) { + switch (predicateIndex) { + case 1: return precpred(_ctx, 1); + + default: + break; + } + return true; +} + +bool SysYParser::relExpSempred(RelExpContext *_localctx, size_t predicateIndex) { + switch (predicateIndex) { + case 2: return precpred(_ctx, 1); + + default: + break; + } + return true; +} + +bool SysYParser::eqExpSempred(EqExpContext *_localctx, size_t predicateIndex) { + switch (predicateIndex) { + case 3: return precpred(_ctx, 1); + + default: + break; + } + return true; +} + +bool SysYParser::lAndExpSempred(LAndExpContext *_localctx, size_t predicateIndex) { + switch (predicateIndex) { + case 4: return precpred(_ctx, 1); + + default: + break; + } + return true; +} + +bool SysYParser::lOrExpSempred(LOrExpContext *_localctx, size_t predicateIndex) { + switch (predicateIndex) { + case 5: return precpred(_ctx, 1); + + default: + break; + } + return true; +} + +void SysYParser::initialize() { +#if ANTLR4_USE_THREAD_LOCAL_CACHE + sysyParserInitialize(); +#else + ::antlr4::internal::call_once(sysyParserOnceFlag, sysyParserInitialize); +#endif +} diff --git a/src/antlr4/SysYParser.h b/src/antlr4/SysYParser.h new file mode 100644 index 0000000..2681e42 --- /dev/null +++ b/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& 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 decl(); + DeclContext* decl(size_t i); + std::vector 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 constDef(); + ConstDefContext* constDef(size_t i); + antlr4::tree::TerminalNode *SEMICOLON(); + std::vector 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 LBRACK(); + antlr4::tree::TerminalNode* LBRACK(size_t i); + std::vector constExp(); + ConstExpContext* constExp(size_t i); + std::vector 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 constInitValue(); + ConstInitValueContext* constInitValue(size_t i); + std::vector 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 varDef(); + VarDefContext* varDef(size_t i); + antlr4::tree::TerminalNode *SEMICOLON(); + std::vector 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 LBRACK(); + antlr4::tree::TerminalNode* LBRACK(size_t i); + std::vector constExp(); + ConstExpContext* constExp(size_t i); + std::vector 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 initValue(); + InitValueContext* initValue(size_t i); + std::vector 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 funcFParam(); + FuncFParamContext* funcFParam(size_t i); + std::vector 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 LBRACK(); + antlr4::tree::TerminalNode* LBRACK(size_t i); + std::vector RBRACK(); + antlr4::tree::TerminalNode* RBRACK(size_t i); + std::vector 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 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 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 LBRACK(); + antlr4::tree::TerminalNode* LBRACK(size_t i); + std::vector exp(); + ExpContext* exp(size_t i); + std::vector 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 exp(); + ExpContext* exp(size_t i); + std::vector 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: +}; + diff --git a/src/antlr4/SysYVisitor.cpp b/src/antlr4/SysYVisitor.cpp new file mode 100644 index 0000000..a4bb3dc --- /dev/null +++ b/src/antlr4/SysYVisitor.cpp @@ -0,0 +1,7 @@ + +// Generated from SysY.g4 by ANTLR 4.13.2 + + +#include "SysYVisitor.h" + + diff --git a/src/antlr4/SysYVisitor.h b/src/antlr4/SysYVisitor.h new file mode 100644 index 0000000..75e8c98 --- /dev/null +++ b/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; + + +}; + diff --git a/src/frontend/AntlrDriver.cpp b/src/frontend/AntlrDriver.cpp index ee3c98c..7a77566 100644 --- a/src/frontend/AntlrDriver.cpp +++ b/src/frontend/AntlrDriver.cpp @@ -6,8 +6,8 @@ #include #include -#include "SysYLexer.h" -#include "SysYParser.h" +#include "antlr4/SysYLexer.h" +#include "antlr4/SysYParser.h" #include "antlr4-runtime.h" #include "utils/Log.h" diff --git a/src/frontend/CMakeLists.txt b/src/frontend/CMakeLists.txt index 524fcd6..4d8d100 100644 --- a/src/frontend/CMakeLists.txt +++ b/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}) diff --git a/src/irgen/IRGenDecl.cpp b/src/irgen/IRGenDecl.cpp index 75cfdf0..346ac3f 100644 --- a/src/irgen/IRGenDecl.cpp +++ b/src/irgen/IRGenDecl.cpp @@ -2,7 +2,7 @@ #include -#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; diff --git a/src/irgen/IRGenDriver.cpp b/src/irgen/IRGenDriver.cpp index ff94412..fbc0eb5 100644 --- a/src/irgen/IRGenDriver.cpp +++ b/src/irgen/IRGenDriver.cpp @@ -2,7 +2,7 @@ #include -#include "SysYParser.h" +#include "antlr4/SysYParser.h" #include "ir/IR.h" #include "utils/Log.h" diff --git a/src/irgen/IRGenExp.cpp b/src/irgen/IRGenExp.cpp index 7e22485..2a22779 100644 --- a/src/irgen/IRGenExp.cpp +++ b/src/irgen/IRGenExp.cpp @@ -2,7 +2,7 @@ #include -#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()) { - 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)); + auto* addr = ResolveLValueAddress(ctx); + if (!addr) { + throw std::runtime_error(FormatError("irgen", "变量地址解析失败")); } return static_cast( - 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 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(builder_.CreateConstInt(0)); + } + return static_cast(call); + } + if (ctx->unaryOp() && ctx->unaryExp()) { ir::Value* v = std::any_cast(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(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()) { - throw std::runtime_error(FormatError("irgen", "非法逻辑与表达式")); + + if (!ctx->lAndExp()) { + if (ctx->eqExp()) { + return ToBoolValue(std::any_cast(ctx->eqExp()->accept(this))); } - auto* lhs = ToBoolValue(std::any_cast(ctx->lAndExp()->accept(this))); - auto* rhs = ToBoolValue(std::any_cast(ctx->eqExp()->accept(this))); - return static_cast( - builder_.CreateMul(lhs, rhs, module_.GetContext().NextTemp())); + throw std::runtime_error(FormatError("irgen", "非法逻辑与表达式")); } - if (ctx->eqExp()) { - return ToBoolValue(std::any_cast(ctx->eqExp()->accept(this))); + + if (!ctx->eqExp()) { + throw std::runtime_error(FormatError("irgen", "非法逻辑与表达式")); + } + + auto* lhs = ToBoolValue(std::any_cast(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(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( + 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()) { - throw std::runtime_error(FormatError("irgen", "非法逻辑或表达式")); + + if (!ctx->lOrExp()) { + if (ctx->lAndExp()) { + return ToBoolValue(std::any_cast(ctx->lAndExp()->accept(this))); } - auto* lhs = ToBoolValue(std::any_cast(ctx->lOrExp()->accept(this))); - auto* rhs = ToBoolValue(std::any_cast(ctx->lAndExp()->accept(this))); - auto* sum = builder_.CreateAdd(lhs, rhs, module_.GetContext().NextTemp()); - return static_cast(ToBoolValue(sum)); + throw std::runtime_error(FormatError("irgen", "非法逻辑或表达式")); + } + + if (!ctx->lAndExp()) { + throw std::runtime_error(FormatError("irgen", "非法逻辑或表达式")); + } + + auto* lhs = ToBoolValue(std::any_cast(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(ctx->lAndExp()->accept(this))); + + builder_.SetInsertPoint(rhs_bb); + auto* rhs = ToBoolValue(std::any_cast(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( + builder_.CreateLoad(result_slot, module_.GetContext().NextTemp())); } diff --git a/src/irgen/IRGenFunc.cpp b/src/irgen/IRGenFunc.cpp index 737563d..cb1990f 100644 --- a/src/irgen/IRGenFunc.cpp +++ b/src/irgen/IRGenFunc.cpp @@ -2,7 +2,7 @@ #include -#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> param_types; + std::vector 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 {}; } diff --git a/src/irgen/IRGenStmt.cpp b/src/irgen/IRGenStmt.cpp index 61ad87e..64e4df2 100644 --- a/src/irgen/IRGenStmt.cpp +++ b/src/irgen/IRGenStmt.cpp @@ -2,10 +2,20 @@ #include -#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 ; @@ -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(); - auto slot_it = named_storage_.find(name); - if (slot_it == named_storage_.end()) { - throw std::runtime_error(FormatError("irgen", "赋值目标未声明: " + name)); + ir::Value* dest = ResolveLValueAddress(ctx->lValue()); + if (!dest) { + throw std::runtime_error( + 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", "全局变量生成未实现")); +} +