From 7405f1327dfafd5649ac96a38c89a457ae21e104 Mon Sep 17 00:00:00 2001 From: mirror Date: Mon, 23 Mar 2026 21:14:07 +0800 Subject: [PATCH 1/2] =?UTF-8?q?=E6=B5=8B=E8=AF=95=E6=8F=90=E4=BA=A4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- include/sem/Sema.h | 1 + include/sem/SymbolTable.h | 1 + src/antlr4/SysYBaseVisitor.cpp | 7 + src/antlr4/SysYBaseVisitor.h | 144 ++ src/antlr4/SysYLexer.cpp | 377 +++++ src/antlr4/SysYLexer.h | 62 + src/antlr4/SysYParser.cpp | 2648 ++++++++++++++++++++++++++++++++ src/antlr4/SysYParser.h | 513 +++++++ src/antlr4/SysYVisitor.cpp | 7 + src/antlr4/SysYVisitor.h | 86 ++ 10 files changed, 3846 insertions(+) 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/include/sem/Sema.h b/include/sem/Sema.h index 9ac057b..0c8949f 100644 --- a/include/sem/Sema.h +++ b/include/sem/Sema.h @@ -1,3 +1,4 @@ +//写这个 // 基于语法树的语义检查与名称绑定。 #pragma once diff --git a/include/sem/SymbolTable.h b/include/sem/SymbolTable.h index c9396dd..ddedf85 100644 --- a/include/sem/SymbolTable.h +++ b/include/sem/SymbolTable.h @@ -1,3 +1,4 @@ +//写这个 // 极简符号表：记录局部变量定义点。 #pragma once diff --git a/src/antlr4/SysYBaseVisitor.cpp b/src/antlr4/SysYBaseVisitor.cpp new file mode 100644 index 0000000..72e9df6 --- /dev/null +++ b/src/antlr4/SysYBaseVisitor.cpp @@ -0,0 +1,7 @@ + +// Generated from SysY.g4 by ANTLR 4.7.2 + + +#include "SysYBaseVisitor.h" + + diff --git a/src/antlr4/SysYBaseVisitor.h b/src/antlr4/SysYBaseVisitor.h new file mode 100644 index 0000000..aed0760 --- /dev/null +++ b/src/antlr4/SysYBaseVisitor.h @@ -0,0 +1,144 @@ + +// Generated from SysY.g4 by ANTLR 4.7.2 + +#pragma once + + +#include "antlr4-runtime.h" +#include "SysYVisitor.h" + + +/** + * This class provides an empty implementation of SysYVisitor, which can be + * extended to create a visitor which only needs to handle a subset of the available methods. + */ +class SysYBaseVisitor : public SysYVisitor { +public: + + virtual antlrcpp::Any visitCompUnit(SysYParser::CompUnitContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitDecl(SysYParser::DeclContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitConstDecl(SysYParser::ConstDeclContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitBType(SysYParser::BTypeContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitConstDef(SysYParser::ConstDefContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitConstInitVal(SysYParser::ConstInitValContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitVarDecl(SysYParser::VarDeclContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitVarDef(SysYParser::VarDefContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitInitVal(SysYParser::InitValContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitFuncDef(SysYParser::FuncDefContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitFuncType(SysYParser::FuncTypeContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitFuncFParams(SysYParser::FuncFParamsContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitFuncFParam(SysYParser::FuncFParamContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitBlock(SysYParser::BlockContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitBlockItem(SysYParser::BlockItemContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitStmt(SysYParser::StmtContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitExp(SysYParser::ExpContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitCond(SysYParser::CondContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitLVal(SysYParser::LValContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitPrimaryExp(SysYParser::PrimaryExpContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitNumber(SysYParser::NumberContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitUnaryExp(SysYParser::UnaryExpContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitUnaryOp(SysYParser::UnaryOpContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitFuncRParams(SysYParser::FuncRParamsContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitMulExp(SysYParser::MulExpContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitAddExp(SysYParser::AddExpContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitRelExp(SysYParser::RelExpContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitEqExp(SysYParser::EqExpContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitLAndExp(SysYParser::LAndExpContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitLOrExp(SysYParser::LOrExpContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitConstExp(SysYParser::ConstExpContext *ctx) override { + return visitChildren(ctx); + } + + +}; + diff --git a/src/antlr4/SysYLexer.cpp b/src/antlr4/SysYLexer.cpp new file mode 100644 index 0000000..a403879 --- /dev/null +++ b/src/antlr4/SysYLexer.cpp @@ -0,0 +1,377 @@ + +// Generated from SysY.g4 by ANTLR 4.7.2 + + +#include "SysYLexer.h" + + +using namespace antlr4; + + +SysYLexer::SysYLexer(CharStream *input) : Lexer(input) { + _interpreter = new atn::LexerATNSimulator(this, _atn, _decisionToDFA, _sharedContextCache); +} + +SysYLexer::~SysYLexer() { + delete _interpreter; +} + +std::string SysYLexer::getGrammarFileName() const { + return "SysY.g4"; +} + +const std::vector& SysYLexer::getRuleNames() const { + return _ruleNames; +} + +const std::vector& SysYLexer::getChannelNames() const { + return _channelNames; +} + +const std::vector& SysYLexer::getModeNames() const { + return _modeNames; +} + +const std::vector& SysYLexer::getTokenNames() const { + return _tokenNames; +} + +dfa::Vocabulary& SysYLexer::getVocabulary() const { + return _vocabulary; +} + +const std::vector SysYLexer::getSerializedATN() const { + return _serializedATN; +} + +const atn::ATN& SysYLexer::getATN() const { + return _atn; +} + + + + +// Static vars and initialization. +std::vector SysYLexer::_decisionToDFA; +atn::PredictionContextCache SysYLexer::_sharedContextCache; + +// We own the ATN which in turn owns the ATN states. +atn::ATN SysYLexer::_atn; +std::vector SysYLexer::_serializedATN; + +std::vector SysYLexer::_ruleNames = { + u8"T__0", u8"T__1", u8"T__2", u8"T__3", u8"T__4", u8"T__5", u8"T__6", + u8"T__7", u8"T__8", u8"T__9", u8"T__10", u8"T__11", u8"T__12", u8"T__13", + u8"T__14", u8"T__15", u8"T__16", u8"T__17", u8"T__18", u8"T__19", u8"T__20", + u8"T__21", u8"T__22", u8"T__23", u8"T__24", u8"T__25", u8"T__26", u8"T__27", + u8"T__28", u8"T__29", u8"T__30", u8"T__31", u8"T__32", u8"DIGIT", u8"HEXDIGIT", + u8"EXP", u8"PEXP", u8"FloatConst", u8"IntConst", u8"Ident", u8"WS", u8"LINE_COMMENT", + u8"BLOCK_COMMENT" +}; + +std::vector SysYLexer::_channelNames = { + "DEFAULT_TOKEN_CHANNEL", "HIDDEN" +}; + +std::vector SysYLexer::_modeNames = { + u8"DEFAULT_MODE" +}; + +std::vector SysYLexer::_literalNames = { + "", u8"'const'", u8"','", u8"';'", u8"'int'", u8"'float'", u8"'['", u8"']'", + u8"'='", u8"'{'", u8"'}'", u8"'('", u8"')'", u8"'void'", u8"'if'", u8"'else'", + u8"'while'", u8"'break'", u8"'continue'", u8"'return'", u8"'+'", u8"'-'", + u8"'!'", u8"'*'", u8"'/'", u8"'%'", u8"'<'", u8"'>'", u8"'<='", u8"'>='", + u8"'=='", u8"'!='", u8"'&&'", u8"'||'" +}; + +std::vector SysYLexer::_symbolicNames = { + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", u8"FloatConst", + u8"IntConst", u8"Ident", u8"WS", u8"LINE_COMMENT", u8"BLOCK_COMMENT" +}; + +dfa::Vocabulary SysYLexer::_vocabulary(_literalNames, _symbolicNames); + +std::vector SysYLexer::_tokenNames; + +SysYLexer::Initializer::Initializer() { + // This code could be in a static initializer lambda, but VS doesn't allow access to private class members from there. + for (size_t i = 0; i < _symbolicNames.size(); ++i) { + std::string name = _vocabulary.getLiteralName(i); + if (name.empty()) { + name = _vocabulary.getSymbolicName(i); + } + + if (name.empty()) { + _tokenNames.push_back(""); + } else { + _tokenNames.push_back(name); + } + } + + _serializedATN = { + 0x3, 0x608b, 0xa72a, 0x8133, 0xb9ed, 0x417c, 0x3be7, 0x7786, 0x5964, + 0x2, 0x29, 0x160, 0x8, 0x1, 0x4, 0x2, 0x9, 0x2, 0x4, 0x3, 0x9, 0x3, + 0x4, 0x4, 0x9, 0x4, 0x4, 0x5, 0x9, 0x5, 0x4, 0x6, 0x9, 0x6, 0x4, 0x7, + 0x9, 0x7, 0x4, 0x8, 0x9, 0x8, 0x4, 0x9, 0x9, 0x9, 0x4, 0xa, 0x9, 0xa, + 0x4, 0xb, 0x9, 0xb, 0x4, 0xc, 0x9, 0xc, 0x4, 0xd, 0x9, 0xd, 0x4, 0xe, + 0x9, 0xe, 0x4, 0xf, 0x9, 0xf, 0x4, 0x10, 0x9, 0x10, 0x4, 0x11, 0x9, + 0x11, 0x4, 0x12, 0x9, 0x12, 0x4, 0x13, 0x9, 0x13, 0x4, 0x14, 0x9, 0x14, + 0x4, 0x15, 0x9, 0x15, 0x4, 0x16, 0x9, 0x16, 0x4, 0x17, 0x9, 0x17, 0x4, + 0x18, 0x9, 0x18, 0x4, 0x19, 0x9, 0x19, 0x4, 0x1a, 0x9, 0x1a, 0x4, 0x1b, + 0x9, 0x1b, 0x4, 0x1c, 0x9, 0x1c, 0x4, 0x1d, 0x9, 0x1d, 0x4, 0x1e, 0x9, + 0x1e, 0x4, 0x1f, 0x9, 0x1f, 0x4, 0x20, 0x9, 0x20, 0x4, 0x21, 0x9, 0x21, + 0x4, 0x22, 0x9, 0x22, 0x4, 0x23, 0x9, 0x23, 0x4, 0x24, 0x9, 0x24, 0x4, + 0x25, 0x9, 0x25, 0x4, 0x26, 0x9, 0x26, 0x4, 0x27, 0x9, 0x27, 0x4, 0x28, + 0x9, 0x28, 0x4, 0x29, 0x9, 0x29, 0x4, 0x2a, 0x9, 0x2a, 0x4, 0x2b, 0x9, + 0x2b, 0x4, 0x2c, 0x9, 0x2c, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, + 0x3, 0x2, 0x3, 0x2, 0x3, 0x3, 0x3, 0x3, 0x3, 0x4, 0x3, 0x4, 0x3, 0x5, + 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x3, 0x6, 0x3, 0x6, 0x3, 0x6, 0x3, 0x6, + 0x3, 0x6, 0x3, 0x6, 0x3, 0x7, 0x3, 0x7, 0x3, 0x8, 0x3, 0x8, 0x3, 0x9, + 0x3, 0x9, 0x3, 0xa, 0x3, 0xa, 0x3, 0xb, 0x3, 0xb, 0x3, 0xc, 0x3, 0xc, + 0x3, 0xd, 0x3, 0xd, 0x3, 0xe, 0x3, 0xe, 0x3, 0xe, 0x3, 0xe, 0x3, 0xe, + 0x3, 0xf, 0x3, 0xf, 0x3, 0xf, 0x3, 0x10, 0x3, 0x10, 0x3, 0x10, 0x3, + 0x10, 0x3, 0x10, 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, + 0x3, 0x11, 0x3, 0x12, 0x3, 0x12, 0x3, 0x12, 0x3, 0x12, 0x3, 0x12, 0x3, + 0x12, 0x3, 0x13, 0x3, 0x13, 0x3, 0x13, 0x3, 0x13, 0x3, 0x13, 0x3, 0x13, + 0x3, 0x13, 0x3, 0x13, 0x3, 0x13, 0x3, 0x14, 0x3, 0x14, 0x3, 0x14, 0x3, + 0x14, 0x3, 0x14, 0x3, 0x14, 0x3, 0x14, 0x3, 0x15, 0x3, 0x15, 0x3, 0x16, + 0x3, 0x16, 0x3, 0x17, 0x3, 0x17, 0x3, 0x18, 0x3, 0x18, 0x3, 0x19, 0x3, + 0x19, 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1b, 0x3, 0x1b, 0x3, 0x1c, 0x3, 0x1c, + 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1e, 0x3, 0x1e, 0x3, 0x1e, 0x3, + 0x1f, 0x3, 0x1f, 0x3, 0x1f, 0x3, 0x20, 0x3, 0x20, 0x3, 0x20, 0x3, 0x21, + 0x3, 0x21, 0x3, 0x21, 0x3, 0x22, 0x3, 0x22, 0x3, 0x22, 0x3, 0x23, 0x3, + 0x23, 0x3, 0x24, 0x3, 0x24, 0x3, 0x25, 0x3, 0x25, 0x5, 0x25, 0xcd, 0xa, + 0x25, 0x3, 0x25, 0x6, 0x25, 0xd0, 0xa, 0x25, 0xd, 0x25, 0xe, 0x25, 0xd1, + 0x3, 0x26, 0x3, 0x26, 0x5, 0x26, 0xd6, 0xa, 0x26, 0x3, 0x26, 0x6, 0x26, + 0xd9, 0xa, 0x26, 0xd, 0x26, 0xe, 0x26, 0xda, 0x3, 0x27, 0x3, 0x27, 0x3, + 0x27, 0x3, 0x27, 0x5, 0x27, 0xe1, 0xa, 0x27, 0x3, 0x27, 0x6, 0x27, 0xe4, + 0xa, 0x27, 0xd, 0x27, 0xe, 0x27, 0xe5, 0x3, 0x27, 0x3, 0x27, 0x7, 0x27, + 0xea, 0xa, 0x27, 0xc, 0x27, 0xe, 0x27, 0xed, 0xb, 0x27, 0x3, 0x27, 0x3, + 0x27, 0x6, 0x27, 0xf1, 0xa, 0x27, 0xd, 0x27, 0xe, 0x27, 0xf2, 0x3, 0x27, + 0x6, 0x27, 0xf6, 0xa, 0x27, 0xd, 0x27, 0xe, 0x27, 0xf7, 0x5, 0x27, 0xfa, + 0xa, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x6, 0x27, 0x100, + 0xa, 0x27, 0xd, 0x27, 0xe, 0x27, 0x101, 0x3, 0x27, 0x5, 0x27, 0x105, + 0xa, 0x27, 0x3, 0x27, 0x6, 0x27, 0x108, 0xa, 0x27, 0xd, 0x27, 0xe, 0x27, + 0x109, 0x3, 0x27, 0x3, 0x27, 0x7, 0x27, 0x10e, 0xa, 0x27, 0xc, 0x27, + 0xe, 0x27, 0x111, 0xb, 0x27, 0x3, 0x27, 0x5, 0x27, 0x114, 0xa, 0x27, + 0x3, 0x27, 0x6, 0x27, 0x117, 0xa, 0x27, 0xd, 0x27, 0xe, 0x27, 0x118, + 0x3, 0x27, 0x3, 0x27, 0x5, 0x27, 0x11d, 0xa, 0x27, 0x3, 0x28, 0x3, 0x28, + 0x3, 0x28, 0x7, 0x28, 0x122, 0xa, 0x28, 0xc, 0x28, 0xe, 0x28, 0x125, + 0xb, 0x28, 0x3, 0x28, 0x3, 0x28, 0x6, 0x28, 0x129, 0xa, 0x28, 0xd, 0x28, + 0xe, 0x28, 0x12a, 0x3, 0x28, 0x3, 0x28, 0x3, 0x28, 0x3, 0x28, 0x5, 0x28, + 0x131, 0xa, 0x28, 0x3, 0x28, 0x6, 0x28, 0x134, 0xa, 0x28, 0xd, 0x28, + 0xe, 0x28, 0x135, 0x5, 0x28, 0x138, 0xa, 0x28, 0x3, 0x29, 0x3, 0x29, + 0x7, 0x29, 0x13c, 0xa, 0x29, 0xc, 0x29, 0xe, 0x29, 0x13f, 0xb, 0x29, + 0x3, 0x2a, 0x6, 0x2a, 0x142, 0xa, 0x2a, 0xd, 0x2a, 0xe, 0x2a, 0x143, + 0x3, 0x2a, 0x3, 0x2a, 0x3, 0x2b, 0x3, 0x2b, 0x3, 0x2b, 0x3, 0x2b, 0x7, + 0x2b, 0x14c, 0xa, 0x2b, 0xc, 0x2b, 0xe, 0x2b, 0x14f, 0xb, 0x2b, 0x3, + 0x2b, 0x3, 0x2b, 0x3, 0x2c, 0x3, 0x2c, 0x3, 0x2c, 0x3, 0x2c, 0x7, 0x2c, + 0x157, 0xa, 0x2c, 0xc, 0x2c, 0xe, 0x2c, 0x15a, 0xb, 0x2c, 0x3, 0x2c, + 0x3, 0x2c, 0x3, 0x2c, 0x3, 0x2c, 0x3, 0x2c, 0x3, 0x158, 0x2, 0x2d, 0x3, + 0x3, 0x5, 0x4, 0x7, 0x5, 0x9, 0x6, 0xb, 0x7, 0xd, 0x8, 0xf, 0x9, 0x11, + 0xa, 0x13, 0xb, 0x15, 0xc, 0x17, 0xd, 0x19, 0xe, 0x1b, 0xf, 0x1d, 0x10, + 0x1f, 0x11, 0x21, 0x12, 0x23, 0x13, 0x25, 0x14, 0x27, 0x15, 0x29, 0x16, + 0x2b, 0x17, 0x2d, 0x18, 0x2f, 0x19, 0x31, 0x1a, 0x33, 0x1b, 0x35, 0x1c, + 0x37, 0x1d, 0x39, 0x1e, 0x3b, 0x1f, 0x3d, 0x20, 0x3f, 0x21, 0x41, 0x22, + 0x43, 0x23, 0x45, 0x2, 0x47, 0x2, 0x49, 0x2, 0x4b, 0x2, 0x4d, 0x24, + 0x4f, 0x25, 0x51, 0x26, 0x53, 0x27, 0x55, 0x28, 0x57, 0x29, 0x3, 0x2, + 0xd, 0x3, 0x2, 0x32, 0x3b, 0x5, 0x2, 0x32, 0x3b, 0x43, 0x48, 0x63, 0x68, + 0x4, 0x2, 0x47, 0x47, 0x67, 0x67, 0x4, 0x2, 0x2d, 0x2d, 0x2f, 0x2f, + 0x4, 0x2, 0x52, 0x52, 0x72, 0x72, 0x3, 0x2, 0x33, 0x3b, 0x3, 0x2, 0x32, + 0x39, 0x5, 0x2, 0x43, 0x5c, 0x61, 0x61, 0x63, 0x7c, 0x6, 0x2, 0x32, + 0x3b, 0x43, 0x5c, 0x61, 0x61, 0x63, 0x7c, 0x5, 0x2, 0xb, 0xc, 0xf, 0xf, + 0x22, 0x22, 0x4, 0x2, 0xc, 0xc, 0xf, 0xf, 0x2, 0x17a, 0x2, 0x3, 0x3, + 0x2, 0x2, 0x2, 0x2, 0x5, 0x3, 0x2, 0x2, 0x2, 0x2, 0x7, 0x3, 0x2, 0x2, + 0x2, 0x2, 0x9, 0x3, 0x2, 0x2, 0x2, 0x2, 0xb, 0x3, 0x2, 0x2, 0x2, 0x2, + 0xd, 0x3, 0x2, 0x2, 0x2, 0x2, 0xf, 0x3, 0x2, 0x2, 0x2, 0x2, 0x11, 0x3, + 0x2, 0x2, 0x2, 0x2, 0x13, 0x3, 0x2, 0x2, 0x2, 0x2, 0x15, 0x3, 0x2, 0x2, + 0x2, 0x2, 0x17, 0x3, 0x2, 0x2, 0x2, 0x2, 0x19, 0x3, 0x2, 0x2, 0x2, 0x2, + 0x1b, 0x3, 0x2, 0x2, 0x2, 0x2, 0x1d, 0x3, 0x2, 0x2, 0x2, 0x2, 0x1f, + 0x3, 0x2, 0x2, 0x2, 0x2, 0x21, 0x3, 0x2, 0x2, 0x2, 0x2, 0x23, 0x3, 0x2, + 0x2, 0x2, 0x2, 0x25, 0x3, 0x2, 0x2, 0x2, 0x2, 0x27, 0x3, 0x2, 0x2, 0x2, + 0x2, 0x29, 0x3, 0x2, 0x2, 0x2, 0x2, 0x2b, 0x3, 0x2, 0x2, 0x2, 0x2, 0x2d, + 0x3, 0x2, 0x2, 0x2, 0x2, 0x2f, 0x3, 0x2, 0x2, 0x2, 0x2, 0x31, 0x3, 0x2, + 0x2, 0x2, 0x2, 0x33, 0x3, 0x2, 0x2, 0x2, 0x2, 0x35, 0x3, 0x2, 0x2, 0x2, + 0x2, 0x37, 0x3, 0x2, 0x2, 0x2, 0x2, 0x39, 0x3, 0x2, 0x2, 0x2, 0x2, 0x3b, + 0x3, 0x2, 0x2, 0x2, 0x2, 0x3d, 0x3, 0x2, 0x2, 0x2, 0x2, 0x3f, 0x3, 0x2, + 0x2, 0x2, 0x2, 0x41, 0x3, 0x2, 0x2, 0x2, 0x2, 0x43, 0x3, 0x2, 0x2, 0x2, + 0x2, 0x4d, 0x3, 0x2, 0x2, 0x2, 0x2, 0x4f, 0x3, 0x2, 0x2, 0x2, 0x2, 0x51, + 0x3, 0x2, 0x2, 0x2, 0x2, 0x53, 0x3, 0x2, 0x2, 0x2, 0x2, 0x55, 0x3, 0x2, + 0x2, 0x2, 0x2, 0x57, 0x3, 0x2, 0x2, 0x2, 0x3, 0x59, 0x3, 0x2, 0x2, 0x2, + 0x5, 0x5f, 0x3, 0x2, 0x2, 0x2, 0x7, 0x61, 0x3, 0x2, 0x2, 0x2, 0x9, 0x63, + 0x3, 0x2, 0x2, 0x2, 0xb, 0x67, 0x3, 0x2, 0x2, 0x2, 0xd, 0x6d, 0x3, 0x2, + 0x2, 0x2, 0xf, 0x6f, 0x3, 0x2, 0x2, 0x2, 0x11, 0x71, 0x3, 0x2, 0x2, + 0x2, 0x13, 0x73, 0x3, 0x2, 0x2, 0x2, 0x15, 0x75, 0x3, 0x2, 0x2, 0x2, + 0x17, 0x77, 0x3, 0x2, 0x2, 0x2, 0x19, 0x79, 0x3, 0x2, 0x2, 0x2, 0x1b, + 0x7b, 0x3, 0x2, 0x2, 0x2, 0x1d, 0x80, 0x3, 0x2, 0x2, 0x2, 0x1f, 0x83, + 0x3, 0x2, 0x2, 0x2, 0x21, 0x88, 0x3, 0x2, 0x2, 0x2, 0x23, 0x8e, 0x3, + 0x2, 0x2, 0x2, 0x25, 0x94, 0x3, 0x2, 0x2, 0x2, 0x27, 0x9d, 0x3, 0x2, + 0x2, 0x2, 0x29, 0xa4, 0x3, 0x2, 0x2, 0x2, 0x2b, 0xa6, 0x3, 0x2, 0x2, + 0x2, 0x2d, 0xa8, 0x3, 0x2, 0x2, 0x2, 0x2f, 0xaa, 0x3, 0x2, 0x2, 0x2, + 0x31, 0xac, 0x3, 0x2, 0x2, 0x2, 0x33, 0xae, 0x3, 0x2, 0x2, 0x2, 0x35, + 0xb0, 0x3, 0x2, 0x2, 0x2, 0x37, 0xb2, 0x3, 0x2, 0x2, 0x2, 0x39, 0xb4, + 0x3, 0x2, 0x2, 0x2, 0x3b, 0xb7, 0x3, 0x2, 0x2, 0x2, 0x3d, 0xba, 0x3, + 0x2, 0x2, 0x2, 0x3f, 0xbd, 0x3, 0x2, 0x2, 0x2, 0x41, 0xc0, 0x3, 0x2, + 0x2, 0x2, 0x43, 0xc3, 0x3, 0x2, 0x2, 0x2, 0x45, 0xc6, 0x3, 0x2, 0x2, + 0x2, 0x47, 0xc8, 0x3, 0x2, 0x2, 0x2, 0x49, 0xca, 0x3, 0x2, 0x2, 0x2, + 0x4b, 0xd3, 0x3, 0x2, 0x2, 0x2, 0x4d, 0x11c, 0x3, 0x2, 0x2, 0x2, 0x4f, + 0x137, 0x3, 0x2, 0x2, 0x2, 0x51, 0x139, 0x3, 0x2, 0x2, 0x2, 0x53, 0x141, + 0x3, 0x2, 0x2, 0x2, 0x55, 0x147, 0x3, 0x2, 0x2, 0x2, 0x57, 0x152, 0x3, + 0x2, 0x2, 0x2, 0x59, 0x5a, 0x7, 0x65, 0x2, 0x2, 0x5a, 0x5b, 0x7, 0x71, + 0x2, 0x2, 0x5b, 0x5c, 0x7, 0x70, 0x2, 0x2, 0x5c, 0x5d, 0x7, 0x75, 0x2, + 0x2, 0x5d, 0x5e, 0x7, 0x76, 0x2, 0x2, 0x5e, 0x4, 0x3, 0x2, 0x2, 0x2, + 0x5f, 0x60, 0x7, 0x2e, 0x2, 0x2, 0x60, 0x6, 0x3, 0x2, 0x2, 0x2, 0x61, + 0x62, 0x7, 0x3d, 0x2, 0x2, 0x62, 0x8, 0x3, 0x2, 0x2, 0x2, 0x63, 0x64, + 0x7, 0x6b, 0x2, 0x2, 0x64, 0x65, 0x7, 0x70, 0x2, 0x2, 0x65, 0x66, 0x7, + 0x76, 0x2, 0x2, 0x66, 0xa, 0x3, 0x2, 0x2, 0x2, 0x67, 0x68, 0x7, 0x68, + 0x2, 0x2, 0x68, 0x69, 0x7, 0x6e, 0x2, 0x2, 0x69, 0x6a, 0x7, 0x71, 0x2, + 0x2, 0x6a, 0x6b, 0x7, 0x63, 0x2, 0x2, 0x6b, 0x6c, 0x7, 0x76, 0x2, 0x2, + 0x6c, 0xc, 0x3, 0x2, 0x2, 0x2, 0x6d, 0x6e, 0x7, 0x5d, 0x2, 0x2, 0x6e, + 0xe, 0x3, 0x2, 0x2, 0x2, 0x6f, 0x70, 0x7, 0x5f, 0x2, 0x2, 0x70, 0x10, + 0x3, 0x2, 0x2, 0x2, 0x71, 0x72, 0x7, 0x3f, 0x2, 0x2, 0x72, 0x12, 0x3, + 0x2, 0x2, 0x2, 0x73, 0x74, 0x7, 0x7d, 0x2, 0x2, 0x74, 0x14, 0x3, 0x2, + 0x2, 0x2, 0x75, 0x76, 0x7, 0x7f, 0x2, 0x2, 0x76, 0x16, 0x3, 0x2, 0x2, + 0x2, 0x77, 0x78, 0x7, 0x2a, 0x2, 0x2, 0x78, 0x18, 0x3, 0x2, 0x2, 0x2, + 0x79, 0x7a, 0x7, 0x2b, 0x2, 0x2, 0x7a, 0x1a, 0x3, 0x2, 0x2, 0x2, 0x7b, + 0x7c, 0x7, 0x78, 0x2, 0x2, 0x7c, 0x7d, 0x7, 0x71, 0x2, 0x2, 0x7d, 0x7e, + 0x7, 0x6b, 0x2, 0x2, 0x7e, 0x7f, 0x7, 0x66, 0x2, 0x2, 0x7f, 0x1c, 0x3, + 0x2, 0x2, 0x2, 0x80, 0x81, 0x7, 0x6b, 0x2, 0x2, 0x81, 0x82, 0x7, 0x68, + 0x2, 0x2, 0x82, 0x1e, 0x3, 0x2, 0x2, 0x2, 0x83, 0x84, 0x7, 0x67, 0x2, + 0x2, 0x84, 0x85, 0x7, 0x6e, 0x2, 0x2, 0x85, 0x86, 0x7, 0x75, 0x2, 0x2, + 0x86, 0x87, 0x7, 0x67, 0x2, 0x2, 0x87, 0x20, 0x3, 0x2, 0x2, 0x2, 0x88, + 0x89, 0x7, 0x79, 0x2, 0x2, 0x89, 0x8a, 0x7, 0x6a, 0x2, 0x2, 0x8a, 0x8b, + 0x7, 0x6b, 0x2, 0x2, 0x8b, 0x8c, 0x7, 0x6e, 0x2, 0x2, 0x8c, 0x8d, 0x7, + 0x67, 0x2, 0x2, 0x8d, 0x22, 0x3, 0x2, 0x2, 0x2, 0x8e, 0x8f, 0x7, 0x64, + 0x2, 0x2, 0x8f, 0x90, 0x7, 0x74, 0x2, 0x2, 0x90, 0x91, 0x7, 0x67, 0x2, + 0x2, 0x91, 0x92, 0x7, 0x63, 0x2, 0x2, 0x92, 0x93, 0x7, 0x6d, 0x2, 0x2, + 0x93, 0x24, 0x3, 0x2, 0x2, 0x2, 0x94, 0x95, 0x7, 0x65, 0x2, 0x2, 0x95, + 0x96, 0x7, 0x71, 0x2, 0x2, 0x96, 0x97, 0x7, 0x70, 0x2, 0x2, 0x97, 0x98, + 0x7, 0x76, 0x2, 0x2, 0x98, 0x99, 0x7, 0x6b, 0x2, 0x2, 0x99, 0x9a, 0x7, + 0x70, 0x2, 0x2, 0x9a, 0x9b, 0x7, 0x77, 0x2, 0x2, 0x9b, 0x9c, 0x7, 0x67, + 0x2, 0x2, 0x9c, 0x26, 0x3, 0x2, 0x2, 0x2, 0x9d, 0x9e, 0x7, 0x74, 0x2, + 0x2, 0x9e, 0x9f, 0x7, 0x67, 0x2, 0x2, 0x9f, 0xa0, 0x7, 0x76, 0x2, 0x2, + 0xa0, 0xa1, 0x7, 0x77, 0x2, 0x2, 0xa1, 0xa2, 0x7, 0x74, 0x2, 0x2, 0xa2, + 0xa3, 0x7, 0x70, 0x2, 0x2, 0xa3, 0x28, 0x3, 0x2, 0x2, 0x2, 0xa4, 0xa5, + 0x7, 0x2d, 0x2, 0x2, 0xa5, 0x2a, 0x3, 0x2, 0x2, 0x2, 0xa6, 0xa7, 0x7, + 0x2f, 0x2, 0x2, 0xa7, 0x2c, 0x3, 0x2, 0x2, 0x2, 0xa8, 0xa9, 0x7, 0x23, + 0x2, 0x2, 0xa9, 0x2e, 0x3, 0x2, 0x2, 0x2, 0xaa, 0xab, 0x7, 0x2c, 0x2, + 0x2, 0xab, 0x30, 0x3, 0x2, 0x2, 0x2, 0xac, 0xad, 0x7, 0x31, 0x2, 0x2, + 0xad, 0x32, 0x3, 0x2, 0x2, 0x2, 0xae, 0xaf, 0x7, 0x27, 0x2, 0x2, 0xaf, + 0x34, 0x3, 0x2, 0x2, 0x2, 0xb0, 0xb1, 0x7, 0x3e, 0x2, 0x2, 0xb1, 0x36, + 0x3, 0x2, 0x2, 0x2, 0xb2, 0xb3, 0x7, 0x40, 0x2, 0x2, 0xb3, 0x38, 0x3, + 0x2, 0x2, 0x2, 0xb4, 0xb5, 0x7, 0x3e, 0x2, 0x2, 0xb5, 0xb6, 0x7, 0x3f, + 0x2, 0x2, 0xb6, 0x3a, 0x3, 0x2, 0x2, 0x2, 0xb7, 0xb8, 0x7, 0x40, 0x2, + 0x2, 0xb8, 0xb9, 0x7, 0x3f, 0x2, 0x2, 0xb9, 0x3c, 0x3, 0x2, 0x2, 0x2, + 0xba, 0xbb, 0x7, 0x3f, 0x2, 0x2, 0xbb, 0xbc, 0x7, 0x3f, 0x2, 0x2, 0xbc, + 0x3e, 0x3, 0x2, 0x2, 0x2, 0xbd, 0xbe, 0x7, 0x23, 0x2, 0x2, 0xbe, 0xbf, + 0x7, 0x3f, 0x2, 0x2, 0xbf, 0x40, 0x3, 0x2, 0x2, 0x2, 0xc0, 0xc1, 0x7, + 0x28, 0x2, 0x2, 0xc1, 0xc2, 0x7, 0x28, 0x2, 0x2, 0xc2, 0x42, 0x3, 0x2, + 0x2, 0x2, 0xc3, 0xc4, 0x7, 0x7e, 0x2, 0x2, 0xc4, 0xc5, 0x7, 0x7e, 0x2, + 0x2, 0xc5, 0x44, 0x3, 0x2, 0x2, 0x2, 0xc6, 0xc7, 0x9, 0x2, 0x2, 0x2, + 0xc7, 0x46, 0x3, 0x2, 0x2, 0x2, 0xc8, 0xc9, 0x9, 0x3, 0x2, 0x2, 0xc9, + 0x48, 0x3, 0x2, 0x2, 0x2, 0xca, 0xcc, 0x9, 0x4, 0x2, 0x2, 0xcb, 0xcd, + 0x9, 0x5, 0x2, 0x2, 0xcc, 0xcb, 0x3, 0x2, 0x2, 0x2, 0xcc, 0xcd, 0x3, + 0x2, 0x2, 0x2, 0xcd, 0xcf, 0x3, 0x2, 0x2, 0x2, 0xce, 0xd0, 0x5, 0x45, + 0x23, 0x2, 0xcf, 0xce, 0x3, 0x2, 0x2, 0x2, 0xd0, 0xd1, 0x3, 0x2, 0x2, + 0x2, 0xd1, 0xcf, 0x3, 0x2, 0x2, 0x2, 0xd1, 0xd2, 0x3, 0x2, 0x2, 0x2, + 0xd2, 0x4a, 0x3, 0x2, 0x2, 0x2, 0xd3, 0xd5, 0x9, 0x6, 0x2, 0x2, 0xd4, + 0xd6, 0x9, 0x5, 0x2, 0x2, 0xd5, 0xd4, 0x3, 0x2, 0x2, 0x2, 0xd5, 0xd6, + 0x3, 0x2, 0x2, 0x2, 0xd6, 0xd8, 0x3, 0x2, 0x2, 0x2, 0xd7, 0xd9, 0x5, + 0x45, 0x23, 0x2, 0xd8, 0xd7, 0x3, 0x2, 0x2, 0x2, 0xd9, 0xda, 0x3, 0x2, + 0x2, 0x2, 0xda, 0xd8, 0x3, 0x2, 0x2, 0x2, 0xda, 0xdb, 0x3, 0x2, 0x2, + 0x2, 0xdb, 0x4c, 0x3, 0x2, 0x2, 0x2, 0xdc, 0xdd, 0x7, 0x32, 0x2, 0x2, + 0xdd, 0xe1, 0x7, 0x7a, 0x2, 0x2, 0xde, 0xdf, 0x7, 0x32, 0x2, 0x2, 0xdf, + 0xe1, 0x7, 0x5a, 0x2, 0x2, 0xe0, 0xdc, 0x3, 0x2, 0x2, 0x2, 0xe0, 0xde, + 0x3, 0x2, 0x2, 0x2, 0xe1, 0xf9, 0x3, 0x2, 0x2, 0x2, 0xe2, 0xe4, 0x5, + 0x47, 0x24, 0x2, 0xe3, 0xe2, 0x3, 0x2, 0x2, 0x2, 0xe4, 0xe5, 0x3, 0x2, + 0x2, 0x2, 0xe5, 0xe3, 0x3, 0x2, 0x2, 0x2, 0xe5, 0xe6, 0x3, 0x2, 0x2, + 0x2, 0xe6, 0xe7, 0x3, 0x2, 0x2, 0x2, 0xe7, 0xeb, 0x7, 0x30, 0x2, 0x2, + 0xe8, 0xea, 0x5, 0x47, 0x24, 0x2, 0xe9, 0xe8, 0x3, 0x2, 0x2, 0x2, 0xea, + 0xed, 0x3, 0x2, 0x2, 0x2, 0xeb, 0xe9, 0x3, 0x2, 0x2, 0x2, 0xeb, 0xec, + 0x3, 0x2, 0x2, 0x2, 0xec, 0xfa, 0x3, 0x2, 0x2, 0x2, 0xed, 0xeb, 0x3, + 0x2, 0x2, 0x2, 0xee, 0xf0, 0x7, 0x30, 0x2, 0x2, 0xef, 0xf1, 0x5, 0x47, + 0x24, 0x2, 0xf0, 0xef, 0x3, 0x2, 0x2, 0x2, 0xf1, 0xf2, 0x3, 0x2, 0x2, + 0x2, 0xf2, 0xf0, 0x3, 0x2, 0x2, 0x2, 0xf2, 0xf3, 0x3, 0x2, 0x2, 0x2, + 0xf3, 0xfa, 0x3, 0x2, 0x2, 0x2, 0xf4, 0xf6, 0x5, 0x47, 0x24, 0x2, 0xf5, + 0xf4, 0x3, 0x2, 0x2, 0x2, 0xf6, 0xf7, 0x3, 0x2, 0x2, 0x2, 0xf7, 0xf5, + 0x3, 0x2, 0x2, 0x2, 0xf7, 0xf8, 0x3, 0x2, 0x2, 0x2, 0xf8, 0xfa, 0x3, + 0x2, 0x2, 0x2, 0xf9, 0xe3, 0x3, 0x2, 0x2, 0x2, 0xf9, 0xee, 0x3, 0x2, + 0x2, 0x2, 0xf9, 0xf5, 0x3, 0x2, 0x2, 0x2, 0xfa, 0xfb, 0x3, 0x2, 0x2, + 0x2, 0xfb, 0xfc, 0x5, 0x4b, 0x26, 0x2, 0xfc, 0x11d, 0x3, 0x2, 0x2, 0x2, + 0xfd, 0xff, 0x7, 0x30, 0x2, 0x2, 0xfe, 0x100, 0x5, 0x45, 0x23, 0x2, + 0xff, 0xfe, 0x3, 0x2, 0x2, 0x2, 0x100, 0x101, 0x3, 0x2, 0x2, 0x2, 0x101, + 0xff, 0x3, 0x2, 0x2, 0x2, 0x101, 0x102, 0x3, 0x2, 0x2, 0x2, 0x102, 0x104, + 0x3, 0x2, 0x2, 0x2, 0x103, 0x105, 0x5, 0x49, 0x25, 0x2, 0x104, 0x103, + 0x3, 0x2, 0x2, 0x2, 0x104, 0x105, 0x3, 0x2, 0x2, 0x2, 0x105, 0x11d, + 0x3, 0x2, 0x2, 0x2, 0x106, 0x108, 0x5, 0x45, 0x23, 0x2, 0x107, 0x106, + 0x3, 0x2, 0x2, 0x2, 0x108, 0x109, 0x3, 0x2, 0x2, 0x2, 0x109, 0x107, + 0x3, 0x2, 0x2, 0x2, 0x109, 0x10a, 0x3, 0x2, 0x2, 0x2, 0x10a, 0x10b, + 0x3, 0x2, 0x2, 0x2, 0x10b, 0x10f, 0x7, 0x30, 0x2, 0x2, 0x10c, 0x10e, + 0x5, 0x45, 0x23, 0x2, 0x10d, 0x10c, 0x3, 0x2, 0x2, 0x2, 0x10e, 0x111, + 0x3, 0x2, 0x2, 0x2, 0x10f, 0x10d, 0x3, 0x2, 0x2, 0x2, 0x10f, 0x110, + 0x3, 0x2, 0x2, 0x2, 0x110, 0x113, 0x3, 0x2, 0x2, 0x2, 0x111, 0x10f, + 0x3, 0x2, 0x2, 0x2, 0x112, 0x114, 0x5, 0x49, 0x25, 0x2, 0x113, 0x112, + 0x3, 0x2, 0x2, 0x2, 0x113, 0x114, 0x3, 0x2, 0x2, 0x2, 0x114, 0x11d, + 0x3, 0x2, 0x2, 0x2, 0x115, 0x117, 0x5, 0x45, 0x23, 0x2, 0x116, 0x115, + 0x3, 0x2, 0x2, 0x2, 0x117, 0x118, 0x3, 0x2, 0x2, 0x2, 0x118, 0x116, + 0x3, 0x2, 0x2, 0x2, 0x118, 0x119, 0x3, 0x2, 0x2, 0x2, 0x119, 0x11a, + 0x3, 0x2, 0x2, 0x2, 0x11a, 0x11b, 0x5, 0x49, 0x25, 0x2, 0x11b, 0x11d, + 0x3, 0x2, 0x2, 0x2, 0x11c, 0xe0, 0x3, 0x2, 0x2, 0x2, 0x11c, 0xfd, 0x3, + 0x2, 0x2, 0x2, 0x11c, 0x107, 0x3, 0x2, 0x2, 0x2, 0x11c, 0x116, 0x3, + 0x2, 0x2, 0x2, 0x11d, 0x4e, 0x3, 0x2, 0x2, 0x2, 0x11e, 0x138, 0x7, 0x32, + 0x2, 0x2, 0x11f, 0x123, 0x9, 0x7, 0x2, 0x2, 0x120, 0x122, 0x9, 0x2, + 0x2, 0x2, 0x121, 0x120, 0x3, 0x2, 0x2, 0x2, 0x122, 0x125, 0x3, 0x2, + 0x2, 0x2, 0x123, 0x121, 0x3, 0x2, 0x2, 0x2, 0x123, 0x124, 0x3, 0x2, + 0x2, 0x2, 0x124, 0x138, 0x3, 0x2, 0x2, 0x2, 0x125, 0x123, 0x3, 0x2, + 0x2, 0x2, 0x126, 0x128, 0x7, 0x32, 0x2, 0x2, 0x127, 0x129, 0x9, 0x8, + 0x2, 0x2, 0x128, 0x127, 0x3, 0x2, 0x2, 0x2, 0x129, 0x12a, 0x3, 0x2, + 0x2, 0x2, 0x12a, 0x128, 0x3, 0x2, 0x2, 0x2, 0x12a, 0x12b, 0x3, 0x2, + 0x2, 0x2, 0x12b, 0x138, 0x3, 0x2, 0x2, 0x2, 0x12c, 0x12d, 0x7, 0x32, + 0x2, 0x2, 0x12d, 0x131, 0x7, 0x7a, 0x2, 0x2, 0x12e, 0x12f, 0x7, 0x32, + 0x2, 0x2, 0x12f, 0x131, 0x7, 0x5a, 0x2, 0x2, 0x130, 0x12c, 0x3, 0x2, + 0x2, 0x2, 0x130, 0x12e, 0x3, 0x2, 0x2, 0x2, 0x131, 0x133, 0x3, 0x2, + 0x2, 0x2, 0x132, 0x134, 0x9, 0x3, 0x2, 0x2, 0x133, 0x132, 0x3, 0x2, + 0x2, 0x2, 0x134, 0x135, 0x3, 0x2, 0x2, 0x2, 0x135, 0x133, 0x3, 0x2, + 0x2, 0x2, 0x135, 0x136, 0x3, 0x2, 0x2, 0x2, 0x136, 0x138, 0x3, 0x2, + 0x2, 0x2, 0x137, 0x11e, 0x3, 0x2, 0x2, 0x2, 0x137, 0x11f, 0x3, 0x2, + 0x2, 0x2, 0x137, 0x126, 0x3, 0x2, 0x2, 0x2, 0x137, 0x130, 0x3, 0x2, + 0x2, 0x2, 0x138, 0x50, 0x3, 0x2, 0x2, 0x2, 0x139, 0x13d, 0x9, 0x9, 0x2, + 0x2, 0x13a, 0x13c, 0x9, 0xa, 0x2, 0x2, 0x13b, 0x13a, 0x3, 0x2, 0x2, + 0x2, 0x13c, 0x13f, 0x3, 0x2, 0x2, 0x2, 0x13d, 0x13b, 0x3, 0x2, 0x2, + 0x2, 0x13d, 0x13e, 0x3, 0x2, 0x2, 0x2, 0x13e, 0x52, 0x3, 0x2, 0x2, 0x2, + 0x13f, 0x13d, 0x3, 0x2, 0x2, 0x2, 0x140, 0x142, 0x9, 0xb, 0x2, 0x2, + 0x141, 0x140, 0x3, 0x2, 0x2, 0x2, 0x142, 0x143, 0x3, 0x2, 0x2, 0x2, + 0x143, 0x141, 0x3, 0x2, 0x2, 0x2, 0x143, 0x144, 0x3, 0x2, 0x2, 0x2, + 0x144, 0x145, 0x3, 0x2, 0x2, 0x2, 0x145, 0x146, 0x8, 0x2a, 0x2, 0x2, + 0x146, 0x54, 0x3, 0x2, 0x2, 0x2, 0x147, 0x148, 0x7, 0x31, 0x2, 0x2, + 0x148, 0x149, 0x7, 0x31, 0x2, 0x2, 0x149, 0x14d, 0x3, 0x2, 0x2, 0x2, + 0x14a, 0x14c, 0xa, 0xc, 0x2, 0x2, 0x14b, 0x14a, 0x3, 0x2, 0x2, 0x2, + 0x14c, 0x14f, 0x3, 0x2, 0x2, 0x2, 0x14d, 0x14b, 0x3, 0x2, 0x2, 0x2, + 0x14d, 0x14e, 0x3, 0x2, 0x2, 0x2, 0x14e, 0x150, 0x3, 0x2, 0x2, 0x2, + 0x14f, 0x14d, 0x3, 0x2, 0x2, 0x2, 0x150, 0x151, 0x8, 0x2b, 0x2, 0x2, + 0x151, 0x56, 0x3, 0x2, 0x2, 0x2, 0x152, 0x153, 0x7, 0x31, 0x2, 0x2, + 0x153, 0x154, 0x7, 0x2c, 0x2, 0x2, 0x154, 0x158, 0x3, 0x2, 0x2, 0x2, + 0x155, 0x157, 0xb, 0x2, 0x2, 0x2, 0x156, 0x155, 0x3, 0x2, 0x2, 0x2, + 0x157, 0x15a, 0x3, 0x2, 0x2, 0x2, 0x158, 0x159, 0x3, 0x2, 0x2, 0x2, + 0x158, 0x156, 0x3, 0x2, 0x2, 0x2, 0x159, 0x15b, 0x3, 0x2, 0x2, 0x2, + 0x15a, 0x158, 0x3, 0x2, 0x2, 0x2, 0x15b, 0x15c, 0x7, 0x2c, 0x2, 0x2, + 0x15c, 0x15d, 0x7, 0x31, 0x2, 0x2, 0x15d, 0x15e, 0x3, 0x2, 0x2, 0x2, + 0x15e, 0x15f, 0x8, 0x2c, 0x2, 0x2, 0x15f, 0x58, 0x3, 0x2, 0x2, 0x2, + 0x1d, 0x2, 0xcc, 0xd1, 0xd5, 0xda, 0xe0, 0xe5, 0xeb, 0xf2, 0xf7, 0xf9, + 0x101, 0x104, 0x109, 0x10f, 0x113, 0x118, 0x11c, 0x123, 0x12a, 0x130, + 0x135, 0x137, 0x13d, 0x143, 0x14d, 0x158, 0x3, 0x8, 0x2, 0x2, + }; + + atn::ATNDeserializer deserializer; + _atn = deserializer.deserialize(_serializedATN); + + size_t count = _atn.getNumberOfDecisions(); + _decisionToDFA.reserve(count); + for (size_t i = 0; i < count; i++) { + _decisionToDFA.emplace_back(_atn.getDecisionState(i), i); + } +} + +SysYLexer::Initializer SysYLexer::_init; diff --git a/src/antlr4/SysYLexer.h b/src/antlr4/SysYLexer.h new file mode 100644 index 0000000..ac9457c --- /dev/null +++ b/src/antlr4/SysYLexer.h @@ -0,0 +1,62 @@ + +// Generated from SysY.g4 by ANTLR 4.7.2 + +#pragma once + + +#include "antlr4-runtime.h" + + + + +class SysYLexer : public antlr4::Lexer { +public: + enum { + T__0 = 1, T__1 = 2, T__2 = 3, T__3 = 4, T__4 = 5, T__5 = 6, T__6 = 7, + T__7 = 8, T__8 = 9, T__9 = 10, T__10 = 11, T__11 = 12, T__12 = 13, T__13 = 14, + T__14 = 15, T__15 = 16, T__16 = 17, T__17 = 18, T__18 = 19, T__19 = 20, + T__20 = 21, T__21 = 22, T__22 = 23, T__23 = 24, T__24 = 25, T__25 = 26, + T__26 = 27, T__27 = 28, T__28 = 29, T__29 = 30, T__30 = 31, T__31 = 32, + T__32 = 33, FloatConst = 34, IntConst = 35, Ident = 36, WS = 37, LINE_COMMENT = 38, + BLOCK_COMMENT = 39 + }; + + SysYLexer(antlr4::CharStream *input); + ~SysYLexer(); + + virtual std::string getGrammarFileName() const override; + virtual const std::vector& getRuleNames() const override; + + virtual const std::vector& getChannelNames() const override; + virtual const std::vector& getModeNames() const override; + virtual const std::vector& getTokenNames() const override; // deprecated, use vocabulary instead + virtual antlr4::dfa::Vocabulary& getVocabulary() const override; + + virtual const std::vector getSerializedATN() const override; + virtual const antlr4::atn::ATN& getATN() const override; + +private: + static std::vector _decisionToDFA; + static antlr4::atn::PredictionContextCache _sharedContextCache; + static std::vector _ruleNames; + static std::vector _tokenNames; + static std::vector _channelNames; + static std::vector _modeNames; + + static std::vector _literalNames; + static std::vector _symbolicNames; + static antlr4::dfa::Vocabulary _vocabulary; + static antlr4::atn::ATN _atn; + static std::vector _serializedATN; + + + // Individual action functions triggered by action() above. + + // Individual semantic predicate functions triggered by sempred() above. + + struct Initializer { + Initializer(); + }; + static Initializer _init; +}; + diff --git a/src/antlr4/SysYParser.cpp b/src/antlr4/SysYParser.cpp new file mode 100644 index 0000000..0efcf6b --- /dev/null +++ b/src/antlr4/SysYParser.cpp @@ -0,0 +1,2648 @@ + +// Generated from SysY.g4 by ANTLR 4.7.2 + + +#include "SysYVisitor.h" + +#include "SysYParser.h" + + +using namespace antlrcpp; +using namespace antlr4; + +SysYParser::SysYParser(TokenStream *input) : Parser(input) { + _interpreter = new atn::ParserATNSimulator(this, _atn, _decisionToDFA, _sharedContextCache); +} + +SysYParser::~SysYParser() { + delete _interpreter; +} + +std::string SysYParser::getGrammarFileName() const { + return "SysY.g4"; +} + +const std::vector& SysYParser::getRuleNames() const { + return _ruleNames; +} + +dfa::Vocabulary& SysYParser::getVocabulary() const { + return _vocabulary; +} + + +//----------------- CompUnitContext ------------------------------------------------------------------ + +SysYParser::CompUnitContext::CompUnitContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +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; +} + +antlrcpp::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; + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(64); + _errHandler->sync(this); + _la = _input->LA(1); + do { + setState(64); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 0, _ctx)) { + case 1: { + setState(62); + decl(); + break; + } + + case 2: { + setState(63); + funcDef(); + break; + } + + } + setState(66); + _errHandler->sync(this); + _la = _input->LA(1); + } while ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & ((1ULL << SysYParser::T__0) + | (1ULL << SysYParser::T__3) + | (1ULL << SysYParser::T__4) + | (1ULL << SysYParser::T__12))) != 0)); + + } + 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; +} + +antlrcpp::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); + + auto onExit = finally([=] { + exitRule(); + }); + try { + setState(70); + _errHandler->sync(this); + switch (_input->LA(1)) { + case SysYParser::T__0: { + enterOuterAlt(_localctx, 1); + setState(68); + constDecl(); + break; + } + + case SysYParser::T__3: + case SysYParser::T__4: { + enterOuterAlt(_localctx, 2); + setState(69); + 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) { +} + +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); +} + + +size_t SysYParser::ConstDeclContext::getRuleIndex() const { + return SysYParser::RuleConstDecl; +} + +antlrcpp::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; + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(72); + match(SysYParser::T__0); + setState(73); + bType(); + setState(74); + constDef(); + setState(79); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysYParser::T__1) { + setState(75); + match(SysYParser::T__1); + setState(76); + constDef(); + setState(81); + _errHandler->sync(this); + _la = _input->LA(1); + } + setState(82); + match(SysYParser::T__2); + + } + 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) { +} + + +size_t SysYParser::BTypeContext::getRuleIndex() const { + return SysYParser::RuleBType; +} + +antlrcpp::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, 6, SysYParser::RuleBType); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(84); + _la = _input->LA(1); + if (!(_la == SysYParser::T__3 + + || _la == SysYParser::T__4)) { + _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; +} + +//----------------- ConstDefContext ------------------------------------------------------------------ + +SysYParser::ConstDefContext::ConstDefContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SysYParser::ConstDefContext::Ident() { + return getToken(SysYParser::Ident, 0); +} + +SysYParser::ConstInitValContext* SysYParser::ConstDefContext::constInitVal() { + return getRuleContext(0); +} + +std::vector SysYParser::ConstDefContext::constExp() { + return getRuleContexts(); +} + +SysYParser::ConstExpContext* SysYParser::ConstDefContext::constExp(size_t i) { + return getRuleContext(i); +} + + +size_t SysYParser::ConstDefContext::getRuleIndex() const { + return SysYParser::RuleConstDef; +} + +antlrcpp::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, 8, SysYParser::RuleConstDef); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(86); + match(SysYParser::Ident); + setState(93); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysYParser::T__5) { + setState(87); + match(SysYParser::T__5); + setState(88); + constExp(); + setState(89); + match(SysYParser::T__6); + setState(95); + _errHandler->sync(this); + _la = _input->LA(1); + } + setState(96); + match(SysYParser::T__7); + setState(97); + constInitVal(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ConstInitValContext ------------------------------------------------------------------ + +SysYParser::ConstInitValContext::ConstInitValContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +SysYParser::ConstExpContext* SysYParser::ConstInitValContext::constExp() { + return getRuleContext(0); +} + +std::vector SysYParser::ConstInitValContext::constInitVal() { + return getRuleContexts(); +} + +SysYParser::ConstInitValContext* SysYParser::ConstInitValContext::constInitVal(size_t i) { + return getRuleContext(i); +} + + +size_t SysYParser::ConstInitValContext::getRuleIndex() const { + return SysYParser::RuleConstInitVal; +} + +antlrcpp::Any SysYParser::ConstInitValContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitConstInitVal(this); + else + return visitor->visitChildren(this); +} + +SysYParser::ConstInitValContext* SysYParser::constInitVal() { + ConstInitValContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 10, SysYParser::RuleConstInitVal); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + setState(112); + _errHandler->sync(this); + switch (_input->LA(1)) { + case SysYParser::T__10: + case SysYParser::T__19: + case SysYParser::T__20: + case SysYParser::T__21: + case SysYParser::FloatConst: + case SysYParser::IntConst: + case SysYParser::Ident: { + enterOuterAlt(_localctx, 1); + setState(99); + constExp(); + break; + } + + case SysYParser::T__8: { + enterOuterAlt(_localctx, 2); + setState(100); + match(SysYParser::T__8); + setState(109); + _errHandler->sync(this); + + _la = _input->LA(1); + if ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & ((1ULL << SysYParser::T__8) + | (1ULL << SysYParser::T__10) + | (1ULL << SysYParser::T__19) + | (1ULL << SysYParser::T__20) + | (1ULL << SysYParser::T__21) + | (1ULL << SysYParser::FloatConst) + | (1ULL << SysYParser::IntConst) + | (1ULL << SysYParser::Ident))) != 0)) { + setState(101); + constInitVal(); + setState(106); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysYParser::T__1) { + setState(102); + match(SysYParser::T__1); + setState(103); + constInitVal(); + setState(108); + _errHandler->sync(this); + _la = _input->LA(1); + } + } + setState(111); + match(SysYParser::T__9); + 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); +} + + +size_t SysYParser::VarDeclContext::getRuleIndex() const { + return SysYParser::RuleVarDecl; +} + +antlrcpp::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, 12, SysYParser::RuleVarDecl); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(114); + bType(); + setState(115); + varDef(); + setState(120); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysYParser::T__1) { + setState(116); + match(SysYParser::T__1); + setState(117); + varDef(); + setState(122); + _errHandler->sync(this); + _la = _input->LA(1); + } + setState(123); + match(SysYParser::T__2); + + } + 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::Ident() { + return getToken(SysYParser::Ident, 0); +} + +std::vector SysYParser::VarDefContext::constExp() { + return getRuleContexts(); +} + +SysYParser::ConstExpContext* SysYParser::VarDefContext::constExp(size_t i) { + return getRuleContext(i); +} + +SysYParser::InitValContext* SysYParser::VarDefContext::initVal() { + return getRuleContext(0); +} + + +size_t SysYParser::VarDefContext::getRuleIndex() const { + return SysYParser::RuleVarDef; +} + +antlrcpp::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; + + auto onExit = finally([=] { + exitRule(); + }); + try { + setState(147); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 11, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(125); + match(SysYParser::Ident); + setState(132); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysYParser::T__5) { + setState(126); + match(SysYParser::T__5); + setState(127); + constExp(); + setState(128); + match(SysYParser::T__6); + setState(134); + _errHandler->sync(this); + _la = _input->LA(1); + } + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(135); + match(SysYParser::Ident); + setState(142); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysYParser::T__5) { + setState(136); + match(SysYParser::T__5); + setState(137); + constExp(); + setState(138); + match(SysYParser::T__6); + setState(144); + _errHandler->sync(this); + _la = _input->LA(1); + } + setState(145); + match(SysYParser::T__7); + setState(146); + initVal(); + break; + } + + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- InitValContext ------------------------------------------------------------------ + +SysYParser::InitValContext::InitValContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +SysYParser::ExpContext* SysYParser::InitValContext::exp() { + return getRuleContext(0); +} + +std::vector SysYParser::InitValContext::initVal() { + return getRuleContexts(); +} + +SysYParser::InitValContext* SysYParser::InitValContext::initVal(size_t i) { + return getRuleContext(i); +} + + +size_t SysYParser::InitValContext::getRuleIndex() const { + return SysYParser::RuleInitVal; +} + +antlrcpp::Any SysYParser::InitValContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitInitVal(this); + else + return visitor->visitChildren(this); +} + +SysYParser::InitValContext* SysYParser::initVal() { + InitValContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 16, SysYParser::RuleInitVal); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + setState(162); + _errHandler->sync(this); + switch (_input->LA(1)) { + case SysYParser::T__10: + case SysYParser::T__19: + case SysYParser::T__20: + case SysYParser::T__21: + case SysYParser::FloatConst: + case SysYParser::IntConst: + case SysYParser::Ident: { + enterOuterAlt(_localctx, 1); + setState(149); + exp(); + break; + } + + case SysYParser::T__8: { + enterOuterAlt(_localctx, 2); + setState(150); + match(SysYParser::T__8); + setState(159); + _errHandler->sync(this); + + _la = _input->LA(1); + if ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & ((1ULL << SysYParser::T__8) + | (1ULL << SysYParser::T__10) + | (1ULL << SysYParser::T__19) + | (1ULL << SysYParser::T__20) + | (1ULL << SysYParser::T__21) + | (1ULL << SysYParser::FloatConst) + | (1ULL << SysYParser::IntConst) + | (1ULL << SysYParser::Ident))) != 0)) { + setState(151); + initVal(); + setState(156); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysYParser::T__1) { + setState(152); + match(SysYParser::T__1); + setState(153); + initVal(); + setState(158); + _errHandler->sync(this); + _la = _input->LA(1); + } + } + setState(161); + match(SysYParser::T__9); + 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::Ident() { + return getToken(SysYParser::Ident, 0); +} + +SysYParser::BlockContext* SysYParser::FuncDefContext::block() { + return getRuleContext(0); +} + +SysYParser::FuncFParamsContext* SysYParser::FuncDefContext::funcFParams() { + return getRuleContext(0); +} + + +size_t SysYParser::FuncDefContext::getRuleIndex() const { + return SysYParser::RuleFuncDef; +} + +antlrcpp::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; + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(164); + funcType(); + setState(165); + match(SysYParser::Ident); + setState(166); + match(SysYParser::T__10); + setState(168); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == SysYParser::T__3 + + || _la == SysYParser::T__4) { + setState(167); + funcFParams(); + } + setState(170); + match(SysYParser::T__11); + setState(171); + block(); + + } + 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) { +} + + +size_t SysYParser::FuncTypeContext::getRuleIndex() const { + return SysYParser::RuleFuncType; +} + +antlrcpp::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; + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(173); + _la = _input->LA(1); + if (!((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & ((1ULL << SysYParser::T__3) + | (1ULL << SysYParser::T__4) + | (1ULL << SysYParser::T__12))) != 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); +} + + +size_t SysYParser::FuncFParamsContext::getRuleIndex() const { + return SysYParser::RuleFuncFParams; +} + +antlrcpp::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; + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(175); + funcFParam(); + setState(180); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysYParser::T__1) { + setState(176); + match(SysYParser::T__1); + setState(177); + funcFParam(); + setState(182); + _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::Ident() { + return getToken(SysYParser::Ident, 0); +} + +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; +} + +antlrcpp::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; + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(183); + bType(); + setState(184); + match(SysYParser::Ident); + setState(196); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == SysYParser::T__5) { + setState(185); + match(SysYParser::T__5); + setState(186); + match(SysYParser::T__6); + setState(193); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysYParser::T__5) { + setState(187); + match(SysYParser::T__5); + setState(188); + exp(); + setState(189); + match(SysYParser::T__6); + setState(195); + _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; +} + +//----------------- BlockContext ------------------------------------------------------------------ + +SysYParser::BlockContext::BlockContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector SysYParser::BlockContext::blockItem() { + return getRuleContexts(); +} + +SysYParser::BlockItemContext* SysYParser::BlockContext::blockItem(size_t i) { + return getRuleContext(i); +} + + +size_t SysYParser::BlockContext::getRuleIndex() const { + return SysYParser::RuleBlock; +} + +antlrcpp::Any SysYParser::BlockContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitBlock(this); + else + return visitor->visitChildren(this); +} + +SysYParser::BlockContext* SysYParser::block() { + BlockContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 26, SysYParser::RuleBlock); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(198); + match(SysYParser::T__8); + setState(202); + _errHandler->sync(this); + _la = _input->LA(1); + while ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & ((1ULL << SysYParser::T__0) + | (1ULL << SysYParser::T__2) + | (1ULL << SysYParser::T__3) + | (1ULL << SysYParser::T__4) + | (1ULL << SysYParser::T__8) + | (1ULL << SysYParser::T__10) + | (1ULL << SysYParser::T__13) + | (1ULL << SysYParser::T__15) + | (1ULL << SysYParser::T__16) + | (1ULL << SysYParser::T__17) + | (1ULL << SysYParser::T__18) + | (1ULL << SysYParser::T__19) + | (1ULL << SysYParser::T__20) + | (1ULL << SysYParser::T__21) + | (1ULL << SysYParser::FloatConst) + | (1ULL << SysYParser::IntConst) + | (1ULL << SysYParser::Ident))) != 0)) { + setState(199); + blockItem(); + setState(204); + _errHandler->sync(this); + _la = _input->LA(1); + } + setState(205); + match(SysYParser::T__9); + + } + 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; +} + +antlrcpp::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); + + auto onExit = finally([=] { + exitRule(); + }); + try { + setState(209); + _errHandler->sync(this); + switch (_input->LA(1)) { + case SysYParser::T__0: + case SysYParser::T__3: + case SysYParser::T__4: { + enterOuterAlt(_localctx, 1); + setState(207); + decl(); + break; + } + + case SysYParser::T__2: + case SysYParser::T__8: + case SysYParser::T__10: + case SysYParser::T__13: + case SysYParser::T__15: + case SysYParser::T__16: + case SysYParser::T__17: + case SysYParser::T__18: + case SysYParser::T__19: + case SysYParser::T__20: + case SysYParser::T__21: + case SysYParser::FloatConst: + case SysYParser::IntConst: + case SysYParser::Ident: { + enterOuterAlt(_localctx, 2); + setState(208); + 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::LValContext* SysYParser::StmtContext::lVal() { + return getRuleContext(0); +} + +SysYParser::ExpContext* SysYParser::StmtContext::exp() { + return getRuleContext(0); +} + +SysYParser::BlockContext* SysYParser::StmtContext::block() { + return getRuleContext(0); +} + +SysYParser::CondContext* SysYParser::StmtContext::cond() { + return getRuleContext(0); +} + +std::vector SysYParser::StmtContext::stmt() { + return getRuleContexts(); +} + +SysYParser::StmtContext* SysYParser::StmtContext::stmt(size_t i) { + return getRuleContext(i); +} + + +size_t SysYParser::StmtContext::getRuleIndex() const { + return SysYParser::RuleStmt; +} + +antlrcpp::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; + + auto onExit = finally([=] { + exitRule(); + }); + try { + setState(245); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 24, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(211); + lVal(); + setState(212); + match(SysYParser::T__7); + setState(213); + exp(); + setState(214); + match(SysYParser::T__2); + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(217); + _errHandler->sync(this); + + _la = _input->LA(1); + if ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & ((1ULL << SysYParser::T__10) + | (1ULL << SysYParser::T__19) + | (1ULL << SysYParser::T__20) + | (1ULL << SysYParser::T__21) + | (1ULL << SysYParser::FloatConst) + | (1ULL << SysYParser::IntConst) + | (1ULL << SysYParser::Ident))) != 0)) { + setState(216); + exp(); + } + setState(219); + match(SysYParser::T__2); + break; + } + + case 3: { + enterOuterAlt(_localctx, 3); + setState(220); + block(); + break; + } + + case 4: { + enterOuterAlt(_localctx, 4); + setState(221); + match(SysYParser::T__13); + setState(222); + match(SysYParser::T__10); + setState(223); + cond(); + setState(224); + match(SysYParser::T__11); + setState(225); + stmt(); + setState(228); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 22, _ctx)) { + case 1: { + setState(226); + match(SysYParser::T__14); + setState(227); + stmt(); + break; + } + + } + break; + } + + case 5: { + enterOuterAlt(_localctx, 5); + setState(230); + match(SysYParser::T__15); + setState(231); + match(SysYParser::T__10); + setState(232); + cond(); + setState(233); + match(SysYParser::T__11); + setState(234); + stmt(); + break; + } + + case 6: { + enterOuterAlt(_localctx, 6); + setState(236); + match(SysYParser::T__16); + setState(237); + match(SysYParser::T__2); + break; + } + + case 7: { + enterOuterAlt(_localctx, 7); + setState(238); + match(SysYParser::T__17); + setState(239); + match(SysYParser::T__2); + break; + } + + case 8: { + enterOuterAlt(_localctx, 8); + setState(240); + match(SysYParser::T__18); + setState(242); + _errHandler->sync(this); + + _la = _input->LA(1); + if ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & ((1ULL << SysYParser::T__10) + | (1ULL << SysYParser::T__19) + | (1ULL << SysYParser::T__20) + | (1ULL << SysYParser::T__21) + | (1ULL << SysYParser::FloatConst) + | (1ULL << SysYParser::IntConst) + | (1ULL << SysYParser::Ident))) != 0)) { + setState(241); + exp(); + } + setState(244); + match(SysYParser::T__2); + break; + } + + } + + } + 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; +} + +antlrcpp::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, 32, SysYParser::RuleExp); + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(247); + addExp(); + + } + 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; +} + +antlrcpp::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, 34, SysYParser::RuleCond); + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(249); + lOrExp(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- LValContext ------------------------------------------------------------------ + +SysYParser::LValContext::LValContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SysYParser::LValContext::Ident() { + return getToken(SysYParser::Ident, 0); +} + +std::vector SysYParser::LValContext::exp() { + return getRuleContexts(); +} + +SysYParser::ExpContext* SysYParser::LValContext::exp(size_t i) { + return getRuleContext(i); +} + + +size_t SysYParser::LValContext::getRuleIndex() const { + return SysYParser::RuleLVal; +} + +antlrcpp::Any SysYParser::LValContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitLVal(this); + else + return visitor->visitChildren(this); +} + +SysYParser::LValContext* SysYParser::lVal() { + LValContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 36, SysYParser::RuleLVal); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(251); + match(SysYParser::Ident); + setState(258); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysYParser::T__5) { + setState(252); + match(SysYParser::T__5); + setState(253); + exp(); + setState(254); + match(SysYParser::T__6); + setState(260); + _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; +} + +//----------------- PrimaryExpContext ------------------------------------------------------------------ + +SysYParser::PrimaryExpContext::PrimaryExpContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +SysYParser::ExpContext* SysYParser::PrimaryExpContext::exp() { + return getRuleContext(0); +} + +SysYParser::LValContext* SysYParser::PrimaryExpContext::lVal() { + return getRuleContext(0); +} + +SysYParser::NumberContext* SysYParser::PrimaryExpContext::number() { + return getRuleContext(0); +} + + +size_t SysYParser::PrimaryExpContext::getRuleIndex() const { + return SysYParser::RulePrimaryExp; +} + +antlrcpp::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, 38, SysYParser::RulePrimaryExp); + + auto onExit = finally([=] { + exitRule(); + }); + try { + setState(267); + _errHandler->sync(this); + switch (_input->LA(1)) { + case SysYParser::T__10: { + enterOuterAlt(_localctx, 1); + setState(261); + match(SysYParser::T__10); + setState(262); + exp(); + setState(263); + match(SysYParser::T__11); + break; + } + + case SysYParser::Ident: { + enterOuterAlt(_localctx, 2); + setState(265); + lVal(); + break; + } + + case SysYParser::FloatConst: + case SysYParser::IntConst: { + enterOuterAlt(_localctx, 3); + setState(266); + 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::FloatConst() { + return getToken(SysYParser::FloatConst, 0); +} + +tree::TerminalNode* SysYParser::NumberContext::IntConst() { + return getToken(SysYParser::IntConst, 0); +} + + +size_t SysYParser::NumberContext::getRuleIndex() const { + return SysYParser::RuleNumber; +} + +antlrcpp::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, 40, SysYParser::RuleNumber); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(269); + _la = _input->LA(1); + if (!(_la == SysYParser::FloatConst + + || _la == SysYParser::IntConst)) { + _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::Ident() { + return getToken(SysYParser::Ident, 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; +} + +antlrcpp::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, 42, SysYParser::RuleUnaryExp); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + setState(281); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 28, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(271); + primaryExp(); + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(272); + match(SysYParser::Ident); + setState(273); + match(SysYParser::T__10); + setState(275); + _errHandler->sync(this); + + _la = _input->LA(1); + if ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & ((1ULL << SysYParser::T__10) + | (1ULL << SysYParser::T__19) + | (1ULL << SysYParser::T__20) + | (1ULL << SysYParser::T__21) + | (1ULL << SysYParser::FloatConst) + | (1ULL << SysYParser::IntConst) + | (1ULL << SysYParser::Ident))) != 0)) { + setState(274); + funcRParams(); + } + setState(277); + match(SysYParser::T__11); + break; + } + + case 3: { + enterOuterAlt(_localctx, 3); + setState(278); + unaryOp(); + setState(279); + unaryExp(); + 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) { +} + + +size_t SysYParser::UnaryOpContext::getRuleIndex() const { + return SysYParser::RuleUnaryOp; +} + +antlrcpp::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, 44, SysYParser::RuleUnaryOp); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(283); + _la = _input->LA(1); + if (!((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & ((1ULL << SysYParser::T__19) + | (1ULL << SysYParser::T__20) + | (1ULL << SysYParser::T__21))) != 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); +} + + +size_t SysYParser::FuncRParamsContext::getRuleIndex() const { + return SysYParser::RuleFuncRParams; +} + +antlrcpp::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, 46, SysYParser::RuleFuncRParams); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(285); + exp(); + setState(290); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysYParser::T__1) { + setState(286); + match(SysYParser::T__1); + setState(287); + exp(); + setState(292); + _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) { +} + +std::vector SysYParser::MulExpContext::unaryExp() { + return getRuleContexts(); +} + +SysYParser::UnaryExpContext* SysYParser::MulExpContext::unaryExp(size_t i) { + return getRuleContext(i); +} + + +size_t SysYParser::MulExpContext::getRuleIndex() const { + return SysYParser::RuleMulExp; +} + +antlrcpp::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() { + MulExpContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 48, SysYParser::RuleMulExp); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(293); + unaryExp(); + setState(298); + _errHandler->sync(this); + _la = _input->LA(1); + while ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & ((1ULL << SysYParser::T__22) + | (1ULL << SysYParser::T__23) + | (1ULL << SysYParser::T__24))) != 0)) { + setState(294); + _la = _input->LA(1); + if (!((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & ((1ULL << SysYParser::T__22) + | (1ULL << SysYParser::T__23) + | (1ULL << SysYParser::T__24))) != 0))) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + setState(295); + unaryExp(); + setState(300); + _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; +} + +//----------------- AddExpContext ------------------------------------------------------------------ + +SysYParser::AddExpContext::AddExpContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector SysYParser::AddExpContext::mulExp() { + return getRuleContexts(); +} + +SysYParser::MulExpContext* SysYParser::AddExpContext::mulExp(size_t i) { + return getRuleContext(i); +} + + +size_t SysYParser::AddExpContext::getRuleIndex() const { + return SysYParser::RuleAddExp; +} + +antlrcpp::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() { + AddExpContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 50, SysYParser::RuleAddExp); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(301); + mulExp(); + setState(306); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysYParser::T__19 + + || _la == SysYParser::T__20) { + setState(302); + _la = _input->LA(1); + if (!(_la == SysYParser::T__19 + + || _la == SysYParser::T__20)) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + setState(303); + mulExp(); + setState(308); + _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; +} + +//----------------- RelExpContext ------------------------------------------------------------------ + +SysYParser::RelExpContext::RelExpContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector SysYParser::RelExpContext::addExp() { + return getRuleContexts(); +} + +SysYParser::AddExpContext* SysYParser::RelExpContext::addExp(size_t i) { + return getRuleContext(i); +} + + +size_t SysYParser::RelExpContext::getRuleIndex() const { + return SysYParser::RuleRelExp; +} + +antlrcpp::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() { + RelExpContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 52, SysYParser::RuleRelExp); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(309); + addExp(); + setState(314); + _errHandler->sync(this); + _la = _input->LA(1); + while ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & ((1ULL << SysYParser::T__25) + | (1ULL << SysYParser::T__26) + | (1ULL << SysYParser::T__27) + | (1ULL << SysYParser::T__28))) != 0)) { + setState(310); + _la = _input->LA(1); + if (!((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & ((1ULL << SysYParser::T__25) + | (1ULL << SysYParser::T__26) + | (1ULL << SysYParser::T__27) + | (1ULL << SysYParser::T__28))) != 0))) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + setState(311); + addExp(); + setState(316); + _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; +} + +//----------------- EqExpContext ------------------------------------------------------------------ + +SysYParser::EqExpContext::EqExpContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector SysYParser::EqExpContext::relExp() { + return getRuleContexts(); +} + +SysYParser::RelExpContext* SysYParser::EqExpContext::relExp(size_t i) { + return getRuleContext(i); +} + + +size_t SysYParser::EqExpContext::getRuleIndex() const { + return SysYParser::RuleEqExp; +} + +antlrcpp::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() { + EqExpContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 54, SysYParser::RuleEqExp); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(317); + relExp(); + setState(322); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysYParser::T__29 + + || _la == SysYParser::T__30) { + setState(318); + _la = _input->LA(1); + if (!(_la == SysYParser::T__29 + + || _la == SysYParser::T__30)) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + setState(319); + relExp(); + setState(324); + _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; +} + +//----------------- LAndExpContext ------------------------------------------------------------------ + +SysYParser::LAndExpContext::LAndExpContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector SysYParser::LAndExpContext::eqExp() { + return getRuleContexts(); +} + +SysYParser::EqExpContext* SysYParser::LAndExpContext::eqExp(size_t i) { + return getRuleContext(i); +} + + +size_t SysYParser::LAndExpContext::getRuleIndex() const { + return SysYParser::RuleLAndExp; +} + +antlrcpp::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() { + LAndExpContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 56, SysYParser::RuleLAndExp); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(325); + eqExp(); + setState(330); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysYParser::T__31) { + setState(326); + match(SysYParser::T__31); + setState(327); + eqExp(); + setState(332); + _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; +} + +//----------------- LOrExpContext ------------------------------------------------------------------ + +SysYParser::LOrExpContext::LOrExpContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector SysYParser::LOrExpContext::lAndExp() { + return getRuleContexts(); +} + +SysYParser::LAndExpContext* SysYParser::LOrExpContext::lAndExp(size_t i) { + return getRuleContext(i); +} + + +size_t SysYParser::LOrExpContext::getRuleIndex() const { + return SysYParser::RuleLOrExp; +} + +antlrcpp::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() { + LOrExpContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 58, SysYParser::RuleLOrExp); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(333); + lAndExp(); + setState(338); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SysYParser::T__32) { + setState(334); + match(SysYParser::T__32); + setState(335); + lAndExp(); + setState(340); + _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; +} + +//----------------- 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; +} + +antlrcpp::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, 60, SysYParser::RuleConstExp); + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(341); + addExp(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +// Static vars and initialization. +std::vector SysYParser::_decisionToDFA; +atn::PredictionContextCache SysYParser::_sharedContextCache; + +// We own the ATN which in turn owns the ATN states. +atn::ATN SysYParser::_atn; +std::vector SysYParser::_serializedATN; + +std::vector SysYParser::_ruleNames = { + "compUnit", "decl", "constDecl", "bType", "constDef", "constInitVal", + "varDecl", "varDef", "initVal", "funcDef", "funcType", "funcFParams", + "funcFParam", "block", "blockItem", "stmt", "exp", "cond", "lVal", "primaryExp", + "number", "unaryExp", "unaryOp", "funcRParams", "mulExp", "addExp", "relExp", + "eqExp", "lAndExp", "lOrExp", "constExp" +}; + +std::vector SysYParser::_literalNames = { + "", "'const'", "','", "';'", "'int'", "'float'", "'['", "']'", "'='", + "'{'", "'}'", "'('", "')'", "'void'", "'if'", "'else'", "'while'", "'break'", + "'continue'", "'return'", "'+'", "'-'", "'!'", "'*'", "'/'", "'%'", "'<'", + "'>'", "'<='", "'>='", "'=='", "'!='", "'&&'", "'||'" +}; + +std::vector SysYParser::_symbolicNames = { + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "FloatConst", + "IntConst", "Ident", "WS", "LINE_COMMENT", "BLOCK_COMMENT" +}; + +dfa::Vocabulary SysYParser::_vocabulary(_literalNames, _symbolicNames); + +std::vector SysYParser::_tokenNames; + +SysYParser::Initializer::Initializer() { + for (size_t i = 0; i < _symbolicNames.size(); ++i) { + std::string name = _vocabulary.getLiteralName(i); + if (name.empty()) { + name = _vocabulary.getSymbolicName(i); + } + + if (name.empty()) { + _tokenNames.push_back(""); + } else { + _tokenNames.push_back(name); + } + } + + _serializedATN = { + 0x3, 0x608b, 0xa72a, 0x8133, 0xb9ed, 0x417c, 0x3be7, 0x7786, 0x5964, + 0x3, 0x29, 0x15a, 0x4, 0x2, 0x9, 0x2, 0x4, 0x3, 0x9, 0x3, 0x4, 0x4, + 0x9, 0x4, 0x4, 0x5, 0x9, 0x5, 0x4, 0x6, 0x9, 0x6, 0x4, 0x7, 0x9, 0x7, + 0x4, 0x8, 0x9, 0x8, 0x4, 0x9, 0x9, 0x9, 0x4, 0xa, 0x9, 0xa, 0x4, 0xb, + 0x9, 0xb, 0x4, 0xc, 0x9, 0xc, 0x4, 0xd, 0x9, 0xd, 0x4, 0xe, 0x9, 0xe, + 0x4, 0xf, 0x9, 0xf, 0x4, 0x10, 0x9, 0x10, 0x4, 0x11, 0x9, 0x11, 0x4, + 0x12, 0x9, 0x12, 0x4, 0x13, 0x9, 0x13, 0x4, 0x14, 0x9, 0x14, 0x4, 0x15, + 0x9, 0x15, 0x4, 0x16, 0x9, 0x16, 0x4, 0x17, 0x9, 0x17, 0x4, 0x18, 0x9, + 0x18, 0x4, 0x19, 0x9, 0x19, 0x4, 0x1a, 0x9, 0x1a, 0x4, 0x1b, 0x9, 0x1b, + 0x4, 0x1c, 0x9, 0x1c, 0x4, 0x1d, 0x9, 0x1d, 0x4, 0x1e, 0x9, 0x1e, 0x4, + 0x1f, 0x9, 0x1f, 0x4, 0x20, 0x9, 0x20, 0x3, 0x2, 0x3, 0x2, 0x6, 0x2, + 0x43, 0xa, 0x2, 0xd, 0x2, 0xe, 0x2, 0x44, 0x3, 0x3, 0x3, 0x3, 0x5, 0x3, + 0x49, 0xa, 0x3, 0x3, 0x4, 0x3, 0x4, 0x3, 0x4, 0x3, 0x4, 0x3, 0x4, 0x7, + 0x4, 0x50, 0xa, 0x4, 0xc, 0x4, 0xe, 0x4, 0x53, 0xb, 0x4, 0x3, 0x4, 0x3, + 0x4, 0x3, 0x5, 0x3, 0x5, 0x3, 0x6, 0x3, 0x6, 0x3, 0x6, 0x3, 0x6, 0x3, + 0x6, 0x7, 0x6, 0x5e, 0xa, 0x6, 0xc, 0x6, 0xe, 0x6, 0x61, 0xb, 0x6, 0x3, + 0x6, 0x3, 0x6, 0x3, 0x6, 0x3, 0x7, 0x3, 0x7, 0x3, 0x7, 0x3, 0x7, 0x3, + 0x7, 0x7, 0x7, 0x6b, 0xa, 0x7, 0xc, 0x7, 0xe, 0x7, 0x6e, 0xb, 0x7, 0x5, + 0x7, 0x70, 0xa, 0x7, 0x3, 0x7, 0x5, 0x7, 0x73, 0xa, 0x7, 0x3, 0x8, 0x3, + 0x8, 0x3, 0x8, 0x3, 0x8, 0x7, 0x8, 0x79, 0xa, 0x8, 0xc, 0x8, 0xe, 0x8, + 0x7c, 0xb, 0x8, 0x3, 0x8, 0x3, 0x8, 0x3, 0x9, 0x3, 0x9, 0x3, 0x9, 0x3, + 0x9, 0x3, 0x9, 0x7, 0x9, 0x85, 0xa, 0x9, 0xc, 0x9, 0xe, 0x9, 0x88, 0xb, + 0x9, 0x3, 0x9, 0x3, 0x9, 0x3, 0x9, 0x3, 0x9, 0x3, 0x9, 0x7, 0x9, 0x8f, + 0xa, 0x9, 0xc, 0x9, 0xe, 0x9, 0x92, 0xb, 0x9, 0x3, 0x9, 0x3, 0x9, 0x5, + 0x9, 0x96, 0xa, 0x9, 0x3, 0xa, 0x3, 0xa, 0x3, 0xa, 0x3, 0xa, 0x3, 0xa, + 0x7, 0xa, 0x9d, 0xa, 0xa, 0xc, 0xa, 0xe, 0xa, 0xa0, 0xb, 0xa, 0x5, 0xa, + 0xa2, 0xa, 0xa, 0x3, 0xa, 0x5, 0xa, 0xa5, 0xa, 0xa, 0x3, 0xb, 0x3, 0xb, + 0x3, 0xb, 0x3, 0xb, 0x5, 0xb, 0xab, 0xa, 0xb, 0x3, 0xb, 0x3, 0xb, 0x3, + 0xb, 0x3, 0xc, 0x3, 0xc, 0x3, 0xd, 0x3, 0xd, 0x3, 0xd, 0x7, 0xd, 0xb5, + 0xa, 0xd, 0xc, 0xd, 0xe, 0xd, 0xb8, 0xb, 0xd, 0x3, 0xe, 0x3, 0xe, 0x3, + 0xe, 0x3, 0xe, 0x3, 0xe, 0x3, 0xe, 0x3, 0xe, 0x3, 0xe, 0x7, 0xe, 0xc2, + 0xa, 0xe, 0xc, 0xe, 0xe, 0xe, 0xc5, 0xb, 0xe, 0x5, 0xe, 0xc7, 0xa, 0xe, + 0x3, 0xf, 0x3, 0xf, 0x7, 0xf, 0xcb, 0xa, 0xf, 0xc, 0xf, 0xe, 0xf, 0xce, + 0xb, 0xf, 0x3, 0xf, 0x3, 0xf, 0x3, 0x10, 0x3, 0x10, 0x5, 0x10, 0xd4, + 0xa, 0x10, 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 0x3, + 0x11, 0x5, 0x11, 0xdc, 0xa, 0x11, 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 0x3, + 0x11, 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 0x5, 0x11, + 0xe7, 0xa, 0x11, 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, + 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 0x3, + 0x11, 0x5, 0x11, 0xf5, 0xa, 0x11, 0x3, 0x11, 0x5, 0x11, 0xf8, 0xa, 0x11, + 0x3, 0x12, 0x3, 0x12, 0x3, 0x13, 0x3, 0x13, 0x3, 0x14, 0x3, 0x14, 0x3, + 0x14, 0x3, 0x14, 0x3, 0x14, 0x7, 0x14, 0x103, 0xa, 0x14, 0xc, 0x14, + 0xe, 0x14, 0x106, 0xb, 0x14, 0x3, 0x15, 0x3, 0x15, 0x3, 0x15, 0x3, 0x15, + 0x3, 0x15, 0x3, 0x15, 0x5, 0x15, 0x10e, 0xa, 0x15, 0x3, 0x16, 0x3, 0x16, + 0x3, 0x17, 0x3, 0x17, 0x3, 0x17, 0x3, 0x17, 0x5, 0x17, 0x116, 0xa, 0x17, + 0x3, 0x17, 0x3, 0x17, 0x3, 0x17, 0x3, 0x17, 0x5, 0x17, 0x11c, 0xa, 0x17, + 0x3, 0x18, 0x3, 0x18, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x7, 0x19, 0x123, + 0xa, 0x19, 0xc, 0x19, 0xe, 0x19, 0x126, 0xb, 0x19, 0x3, 0x1a, 0x3, 0x1a, + 0x3, 0x1a, 0x7, 0x1a, 0x12b, 0xa, 0x1a, 0xc, 0x1a, 0xe, 0x1a, 0x12e, + 0xb, 0x1a, 0x3, 0x1b, 0x3, 0x1b, 0x3, 0x1b, 0x7, 0x1b, 0x133, 0xa, 0x1b, + 0xc, 0x1b, 0xe, 0x1b, 0x136, 0xb, 0x1b, 0x3, 0x1c, 0x3, 0x1c, 0x3, 0x1c, + 0x7, 0x1c, 0x13b, 0xa, 0x1c, 0xc, 0x1c, 0xe, 0x1c, 0x13e, 0xb, 0x1c, + 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x7, 0x1d, 0x143, 0xa, 0x1d, 0xc, 0x1d, + 0xe, 0x1d, 0x146, 0xb, 0x1d, 0x3, 0x1e, 0x3, 0x1e, 0x3, 0x1e, 0x7, 0x1e, + 0x14b, 0xa, 0x1e, 0xc, 0x1e, 0xe, 0x1e, 0x14e, 0xb, 0x1e, 0x3, 0x1f, + 0x3, 0x1f, 0x3, 0x1f, 0x7, 0x1f, 0x153, 0xa, 0x1f, 0xc, 0x1f, 0xe, 0x1f, + 0x156, 0xb, 0x1f, 0x3, 0x20, 0x3, 0x20, 0x3, 0x20, 0x2, 0x2, 0x21, 0x2, + 0x4, 0x6, 0x8, 0xa, 0xc, 0xe, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1a, 0x1c, + 0x1e, 0x20, 0x22, 0x24, 0x26, 0x28, 0x2a, 0x2c, 0x2e, 0x30, 0x32, 0x34, + 0x36, 0x38, 0x3a, 0x3c, 0x3e, 0x2, 0xa, 0x3, 0x2, 0x6, 0x7, 0x4, 0x2, + 0x6, 0x7, 0xf, 0xf, 0x3, 0x2, 0x24, 0x25, 0x3, 0x2, 0x16, 0x18, 0x3, + 0x2, 0x19, 0x1b, 0x3, 0x2, 0x16, 0x17, 0x3, 0x2, 0x1c, 0x1f, 0x3, 0x2, + 0x20, 0x21, 0x2, 0x166, 0x2, 0x42, 0x3, 0x2, 0x2, 0x2, 0x4, 0x48, 0x3, + 0x2, 0x2, 0x2, 0x6, 0x4a, 0x3, 0x2, 0x2, 0x2, 0x8, 0x56, 0x3, 0x2, 0x2, + 0x2, 0xa, 0x58, 0x3, 0x2, 0x2, 0x2, 0xc, 0x72, 0x3, 0x2, 0x2, 0x2, 0xe, + 0x74, 0x3, 0x2, 0x2, 0x2, 0x10, 0x95, 0x3, 0x2, 0x2, 0x2, 0x12, 0xa4, + 0x3, 0x2, 0x2, 0x2, 0x14, 0xa6, 0x3, 0x2, 0x2, 0x2, 0x16, 0xaf, 0x3, + 0x2, 0x2, 0x2, 0x18, 0xb1, 0x3, 0x2, 0x2, 0x2, 0x1a, 0xb9, 0x3, 0x2, + 0x2, 0x2, 0x1c, 0xc8, 0x3, 0x2, 0x2, 0x2, 0x1e, 0xd3, 0x3, 0x2, 0x2, + 0x2, 0x20, 0xf7, 0x3, 0x2, 0x2, 0x2, 0x22, 0xf9, 0x3, 0x2, 0x2, 0x2, + 0x24, 0xfb, 0x3, 0x2, 0x2, 0x2, 0x26, 0xfd, 0x3, 0x2, 0x2, 0x2, 0x28, + 0x10d, 0x3, 0x2, 0x2, 0x2, 0x2a, 0x10f, 0x3, 0x2, 0x2, 0x2, 0x2c, 0x11b, + 0x3, 0x2, 0x2, 0x2, 0x2e, 0x11d, 0x3, 0x2, 0x2, 0x2, 0x30, 0x11f, 0x3, + 0x2, 0x2, 0x2, 0x32, 0x127, 0x3, 0x2, 0x2, 0x2, 0x34, 0x12f, 0x3, 0x2, + 0x2, 0x2, 0x36, 0x137, 0x3, 0x2, 0x2, 0x2, 0x38, 0x13f, 0x3, 0x2, 0x2, + 0x2, 0x3a, 0x147, 0x3, 0x2, 0x2, 0x2, 0x3c, 0x14f, 0x3, 0x2, 0x2, 0x2, + 0x3e, 0x157, 0x3, 0x2, 0x2, 0x2, 0x40, 0x43, 0x5, 0x4, 0x3, 0x2, 0x41, + 0x43, 0x5, 0x14, 0xb, 0x2, 0x42, 0x40, 0x3, 0x2, 0x2, 0x2, 0x42, 0x41, + 0x3, 0x2, 0x2, 0x2, 0x43, 0x44, 0x3, 0x2, 0x2, 0x2, 0x44, 0x42, 0x3, + 0x2, 0x2, 0x2, 0x44, 0x45, 0x3, 0x2, 0x2, 0x2, 0x45, 0x3, 0x3, 0x2, + 0x2, 0x2, 0x46, 0x49, 0x5, 0x6, 0x4, 0x2, 0x47, 0x49, 0x5, 0xe, 0x8, + 0x2, 0x48, 0x46, 0x3, 0x2, 0x2, 0x2, 0x48, 0x47, 0x3, 0x2, 0x2, 0x2, + 0x49, 0x5, 0x3, 0x2, 0x2, 0x2, 0x4a, 0x4b, 0x7, 0x3, 0x2, 0x2, 0x4b, + 0x4c, 0x5, 0x8, 0x5, 0x2, 0x4c, 0x51, 0x5, 0xa, 0x6, 0x2, 0x4d, 0x4e, + 0x7, 0x4, 0x2, 0x2, 0x4e, 0x50, 0x5, 0xa, 0x6, 0x2, 0x4f, 0x4d, 0x3, + 0x2, 0x2, 0x2, 0x50, 0x53, 0x3, 0x2, 0x2, 0x2, 0x51, 0x4f, 0x3, 0x2, + 0x2, 0x2, 0x51, 0x52, 0x3, 0x2, 0x2, 0x2, 0x52, 0x54, 0x3, 0x2, 0x2, + 0x2, 0x53, 0x51, 0x3, 0x2, 0x2, 0x2, 0x54, 0x55, 0x7, 0x5, 0x2, 0x2, + 0x55, 0x7, 0x3, 0x2, 0x2, 0x2, 0x56, 0x57, 0x9, 0x2, 0x2, 0x2, 0x57, + 0x9, 0x3, 0x2, 0x2, 0x2, 0x58, 0x5f, 0x7, 0x26, 0x2, 0x2, 0x59, 0x5a, + 0x7, 0x8, 0x2, 0x2, 0x5a, 0x5b, 0x5, 0x3e, 0x20, 0x2, 0x5b, 0x5c, 0x7, + 0x9, 0x2, 0x2, 0x5c, 0x5e, 0x3, 0x2, 0x2, 0x2, 0x5d, 0x59, 0x3, 0x2, + 0x2, 0x2, 0x5e, 0x61, 0x3, 0x2, 0x2, 0x2, 0x5f, 0x5d, 0x3, 0x2, 0x2, + 0x2, 0x5f, 0x60, 0x3, 0x2, 0x2, 0x2, 0x60, 0x62, 0x3, 0x2, 0x2, 0x2, + 0x61, 0x5f, 0x3, 0x2, 0x2, 0x2, 0x62, 0x63, 0x7, 0xa, 0x2, 0x2, 0x63, + 0x64, 0x5, 0xc, 0x7, 0x2, 0x64, 0xb, 0x3, 0x2, 0x2, 0x2, 0x65, 0x73, + 0x5, 0x3e, 0x20, 0x2, 0x66, 0x6f, 0x7, 0xb, 0x2, 0x2, 0x67, 0x6c, 0x5, + 0xc, 0x7, 0x2, 0x68, 0x69, 0x7, 0x4, 0x2, 0x2, 0x69, 0x6b, 0x5, 0xc, + 0x7, 0x2, 0x6a, 0x68, 0x3, 0x2, 0x2, 0x2, 0x6b, 0x6e, 0x3, 0x2, 0x2, + 0x2, 0x6c, 0x6a, 0x3, 0x2, 0x2, 0x2, 0x6c, 0x6d, 0x3, 0x2, 0x2, 0x2, + 0x6d, 0x70, 0x3, 0x2, 0x2, 0x2, 0x6e, 0x6c, 0x3, 0x2, 0x2, 0x2, 0x6f, + 0x67, 0x3, 0x2, 0x2, 0x2, 0x6f, 0x70, 0x3, 0x2, 0x2, 0x2, 0x70, 0x71, + 0x3, 0x2, 0x2, 0x2, 0x71, 0x73, 0x7, 0xc, 0x2, 0x2, 0x72, 0x65, 0x3, + 0x2, 0x2, 0x2, 0x72, 0x66, 0x3, 0x2, 0x2, 0x2, 0x73, 0xd, 0x3, 0x2, + 0x2, 0x2, 0x74, 0x75, 0x5, 0x8, 0x5, 0x2, 0x75, 0x7a, 0x5, 0x10, 0x9, + 0x2, 0x76, 0x77, 0x7, 0x4, 0x2, 0x2, 0x77, 0x79, 0x5, 0x10, 0x9, 0x2, + 0x78, 0x76, 0x3, 0x2, 0x2, 0x2, 0x79, 0x7c, 0x3, 0x2, 0x2, 0x2, 0x7a, + 0x78, 0x3, 0x2, 0x2, 0x2, 0x7a, 0x7b, 0x3, 0x2, 0x2, 0x2, 0x7b, 0x7d, + 0x3, 0x2, 0x2, 0x2, 0x7c, 0x7a, 0x3, 0x2, 0x2, 0x2, 0x7d, 0x7e, 0x7, + 0x5, 0x2, 0x2, 0x7e, 0xf, 0x3, 0x2, 0x2, 0x2, 0x7f, 0x86, 0x7, 0x26, + 0x2, 0x2, 0x80, 0x81, 0x7, 0x8, 0x2, 0x2, 0x81, 0x82, 0x5, 0x3e, 0x20, + 0x2, 0x82, 0x83, 0x7, 0x9, 0x2, 0x2, 0x83, 0x85, 0x3, 0x2, 0x2, 0x2, + 0x84, 0x80, 0x3, 0x2, 0x2, 0x2, 0x85, 0x88, 0x3, 0x2, 0x2, 0x2, 0x86, + 0x84, 0x3, 0x2, 0x2, 0x2, 0x86, 0x87, 0x3, 0x2, 0x2, 0x2, 0x87, 0x96, + 0x3, 0x2, 0x2, 0x2, 0x88, 0x86, 0x3, 0x2, 0x2, 0x2, 0x89, 0x90, 0x7, + 0x26, 0x2, 0x2, 0x8a, 0x8b, 0x7, 0x8, 0x2, 0x2, 0x8b, 0x8c, 0x5, 0x3e, + 0x20, 0x2, 0x8c, 0x8d, 0x7, 0x9, 0x2, 0x2, 0x8d, 0x8f, 0x3, 0x2, 0x2, + 0x2, 0x8e, 0x8a, 0x3, 0x2, 0x2, 0x2, 0x8f, 0x92, 0x3, 0x2, 0x2, 0x2, + 0x90, 0x8e, 0x3, 0x2, 0x2, 0x2, 0x90, 0x91, 0x3, 0x2, 0x2, 0x2, 0x91, + 0x93, 0x3, 0x2, 0x2, 0x2, 0x92, 0x90, 0x3, 0x2, 0x2, 0x2, 0x93, 0x94, + 0x7, 0xa, 0x2, 0x2, 0x94, 0x96, 0x5, 0x12, 0xa, 0x2, 0x95, 0x7f, 0x3, + 0x2, 0x2, 0x2, 0x95, 0x89, 0x3, 0x2, 0x2, 0x2, 0x96, 0x11, 0x3, 0x2, + 0x2, 0x2, 0x97, 0xa5, 0x5, 0x22, 0x12, 0x2, 0x98, 0xa1, 0x7, 0xb, 0x2, + 0x2, 0x99, 0x9e, 0x5, 0x12, 0xa, 0x2, 0x9a, 0x9b, 0x7, 0x4, 0x2, 0x2, + 0x9b, 0x9d, 0x5, 0x12, 0xa, 0x2, 0x9c, 0x9a, 0x3, 0x2, 0x2, 0x2, 0x9d, + 0xa0, 0x3, 0x2, 0x2, 0x2, 0x9e, 0x9c, 0x3, 0x2, 0x2, 0x2, 0x9e, 0x9f, + 0x3, 0x2, 0x2, 0x2, 0x9f, 0xa2, 0x3, 0x2, 0x2, 0x2, 0xa0, 0x9e, 0x3, + 0x2, 0x2, 0x2, 0xa1, 0x99, 0x3, 0x2, 0x2, 0x2, 0xa1, 0xa2, 0x3, 0x2, + 0x2, 0x2, 0xa2, 0xa3, 0x3, 0x2, 0x2, 0x2, 0xa3, 0xa5, 0x7, 0xc, 0x2, + 0x2, 0xa4, 0x97, 0x3, 0x2, 0x2, 0x2, 0xa4, 0x98, 0x3, 0x2, 0x2, 0x2, + 0xa5, 0x13, 0x3, 0x2, 0x2, 0x2, 0xa6, 0xa7, 0x5, 0x16, 0xc, 0x2, 0xa7, + 0xa8, 0x7, 0x26, 0x2, 0x2, 0xa8, 0xaa, 0x7, 0xd, 0x2, 0x2, 0xa9, 0xab, + 0x5, 0x18, 0xd, 0x2, 0xaa, 0xa9, 0x3, 0x2, 0x2, 0x2, 0xaa, 0xab, 0x3, + 0x2, 0x2, 0x2, 0xab, 0xac, 0x3, 0x2, 0x2, 0x2, 0xac, 0xad, 0x7, 0xe, + 0x2, 0x2, 0xad, 0xae, 0x5, 0x1c, 0xf, 0x2, 0xae, 0x15, 0x3, 0x2, 0x2, + 0x2, 0xaf, 0xb0, 0x9, 0x3, 0x2, 0x2, 0xb0, 0x17, 0x3, 0x2, 0x2, 0x2, + 0xb1, 0xb6, 0x5, 0x1a, 0xe, 0x2, 0xb2, 0xb3, 0x7, 0x4, 0x2, 0x2, 0xb3, + 0xb5, 0x5, 0x1a, 0xe, 0x2, 0xb4, 0xb2, 0x3, 0x2, 0x2, 0x2, 0xb5, 0xb8, + 0x3, 0x2, 0x2, 0x2, 0xb6, 0xb4, 0x3, 0x2, 0x2, 0x2, 0xb6, 0xb7, 0x3, + 0x2, 0x2, 0x2, 0xb7, 0x19, 0x3, 0x2, 0x2, 0x2, 0xb8, 0xb6, 0x3, 0x2, + 0x2, 0x2, 0xb9, 0xba, 0x5, 0x8, 0x5, 0x2, 0xba, 0xc6, 0x7, 0x26, 0x2, + 0x2, 0xbb, 0xbc, 0x7, 0x8, 0x2, 0x2, 0xbc, 0xc3, 0x7, 0x9, 0x2, 0x2, + 0xbd, 0xbe, 0x7, 0x8, 0x2, 0x2, 0xbe, 0xbf, 0x5, 0x22, 0x12, 0x2, 0xbf, + 0xc0, 0x7, 0x9, 0x2, 0x2, 0xc0, 0xc2, 0x3, 0x2, 0x2, 0x2, 0xc1, 0xbd, + 0x3, 0x2, 0x2, 0x2, 0xc2, 0xc5, 0x3, 0x2, 0x2, 0x2, 0xc3, 0xc1, 0x3, + 0x2, 0x2, 0x2, 0xc3, 0xc4, 0x3, 0x2, 0x2, 0x2, 0xc4, 0xc7, 0x3, 0x2, + 0x2, 0x2, 0xc5, 0xc3, 0x3, 0x2, 0x2, 0x2, 0xc6, 0xbb, 0x3, 0x2, 0x2, + 0x2, 0xc6, 0xc7, 0x3, 0x2, 0x2, 0x2, 0xc7, 0x1b, 0x3, 0x2, 0x2, 0x2, + 0xc8, 0xcc, 0x7, 0xb, 0x2, 0x2, 0xc9, 0xcb, 0x5, 0x1e, 0x10, 0x2, 0xca, + 0xc9, 0x3, 0x2, 0x2, 0x2, 0xcb, 0xce, 0x3, 0x2, 0x2, 0x2, 0xcc, 0xca, + 0x3, 0x2, 0x2, 0x2, 0xcc, 0xcd, 0x3, 0x2, 0x2, 0x2, 0xcd, 0xcf, 0x3, + 0x2, 0x2, 0x2, 0xce, 0xcc, 0x3, 0x2, 0x2, 0x2, 0xcf, 0xd0, 0x7, 0xc, + 0x2, 0x2, 0xd0, 0x1d, 0x3, 0x2, 0x2, 0x2, 0xd1, 0xd4, 0x5, 0x4, 0x3, + 0x2, 0xd2, 0xd4, 0x5, 0x20, 0x11, 0x2, 0xd3, 0xd1, 0x3, 0x2, 0x2, 0x2, + 0xd3, 0xd2, 0x3, 0x2, 0x2, 0x2, 0xd4, 0x1f, 0x3, 0x2, 0x2, 0x2, 0xd5, + 0xd6, 0x5, 0x26, 0x14, 0x2, 0xd6, 0xd7, 0x7, 0xa, 0x2, 0x2, 0xd7, 0xd8, + 0x5, 0x22, 0x12, 0x2, 0xd8, 0xd9, 0x7, 0x5, 0x2, 0x2, 0xd9, 0xf8, 0x3, + 0x2, 0x2, 0x2, 0xda, 0xdc, 0x5, 0x22, 0x12, 0x2, 0xdb, 0xda, 0x3, 0x2, + 0x2, 0x2, 0xdb, 0xdc, 0x3, 0x2, 0x2, 0x2, 0xdc, 0xdd, 0x3, 0x2, 0x2, + 0x2, 0xdd, 0xf8, 0x7, 0x5, 0x2, 0x2, 0xde, 0xf8, 0x5, 0x1c, 0xf, 0x2, + 0xdf, 0xe0, 0x7, 0x10, 0x2, 0x2, 0xe0, 0xe1, 0x7, 0xd, 0x2, 0x2, 0xe1, + 0xe2, 0x5, 0x24, 0x13, 0x2, 0xe2, 0xe3, 0x7, 0xe, 0x2, 0x2, 0xe3, 0xe6, + 0x5, 0x20, 0x11, 0x2, 0xe4, 0xe5, 0x7, 0x11, 0x2, 0x2, 0xe5, 0xe7, 0x5, + 0x20, 0x11, 0x2, 0xe6, 0xe4, 0x3, 0x2, 0x2, 0x2, 0xe6, 0xe7, 0x3, 0x2, + 0x2, 0x2, 0xe7, 0xf8, 0x3, 0x2, 0x2, 0x2, 0xe8, 0xe9, 0x7, 0x12, 0x2, + 0x2, 0xe9, 0xea, 0x7, 0xd, 0x2, 0x2, 0xea, 0xeb, 0x5, 0x24, 0x13, 0x2, + 0xeb, 0xec, 0x7, 0xe, 0x2, 0x2, 0xec, 0xed, 0x5, 0x20, 0x11, 0x2, 0xed, + 0xf8, 0x3, 0x2, 0x2, 0x2, 0xee, 0xef, 0x7, 0x13, 0x2, 0x2, 0xef, 0xf8, + 0x7, 0x5, 0x2, 0x2, 0xf0, 0xf1, 0x7, 0x14, 0x2, 0x2, 0xf1, 0xf8, 0x7, + 0x5, 0x2, 0x2, 0xf2, 0xf4, 0x7, 0x15, 0x2, 0x2, 0xf3, 0xf5, 0x5, 0x22, + 0x12, 0x2, 0xf4, 0xf3, 0x3, 0x2, 0x2, 0x2, 0xf4, 0xf5, 0x3, 0x2, 0x2, + 0x2, 0xf5, 0xf6, 0x3, 0x2, 0x2, 0x2, 0xf6, 0xf8, 0x7, 0x5, 0x2, 0x2, + 0xf7, 0xd5, 0x3, 0x2, 0x2, 0x2, 0xf7, 0xdb, 0x3, 0x2, 0x2, 0x2, 0xf7, + 0xde, 0x3, 0x2, 0x2, 0x2, 0xf7, 0xdf, 0x3, 0x2, 0x2, 0x2, 0xf7, 0xe8, + 0x3, 0x2, 0x2, 0x2, 0xf7, 0xee, 0x3, 0x2, 0x2, 0x2, 0xf7, 0xf0, 0x3, + 0x2, 0x2, 0x2, 0xf7, 0xf2, 0x3, 0x2, 0x2, 0x2, 0xf8, 0x21, 0x3, 0x2, + 0x2, 0x2, 0xf9, 0xfa, 0x5, 0x34, 0x1b, 0x2, 0xfa, 0x23, 0x3, 0x2, 0x2, + 0x2, 0xfb, 0xfc, 0x5, 0x3c, 0x1f, 0x2, 0xfc, 0x25, 0x3, 0x2, 0x2, 0x2, + 0xfd, 0x104, 0x7, 0x26, 0x2, 0x2, 0xfe, 0xff, 0x7, 0x8, 0x2, 0x2, 0xff, + 0x100, 0x5, 0x22, 0x12, 0x2, 0x100, 0x101, 0x7, 0x9, 0x2, 0x2, 0x101, + 0x103, 0x3, 0x2, 0x2, 0x2, 0x102, 0xfe, 0x3, 0x2, 0x2, 0x2, 0x103, 0x106, + 0x3, 0x2, 0x2, 0x2, 0x104, 0x102, 0x3, 0x2, 0x2, 0x2, 0x104, 0x105, + 0x3, 0x2, 0x2, 0x2, 0x105, 0x27, 0x3, 0x2, 0x2, 0x2, 0x106, 0x104, 0x3, + 0x2, 0x2, 0x2, 0x107, 0x108, 0x7, 0xd, 0x2, 0x2, 0x108, 0x109, 0x5, + 0x22, 0x12, 0x2, 0x109, 0x10a, 0x7, 0xe, 0x2, 0x2, 0x10a, 0x10e, 0x3, + 0x2, 0x2, 0x2, 0x10b, 0x10e, 0x5, 0x26, 0x14, 0x2, 0x10c, 0x10e, 0x5, + 0x2a, 0x16, 0x2, 0x10d, 0x107, 0x3, 0x2, 0x2, 0x2, 0x10d, 0x10b, 0x3, + 0x2, 0x2, 0x2, 0x10d, 0x10c, 0x3, 0x2, 0x2, 0x2, 0x10e, 0x29, 0x3, 0x2, + 0x2, 0x2, 0x10f, 0x110, 0x9, 0x4, 0x2, 0x2, 0x110, 0x2b, 0x3, 0x2, 0x2, + 0x2, 0x111, 0x11c, 0x5, 0x28, 0x15, 0x2, 0x112, 0x113, 0x7, 0x26, 0x2, + 0x2, 0x113, 0x115, 0x7, 0xd, 0x2, 0x2, 0x114, 0x116, 0x5, 0x30, 0x19, + 0x2, 0x115, 0x114, 0x3, 0x2, 0x2, 0x2, 0x115, 0x116, 0x3, 0x2, 0x2, + 0x2, 0x116, 0x117, 0x3, 0x2, 0x2, 0x2, 0x117, 0x11c, 0x7, 0xe, 0x2, + 0x2, 0x118, 0x119, 0x5, 0x2e, 0x18, 0x2, 0x119, 0x11a, 0x5, 0x2c, 0x17, + 0x2, 0x11a, 0x11c, 0x3, 0x2, 0x2, 0x2, 0x11b, 0x111, 0x3, 0x2, 0x2, + 0x2, 0x11b, 0x112, 0x3, 0x2, 0x2, 0x2, 0x11b, 0x118, 0x3, 0x2, 0x2, + 0x2, 0x11c, 0x2d, 0x3, 0x2, 0x2, 0x2, 0x11d, 0x11e, 0x9, 0x5, 0x2, 0x2, + 0x11e, 0x2f, 0x3, 0x2, 0x2, 0x2, 0x11f, 0x124, 0x5, 0x22, 0x12, 0x2, + 0x120, 0x121, 0x7, 0x4, 0x2, 0x2, 0x121, 0x123, 0x5, 0x22, 0x12, 0x2, + 0x122, 0x120, 0x3, 0x2, 0x2, 0x2, 0x123, 0x126, 0x3, 0x2, 0x2, 0x2, + 0x124, 0x122, 0x3, 0x2, 0x2, 0x2, 0x124, 0x125, 0x3, 0x2, 0x2, 0x2, + 0x125, 0x31, 0x3, 0x2, 0x2, 0x2, 0x126, 0x124, 0x3, 0x2, 0x2, 0x2, 0x127, + 0x12c, 0x5, 0x2c, 0x17, 0x2, 0x128, 0x129, 0x9, 0x6, 0x2, 0x2, 0x129, + 0x12b, 0x5, 0x2c, 0x17, 0x2, 0x12a, 0x128, 0x3, 0x2, 0x2, 0x2, 0x12b, + 0x12e, 0x3, 0x2, 0x2, 0x2, 0x12c, 0x12a, 0x3, 0x2, 0x2, 0x2, 0x12c, + 0x12d, 0x3, 0x2, 0x2, 0x2, 0x12d, 0x33, 0x3, 0x2, 0x2, 0x2, 0x12e, 0x12c, + 0x3, 0x2, 0x2, 0x2, 0x12f, 0x134, 0x5, 0x32, 0x1a, 0x2, 0x130, 0x131, + 0x9, 0x7, 0x2, 0x2, 0x131, 0x133, 0x5, 0x32, 0x1a, 0x2, 0x132, 0x130, + 0x3, 0x2, 0x2, 0x2, 0x133, 0x136, 0x3, 0x2, 0x2, 0x2, 0x134, 0x132, + 0x3, 0x2, 0x2, 0x2, 0x134, 0x135, 0x3, 0x2, 0x2, 0x2, 0x135, 0x35, 0x3, + 0x2, 0x2, 0x2, 0x136, 0x134, 0x3, 0x2, 0x2, 0x2, 0x137, 0x13c, 0x5, + 0x34, 0x1b, 0x2, 0x138, 0x139, 0x9, 0x8, 0x2, 0x2, 0x139, 0x13b, 0x5, + 0x34, 0x1b, 0x2, 0x13a, 0x138, 0x3, 0x2, 0x2, 0x2, 0x13b, 0x13e, 0x3, + 0x2, 0x2, 0x2, 0x13c, 0x13a, 0x3, 0x2, 0x2, 0x2, 0x13c, 0x13d, 0x3, + 0x2, 0x2, 0x2, 0x13d, 0x37, 0x3, 0x2, 0x2, 0x2, 0x13e, 0x13c, 0x3, 0x2, + 0x2, 0x2, 0x13f, 0x144, 0x5, 0x36, 0x1c, 0x2, 0x140, 0x141, 0x9, 0x9, + 0x2, 0x2, 0x141, 0x143, 0x5, 0x36, 0x1c, 0x2, 0x142, 0x140, 0x3, 0x2, + 0x2, 0x2, 0x143, 0x146, 0x3, 0x2, 0x2, 0x2, 0x144, 0x142, 0x3, 0x2, + 0x2, 0x2, 0x144, 0x145, 0x3, 0x2, 0x2, 0x2, 0x145, 0x39, 0x3, 0x2, 0x2, + 0x2, 0x146, 0x144, 0x3, 0x2, 0x2, 0x2, 0x147, 0x14c, 0x5, 0x38, 0x1d, + 0x2, 0x148, 0x149, 0x7, 0x22, 0x2, 0x2, 0x149, 0x14b, 0x5, 0x38, 0x1d, + 0x2, 0x14a, 0x148, 0x3, 0x2, 0x2, 0x2, 0x14b, 0x14e, 0x3, 0x2, 0x2, + 0x2, 0x14c, 0x14a, 0x3, 0x2, 0x2, 0x2, 0x14c, 0x14d, 0x3, 0x2, 0x2, + 0x2, 0x14d, 0x3b, 0x3, 0x2, 0x2, 0x2, 0x14e, 0x14c, 0x3, 0x2, 0x2, 0x2, + 0x14f, 0x154, 0x5, 0x3a, 0x1e, 0x2, 0x150, 0x151, 0x7, 0x23, 0x2, 0x2, + 0x151, 0x153, 0x5, 0x3a, 0x1e, 0x2, 0x152, 0x150, 0x3, 0x2, 0x2, 0x2, + 0x153, 0x156, 0x3, 0x2, 0x2, 0x2, 0x154, 0x152, 0x3, 0x2, 0x2, 0x2, + 0x154, 0x155, 0x3, 0x2, 0x2, 0x2, 0x155, 0x3d, 0x3, 0x2, 0x2, 0x2, 0x156, + 0x154, 0x3, 0x2, 0x2, 0x2, 0x157, 0x158, 0x5, 0x34, 0x1b, 0x2, 0x158, + 0x3f, 0x3, 0x2, 0x2, 0x2, 0x26, 0x42, 0x44, 0x48, 0x51, 0x5f, 0x6c, + 0x6f, 0x72, 0x7a, 0x86, 0x90, 0x95, 0x9e, 0xa1, 0xa4, 0xaa, 0xb6, 0xc3, + 0xc6, 0xcc, 0xd3, 0xdb, 0xe6, 0xf4, 0xf7, 0x104, 0x10d, 0x115, 0x11b, + 0x124, 0x12c, 0x134, 0x13c, 0x144, 0x14c, 0x154, + }; + + atn::ATNDeserializer deserializer; + _atn = deserializer.deserialize(_serializedATN); + + size_t count = _atn.getNumberOfDecisions(); + _decisionToDFA.reserve(count); + for (size_t i = 0; i < count; i++) { + _decisionToDFA.emplace_back(_atn.getDecisionState(i), i); + } +} + +SysYParser::Initializer SysYParser::_init; diff --git a/src/antlr4/SysYParser.h b/src/antlr4/SysYParser.h new file mode 100644 index 0000000..3f76b79 --- /dev/null +++ b/src/antlr4/SysYParser.h @@ -0,0 +1,513 @@ + +// Generated from SysY.g4 by ANTLR 4.7.2 + +#pragma once + + +#include "antlr4-runtime.h" + + + + +class SysYParser : public antlr4::Parser { +public: + enum { + T__0 = 1, T__1 = 2, T__2 = 3, T__3 = 4, T__4 = 5, T__5 = 6, T__6 = 7, + T__7 = 8, T__8 = 9, T__9 = 10, T__10 = 11, T__11 = 12, T__12 = 13, T__13 = 14, + T__14 = 15, T__15 = 16, T__16 = 17, T__17 = 18, T__18 = 19, T__19 = 20, + T__20 = 21, T__21 = 22, T__22 = 23, T__23 = 24, T__24 = 25, T__25 = 26, + T__26 = 27, T__27 = 28, T__28 = 29, T__29 = 30, T__30 = 31, T__31 = 32, + T__32 = 33, FloatConst = 34, IntConst = 35, Ident = 36, WS = 37, LINE_COMMENT = 38, + BLOCK_COMMENT = 39 + }; + + enum { + RuleCompUnit = 0, RuleDecl = 1, RuleConstDecl = 2, RuleBType = 3, RuleConstDef = 4, + RuleConstInitVal = 5, RuleVarDecl = 6, RuleVarDef = 7, RuleInitVal = 8, + RuleFuncDef = 9, RuleFuncType = 10, RuleFuncFParams = 11, RuleFuncFParam = 12, + RuleBlock = 13, RuleBlockItem = 14, RuleStmt = 15, RuleExp = 16, RuleCond = 17, + RuleLVal = 18, RulePrimaryExp = 19, RuleNumber = 20, RuleUnaryExp = 21, + RuleUnaryOp = 22, RuleFuncRParams = 23, RuleMulExp = 24, RuleAddExp = 25, + RuleRelExp = 26, RuleEqExp = 27, RuleLAndExp = 28, RuleLOrExp = 29, + RuleConstExp = 30 + }; + + SysYParser(antlr4::TokenStream *input); + ~SysYParser(); + + virtual std::string getGrammarFileName() const override; + virtual const antlr4::atn::ATN& getATN() const override { return _atn; }; + virtual const std::vector& getTokenNames() const override { return _tokenNames; }; // deprecated: use vocabulary instead. + virtual const std::vector& getRuleNames() const override; + virtual antlr4::dfa::Vocabulary& getVocabulary() const override; + + + class CompUnitContext; + class DeclContext; + class ConstDeclContext; + class BTypeContext; + class ConstDefContext; + class ConstInitValContext; + class VarDeclContext; + class VarDefContext; + class InitValContext; + class FuncDefContext; + class FuncTypeContext; + class FuncFParamsContext; + class FuncFParamContext; + class BlockContext; + class BlockItemContext; + class StmtContext; + class ExpContext; + class CondContext; + class LValContext; + class PrimaryExpContext; + class NumberContext; + class UnaryExpContext; + class UnaryOpContext; + class FuncRParamsContext; + class MulExpContext; + class AddExpContext; + class RelExpContext; + class EqExpContext; + class LAndExpContext; + class LOrExpContext; + class ConstExpContext; + + class CompUnitContext : public antlr4::ParserRuleContext { + public: + CompUnitContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector decl(); + DeclContext* decl(size_t i); + std::vector funcDef(); + FuncDefContext* funcDef(size_t i); + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + CompUnitContext* compUnit(); + + class DeclContext : public antlr4::ParserRuleContext { + public: + DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + ConstDeclContext *constDecl(); + VarDeclContext *varDecl(); + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + DeclContext* decl(); + + class ConstDeclContext : public antlr4::ParserRuleContext { + public: + ConstDeclContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + BTypeContext *bType(); + std::vector constDef(); + ConstDefContext* constDef(size_t i); + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + ConstDeclContext* constDecl(); + + class BTypeContext : public antlr4::ParserRuleContext { + public: + BTypeContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + BTypeContext* bType(); + + class ConstDefContext : public antlr4::ParserRuleContext { + public: + ConstDefContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Ident(); + ConstInitValContext *constInitVal(); + std::vector constExp(); + ConstExpContext* constExp(size_t i); + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + ConstDefContext* constDef(); + + class ConstInitValContext : public antlr4::ParserRuleContext { + public: + ConstInitValContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + ConstExpContext *constExp(); + std::vector constInitVal(); + ConstInitValContext* constInitVal(size_t i); + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + ConstInitValContext* constInitVal(); + + class VarDeclContext : public antlr4::ParserRuleContext { + public: + VarDeclContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + BTypeContext *bType(); + std::vector varDef(); + VarDefContext* varDef(size_t i); + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + VarDeclContext* varDecl(); + + class VarDefContext : public antlr4::ParserRuleContext { + public: + VarDefContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Ident(); + std::vector constExp(); + ConstExpContext* constExp(size_t i); + InitValContext *initVal(); + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + VarDefContext* varDef(); + + class InitValContext : public antlr4::ParserRuleContext { + public: + InitValContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + ExpContext *exp(); + std::vector initVal(); + InitValContext* initVal(size_t i); + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + InitValContext* initVal(); + + class FuncDefContext : public antlr4::ParserRuleContext { + public: + FuncDefContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + FuncTypeContext *funcType(); + antlr4::tree::TerminalNode *Ident(); + BlockContext *block(); + FuncFParamsContext *funcFParams(); + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + FuncDefContext* funcDef(); + + class FuncTypeContext : public antlr4::ParserRuleContext { + public: + FuncTypeContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + FuncTypeContext* funcType(); + + class FuncFParamsContext : public antlr4::ParserRuleContext { + public: + FuncFParamsContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector funcFParam(); + FuncFParamContext* funcFParam(size_t i); + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + FuncFParamsContext* funcFParams(); + + class FuncFParamContext : public antlr4::ParserRuleContext { + public: + FuncFParamContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + BTypeContext *bType(); + antlr4::tree::TerminalNode *Ident(); + std::vector exp(); + ExpContext* exp(size_t i); + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + FuncFParamContext* funcFParam(); + + class BlockContext : public antlr4::ParserRuleContext { + public: + BlockContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector blockItem(); + BlockItemContext* blockItem(size_t i); + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + BlockContext* block(); + + class BlockItemContext : public antlr4::ParserRuleContext { + public: + BlockItemContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + DeclContext *decl(); + StmtContext *stmt(); + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + BlockItemContext* blockItem(); + + class StmtContext : public antlr4::ParserRuleContext { + public: + StmtContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + LValContext *lVal(); + ExpContext *exp(); + BlockContext *block(); + CondContext *cond(); + std::vector stmt(); + StmtContext* stmt(size_t i); + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + StmtContext* stmt(); + + class ExpContext : public antlr4::ParserRuleContext { + public: + ExpContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + AddExpContext *addExp(); + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + ExpContext* exp(); + + class CondContext : public antlr4::ParserRuleContext { + public: + CondContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + LOrExpContext *lOrExp(); + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + CondContext* cond(); + + class LValContext : public antlr4::ParserRuleContext { + public: + LValContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Ident(); + std::vector exp(); + ExpContext* exp(size_t i); + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + LValContext* lVal(); + + class PrimaryExpContext : public antlr4::ParserRuleContext { + public: + PrimaryExpContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + ExpContext *exp(); + LValContext *lVal(); + NumberContext *number(); + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + PrimaryExpContext* primaryExp(); + + class NumberContext : public antlr4::ParserRuleContext { + public: + NumberContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *FloatConst(); + antlr4::tree::TerminalNode *IntConst(); + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + NumberContext* number(); + + class UnaryExpContext : public antlr4::ParserRuleContext { + public: + UnaryExpContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + PrimaryExpContext *primaryExp(); + antlr4::tree::TerminalNode *Ident(); + FuncRParamsContext *funcRParams(); + UnaryOpContext *unaryOp(); + UnaryExpContext *unaryExp(); + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + UnaryExpContext* unaryExp(); + + class UnaryOpContext : public antlr4::ParserRuleContext { + public: + UnaryOpContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + UnaryOpContext* unaryOp(); + + class FuncRParamsContext : public antlr4::ParserRuleContext { + public: + FuncRParamsContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector exp(); + ExpContext* exp(size_t i); + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + FuncRParamsContext* funcRParams(); + + class MulExpContext : public antlr4::ParserRuleContext { + public: + MulExpContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector unaryExp(); + UnaryExpContext* unaryExp(size_t i); + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + MulExpContext* mulExp(); + + class AddExpContext : public antlr4::ParserRuleContext { + public: + AddExpContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector mulExp(); + MulExpContext* mulExp(size_t i); + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + AddExpContext* addExp(); + + class RelExpContext : public antlr4::ParserRuleContext { + public: + RelExpContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector addExp(); + AddExpContext* addExp(size_t i); + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + RelExpContext* relExp(); + + class EqExpContext : public antlr4::ParserRuleContext { + public: + EqExpContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector relExp(); + RelExpContext* relExp(size_t i); + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + EqExpContext* eqExp(); + + class LAndExpContext : public antlr4::ParserRuleContext { + public: + LAndExpContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector eqExp(); + EqExpContext* eqExp(size_t i); + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + LAndExpContext* lAndExp(); + + class LOrExpContext : public antlr4::ParserRuleContext { + public: + LOrExpContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector lAndExp(); + LAndExpContext* lAndExp(size_t i); + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + LOrExpContext* lOrExp(); + + class ConstExpContext : public antlr4::ParserRuleContext { + public: + ConstExpContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + AddExpContext *addExp(); + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + ConstExpContext* constExp(); + + +private: + static std::vector _decisionToDFA; + static antlr4::atn::PredictionContextCache _sharedContextCache; + static std::vector _ruleNames; + static std::vector _tokenNames; + + static std::vector _literalNames; + static std::vector _symbolicNames; + static antlr4::dfa::Vocabulary _vocabulary; + static antlr4::atn::ATN _atn; + static std::vector _serializedATN; + + + struct Initializer { + Initializer(); + }; + static Initializer _init; +}; + diff --git a/src/antlr4/SysYVisitor.cpp b/src/antlr4/SysYVisitor.cpp new file mode 100644 index 0000000..a079f4d --- /dev/null +++ b/src/antlr4/SysYVisitor.cpp @@ -0,0 +1,7 @@ + +// Generated from SysY.g4 by ANTLR 4.7.2 + + +#include "SysYVisitor.h" + + diff --git a/src/antlr4/SysYVisitor.h b/src/antlr4/SysYVisitor.h new file mode 100644 index 0000000..32ef9ee --- /dev/null +++ b/src/antlr4/SysYVisitor.h @@ -0,0 +1,86 @@ + +// Generated from SysY.g4 by ANTLR 4.7.2 + +#pragma once + + +#include "antlr4-runtime.h" +#include "SysYParser.h" + + + +/** + * This class defines an abstract visitor for a parse tree + * produced by SysYParser. + */ +class SysYVisitor : public antlr4::tree::AbstractParseTreeVisitor { +public: + + /** + * Visit parse trees produced by SysYParser. + */ + virtual antlrcpp::Any visitCompUnit(SysYParser::CompUnitContext *context) = 0; + + virtual antlrcpp::Any visitDecl(SysYParser::DeclContext *context) = 0; + + virtual antlrcpp::Any visitConstDecl(SysYParser::ConstDeclContext *context) = 0; + + virtual antlrcpp::Any visitBType(SysYParser::BTypeContext *context) = 0; + + virtual antlrcpp::Any visitConstDef(SysYParser::ConstDefContext *context) = 0; + + virtual antlrcpp::Any visitConstInitVal(SysYParser::ConstInitValContext *context) = 0; + + virtual antlrcpp::Any visitVarDecl(SysYParser::VarDeclContext *context) = 0; + + virtual antlrcpp::Any visitVarDef(SysYParser::VarDefContext *context) = 0; + + virtual antlrcpp::Any visitInitVal(SysYParser::InitValContext *context) = 0; + + virtual antlrcpp::Any visitFuncDef(SysYParser::FuncDefContext *context) = 0; + + virtual antlrcpp::Any visitFuncType(SysYParser::FuncTypeContext *context) = 0; + + virtual antlrcpp::Any visitFuncFParams(SysYParser::FuncFParamsContext *context) = 0; + + virtual antlrcpp::Any visitFuncFParam(SysYParser::FuncFParamContext *context) = 0; + + virtual antlrcpp::Any visitBlock(SysYParser::BlockContext *context) = 0; + + virtual antlrcpp::Any visitBlockItem(SysYParser::BlockItemContext *context) = 0; + + virtual antlrcpp::Any visitStmt(SysYParser::StmtContext *context) = 0; + + virtual antlrcpp::Any visitExp(SysYParser::ExpContext *context) = 0; + + virtual antlrcpp::Any visitCond(SysYParser::CondContext *context) = 0; + + virtual antlrcpp::Any visitLVal(SysYParser::LValContext *context) = 0; + + virtual antlrcpp::Any visitPrimaryExp(SysYParser::PrimaryExpContext *context) = 0; + + virtual antlrcpp::Any visitNumber(SysYParser::NumberContext *context) = 0; + + virtual antlrcpp::Any visitUnaryExp(SysYParser::UnaryExpContext *context) = 0; + + virtual antlrcpp::Any visitUnaryOp(SysYParser::UnaryOpContext *context) = 0; + + virtual antlrcpp::Any visitFuncRParams(SysYParser::FuncRParamsContext *context) = 0; + + virtual antlrcpp::Any visitMulExp(SysYParser::MulExpContext *context) = 0; + + virtual antlrcpp::Any visitAddExp(SysYParser::AddExpContext *context) = 0; + + virtual antlrcpp::Any visitRelExp(SysYParser::RelExpContext *context) = 0; + + virtual antlrcpp::Any visitEqExp(SysYParser::EqExpContext *context) = 0; + + virtual antlrcpp::Any visitLAndExp(SysYParser::LAndExpContext *context) = 0; + + virtual antlrcpp::Any visitLOrExp(SysYParser::LOrExpContext *context) = 0; + + virtual antlrcpp::Any visitConstExp(SysYParser::ConstExpContext *context) = 0; + + +}; + From 8414298089f89e02760e4574adec236614f02311 Mon Sep 17 00:00:00 2001 From: mirror Date: Tue, 24 Mar 2026 15:42:33 +0800 Subject: [PATCH 2/2] =?UTF-8?q?Sema=E6=A8=A1=E5=9D=97?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- include/sem/Sema.h | 199 ++++++++++++-- include/sem/SymbolTable.h | 203 +++++++++++++- src/sem/Sema.cpp | 562 +++++++++++++++++++++++++++----------- src/sem/SymbolTable.cpp | 167 ++++++++++- 4 files changed, 924 insertions(+), 207 deletions(-) diff --git a/include/sem/Sema.h b/include/sem/Sema.h index 0c8949f..790a1b9 100644 --- a/include/sem/Sema.h +++ b/include/sem/Sema.h @@ -1,31 +1,178 @@ -//写这个 -// 基于语法树的语义检查与名称绑定。 -#pragma once +#ifndef SEMANTIC_ANALYSIS_H +#define SEMANTIC_ANALYSIS_H +#include "SymbolTable.h" +#include "../../generated/src/antlr4/SysYBaseVisitor.h" +#include +#include +#include #include +#include +#include -#include "SysYParser.h" - -class SemanticContext { - public: - void BindVarUse(SysYParser::VarContext* use, - SysYParser::VarDefContext* decl) { - var_uses_[use] = decl; - } - - SysYParser::VarDefContext* ResolveVarUse( - const SysYParser::VarContext* use) const { - auto it = var_uses_.find(use); - return it == var_uses_.end() ? nullptr : it->second; - } - - private: - std::unordered_map - var_uses_; +// 错误信息结构体 +struct ErrorMsg { + std::string msg; + int line; + int column; + ErrorMsg(std::string m, int l, int c) : msg(std::move(m)), line(l), column(c) {} }; -// 目前仅检查： -// - 变量先声明后使用 -// - 局部变量不允许重复定义 -SemanticContext RunSema(SysYParser::CompUnitContext& comp_unit); +// 前向声明 +namespace antlr4 { + class ParserRuleContext; + namespace tree { + class ParseTree; + } +} + +// 语义/IR生成上下文核心类 +class IRGenContext { +public: + // 错误管理 + void RecordError(const ErrorMsg& err) { errors_.push_back(err); } + const std::vector& GetErrors() const { return errors_; } + bool HasError() const { return !errors_.empty(); } + void ClearErrors() { errors_.clear(); } + + // 类型绑定/查询 - 使用 void* 以兼容测试代码 + void SetType(void* ctx, SymbolType type) { + node_type_map_[ctx] = type; + } + + SymbolType GetType(void* ctx) const { + auto it = node_type_map_.find(ctx); + return it == node_type_map_.end() ? SymbolType::TYPE_UNKNOWN : it->second; + } + + // 常量值绑定/查询 - 使用 void* 以兼容测试代码 + void SetConstVal(void* ctx, const std::any& val) { + const_val_map_[ctx] = val; + } + + std::any GetConstVal(void* ctx) const { + auto it = const_val_map_.find(ctx); + return it == const_val_map_.end() ? std::any() : it->second; + } + + // 循环状态管理 + void EnterLoop() { sym_table_.EnterLoop(); } + void ExitLoop() { sym_table_.ExitLoop(); } + bool InLoop() const { return sym_table_.InLoop(); } + + // 类型判断工具函数 + bool IsIntType(const std::any& val) const { + return val.type() == typeid(long) || val.type() == typeid(int); + } + + bool IsFloatType(const std::any& val) const { + return val.type() == typeid(double) || val.type() == typeid(float); + } + + // 当前函数返回类型 + SymbolType GetCurrentFuncReturnType() const { + return current_func_ret_type_; + } + + void SetCurrentFuncReturnType(SymbolType type) { + current_func_ret_type_ = type; + } + + // 符号表访问 + SymbolTable& GetSymbolTable() { return sym_table_; } + const SymbolTable& GetSymbolTable() const { return sym_table_; } + + // 作用域管理 + void EnterScope() { sym_table_.EnterScope(); } + void LeaveScope() { sym_table_.LeaveScope(); } + size_t GetScopeDepth() const { return sym_table_.GetScopeDepth(); } + +private: + SymbolTable sym_table_; + std::unordered_map node_type_map_; + std::unordered_map const_val_map_; + std::vector errors_; + SymbolType current_func_ret_type_ = SymbolType::TYPE_UNKNOWN; +}; + +// 错误信息格式化工具函数 +inline std::string FormatErrMsg(const std::string& msg, int line, int col) { + std::ostringstream oss; + oss << "[行:" << line << ",列:" << col << "] " << msg; + return oss.str(); +} + +// 语义分析访问器 - 继承自生成的基类 +class SemaVisitor : public SysYBaseVisitor { +public: + explicit SemaVisitor(IRGenContext& ctx) : ir_ctx_(ctx) {} + + // 必须实现的 ANTLR4 接口 + std::any visit(antlr4::tree::ParseTree* tree) override { + if (tree) { + return tree->accept(this); + } + return std::any(); + } + + std::any visitTerminal(antlr4::tree::TerminalNode* node) override { + return std::any(); + } + + std::any visitErrorNode(antlr4::tree::ErrorNode* node) override { + if (node) { + int line = node->getSymbol()->getLine(); + int col = node->getSymbol()->getCharPositionInLine() + 1; + ir_ctx_.RecordError(ErrorMsg("语法错误节点", line, col)); + } + return std::any(); + } + + // 核心访问方法 + std::any visitCompUnit(SysYParser::CompUnitContext* ctx) override; + std::any visitFuncDef(SysYParser::FuncDefContext* ctx) override; + std::any visitDecl(SysYParser::DeclContext* ctx) override; + std::any visitConstDecl(SysYParser::ConstDeclContext* ctx) override; + std::any visitVarDecl(SysYParser::VarDeclContext* ctx) override; + std::any visitBlock(SysYParser::BlockContext* ctx) override; + std::any visitStmt(SysYParser::StmtContext* ctx) override; + std::any visitLVal(SysYParser::LValContext* ctx) override; + std::any visitExp(SysYParser::ExpContext* ctx) override; + std::any visitCond(SysYParser::CondContext* ctx) override; + std::any visitPrimaryExp(SysYParser::PrimaryExpContext* ctx) override; + std::any visitUnaryExp(SysYParser::UnaryExpContext* ctx) override; + std::any visitMulExp(SysYParser::MulExpContext* ctx) override; + std::any visitAddExp(SysYParser::AddExpContext* ctx) override; + std::any visitRelExp(SysYParser::RelExpContext* ctx) override; + std::any visitEqExp(SysYParser::EqExpContext* ctx) override; + std::any visitLAndExp(SysYParser::LAndExpContext* ctx) override; + std::any visitLOrExp(SysYParser::LOrExpContext* ctx) override; + std::any visitConstExp(SysYParser::ConstExpContext* ctx) override; + std::any visitNumber(SysYParser::NumberContext* ctx) override; + std::any visitFuncRParams(SysYParser::FuncRParamsContext* ctx) override; + + // 通用子节点访问 + std::any visitChildren(antlr4::tree::ParseTree* node) override { + std::any result; + if (node) { + for (auto* child : node->children) { + if (child) { + result = child->accept(this); + } + } + } + return result; + } + + // 获取上下文引用 + IRGenContext& GetContext() { return ir_ctx_; } + const IRGenContext& GetContext() const { return ir_ctx_; } + +private: + IRGenContext& ir_ctx_; +}; + +// 语义分析入口函数 +void RunSemanticAnalysis(SysYParser::CompUnitContext* ctx, IRGenContext& ir_ctx); + +#endif // SEMANTIC_ANALYSIS_H \ No newline at end of file diff --git a/include/sem/SymbolTable.h b/include/sem/SymbolTable.h index ddedf85..7aaf966 100644 --- a/include/sem/SymbolTable.h +++ b/include/sem/SymbolTable.h @@ -1,18 +1,201 @@ -//写这个 -// 极简符号表：记录局部变量定义点。 -#pragma once +#ifndef SYMBOL_TABLE_H +#define SYMBOL_TABLE_H +#include #include +#include #include +#include +#include -#include "SysYParser.h" +// 核心类型枚举 +enum class SymbolType { + TYPE_UNKNOWN, // 未知类型 + TYPE_INT, // 整型 + TYPE_FLOAT, // 浮点型 + TYPE_VOID, // 空类型 + TYPE_ARRAY, // 数组类型 + TYPE_FUNCTION // 函数类型 +}; + +// 获取类型名称字符串 +inline const char* SymbolTypeToString(SymbolType type) { + switch (type) { + case SymbolType::TYPE_INT: return "int"; + case SymbolType::TYPE_FLOAT: return "float"; + case SymbolType::TYPE_VOID: return "void"; + case SymbolType::TYPE_ARRAY: return "array"; + case SymbolType::TYPE_FUNCTION: return "function"; + default: return "unknown"; + } +} + +// 变量信息结构体 +struct VarInfo { + SymbolType type = SymbolType::TYPE_UNKNOWN; + bool is_const = false; + std::any const_val; + std::vector array_dims; // 数组维度，空表示非数组 + void* decl_ctx = nullptr; // 关联的语法节点 + + // 检查是否为数组类型 + bool IsArray() const { return !array_dims.empty(); } + + // 获取数组元素总数 + int GetArrayElementCount() const { + int count = 1; + for (int dim : array_dims) { + count *= dim; + } + return count; + } +}; + +// 函数信息结构体 +struct FuncInfo { + SymbolType ret_type = SymbolType::TYPE_UNKNOWN; + std::string name; + std::vector param_types; // 参数类型列表 + void* decl_ctx = nullptr; // 关联的语法节点 + + // 检查参数匹配 + bool CheckParams(const std::vector& actual_params) const { + if (actual_params.size() != param_types.size()) { + return false; + } + + for (size_t i = 0; i < param_types.size(); ++i) { + if (param_types[i] != actual_params[i] && + param_types[i] != SymbolType::TYPE_UNKNOWN && + actual_params[i] != SymbolType::TYPE_UNKNOWN) { + return false; + } + } + return true; + } +}; + +// 作用域条目结构体 +struct ScopeEntry { + // 变量符号表：符号名 -> (符号信息, 声明节点) + std::unordered_map> var_symbols; + + // 函数符号表：符号名 -> (函数信息, 声明节点) + std::unordered_map> func_symbols; + + // 清空作用域 + void Clear() { + var_symbols.clear(); + func_symbols.clear(); + } +}; +// 符号表核心类 class SymbolTable { - public: - void Add(const std::string& name, SysYParser::VarDefContext* decl); - bool Contains(const std::string& name) const; - SysYParser::VarDefContext* Lookup(const std::string& name) const; +public: + // ========== 作用域管理 ========== + + // 进入新作用域 + void EnterScope(); + + // 离开当前作用域 + void LeaveScope(); + + // 获取当前作用域深度 + size_t GetScopeDepth() const { return scopes_.size(); } + + // 检查作用域栈是否为空 + bool IsEmpty() const { return scopes_.empty(); } + + // ========== 变量符号管理 ========== + + // 检查当前作用域是否包含指定变量 + bool CurrentScopeHasVar(const std::string& name) const; + + // 绑定变量到当前作用域 + void BindVar(const std::string& name, const VarInfo& info, void* decl_ctx); + + // 查找变量（从当前作用域向上遍历） + bool LookupVar(const std::string& name, VarInfo& out_info, void*& out_decl_ctx) const; + + // 快速查找变量（不获取详细信息） + bool HasVar(const std::string& name) const { + VarInfo info; + void* ctx; + return LookupVar(name, info, ctx); + } + + // ========== 函数符号管理 ========== + + // 检查当前作用域是否包含指定函数 + bool CurrentScopeHasFunc(const std::string& name) const; + + // 绑定函数到当前作用域 + void BindFunc(const std::string& name, const FuncInfo& info, void* decl_ctx); + + // 查找函数（从当前作用域向上遍历） + bool LookupFunc(const std::string& name, FuncInfo& out_info, void*& out_decl_ctx) const; + + // 快速查找函数（不获取详细信息） + bool HasFunc(const std::string& name) const { + FuncInfo info; + void* ctx; + return LookupFunc(name, info, ctx); + } + + // ========== 循环状态管理 ========== + + // 进入循环 + void EnterLoop(); + + // 离开循环 + void ExitLoop(); + + // 检查是否在循环内 + bool InLoop() const; + + // 获取循环嵌套深度 + int GetLoopDepth() const { return loop_depth_; } + + // ========== 辅助功能 ========== + + // 清空所有作用域和状态 + void Clear(); + + // 获取当前作用域中所有变量名 + std::vector GetCurrentScopeVarNames() const; + + // 获取当前作用域中所有函数名 + std::vector GetCurrentScopeFuncNames() const; + + // 调试：打印符号表内容 + void Dump() const; - private: - std::unordered_map table_; +private: + // 作用域栈 + std::stack scopes_; + + // 循环嵌套深度 + int loop_depth_ = 0; }; + +// 类型兼容性检查函数 +inline bool IsTypeCompatible(SymbolType expected, SymbolType actual) { + if (expected == SymbolType::TYPE_UNKNOWN || actual == SymbolType::TYPE_UNKNOWN) { + return true; // 未知类型视为兼容 + } + + // 基本类型兼容规则 + if (expected == actual) { + return true; + } + + // int 可以隐式转换为 float + if (expected == SymbolType::TYPE_FLOAT && actual == SymbolType::TYPE_INT) { + return true; + } + + return false; +} + +#endif // SYMBOL_TABLE_H \ No newline at end of file diff --git a/src/sem/Sema.cpp b/src/sem/Sema.cpp index 745374c..c25423f 100644 --- a/src/sem/Sema.cpp +++ b/src/sem/Sema.cpp @@ -1,200 +1,440 @@ -#include "sem/Sema.h" - -#include +#include "../../include/sem/Sema.h" +#include "../../generated/src/antlr4/SysYParser.h" #include -#include +#include +#include -#include "SysYBaseVisitor.h" -#include "sem/SymbolTable.h" -#include "utils/Log.h" +using namespace antlr4; -namespace { +// ===================== 核心访问器实现 ===================== -std::string GetLValueName(SysYParser::LValueContext& lvalue) { - if (!lvalue.ID()) { - throw std::runtime_error(FormatError("sema", "非法左值")); - } - return lvalue.ID()->getText(); +// 1. 编译单元节点访问 +std::any SemaVisitor::visitCompUnit(SysYParser::CompUnitContext* ctx) { + // 分析编译单元中的所有子节点 + return visitChildren(ctx); } -class SemaVisitor final : public SysYBaseVisitor { - public: - std::any visitCompUnit(SysYParser::CompUnitContext* ctx) override { - if (!ctx) { - throw std::runtime_error(FormatError("sema", "缺少编译单元")); - } - auto* func = ctx->funcDef(); - if (!func || !func->blockStmt()) { - throw std::runtime_error(FormatError("sema", "缺少 main 函数定义")); +// 2. 函数定义节点访问 +std::any SemaVisitor::visitFuncDef(SysYParser::FuncDefContext* ctx) { + FuncInfo info; + + // 通过funcType()获取函数类型 + if (ctx->funcType()) { + std::string func_type_text = ctx->funcType()->getText(); + if (func_type_text == "void") { + info.ret_type = SymbolType::TYPE_VOID; + } else if (func_type_text == "int") { + info.ret_type = SymbolType::TYPE_INT; + } else if (func_type_text == "float") { + info.ret_type = SymbolType::TYPE_FLOAT; + } } - if (!func->ID() || func->ID()->getText() != "main") { - throw std::runtime_error(FormatError("sema", "缺少 main 函数定义")); - } - func->accept(this); - if (!seen_return_) { - throw std::runtime_error( - FormatError("sema", "main 函数必须包含 return 语句")); + + // 绑定函数名和返回类型 + if (ctx->Ident()) { + info.name = ctx->Ident()->getText(); } - return {}; - } + ir_ctx_.SetCurrentFuncReturnType(info.ret_type); - std::any visitFuncDef(SysYParser::FuncDefContext* ctx) override { - if (!ctx || !ctx->blockStmt()) { - throw std::runtime_error(FormatError("sema", "缺少 main 函数定义")); + // 递归分析函数体 + if (ctx->block()) { + visit(ctx->block()); } - if (!ctx->funcType() || !ctx->funcType()->INT()) { - throw std::runtime_error(FormatError("sema", "当前仅支持 int main")); + + return std::any(); +} + +// 3. 声明节点访问 +std::any SemaVisitor::visitDecl(SysYParser::DeclContext* ctx) { + return visitChildren(ctx); +} + +// 4. 常量声明节点访问 +std::any SemaVisitor::visitConstDecl(SysYParser::ConstDeclContext* ctx) { + return visitChildren(ctx); +} + +// 5. 变量声明节点访问 +std::any SemaVisitor::visitVarDecl(SysYParser::VarDeclContext* ctx) { + return visitChildren(ctx); +} + +// 6. 代码块节点访问 +std::any SemaVisitor::visitBlock(SysYParser::BlockContext* ctx) { + // 进入新的作用域 + ir_ctx_.EnterScope(); + + // 访问块内的语句 + std::any result = visitChildren(ctx); + + // 离开作用域 + ir_ctx_.LeaveScope(); + + return result; +} + +// 7. 语句节点访问 +std::any SemaVisitor::visitStmt(SysYParser::StmtContext* ctx) { + // 赋值语句：lVal = exp; + if (ctx->lVal() && ctx->exp()) { + auto l_val_ctx = ctx->lVal(); + auto exp_ctx = ctx->exp(); + + // 解析左右值类型 + SymbolType l_type = ir_ctx_.GetType(l_val_ctx); + SymbolType r_type = ir_ctx_.GetType(exp_ctx); + + // 类型不匹配报错 + if (l_type != r_type && l_type != SymbolType::TYPE_UNKNOWN && r_type != SymbolType::TYPE_UNKNOWN) { + std::string l_type_str = (l_type == SymbolType::TYPE_INT ? "int" : "float"); + std::string r_type_str = (r_type == SymbolType::TYPE_INT ? "int" : "float"); + std::string err_msg = "赋值类型不匹配，左值为" + l_type_str + "，右值为" + r_type_str; + + int line = ctx->getStart()->getLine(); + int col = ctx->getStart()->getCharPositionInLine() + 1; + ir_ctx_.RecordError(ErrorMsg(err_msg, line, col)); + } + + // 绑定左值类型（同步右值类型） + ir_ctx_.SetType(l_val_ctx, r_type); } - const auto& items = ctx->blockStmt()->blockItem(); - if (items.empty()) { - throw std::runtime_error( - FormatError("sema", "main 函数不能为空，且必须以 return 结束")); + // IF语句 + else if (ctx->cond() && ctx->stmt().size() >= 1) { + auto cond_ctx = ctx->cond(); + + // IF条件必须为整型 + SymbolType cond_type = ir_ctx_.GetType(cond_ctx); + if (cond_type != SymbolType::TYPE_INT && cond_type != SymbolType::TYPE_UNKNOWN) { + int line = cond_ctx->getStart()->getLine(); + int col = cond_ctx->getStart()->getCharPositionInLine() + 1; + ir_ctx_.RecordError(ErrorMsg("if条件表达式必须为整型", line, col)); + } + + // 递归分析IF体和可能的ELSE体 + visit(ctx->stmt(0)); + if (ctx->stmt().size() >= 2) { + visit(ctx->stmt(1)); + } } - ctx->blockStmt()->accept(this); - return {}; - } + // WHILE语句 + else if (ctx->cond() && ctx->stmt().size() >= 1) { + ir_ctx_.EnterLoop(); // 标记进入循环 + + auto cond_ctx = ctx->cond(); + // WHILE条件必须为整型 + SymbolType cond_type = ir_ctx_.GetType(cond_ctx); + if (cond_type != SymbolType::TYPE_INT && cond_type != SymbolType::TYPE_UNKNOWN) { + int line = cond_ctx->getStart()->getLine(); + int col = cond_ctx->getStart()->getCharPositionInLine() + 1; + ir_ctx_.RecordError(ErrorMsg("while条件表达式必须为整型", line, col)); + } - std::any visitBlockStmt(SysYParser::BlockStmtContext* ctx) override { - if (!ctx) { - throw std::runtime_error(FormatError("sema", "缺少语句块")); - } - const auto& items = ctx->blockItem(); - for (size_t i = 0; i < items.size(); ++i) { - auto* item = items[i]; - if (!item) { - continue; - } - if (seen_return_) { - throw std::runtime_error( - FormatError("sema", "return 必须是 main 函数中的最后一条语句")); - } - current_item_index_ = i; - total_items_ = items.size(); - item->accept(this); - } - return {}; - } - - std::any visitBlockItem(SysYParser::BlockItemContext* ctx) override { - if (!ctx) { - throw std::runtime_error(FormatError("sema", "暂不支持的语句或声明")); + // 递归分析循环体 + visit(ctx->stmt(0)); + + ir_ctx_.ExitLoop(); // 标记退出循环 } - if (ctx->decl()) { - ctx->decl()->accept(this); - return {}; + // BREAK语句 + else if (ctx->getText().find("break") != std::string::npos) { + if (!ir_ctx_.InLoop()) { + int line = ctx->getStart()->getLine(); + int col = ctx->getStart()->getCharPositionInLine() + 1; + ir_ctx_.RecordError(ErrorMsg("break只能出现在循环语句中", line, col)); + } } - if (ctx->stmt()) { - ctx->stmt()->accept(this); - return {}; + // CONTINUE语句 + else if (ctx->getText().find("continue") != std::string::npos) { + if (!ir_ctx_.InLoop()) { + int line = ctx->getStart()->getLine(); + int col = ctx->getStart()->getCharPositionInLine() + 1; + ir_ctx_.RecordError(ErrorMsg("continue只能出现在循环语句中", line, col)); + } } - throw std::runtime_error(FormatError("sema", "暂不支持的语句或声明")); - } + // RETURN语句 + else if (ctx->getText().find("return") != std::string::npos) { + SymbolType func_ret_type = ir_ctx_.GetCurrentFuncReturnType(); + + // 有返回表达式的情况 + if (ctx->exp()) { + auto exp_ctx = ctx->exp(); + SymbolType exp_type = ir_ctx_.GetType(exp_ctx); - std::any visitDecl(SysYParser::DeclContext* ctx) override { - if (!ctx) { - throw std::runtime_error(FormatError("sema", "非法变量声明")); + // 返回类型不匹配报错 + if (exp_type != func_ret_type && exp_type != SymbolType::TYPE_UNKNOWN && func_ret_type != SymbolType::TYPE_UNKNOWN) { + std::string ret_type_str = (func_ret_type == SymbolType::TYPE_INT ? "int" : (func_ret_type == SymbolType::TYPE_FLOAT ? "float" : "void")); + std::string exp_type_str = (exp_type == SymbolType::TYPE_INT ? "int" : "float"); + std::string err_msg = "return表达式类型与函数返回类型不匹配，期望" + ret_type_str + "，实际为" + exp_type_str; + + int line = exp_ctx->getStart()->getLine(); + int col = exp_ctx->getStart()->getCharPositionInLine() + 1; + ir_ctx_.RecordError(ErrorMsg(err_msg, line, col)); + } + } + // 无返回表达式的情况 + else { + if (func_ret_type != SymbolType::TYPE_VOID && func_ret_type != SymbolType::TYPE_UNKNOWN) { + int line = ctx->getStart()->getLine(); + int col = ctx->getStart()->getCharPositionInLine() + 1; + ir_ctx_.RecordError(ErrorMsg("非void函数return必须带表达式", line, col)); + } + } } - if (!ctx->btype() || !ctx->btype()->INT()) { - throw std::runtime_error(FormatError("sema", "当前仅支持局部 int 变量声明")); - } - auto* var_def = ctx->varDef(); - if (!var_def || !var_def->lValue()) { - throw std::runtime_error(FormatError("sema", "非法变量声明")); + + // 其他语句 + return visitChildren(ctx); +} + +// 8. 左值节点访问 +std::any SemaVisitor::visitLVal(SysYParser::LValContext* ctx) { + return visitChildren(ctx); +} + +// 9. 表达式节点访问 +std::any SemaVisitor::visitExp(SysYParser::ExpContext* ctx) { + return visitChildren(ctx); +} + +// 10. 条件表达式节点访问 +std::any SemaVisitor::visitCond(SysYParser::CondContext* ctx) { + return visitChildren(ctx); +} + +// 11. 基本表达式节点访问 +std::any SemaVisitor::visitPrimaryExp(SysYParser::PrimaryExpContext* ctx) { + return visitChildren(ctx); +} + +// 12. 一元表达式节点访问 +std::any SemaVisitor::visitUnaryExp(SysYParser::UnaryExpContext* ctx) { + // 带一元运算符的表达式（+/-/!） + if (ctx->unaryOp() && ctx->unaryExp()) { + auto op_ctx = ctx->unaryOp(); + auto uexp_ctx = ctx->unaryExp(); + auto uexp_val = visit(uexp_ctx); + + std::string op_text = op_ctx->getText(); + SymbolType uexp_type = ir_ctx_.GetType(uexp_ctx); + + // 正号 +x → 直接返回原值 + if (op_text == "+") { + ir_ctx_.SetType(ctx, uexp_type); + ir_ctx_.SetConstVal(ctx, uexp_val); + return uexp_val; + } + // 负号 -x → 取反 + else if (op_text == "-") { + if (ir_ctx_.IsIntType(uexp_val)) { + long val = std::any_cast(uexp_val); + ir_ctx_.SetConstVal(ctx, std::any(-val)); + ir_ctx_.SetType(ctx, SymbolType::TYPE_INT); + return std::any(-val); + } else if (ir_ctx_.IsFloatType(uexp_val)) { + double val = std::any_cast(uexp_val); + ir_ctx_.SetConstVal(ctx, std::any(-val)); + ir_ctx_.SetType(ctx, SymbolType::TYPE_FLOAT); + return std::any(-val); + } + } + // 逻辑非 !x → 0/1转换 + else if (op_text == "!") { + if (ir_ctx_.IsIntType(uexp_val)) { + long val = std::any_cast(uexp_val); + long res = (val == 0) ? 1L : 0L; + ir_ctx_.SetConstVal(ctx, std::any(res)); + ir_ctx_.SetType(ctx, SymbolType::TYPE_INT); + return std::any(res); + } + } } - const std::string name = GetLValueName(*var_def->lValue()); - if (table_.Contains(name)) { - throw std::runtime_error(FormatError("sema", "重复定义变量: " + name)); + // 函数调用表达式 + else if (ctx->Ident() && ctx->funcRParams()) { + // 这里简化处理 + ir_ctx_.SetType(ctx, SymbolType::TYPE_INT); + return std::any(0L); } - if (auto* init = var_def->initValue()) { - if (!init->exp()) { - throw std::runtime_error(FormatError("sema", "当前不支持聚合初始化")); - } - init->exp()->accept(this); + // 基础表达式 + else if (ctx->primaryExp()) { + auto val = visit(ctx->primaryExp()); + ir_ctx_.SetType(ctx, ir_ctx_.GetType(ctx->primaryExp())); + ir_ctx_.SetConstVal(ctx, val); + return val; } - table_.Add(name, var_def); - return {}; - } - std::any visitStmt(SysYParser::StmtContext* ctx) override { - if (!ctx || !ctx->returnStmt()) { - throw std::runtime_error(FormatError("sema", "暂不支持的语句或声明")); - } - ctx->returnStmt()->accept(this); - return {}; - } + return std::any(); +} - std::any visitReturnStmt(SysYParser::ReturnStmtContext* ctx) override { - if (!ctx || !ctx->exp()) { - throw std::runtime_error(FormatError("sema", "return 缺少表达式")); - } - ctx->exp()->accept(this); - seen_return_ = true; - if (current_item_index_ + 1 != total_items_) { - throw std::runtime_error( - FormatError("sema", "return 必须是 main 函数中的最后一条语句")); +// 13. 乘法表达式节点访问 +std::any SemaVisitor::visitMulExp(SysYParser::MulExpContext* ctx) { + auto uexps = ctx->unaryExp(); + + // 单操作数 → 直接返回 + if (uexps.size() == 1) { + auto val = visit(uexps[0]); + ir_ctx_.SetType(ctx, ir_ctx_.GetType(uexps[0])); + ir_ctx_.SetConstVal(ctx, val); + return val; } - return {}; - } - std::any visitParenExp(SysYParser::ParenExpContext* ctx) override { - if (!ctx || !ctx->exp()) { - throw std::runtime_error(FormatError("sema", "非法括号表达式")); - } - ctx->exp()->accept(this); - return {}; - } + // 多操作数 → 依次计算 + std::any result = visit(uexps[0]); + SymbolType current_type = ir_ctx_.GetType(uexps[0]); + + for (size_t i = 1; i < uexps.size(); ++i) { + auto next_uexp = uexps[i]; + auto next_val = visit(next_uexp); + SymbolType next_type = ir_ctx_.GetType(next_uexp); + + // 类型统一：int和float混合转为float + if (current_type == SymbolType::TYPE_INT && next_type == SymbolType::TYPE_FLOAT) { + current_type = SymbolType::TYPE_FLOAT; + } else if (current_type == SymbolType::TYPE_FLOAT && next_type == SymbolType::TYPE_INT) { + current_type = SymbolType::TYPE_FLOAT; + } + + // 简化处理：这里假设是乘法运算 + if (ir_ctx_.IsIntType(result) && ir_ctx_.IsIntType(next_val)) { + long v1 = std::any_cast(result); + long v2 = std::any_cast(next_val); + result = std::any(v1 * v2); + } else if (ir_ctx_.IsFloatType(result) && ir_ctx_.IsFloatType(next_val)) { + double v1 = std::any_cast(result); + double v2 = std::any_cast(next_val); + result = std::any(v1 * v2); + } - std::any visitVarExp(SysYParser::VarExpContext* ctx) override { - if (!ctx || !ctx->var()) { - throw std::runtime_error(FormatError("sema", "非法变量表达式")); + // 更新当前节点类型和常量值 + ir_ctx_.SetType(ctx, current_type); + ir_ctx_.SetConstVal(ctx, result); } - ctx->var()->accept(this); - return {}; - } - std::any visitNumberExp(SysYParser::NumberExpContext* ctx) override { - if (!ctx || !ctx->number() || !ctx->number()->ILITERAL()) { - throw std::runtime_error(FormatError("sema", "当前仅支持整数字面量")); + return result; +} + +// 14. 加法表达式节点访问 +std::any SemaVisitor::visitAddExp(SysYParser::AddExpContext* ctx) { + auto mexps = ctx->mulExp(); + + // 单操作数 → 直接返回 + if (mexps.size() == 1) { + auto val = visit(mexps[0]); + ir_ctx_.SetType(ctx, ir_ctx_.GetType(mexps[0])); + ir_ctx_.SetConstVal(ctx, val); + return val; } - return {}; - } - std::any visitAdditiveExp(SysYParser::AdditiveExpContext* ctx) override { - if (!ctx || !ctx->exp(0) || !ctx->exp(1)) { - throw std::runtime_error(FormatError("sema", "暂不支持的表达式形式")); + // 多操作数 → 依次计算 + std::any result = visit(mexps[0]); + SymbolType current_type = ir_ctx_.GetType(mexps[0]); + + for (size_t i = 1; i < mexps.size(); ++i) { + auto next_mexp = mexps[i]; + auto next_val = visit(next_mexp); + SymbolType next_type = ir_ctx_.GetType(next_mexp); + + // 类型统一 + if (current_type == SymbolType::TYPE_INT && next_type == SymbolType::TYPE_FLOAT) { + current_type = SymbolType::TYPE_FLOAT; + } else if (current_type == SymbolType::TYPE_FLOAT && next_type == SymbolType::TYPE_INT) { + current_type = SymbolType::TYPE_FLOAT; + } + + // 简化处理：这里假设是加法运算 + if (ir_ctx_.IsIntType(result) && ir_ctx_.IsIntType(next_val)) { + long v1 = std::any_cast(result); + long v2 = std::any_cast(next_val); + result = std::any(v1 + v2); + } else if (ir_ctx_.IsFloatType(result) && ir_ctx_.IsFloatType(next_val)) { + double v1 = std::any_cast(result); + double v2 = std::any_cast(next_val); + result = std::any(v1 + v2); + } + + ir_ctx_.SetType(ctx, current_type); + ir_ctx_.SetConstVal(ctx, result); } - ctx->exp(0)->accept(this); - ctx->exp(1)->accept(this); - return {}; - } - std::any visitVar(SysYParser::VarContext* ctx) override { - if (!ctx || !ctx->ID()) { - throw std::runtime_error(FormatError("sema", "非法变量引用")); + return result; +} + +// 15. 关系表达式节点访问 +std::any SemaVisitor::visitRelExp(SysYParser::RelExpContext* ctx) { + auto aexps = ctx->addExp(); + + // 单操作数 → 直接返回 + if (aexps.size() == 1) { + auto val = visit(aexps[0]); + ir_ctx_.SetType(ctx, SymbolType::TYPE_INT); + return val; } - const std::string name = ctx->ID()->getText(); - auto* decl = table_.Lookup(name); - if (!decl) { - throw std::runtime_error(FormatError("sema", "使用了未定义的变量: " + name)); + + // 多操作数 → 简化处理 + std::any result = std::any(1L); + ir_ctx_.SetType(ctx, SymbolType::TYPE_INT); + ir_ctx_.SetConstVal(ctx, result); + + return result; +} + +// 16. 相等表达式节点访问 +std::any SemaVisitor::visitEqExp(SysYParser::EqExpContext* ctx) { + auto rexps = ctx->relExp(); + + // 单操作数 → 直接返回 + if (rexps.size() == 1) { + auto val = visit(rexps[0]); + ir_ctx_.SetType(ctx, SymbolType::TYPE_INT); + return val; } - sema_.BindVarUse(ctx, decl); - return {}; - } - SemanticContext TakeSemanticContext() { return std::move(sema_); } + // 多操作数 → 简化处理 + std::any result = std::any(1L); + ir_ctx_.SetType(ctx, SymbolType::TYPE_INT); + ir_ctx_.SetConstVal(ctx, result); + + return result; +} + +// 17. 逻辑与表达式节点访问 +std::any SemaVisitor::visitLAndExp(SysYParser::LAndExpContext* ctx) { + return visitChildren(ctx); +} + +// 18. 逻辑或表达式节点访问 +std::any SemaVisitor::visitLOrExp(SysYParser::LOrExpContext* ctx) { + return visitChildren(ctx); +} - private: - SymbolTable table_; - SemanticContext sema_; - bool seen_return_ = false; - size_t current_item_index_ = 0; - size_t total_items_ = 0; -}; +// 19. 常量表达式节点访问 +std::any SemaVisitor::visitConstExp(SysYParser::ConstExpContext* ctx) { + return visitChildren(ctx); +} -} // namespace +// 20. 数字节点访问 +std::any SemaVisitor::visitNumber(SysYParser::NumberContext* ctx) { + // 这里简化处理，实际需要解析整型和浮点型 + if (ctx->IntConst()) { + ir_ctx_.SetType(ctx, SymbolType::TYPE_INT); + ir_ctx_.SetConstVal(ctx, std::any(0L)); + return std::any(0L); + } else if (ctx->FloatConst()) { + ir_ctx_.SetType(ctx, SymbolType::TYPE_FLOAT); + ir_ctx_.SetConstVal(ctx, std::any(0.0)); + return std::any(0.0); + } + + return std::any(); +} -SemanticContext RunSema(SysYParser::CompUnitContext& comp_unit) { - SemaVisitor visitor; - comp_unit.accept(&visitor); - return visitor.TakeSemanticContext(); +// 21. 函数参数节点访问 +std::any SemaVisitor::visitFuncRParams(SysYParser::FuncRParamsContext* ctx) { + return visitChildren(ctx); } + +// ===================== 语义分析入口函数 ===================== +void RunSemanticAnalysis(SysYParser::CompUnitContext* ctx, IRGenContext& ir_ctx) { + if (!ctx) { + throw std::invalid_argument("CompUnitContext is null"); + } + SemaVisitor visitor(ir_ctx); + visitor.visit(ctx); +} \ No newline at end of file diff --git a/src/sem/SymbolTable.cpp b/src/sem/SymbolTable.cpp index ffeea89..b896ce4 100644 --- a/src/sem/SymbolTable.cpp +++ b/src/sem/SymbolTable.cpp @@ -1,17 +1,164 @@ -// 维护局部变量声明的注册与查找。 +#include "../../include/sem/SymbolTable.h" +#include +#include +#include -#include "sem/SymbolTable.h" +// 进入新作用域 +void SymbolTable::EnterScope() { + scopes_.push(ScopeEntry()); +} + +// 离开当前作用域 +void SymbolTable::LeaveScope() { + if (scopes_.empty()) { + throw std::runtime_error("SymbolTable Error: 作用域栈为空，无法退出"); + } + scopes_.pop(); +} + +// 绑定变量到当前作用域 +void SymbolTable::BindVar(const std::string& name, const VarInfo& info, void* decl_ctx) { + if (CurrentScopeHasVar(name)) { + throw std::runtime_error("变量'" + name + "'在当前作用域重复定义"); + } + scopes_.top().var_symbols[name] = {info, decl_ctx}; +} + +// 绑定函数到当前作用域 +void SymbolTable::BindFunc(const std::string& name, const FuncInfo& info, void* decl_ctx) { + if (CurrentScopeHasFunc(name)) { + throw std::runtime_error("函数'" + name + "'在当前作用域重复定义"); + } + scopes_.top().func_symbols[name] = {info, decl_ctx}; +} + +// 查找变量（从当前作用域向上遍历） +bool SymbolTable::LookupVar(const std::string& name, VarInfo& out_info, void*& out_decl_ctx) const { + if (scopes_.empty()) { + return false; + } + auto temp_stack = scopes_; + while (!temp_stack.empty()) { + auto& scope = temp_stack.top(); + auto it = scope.var_symbols.find(name); + if (it != scope.var_symbols.end()) { + out_info = it->second.first; + out_decl_ctx = it->second.second; + return true; + } + temp_stack.pop(); + } + return false; +} + +// 查找函数（从当前作用域向上遍历，通常函数在全局作用域） +bool SymbolTable::LookupFunc(const std::string& name, FuncInfo& out_info, void*& out_decl_ctx) const { + if (scopes_.empty()) { + return false; + } + auto temp_stack = scopes_; + while (!temp_stack.empty()) { + auto& scope = temp_stack.top(); + auto it = scope.func_symbols.find(name); + if (it != scope.func_symbols.end()) { + out_info = it->second.first; + out_decl_ctx = it->second.second; + return true; + } + temp_stack.pop(); + } + return false; +} -void SymbolTable::Add(const std::string& name, - SysYParser::VarDefContext* decl) { - table_[name] = decl; +// 检查当前作用域是否包含指定变量 +bool SymbolTable::CurrentScopeHasVar(const std::string& name) const { + if (scopes_.empty()) { + return false; + } + return scopes_.top().var_symbols.count(name) > 0; } -bool SymbolTable::Contains(const std::string& name) const { - return table_.find(name) != table_.end(); +// 检查当前作用域是否包含指定函数 +bool SymbolTable::CurrentScopeHasFunc(const std::string& name) const { + if (scopes_.empty()) { + return false; + } + return scopes_.top().func_symbols.count(name) > 0; } -SysYParser::VarDefContext* SymbolTable::Lookup(const std::string& name) const { - auto it = table_.find(name); - return it == table_.end() ? nullptr : it->second; +// 进入循环 +void SymbolTable::EnterLoop() { + loop_depth_++; } + +// 离开循环 +void SymbolTable::ExitLoop() { + if (loop_depth_ > 0) loop_depth_--; +} + +// 检查是否在循环内 +bool SymbolTable::InLoop() const { + return loop_depth_ > 0; +} + +// 清空所有作用域和状态 +void SymbolTable::Clear() { + while (!scopes_.empty()) { + scopes_.pop(); + } + loop_depth_ = 0; +} + +// 获取当前作用域中所有变量名 +std::vector SymbolTable::GetCurrentScopeVarNames() const { + std::vector names; + if (!scopes_.empty()) { + for (const auto& pair : scopes_.top().var_symbols) { + names.push_back(pair.first); + } + } + return names; +} + +// 获取当前作用域中所有函数名 +std::vector SymbolTable::GetCurrentScopeFuncNames() const { + std::vector names; + if (!scopes_.empty()) { + for (const auto& pair : scopes_.top().func_symbols) { + names.push_back(pair.first); + } + } + return names; +} + +// 调试：打印符号表内容 +void SymbolTable::Dump() const { + std::cout << "符号表内容 (作用域深度: " << scopes_.size() << "):\n"; + int scope_idx = 0; + auto temp_stack = scopes_; + + while (!temp_stack.empty()) { + std::cout << "\n作用域 " << scope_idx++ << ":\n"; + auto& scope = temp_stack.top(); + + std::cout << " 变量:\n"; + for (const auto& var_pair : scope.var_symbols) { + const VarInfo& info = var_pair.second.first; + std::cout << " " << var_pair.first << ": " + << SymbolTypeToString(info.type) + << (info.is_const ? " (const)" : "") + << (info.IsArray() ? " [数组]" : "") + << "\n"; + } + + std::cout << " 函数:\n"; + for (const auto& func_pair : scope.func_symbols) { + const FuncInfo& info = func_pair.second.first; + std::cout << " " << func_pair.first << ": " + << SymbolTypeToString(info.ret_type) << " (" + << info.param_types.size() << " 个参数)\n"; + } + + temp_stack.pop(); + } +} \ No newline at end of file