diff --git a/include/ir/IR.h b/include/ir/IR.h index b961192..f5194ed 100644 --- a/include/ir/IR.h +++ b/include/ir/IR.h @@ -37,6 +37,7 @@ #include #include #include +#include namespace ir { @@ -45,17 +46,15 @@ class Value; class User; class ConstantValue; class ConstantInt; +class ConstantFloat; +class ConstantArray; class GlobalValue; class Instruction; class BasicBlock; class Function; +class Module; -// Use 表示一个 Value 的一次使用记录。 -// 当前实现设计： -// - value：被使用的值 -// - user：使用该值的 User -// - operand_index：该值在 user 操作数列表中的位置 - +// ======================== Use 类 ======================== class Use { public: Use() = default; @@ -76,54 +75,130 @@ class Use { size_t operand_index_ = 0; }; -// IR 上下文：集中管理类型、常量等共享资源，便于复用与扩展。 +// ======================== Context 类 ======================== class Context { public: Context() = default; ~Context(); - // 去重创建 i32 常量。 + + // 常量创建 ConstantInt* GetConstInt(int v); + ConstantFloat* GetConstFloat(float v); + // 临时变量名生成 std::string NextTemp(); private: std::unordered_map> const_ints_; + std::unordered_map> const_floats_; int temp_index_ = -1; }; +// ======================== Type 类型体系 ======================== +// 类型基类，支持参数化类型 class Type { public: - enum class Kind { Void, Int32, PtrInt32 }; + enum class Kind { + Void, + Int32, + Float32, + Pointer, + Array, + Function, + Label + }; + explicit Type(Kind k); - // 使用静态共享对象获取类型。 - // 同一类型可直接比较返回值是否相等，例如： - // Type::GetInt32Type() == Type::GetInt32Type() - static const std::shared_ptr& GetVoidType(); - static const std::shared_ptr& GetInt32Type(); - static const std::shared_ptr& GetPtrInt32Type(); + virtual ~Type() = default; + Kind GetKind() const; bool IsVoid() const; bool IsInt32() const; - bool IsPtrInt32() const; + bool IsFloat32() const; + bool IsPointer() const; + bool IsArray() const; + bool IsFunction() const; + bool IsLabel() const; + bool IsPtrInt32() const; // 兼容旧接口 + bool IsPtrFloat32() const; // 判断是否为 float32* + + bool operator==(const Type& other) const; + bool operator!=(const Type& other) const; + + // 静态单例获取基础类型 + static const std::shared_ptr& GetVoidType(); + static const std::shared_ptr& GetInt32Type(); + static const std::shared_ptr& GetFloat32Type(); + static const std::shared_ptr& GetLabelType(); + static const std::shared_ptr& GetPtrInt32Type(); + + // 复合类型工厂方法 + static std::shared_ptr GetPointerType(std::shared_ptr pointee); + static std::shared_ptr GetArrayType(std::shared_ptr elem, size_t size); + static std::shared_ptr GetFunctionType(std::shared_ptr ret, + std::vector> params); private: Kind kind_; }; +// 指针类型 +class PointerType : public Type { + public: + PointerType(std::shared_ptr pointee) + : Type(Type::Kind::Pointer), pointee_(std::move(pointee)) {} + const std::shared_ptr& GetPointeeType() const { return pointee_; } + + private: + std::shared_ptr pointee_; +}; + +// 数组类型 +class ArrayType : public Type { + public: + ArrayType(std::shared_ptr elem, size_t size) + : Type(Type::Kind::Array), elem_type_(std::move(elem)), size_(size) {} + const std::shared_ptr& GetElementType() const { return elem_type_; } + size_t GetSize() const { return size_; } + + private: + std::shared_ptr elem_type_; + size_t size_; +}; + +// 函数类型 +class FunctionType : public Type { + public: + FunctionType(std::shared_ptr ret, std::vector> params) + : Type(Type::Kind::Function), ret_type_(std::move(ret)), param_types_(std::move(params)) {} + const std::shared_ptr& GetReturnType() const { return ret_type_; } + const std::vector>& GetParamTypes() const { return param_types_; } + + private: + std::shared_ptr ret_type_; + std::vector> param_types_; +}; + +// ======================== Value 类 ======================== class Value { public: Value(std::shared_ptr ty, std::string name); virtual ~Value() = default; + const std::shared_ptr& GetType() const; const std::string& GetName() const; void SetName(std::string n); bool IsVoid() const; bool IsInt32() const; - bool IsPtrInt32() const; + bool IsFloat32() const; + bool IsPtrInt32() const; // 兼容旧接口，实际上判断是否为 i32* + bool IsPtrFloat32() const; // 判断是否为 float32* bool IsConstant() const; bool IsInstruction() const; bool IsUser() const; bool IsFunction() const; + bool IsGlobalValue() const; + void AddUse(User* user, size_t operand_index); void RemoveUse(User* user, size_t operand_index); const std::vector& GetUses() const; @@ -135,8 +210,7 @@ class Value { std::vector uses_; }; -// ConstantValue 是常量体系的基类。 -// 当前只实现了 ConstantInt，后续可继续扩展更多常量种类。 +// ======================== 常量体系 ======================== class ConstantValue : public Value { public: ConstantValue(std::shared_ptr ty, std::string name = ""); @@ -151,11 +225,26 @@ class ConstantInt : public ConstantValue { int value_{}; }; -// 后续还需要扩展更多指令类型。 -enum class Opcode { Add, Sub, Mul, Alloca, Load, Store, Ret }; +class ConstantFloat : public ConstantValue { + public: + ConstantFloat(std::shared_ptr ty, float v); + float GetValue() const { return value_; } + + private: + float value_{}; +}; -// User 是所有“会使用其他 Value 作为输入”的 IR 对象的抽象基类。 -// 当前实现中只有 Instruction 继承自 User。 +// 常量数组（简单聚合，可存储常量元素） +class ConstantArray : public ConstantValue { + public: + ConstantArray(std::shared_ptr ty, std::vector elems); + const std::vector& GetElements() const { return elements_; } + + private: + std::vector elements_; +}; + +// ======================== User 类 ======================== class User : public Value { public: User(std::shared_ptr ty, std::string name); @@ -164,20 +253,44 @@ class User : public Value { void SetOperand(size_t index, Value* value); protected: - // 统一的 operand 入口。 void AddOperand(Value* value); private: std::vector operands_; }; -// GlobalValue 是全局值/全局变量体系的空壳占位类。 -// 当前只补齐类层次，具体初始化器、打印和链接语义后续再补。 +// ======================== GlobalValue 类 ======================== class GlobalValue : public User { public: GlobalValue(std::shared_ptr ty, std::string name); + ConstantValue* GetInitializer() const { return init_; } + void SetInitializer(ConstantValue* init) { init_ = init; } + + private: + ConstantValue* init_ = nullptr; +}; + +// ======================== 指令操作码 ======================== +enum class Opcode { + // 算术 + Add, Sub, Mul, Div, Mod, + // 位运算 + And, Or, Xor, Shl, LShr, AShr, + // 比较 + ICmp, FCmp, + // 内存 + Alloca, Load, Store, + // 控制流 + Ret, Br, CondBr, + // 函数调用 + Call, + // 数组访问 + GEP, + // Phi + Phi }; +// ======================== Instruction 类 ======================== class Instruction : public User { public: Instruction(Opcode op, std::shared_ptr ty, std::string name = ""); @@ -191,31 +304,94 @@ class Instruction : public User { BasicBlock* parent_ = nullptr; }; +// 二元运算指令 class BinaryInst : public Instruction { public: BinaryInst(Opcode op, std::shared_ptr ty, Value* lhs, Value* rhs, std::string name); Value* GetLhs() const; - Value* GetRhs() const; + Value* GetRhs() const; +}; + +// 比较指令（icmp/fcmp） +class CmpInst : public Instruction { + public: + enum Predicate { + EQ, NE, LT, LE, GT, GE + }; + CmpInst(Opcode op, Predicate pred, Value* lhs, Value* rhs, std::string name); + Predicate GetPredicate() const { return pred_; } + Value* GetLhs() const { return lhs_; } + Value* GetRhs() const { return rhs_; } + + private: + Predicate pred_; + Value* lhs_; + Value* rhs_; }; +// 返回指令 class ReturnInst : public Instruction { public: - ReturnInst(std::shared_ptr void_ty, Value* val); + ReturnInst(std::shared_ptr void_ty, Value* val = nullptr); Value* GetValue() const; }; +// 无条件分支 +class BranchInst : public Instruction { + public: + BranchInst(BasicBlock* target); + BasicBlock* GetTarget() const; +}; + +// 条件分支 +class CondBranchInst : public Instruction { + public: + CondBranchInst(Value* cond, BasicBlock* true_bb, BasicBlock* false_bb); + Value* GetCond() const; + BasicBlock* GetTrueBlock() const; + BasicBlock* GetFalseBlock() const; +}; + +// 函数调用 +class CallInst : public Instruction { + public: + CallInst(Function* callee, std::vector args, std::string name); + Function* GetCallee() const; + const std::vector& GetArgs() const; +}; + +// Phi 指令（用于 SSA） +class PhiInst : public Instruction { + public: + PhiInst(std::shared_ptr ty, std::string name); + void AddIncoming(Value* val, BasicBlock* block); + const std::vector>& GetIncomings() const; +}; + +// GetElementPtr 指令（数组/结构体指针计算） +class GetElementPtrInst : public Instruction { + public: + GetElementPtrInst(std::shared_ptr ty, Value* ptr, + std::vector indices, std::string name); + Value* GetPtr() const; + const std::vector& GetIndices() const; +}; + +// 分配栈内存指令 class AllocaInst : public Instruction { public: AllocaInst(std::shared_ptr ptr_ty, std::string name); }; +// 加载指令 class LoadInst : public Instruction { public: LoadInst(std::shared_ptr val_ty, Value* ptr, std::string name); Value* GetPtr() const; }; +// 存储指令 class StoreInst : public Instruction { public: StoreInst(std::shared_ptr void_ty, Value* val, Value* ptr); @@ -223,8 +399,7 @@ class StoreInst : public Instruction { Value* GetPtr() const; }; -// BasicBlock 已纳入 Value 体系，便于后续向更完整 IR 类图靠拢。 -// 当前其类型仍使用 void 作为占位，后续可替换为专门的 label type。 +// ======================== BasicBlock 类 ======================== class BasicBlock : public Value { public: explicit BasicBlock(std::string name); @@ -234,6 +409,11 @@ class BasicBlock : public Value { const std::vector>& GetInstructions() const; const std::vector& GetPredecessors() const; const std::vector& GetSuccessors() const; + void AddPredecessor(BasicBlock* pred); + void AddSuccessor(BasicBlock* succ); + void RemovePredecessor(BasicBlock* pred); + void RemoveSuccessor(BasicBlock* succ); + template T* Append(Args&&... args) { if (HasTerminator()) { @@ -254,65 +434,117 @@ class BasicBlock : public Value { std::vector successors_; }; -// Function 当前也采用了最小实现。 -// 需要特别注意：由于项目里还没有单独的 FunctionType， -// Function 继承自 Value 后，其 type_ 目前只保存“返回类型”， -// 并不能完整表达“返回类型 + 形参列表”这一整套函数签名。 -// 这对当前只支持 int main() 的最小 IR 足够，但后续若补普通函数、 -// 形参和调用，通常需要引入专门的函数类型表示。 +// ======================== Function 类 ======================== class Function : public Value { public: - // 当前构造函数接收的也是返回类型，而不是完整函数类型。 - Function(std::string name, std::shared_ptr ret_type); + // 构造函数，接收函数名、返回类型和参数类型列表（可选） + Function(std::string name, std::shared_ptr ret_type, + std::vector> param_types = {}); + BasicBlock* CreateBlock(const std::string& name); BasicBlock* GetEntry(); const BasicBlock* GetEntry() const; const std::vector>& GetBlocks() const; + // 参数管理 + const std::vector& GetParams() const { return params_; } + void AddParam(Value* param); + + // 函数类型（完整签名） + std::shared_ptr GetFunctionType() const; + private: BasicBlock* entry_ = nullptr; std::vector> blocks_; + std::vector params_; // 参数值（通常是 Argument 类型，后续可定义） + std::shared_ptr func_type_; // 缓存函数类型 }; +// ======================== Module 类 ======================== class Module { public: Module() = default; Context& GetContext(); const Context& GetContext() const; - // 创建函数时当前只显式传入返回类型，尚未接入完整的 FunctionType。 + + // 创建函数，支持参数类型 Function* CreateFunction(const std::string& name, - std::shared_ptr ret_type); + std::shared_ptr ret_type, + std::vector> param_types = {}); + + // 创建全局变量 + GlobalValue* CreateGlobalVariable(const std::string& name, + std::shared_ptr ty, + ConstantValue* init = nullptr); + const std::vector>& GetFunctions() const; + const std::vector>& GetGlobalVariables() const; private: Context context_; std::vector> functions_; + std::vector> global_vars_; }; +// ======================== IRBuilder 类 ======================== class IRBuilder { public: - IRBuilder(Context& ctx, BasicBlock* bb); + IRBuilder(Context& ctx, BasicBlock* bb = nullptr); void SetInsertPoint(BasicBlock* bb); BasicBlock* GetInsertBlock() const; - // 构造常量、二元运算、返回指令的最小集合。 + // 常量创建 ConstantInt* CreateConstInt(int v); + ConstantFloat* CreateConstFloat(float v); + + // 算术指令 BinaryInst* CreateBinary(Opcode op, Value* lhs, Value* rhs, const std::string& name); BinaryInst* CreateAdd(Value* lhs, Value* rhs, const std::string& name); + BinaryInst* CreateSub(Value* lhs, Value* rhs, const std::string& name); + BinaryInst* CreateMul(Value* lhs, Value* rhs, const std::string& name); + BinaryInst* CreateDiv(Value* lhs, Value* rhs, const std::string& name); + BinaryInst* CreateMod(Value* lhs, Value* rhs, const std::string& name); + + // 比较指令 + CmpInst* CreateICmp(CmpInst::Predicate pred, Value* lhs, Value* rhs, + const std::string& name); + CmpInst* CreateFCmp(CmpInst::Predicate pred, Value* lhs, Value* rhs, + const std::string& name); + + // 内存指令 AllocaInst* CreateAllocaI32(const std::string& name); + AllocaInst* CreateAllocaFloat(const std::string& name); + AllocaInst* CreateAlloca(std::shared_ptr ty, const std::string& name); LoadInst* CreateLoad(Value* ptr, const std::string& name); StoreInst* CreateStore(Value* val, Value* ptr); + + // 控制流指令 ReturnInst* CreateRet(Value* v); + BranchInst* CreateBr(BasicBlock* target); + CondBranchInst* CreateCondBr(Value* cond, BasicBlock* true_bb, + BasicBlock* false_bb); + + // 函数调用 + CallInst* CreateCall(Function* callee, std::vector args, + const std::string& name); + + // 数组访问 + GetElementPtrInst* CreateGEP(Value* ptr, std::vector indices, + const std::string& name); + + // Phi 指令 + PhiInst* CreatePhi(std::shared_ptr ty, const std::string& name); private: Context& ctx_; BasicBlock* insert_block_; }; +// ======================== IRPrinter 类 ======================== class IRPrinter { public: void Print(const Module& module, std::ostream& os); }; -} // namespace ir +} // namespace ir \ No newline at end of file diff --git a/include/irgen/IRGen.h b/include/irgen/IRGen.h index 231ba90..abd03b7 100644 --- a/include/irgen/IRGen.h +++ b/include/irgen/IRGen.h @@ -22,20 +22,19 @@ class Value; class IRGenImpl final : public SysYBaseVisitor { public: - IRGenImpl(ir::Module& module, const SemanticContext& sema); + IRGenImpl(ir::Module& module, IRGenContext& sema); std::any visitCompUnit(SysYParser::CompUnitContext* ctx) override; std::any visitFuncDef(SysYParser::FuncDefContext* ctx) override; - std::any visitBlockStmt(SysYParser::BlockStmtContext* ctx) override; + std::any visitBlock(SysYParser::BlockContext* ctx) override; std::any visitBlockItem(SysYParser::BlockItemContext* ctx) override; std::any visitDecl(SysYParser::DeclContext* ctx) override; std::any visitStmt(SysYParser::StmtContext* ctx) override; std::any visitVarDef(SysYParser::VarDefContext* ctx) override; - std::any visitReturnStmt(SysYParser::ReturnStmtContext* ctx) override; - std::any visitParenExp(SysYParser::ParenExpContext* ctx) override; - std::any visitNumberExp(SysYParser::NumberExpContext* ctx) override; - std::any visitVarExp(SysYParser::VarExpContext* ctx) override; - std::any visitAdditiveExp(SysYParser::AdditiveExpContext* ctx) override; + std::any visitPrimaryExp(SysYParser::PrimaryExpContext* ctx) override; + std::any visitNumber(SysYParser::NumberContext* ctx) override; + std::any visitLVal(SysYParser::LValContext* ctx) override; + std::any visitAddExp(SysYParser::AddExpContext* ctx) override; private: enum class BlockFlow { @@ -47,7 +46,7 @@ class IRGenImpl final : public SysYBaseVisitor { ir::Value* EvalExpr(SysYParser::ExpContext& expr); ir::Module& module_; - const SemanticContext& sema_; + IRGenContext& sema_; ir::Function* func_; ir::IRBuilder builder_; // 名称绑定由 Sema 负责；IRGen 只维护“声明 -> 存储槽位”的代码生成状态。 @@ -55,4 +54,4 @@ class IRGenImpl final : public SysYBaseVisitor { }; std::unique_ptr GenerateIR(SysYParser::CompUnitContext& tree, - const SemanticContext& sema); + IRGenContext& sema); diff --git a/include/sem/Sema.h b/include/sem/Sema.h index 191c45c..555d5e4 100644 --- a/include/sem/Sema.h +++ b/include/sem/Sema.h @@ -2,7 +2,7 @@ #define SEMANTIC_ANALYSIS_H #include "SymbolTable.h" -#include "../../generated/antlr4/SysYBaseVisitor.h" +#include "SysYBaseVisitor.h" #include #include #include @@ -175,4 +175,7 @@ private: // 语义分析入口函数 void RunSemanticAnalysis(SysYParser::CompUnitContext* ctx, IRGenContext& ir_ctx); +// 兼容主程序的简单包装：返回构造好的 IRGenContext（按值） +IRGenContext RunSema(SysYParser::CompUnitContext& ctx); + #endif // SEMANTIC_ANALYSIS_H \ No newline at end of file diff --git a/src/antlr4/SysYBaseVisitor.cpp b/src/antlr4/SysYBaseVisitor.cpp deleted file mode 100644 index 72e9df6..0000000 --- a/src/antlr4/SysYBaseVisitor.cpp +++ /dev/null @@ -1,7 +0,0 @@ - -// Generated from SysY.g4 by ANTLR 4.7.2 - - -#include "SysYBaseVisitor.h" - - diff --git a/src/antlr4/SysYBaseVisitor.h b/src/antlr4/SysYBaseVisitor.h deleted file mode 100644 index aed0760..0000000 --- a/src/antlr4/SysYBaseVisitor.h +++ /dev/null @@ -1,144 +0,0 @@ - -// Generated from SysY.g4 by ANTLR 4.7.2 - -#pragma once - - -#include "antlr4-runtime.h" -#include "SysYVisitor.h" - - -/** - * This class provides an empty implementation of SysYVisitor, which can be - * extended to create a visitor which only needs to handle a subset of the available methods. - */ -class SysYBaseVisitor : public SysYVisitor { -public: - - virtual antlrcpp::Any visitCompUnit(SysYParser::CompUnitContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitDecl(SysYParser::DeclContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitConstDecl(SysYParser::ConstDeclContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitBType(SysYParser::BTypeContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitConstDef(SysYParser::ConstDefContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitConstInitVal(SysYParser::ConstInitValContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitVarDecl(SysYParser::VarDeclContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitVarDef(SysYParser::VarDefContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitInitVal(SysYParser::InitValContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitFuncDef(SysYParser::FuncDefContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitFuncType(SysYParser::FuncTypeContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitFuncFParams(SysYParser::FuncFParamsContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitFuncFParam(SysYParser::FuncFParamContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitBlock(SysYParser::BlockContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitBlockItem(SysYParser::BlockItemContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitStmt(SysYParser::StmtContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitExp(SysYParser::ExpContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitCond(SysYParser::CondContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitLVal(SysYParser::LValContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitPrimaryExp(SysYParser::PrimaryExpContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitNumber(SysYParser::NumberContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitUnaryExp(SysYParser::UnaryExpContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitUnaryOp(SysYParser::UnaryOpContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitFuncRParams(SysYParser::FuncRParamsContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitMulExp(SysYParser::MulExpContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitAddExp(SysYParser::AddExpContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitRelExp(SysYParser::RelExpContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitEqExp(SysYParser::EqExpContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitLAndExp(SysYParser::LAndExpContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitLOrExp(SysYParser::LOrExpContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitConstExp(SysYParser::ConstExpContext *ctx) override { - return visitChildren(ctx); - } - - -}; - diff --git a/src/antlr4/SysYLexer.cpp b/src/antlr4/SysYLexer.cpp deleted file mode 100644 index a403879..0000000 --- a/src/antlr4/SysYLexer.cpp +++ /dev/null @@ -1,377 +0,0 @@ - -// Generated from SysY.g4 by ANTLR 4.7.2 - - -#include "SysYLexer.h" - - -using namespace antlr4; - - -SysYLexer::SysYLexer(CharStream *input) : Lexer(input) { - _interpreter = new atn::LexerATNSimulator(this, _atn, _decisionToDFA, _sharedContextCache); -} - -SysYLexer::~SysYLexer() { - delete _interpreter; -} - -std::string SysYLexer::getGrammarFileName() const { - return "SysY.g4"; -} - -const std::vector& 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 deleted file mode 100644 index ac9457c..0000000 --- a/src/antlr4/SysYLexer.h +++ /dev/null @@ -1,62 +0,0 @@ - -// Generated from SysY.g4 by ANTLR 4.7.2 - -#pragma once - - -#include "antlr4-runtime.h" - - - - -class SysYLexer : public antlr4::Lexer { -public: - enum { - T__0 = 1, T__1 = 2, T__2 = 3, T__3 = 4, T__4 = 5, T__5 = 6, T__6 = 7, - T__7 = 8, T__8 = 9, T__9 = 10, T__10 = 11, T__11 = 12, T__12 = 13, T__13 = 14, - T__14 = 15, T__15 = 16, T__16 = 17, T__17 = 18, T__18 = 19, T__19 = 20, - T__20 = 21, T__21 = 22, T__22 = 23, T__23 = 24, T__24 = 25, T__25 = 26, - T__26 = 27, T__27 = 28, T__28 = 29, T__29 = 30, T__30 = 31, T__31 = 32, - T__32 = 33, FloatConst = 34, IntConst = 35, Ident = 36, WS = 37, LINE_COMMENT = 38, - BLOCK_COMMENT = 39 - }; - - SysYLexer(antlr4::CharStream *input); - ~SysYLexer(); - - virtual std::string getGrammarFileName() const override; - virtual const std::vector& 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 deleted file mode 100644 index 0efcf6b..0000000 --- a/src/antlr4/SysYParser.cpp +++ /dev/null @@ -1,2648 +0,0 @@ - -// 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 deleted file mode 100644 index 3f76b79..0000000 --- a/src/antlr4/SysYParser.h +++ /dev/null @@ -1,513 +0,0 @@ - -// Generated from SysY.g4 by ANTLR 4.7.2 - -#pragma once - - -#include "antlr4-runtime.h" - - - - -class SysYParser : public antlr4::Parser { -public: - enum { - T__0 = 1, T__1 = 2, T__2 = 3, T__3 = 4, T__4 = 5, T__5 = 6, T__6 = 7, - T__7 = 8, T__8 = 9, T__9 = 10, T__10 = 11, T__11 = 12, T__12 = 13, T__13 = 14, - T__14 = 15, T__15 = 16, T__16 = 17, T__17 = 18, T__18 = 19, T__19 = 20, - T__20 = 21, T__21 = 22, T__22 = 23, T__23 = 24, T__24 = 25, T__25 = 26, - T__26 = 27, T__27 = 28, T__28 = 29, T__29 = 30, T__30 = 31, T__31 = 32, - T__32 = 33, FloatConst = 34, IntConst = 35, Ident = 36, WS = 37, LINE_COMMENT = 38, - BLOCK_COMMENT = 39 - }; - - enum { - RuleCompUnit = 0, RuleDecl = 1, RuleConstDecl = 2, RuleBType = 3, RuleConstDef = 4, - RuleConstInitVal = 5, RuleVarDecl = 6, RuleVarDef = 7, RuleInitVal = 8, - RuleFuncDef = 9, RuleFuncType = 10, RuleFuncFParams = 11, RuleFuncFParam = 12, - RuleBlock = 13, RuleBlockItem = 14, RuleStmt = 15, RuleExp = 16, RuleCond = 17, - RuleLVal = 18, RulePrimaryExp = 19, RuleNumber = 20, RuleUnaryExp = 21, - RuleUnaryOp = 22, RuleFuncRParams = 23, RuleMulExp = 24, RuleAddExp = 25, - RuleRelExp = 26, RuleEqExp = 27, RuleLAndExp = 28, RuleLOrExp = 29, - RuleConstExp = 30 - }; - - SysYParser(antlr4::TokenStream *input); - ~SysYParser(); - - virtual std::string getGrammarFileName() const override; - virtual const antlr4::atn::ATN& getATN() const override { return _atn; }; - virtual const std::vector& 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 deleted file mode 100644 index a079f4d..0000000 --- a/src/antlr4/SysYVisitor.cpp +++ /dev/null @@ -1,7 +0,0 @@ - -// Generated from SysY.g4 by ANTLR 4.7.2 - - -#include "SysYVisitor.h" - - diff --git a/src/antlr4/SysYVisitor.h b/src/antlr4/SysYVisitor.h deleted file mode 100644 index 32ef9ee..0000000 --- a/src/antlr4/SysYVisitor.h +++ /dev/null @@ -1,86 +0,0 @@ - -// Generated from SysY.g4 by ANTLR 4.7.2 - -#pragma once - - -#include "antlr4-runtime.h" -#include "SysYParser.h" - - - -/** - * This class defines an abstract visitor for a parse tree - * produced by SysYParser. - */ -class SysYVisitor : public antlr4::tree::AbstractParseTreeVisitor { -public: - - /** - * Visit parse trees produced by SysYParser. - */ - virtual antlrcpp::Any visitCompUnit(SysYParser::CompUnitContext *context) = 0; - - virtual antlrcpp::Any visitDecl(SysYParser::DeclContext *context) = 0; - - virtual antlrcpp::Any visitConstDecl(SysYParser::ConstDeclContext *context) = 0; - - virtual antlrcpp::Any visitBType(SysYParser::BTypeContext *context) = 0; - - virtual antlrcpp::Any visitConstDef(SysYParser::ConstDefContext *context) = 0; - - virtual antlrcpp::Any visitConstInitVal(SysYParser::ConstInitValContext *context) = 0; - - virtual antlrcpp::Any visitVarDecl(SysYParser::VarDeclContext *context) = 0; - - virtual antlrcpp::Any visitVarDef(SysYParser::VarDefContext *context) = 0; - - virtual antlrcpp::Any visitInitVal(SysYParser::InitValContext *context) = 0; - - virtual antlrcpp::Any visitFuncDef(SysYParser::FuncDefContext *context) = 0; - - virtual antlrcpp::Any visitFuncType(SysYParser::FuncTypeContext *context) = 0; - - virtual antlrcpp::Any visitFuncFParams(SysYParser::FuncFParamsContext *context) = 0; - - virtual antlrcpp::Any visitFuncFParam(SysYParser::FuncFParamContext *context) = 0; - - virtual antlrcpp::Any visitBlock(SysYParser::BlockContext *context) = 0; - - virtual antlrcpp::Any visitBlockItem(SysYParser::BlockItemContext *context) = 0; - - virtual antlrcpp::Any visitStmt(SysYParser::StmtContext *context) = 0; - - virtual antlrcpp::Any visitExp(SysYParser::ExpContext *context) = 0; - - virtual antlrcpp::Any visitCond(SysYParser::CondContext *context) = 0; - - virtual antlrcpp::Any visitLVal(SysYParser::LValContext *context) = 0; - - virtual antlrcpp::Any visitPrimaryExp(SysYParser::PrimaryExpContext *context) = 0; - - virtual antlrcpp::Any visitNumber(SysYParser::NumberContext *context) = 0; - - virtual antlrcpp::Any visitUnaryExp(SysYParser::UnaryExpContext *context) = 0; - - virtual antlrcpp::Any visitUnaryOp(SysYParser::UnaryOpContext *context) = 0; - - virtual antlrcpp::Any visitFuncRParams(SysYParser::FuncRParamsContext *context) = 0; - - virtual antlrcpp::Any visitMulExp(SysYParser::MulExpContext *context) = 0; - - virtual antlrcpp::Any visitAddExp(SysYParser::AddExpContext *context) = 0; - - virtual antlrcpp::Any visitRelExp(SysYParser::RelExpContext *context) = 0; - - virtual antlrcpp::Any visitEqExp(SysYParser::EqExpContext *context) = 0; - - virtual antlrcpp::Any visitLAndExp(SysYParser::LAndExpContext *context) = 0; - - virtual antlrcpp::Any visitLOrExp(SysYParser::LOrExpContext *context) = 0; - - virtual antlrcpp::Any visitConstExp(SysYParser::ConstExpContext *context) = 0; - - -}; - diff --git a/src/ir/BasicBlock.cpp b/src/ir/BasicBlock.cpp index b18502c..771629c 100644 --- a/src/ir/BasicBlock.cpp +++ b/src/ir/BasicBlock.cpp @@ -10,6 +10,7 @@ #include "ir/IR.h" #include +#include // 用于 std::find namespace ir { @@ -21,7 +22,6 @@ Function* BasicBlock::GetParent() const { return parent_; } void BasicBlock::SetParent(Function* parent) { parent_ = parent; } - bool BasicBlock::HasTerminator() const { return !instructions_.empty() && instructions_.back()->IsTerminator(); } @@ -42,4 +42,36 @@ const std::vector& BasicBlock::GetSuccessors() const { return successors_; } -} // namespace ir +// 添加前驱基本块（避免重复） +void BasicBlock::AddPredecessor(BasicBlock* pred) { + if (std::find(predecessors_.begin(), predecessors_.end(), pred) == + predecessors_.end()) { + predecessors_.push_back(pred); + } +} + +// 添加后继基本块（避免重复） +void BasicBlock::AddSuccessor(BasicBlock* succ) { + if (std::find(successors_.begin(), successors_.end(), succ) == + successors_.end()) { + successors_.push_back(succ); + } +} + +// 移除前驱基本块 +void BasicBlock::RemovePredecessor(BasicBlock* pred) { + auto it = std::find(predecessors_.begin(), predecessors_.end(), pred); + if (it != predecessors_.end()) { + predecessors_.erase(it); + } +} + +// 移除后继基本块 +void BasicBlock::RemoveSuccessor(BasicBlock* succ) { + auto it = std::find(successors_.begin(), successors_.end(), succ); + if (it != successors_.end()) { + successors_.erase(it); + } +} + +} // namespace ir \ No newline at end of file diff --git a/src/ir/Context.cpp b/src/ir/Context.cpp index 16c982c..4f075d6 100644 --- a/src/ir/Context.cpp +++ b/src/ir/Context.cpp @@ -15,6 +15,14 @@ ConstantInt* Context::GetConstInt(int v) { return inserted->second.get(); } +ConstantFloat* Context::GetConstFloat(float v) { + auto it = const_floats_.find(v); + if (it != const_floats_.end()) return it->second.get(); + auto inserted = const_floats_.emplace( + v, std::make_unique(Type::GetFloat32Type(), v)).first; + return inserted->second.get(); +} + std::string Context::NextTemp() { std::ostringstream oss; oss << "%" << ++temp_index_; diff --git a/src/ir/Function.cpp b/src/ir/Function.cpp index cf14d48..312abfc 100644 --- a/src/ir/Function.cpp +++ b/src/ir/Function.cpp @@ -5,8 +5,11 @@ namespace ir { -Function::Function(std::string name, std::shared_ptr ret_type) +Function::Function(std::string name, std::shared_ptr ret_type, + std::vector> param_types) : Value(std::move(ret_type), std::move(name)) { + func_type_ = std::static_pointer_cast( + Type::GetFunctionType(GetType(), std::move(param_types))); entry_ = CreateBlock("entry"); } @@ -29,4 +32,15 @@ const std::vector>& Function::GetBlocks() const { return blocks_; } +void Function::AddParam(Value* param) { + if (!param) { + throw std::runtime_error("Function::AddParam cannot add null param"); + } + params_.push_back(param); +} + +std::shared_ptr Function::GetFunctionType() const { + return func_type_; +} + } // namespace ir diff --git a/src/ir/IRBuilder.cpp b/src/ir/IRBuilder.cpp index 90f03c4..4fb364c 100644 --- a/src/ir/IRBuilder.cpp +++ b/src/ir/IRBuilder.cpp @@ -49,15 +49,35 @@ AllocaInst* IRBuilder::CreateAllocaI32(const std::string& name) { return insert_block_->Append(Type::GetPtrInt32Type(), name); } +AllocaInst* IRBuilder::CreateAllocaFloat(const std::string& name) { + if (!insert_block_) { + throw std::runtime_error(FormatError("ir", "IRBuilder 未设置插入点")); + } + return insert_block_->Append(Type::GetPointerType(Type::GetFloat32Type()), name); +} + +AllocaInst* IRBuilder::CreateAlloca(std::shared_ptr ty, const std::string& name) { + if (!insert_block_) { + throw std::runtime_error(FormatError("ir", "IRBuilder 未设置插入点")); + } + if (!ty || !ty->IsPointer()) { + throw std::runtime_error(FormatError("ir", "CreateAlloca 仅支持指针类型")); + } + return insert_block_->Append(ty, name); +} + LoadInst* IRBuilder::CreateLoad(Value* ptr, const std::string& name) { if (!insert_block_) { throw std::runtime_error(FormatError("ir", "IRBuilder 未设置插入点")); } if (!ptr) { - throw std::runtime_error( - FormatError("ir", "IRBuilder::CreateLoad 缺少 ptr")); + throw std::runtime_error(FormatError("ir", "IRBuilder::CreateLoad 缺少 ptr")); } - return insert_block_->Append(Type::GetInt32Type(), ptr, name); + if (!ptr->GetType() || !ptr->GetType()->IsPointer()) { + throw std::runtime_error(FormatError("ir", "IRBuilder::CreateLoad ptr 必须为指针类型")); + } + const auto* ptr_ty = static_cast(ptr->GetType().get()); + return insert_block_->Append(ptr_ty->GetPointeeType(), ptr, name); } StoreInst* IRBuilder::CreateStore(Value* val, Value* ptr) { @@ -79,11 +99,78 @@ ReturnInst* IRBuilder::CreateRet(Value* v) { if (!insert_block_) { throw std::runtime_error(FormatError("ir", "IRBuilder 未设置插入点")); } - if (!v) { - throw std::runtime_error( - FormatError("ir", "IRBuilder::CreateRet 缺少返回值")); - } + // ReturnInst expects its own type to be void; the returned value is an + // operand. Always use void as the instruction type. return insert_block_->Append(Type::GetVoidType(), v); } +BinaryInst* IRBuilder::CreateSub(Value* lhs, Value* rhs, const std::string& name) { + return CreateBinary(Opcode::Sub, lhs, rhs, name); +} + +BinaryInst* IRBuilder::CreateMul(Value* lhs, Value* rhs, const std::string& name) { + return CreateBinary(Opcode::Mul, lhs, rhs, name); +} + +BinaryInst* IRBuilder::CreateDiv(Value* lhs, Value* rhs, const std::string& name) { + return CreateBinary(Opcode::Div, lhs, rhs, name); +} + +BinaryInst* IRBuilder::CreateMod(Value* lhs, Value* rhs, const std::string& name) { + return CreateBinary(Opcode::Mod, lhs, rhs, name); +} + +CmpInst* IRBuilder::CreateICmp(CmpInst::Predicate pred, Value* lhs, Value* rhs, + const std::string& name) { + if (!insert_block_) { + throw std::runtime_error(FormatError("ir", "IRBuilder 未设置插入点")); + } + return insert_block_->Append(Opcode::ICmp, pred, lhs, rhs, name); +} + +CmpInst* IRBuilder::CreateFCmp(CmpInst::Predicate pred, Value* lhs, Value* rhs, + const std::string& name) { + if (!insert_block_) { + throw std::runtime_error(FormatError("ir", "IRBuilder 未设置插入点")); + } + return insert_block_->Append(Opcode::FCmp, pred, lhs, rhs, name); +} + +BranchInst* IRBuilder::CreateBr(BasicBlock* target) { + if (!insert_block_) { + throw std::runtime_error(FormatError("ir", "IRBuilder 未设置插入点")); + } + return insert_block_->Append(target); +} + +CondBranchInst* IRBuilder::CreateCondBr(Value* cond, BasicBlock* true_bb, BasicBlock* false_bb) { + if (!insert_block_) { + throw std::runtime_error(FormatError("ir", "IRBuilder 未设置插入点")); + } + return insert_block_->Append(cond, true_bb, false_bb); +} + +CallInst* IRBuilder::CreateCall(Function* callee, std::vector args, const std::string& name) { + if (!insert_block_) { + throw std::runtime_error(FormatError("ir", "IRBuilder 未设置插入点")); + } + return insert_block_->Append(callee, args, name); +} + +GetElementPtrInst* IRBuilder::CreateGEP(Value* ptr, std::vector indices, const std::string& name) { + if (!insert_block_) { + throw std::runtime_error(FormatError("ir", "IRBuilder 未设置插入点")); + } + // 计算结果类型（简化：假设为指针类型） + auto result_ty = Type::GetPointerType(ptr->GetType()); + return insert_block_->Append(result_ty, ptr, indices, name); +} + +PhiInst* IRBuilder::CreatePhi(std::shared_ptr ty, const std::string& name) { + if (!insert_block_) { + throw std::runtime_error(FormatError("ir", "IRBuilder 未设置插入点")); + } + return insert_block_->Append(ty, name); +} + } // namespace ir diff --git a/src/ir/IRPrinter.cpp b/src/ir/IRPrinter.cpp index 30efbb6..5df779b 100644 --- a/src/ir/IRPrinter.cpp +++ b/src/ir/IRPrinter.cpp @@ -18,28 +18,44 @@ static const char* TypeToString(const Type& ty) { return "void"; case Type::Kind::Int32: return "i32"; - case Type::Kind::PtrInt32: - return "i32*"; + case Type::Kind::Float32: + return "float"; + case Type::Kind::Pointer: + return "i32*"; // 目前仅支持 i32* 指针打印 + case Type::Kind::Array: + return "[array]"; + case Type::Kind::Function: + return "[function]"; + case Type::Kind::Label: + return "label"; } throw std::runtime_error(FormatError("ir", "未知类型")); } static const char* OpcodeToString(Opcode op) { switch (op) { - case Opcode::Add: - return "add"; - case Opcode::Sub: - return "sub"; - case Opcode::Mul: - return "mul"; - case Opcode::Alloca: - return "alloca"; - case Opcode::Load: - return "load"; - case Opcode::Store: - return "store"; - case Opcode::Ret: - return "ret"; + case Opcode::Add: return "add"; + case Opcode::Sub: return "sub"; + case Opcode::Mul: return "mul"; + case Opcode::Div: return "sdiv"; + case Opcode::Mod: return "srem"; + case Opcode::And: return "and"; + case Opcode::Or: return "or"; + case Opcode::Xor: return "xor"; + case Opcode::Shl: return "shl"; + case Opcode::LShr: return "lshr"; + case Opcode::AShr: return "ashr"; + case Opcode::ICmp: return "icmp"; + case Opcode::FCmp: return "fcmp"; + case Opcode::Alloca: return "alloca"; + case Opcode::Load: return "load"; + case Opcode::Store: return "store"; + case Opcode::Ret: return "ret"; + case Opcode::Br: return "br"; + case Opcode::CondBr: return "br"; + case Opcode::Call: return "call"; + case Opcode::GEP: return "getelementptr"; + case Opcode::Phi: return "phi"; } return "?"; } @@ -65,7 +81,15 @@ void IRPrinter::Print(const Module& module, std::ostream& os) { switch (inst->GetOpcode()) { case Opcode::Add: case Opcode::Sub: - case Opcode::Mul: { + case Opcode::Mul: + case Opcode::Div: + case Opcode::Mod: + case Opcode::And: + case Opcode::Or: + case Opcode::Xor: + case Opcode::Shl: + case Opcode::LShr: + case Opcode::AShr: { auto* bin = static_cast(inst); os << " " << bin->GetName() << " = " << OpcodeToString(bin->GetOpcode()) << " " @@ -74,21 +98,36 @@ void IRPrinter::Print(const Module& module, std::ostream& os) { << ValueToString(bin->GetRhs()) << "\n"; break; } + case Opcode::ICmp: + case Opcode::FCmp: { + auto* cmp = static_cast(inst); + os << " " << cmp->GetName() << " = " + << OpcodeToString(cmp->GetOpcode()) << " eq " + << TypeToString(*cmp->GetLhs()->GetType()) << " " + << ValueToString(cmp->GetLhs()) << ", " + << ValueToString(cmp->GetRhs()) << "\n"; + break; + } case Opcode::Alloca: { auto* alloca = static_cast(inst); - os << " " << alloca->GetName() << " = alloca i32\n"; + os << " " << alloca->GetName() << " = alloca " + << TypeToString(*static_cast(alloca->GetType().get())->GetPointeeType()) << "\n"; break; } case Opcode::Load: { auto* load = static_cast(inst); - os << " " << load->GetName() << " = load i32, i32* " + os << " " << load->GetName() << " = load " + << TypeToString(*load->GetType()) << ", " + << TypeToString(*load->GetPtr()->GetType()) << " " << ValueToString(load->GetPtr()) << "\n"; break; } case Opcode::Store: { auto* store = static_cast(inst); - os << " store i32 " << ValueToString(store->GetValue()) - << ", i32* " << ValueToString(store->GetPtr()) << "\n"; + os << " store " << TypeToString(*store->GetValue()->GetType()) << " " + << ValueToString(store->GetValue()) << ", " + << TypeToString(*store->GetPtr()->GetType()) << " " + << ValueToString(store->GetPtr()) << "\n"; break; } case Opcode::Ret: { @@ -97,6 +136,56 @@ void IRPrinter::Print(const Module& module, std::ostream& os) { << ValueToString(ret->GetValue()) << "\n"; break; } + case Opcode::Br: { + auto* br = static_cast(inst); + os << " br label %" << br->GetTarget()->GetName() << "\n"; + break; + } + case Opcode::CondBr: { + auto* condbr = static_cast(inst); + os << " br i1 " << ValueToString(condbr->GetCond()) + << ", label %" << condbr->GetTrueBlock()->GetName() + << ", label %" << condbr->GetFalseBlock()->GetName() << "\n"; + break; + } + case Opcode::Call: { + auto* call = static_cast(inst); + os << " "; + if (!call->GetName().empty()) { + os << call->GetName() << " = "; + } + os << "call " << TypeToString(*call->GetCallee()->GetType()) << " @" + << call->GetCallee()->GetName() << "("; + for (size_t i = 0; i < call->GetArgs().size(); ++i) { + if (i > 0) os << ", "; + os << TypeToString(*call->GetArgs()[i]->GetType()) << " " + << ValueToString(call->GetArgs()[i]); + } + os << ")\n"; + break; + } + case Opcode::GEP: { + auto* gep = static_cast(inst); + os << " " << gep->GetName() << " = getelementptr " + << TypeToString(*gep->GetPtr()->GetType()) << " " + << ValueToString(gep->GetPtr()); + for (auto* idx : gep->GetIndices()) { + os << ", " << TypeToString(*idx->GetType()) << " " << ValueToString(idx); + } + os << "\n"; + break; + } + case Opcode::Phi: { + auto* phi = static_cast(inst); + os << " " << phi->GetName() << " = phi " + << TypeToString(*phi->GetType()); + for (const auto& incoming : phi->GetIncomings()) { + os << " [ " << ValueToString(incoming.first) << ", %" + << incoming.second->GetName() << " ]"; + } + os << "\n"; + break; + } } } } diff --git a/src/ir/Instruction.cpp b/src/ir/Instruction.cpp index 7928716..236abd9 100644 --- a/src/ir/Instruction.cpp +++ b/src/ir/Instruction.cpp @@ -52,7 +52,9 @@ Instruction::Instruction(Opcode op, std::shared_ptr ty, std::string name) Opcode Instruction::GetOpcode() const { return opcode_; } -bool Instruction::IsTerminator() const { return opcode_ == Opcode::Ret; } +bool Instruction::IsTerminator() const { + return opcode_ == Opcode::Ret || opcode_ == Opcode::Br || opcode_ == Opcode::CondBr; +} BasicBlock* Instruction::GetParent() const { return parent_; } @@ -87,21 +89,22 @@ Value* BinaryInst::GetRhs() const { return GetOperand(1); } ReturnInst::ReturnInst(std::shared_ptr void_ty, Value* val) : Instruction(Opcode::Ret, std::move(void_ty), "") { - if (!val) { - throw std::runtime_error(FormatError("ir", "ReturnInst 缺少返回值")); - } if (!type_ || !type_->IsVoid()) { throw std::runtime_error(FormatError("ir", "ReturnInst 返回类型必须为 void")); } - AddOperand(val); + // val may be nullptr to represent a void return; only add operand when + // a returned value is present. + if (val) { + AddOperand(val); + } } Value* ReturnInst::GetValue() const { return GetOperand(0); } AllocaInst::AllocaInst(std::shared_ptr ptr_ty, std::string name) : Instruction(Opcode::Alloca, std::move(ptr_ty), std::move(name)) { - if (!type_ || !type_->IsPtrInt32()) { - throw std::runtime_error(FormatError("ir", "AllocaInst 当前只支持 i32*")); + if (!type_ || !type_->IsPointer()) { + throw std::runtime_error(FormatError("ir", "AllocaInst 类型必须为指针")); } } @@ -110,12 +113,12 @@ LoadInst::LoadInst(std::shared_ptr val_ty, Value* ptr, std::string name) if (!ptr) { throw std::runtime_error(FormatError("ir", "LoadInst 缺少 ptr")); } - if (!type_ || !type_->IsInt32()) { - throw std::runtime_error(FormatError("ir", "LoadInst 当前只支持加载 i32")); + if (!ptr->GetType() || !ptr->GetType()->IsPointer()) { + throw std::runtime_error(FormatError("ir", "LoadInst ptr 必须为指针类型")); } - if (!ptr->GetType() || !ptr->GetType()->IsPtrInt32()) { - throw std::runtime_error( - FormatError("ir", "LoadInst 当前只支持从 i32* 加载")); + const auto* ptr_ty = static_cast(ptr->GetType().get()); + if (!type_ || *type_ != *ptr_ty->GetPointeeType()) { + throw std::runtime_error(FormatError("ir", "LoadInst 类型不匹配")); } AddOperand(ptr); } @@ -133,12 +136,12 @@ StoreInst::StoreInst(std::shared_ptr void_ty, Value* val, Value* ptr) if (!type_ || !type_->IsVoid()) { throw std::runtime_error(FormatError("ir", "StoreInst 返回类型必须为 void")); } - if (!val->GetType() || !val->GetType()->IsInt32()) { - throw std::runtime_error(FormatError("ir", "StoreInst 当前只支持存储 i32")); + if (!ptr->GetType() || !ptr->GetType()->IsPointer()) { + throw std::runtime_error(FormatError("ir", "StoreInst ptr 必须为指针类型")); } - if (!ptr->GetType() || !ptr->GetType()->IsPtrInt32()) { - throw std::runtime_error( - FormatError("ir", "StoreInst 当前只支持写入 i32*")); + const auto* ptr_ty = static_cast(ptr->GetType().get()); + if (!val->GetType() || *val->GetType() != *ptr_ty->GetPointeeType()) { + throw std::runtime_error(FormatError("ir", "StoreInst 类型不匹配")); } AddOperand(val); AddOperand(ptr); @@ -148,4 +151,120 @@ Value* StoreInst::GetValue() const { return GetOperand(0); } Value* StoreInst::GetPtr() const { return GetOperand(1); } +CmpInst::CmpInst(Opcode op, Predicate pred, Value* lhs, Value* rhs, std::string name) + : Instruction(op, Type::GetInt32Type(), std::move(name)), pred_(pred), lhs_(lhs), rhs_(rhs) { + if (op != Opcode::ICmp && op != Opcode::FCmp) { + throw std::runtime_error(FormatError("ir", "CmpInst 仅支持 ICmp 和 FCmp")); + } + if (!lhs || !rhs) { + throw std::runtime_error(FormatError("ir", "CmpInst 缺少操作数")); + } + AddOperand(lhs); + AddOperand(rhs); +} + +BranchInst::BranchInst(BasicBlock* target) + : Instruction(Opcode::Br, Type::GetVoidType(), "") { + if (!target) { + throw std::runtime_error(FormatError("ir", "BranchInst 缺少目标基本块")); + } + AddOperand(target); +} + +BasicBlock* BranchInst::GetTarget() const { return static_cast(GetOperand(0)); } + +CondBranchInst::CondBranchInst(Value* cond, BasicBlock* true_bb, BasicBlock* false_bb) + : Instruction(Opcode::CondBr, Type::GetVoidType(), "") { + if (!cond || !true_bb || !false_bb) { + throw std::runtime_error(FormatError("ir", "CondBranchInst 缺少操作数")); + } + AddOperand(cond); + AddOperand(true_bb); + AddOperand(false_bb); +} + +Value* CondBranchInst::GetCond() const { return GetOperand(0); } +BasicBlock* CondBranchInst::GetTrueBlock() const { return static_cast(GetOperand(1)); } +BasicBlock* CondBranchInst::GetFalseBlock() const { return static_cast(GetOperand(2)); } + +CallInst::CallInst(Function* callee, std::vector args, std::string name) + : Instruction(Opcode::Call, callee->GetType(), std::move(name)) { + if (!callee) { + throw std::runtime_error(FormatError("ir", "CallInst 缺少被调用函数")); + } + AddOperand(callee); + for (auto* arg : args) { + if (!arg) { + throw std::runtime_error(FormatError("ir", "CallInst 参数不能为空")); + } + AddOperand(arg); + } +} + +PhiInst::PhiInst(std::shared_ptr ty, std::string name) + : Instruction(Opcode::Phi, std::move(ty), std::move(name)) {} + +void PhiInst::AddIncoming(Value* val, BasicBlock* block) { + if (!val || !block) { + throw std::runtime_error(FormatError("ir", "PhiInst AddIncoming 参数不能为空")); + } + AddOperand(val); + AddOperand(block); +} + +GetElementPtrInst::GetElementPtrInst(std::shared_ptr ty, Value* ptr, + std::vector indices, std::string name) + : Instruction(Opcode::GEP, std::move(ty), std::move(name)) { + if (!ptr) { + throw std::runtime_error(FormatError("ir", "GetElementPtrInst 缺少指针")); + } + AddOperand(ptr); + for (auto* idx : indices) { + if (!idx) { + throw std::runtime_error(FormatError("ir", "GetElementPtrInst 索引不能为空")); + } + AddOperand(idx); + } +} + +Function* CallInst::GetCallee() const { + return static_cast(GetOperand(0)); +} + +const std::vector& CallInst::GetArgs() const { + // 返回参数列表（跳过被调用函数） + static std::vector args; + args.clear(); + for (size_t i = 1; i < GetNumOperands(); ++i) { + args.push_back(GetOperand(i)); + } + return args; +} + +const std::vector>& PhiInst::GetIncomings() const { + // Phi 指令的操作数是成对的：值和基本块 + static std::vector> incomings; + incomings.clear(); + for (size_t i = 0; i < GetNumOperands(); i += 2) { + Value* val = GetOperand(i); + BasicBlock* block = static_cast(GetOperand(i + 1)); + incomings.emplace_back(val, block); + } + return incomings; +} + +Value* GetElementPtrInst::GetPtr() const { + return GetOperand(0); +} + +const std::vector& GetElementPtrInst::GetIndices() const { + // 返回索引列表（跳过指针） + static std::vector indices; + indices.clear(); + for (size_t i = 1; i < GetNumOperands(); ++i) { + indices.push_back(GetOperand(i)); + } + return indices; +} + } // namespace ir diff --git a/src/ir/Module.cpp b/src/ir/Module.cpp index 928efdc..9ccd6d0 100644 --- a/src/ir/Module.cpp +++ b/src/ir/Module.cpp @@ -9,13 +9,30 @@ Context& Module::GetContext() { return context_; } const Context& Module::GetContext() const { return context_; } Function* Module::CreateFunction(const std::string& name, - std::shared_ptr ret_type) { - functions_.push_back(std::make_unique(name, std::move(ret_type))); + std::shared_ptr ret_type, + std::vector> param_types) { + functions_.push_back( + std::make_unique(name, std::move(ret_type), std::move(param_types))); return functions_.back().get(); } +GlobalValue* Module::CreateGlobalVariable(const std::string& name, + std::shared_ptr ty, + ConstantValue* init) { + auto gv = std::make_unique(std::move(ty), name); + if (init) { + gv->SetInitializer(init); + } + global_vars_.push_back(std::move(gv)); + return global_vars_.back().get(); +} + const std::vector>& Module::GetFunctions() const { return functions_; } +const std::vector>& Module::GetGlobalVariables() const { + return global_vars_; +} + } // namespace ir diff --git a/src/ir/Type.cpp b/src/ir/Type.cpp index 3e1684d..c937173 100644 --- a/src/ir/Type.cpp +++ b/src/ir/Type.cpp @@ -1,8 +1,20 @@ // 当前仅支持 void、i32 和 i32*。 #include "ir/IR.h" +#include +#include namespace ir { +// 用于缓存复合类型的静态映射（简单实现） +static std::unordered_map> pointer_cache; +static std::unordered_map> array_cache; +static std::unordered_map> function_cache; + +// 简单哈希组合函数 +static std::size_t hash_combine(std::size_t seed, std::size_t v) { + return seed ^ (v + 0x9e3779b9 + (seed << 6) + (seed >> 2)); +} + Type::Type(Kind k) : kind_(k) {} const std::shared_ptr& Type::GetVoidType() { @@ -15,17 +27,133 @@ const std::shared_ptr& Type::GetInt32Type() { return type; } +const std::shared_ptr& Type::GetFloat32Type() { + static const std::shared_ptr type = std::make_shared(Kind::Float32); + return type; +} + +const std::shared_ptr& Type::GetLabelType() { + static const std::shared_ptr type = std::make_shared(Kind::Label); + return type; +} + +// 兼容旧的 i32* 类型，返回指向 i32 的指针类型 const std::shared_ptr& Type::GetPtrInt32Type() { - static const std::shared_ptr type = std::make_shared(Kind::PtrInt32); + static const std::shared_ptr type = GetPointerType(GetInt32Type()); return type; } +std::shared_ptr Type::GetPointerType(std::shared_ptr pointee) { + // 简单缓存：使用 pointee 的地址作为键（实际应使用更可靠的标识，但作为演示足够） + std::size_t key = reinterpret_cast(pointee.get()); + auto it = pointer_cache.find(key); + if (it != pointer_cache.end()) { + return it->second; + } + auto ptr_type = std::make_shared(pointee); + pointer_cache[key] = ptr_type; + return ptr_type; +} + +std::shared_ptr Type::GetArrayType(std::shared_ptr elem, size_t size) { + // 使用元素类型指针和大小组合哈希 + std::size_t seed = 0; + seed = hash_combine(seed, reinterpret_cast(elem.get())); + seed = hash_combine(seed, size); + auto it = array_cache.find(seed); + if (it != array_cache.end()) { + return it->second; + } + auto arr_type = std::make_shared(elem, size); + array_cache[seed] = arr_type; + return arr_type; +} + +std::shared_ptr Type::GetFunctionType(std::shared_ptr ret, + std::vector> params) { + // 哈希组合：返回类型 + 参数类型列表 + std::size_t seed = reinterpret_cast(ret.get()); + for (const auto& p : params) { + seed = hash_combine(seed, reinterpret_cast(p.get())); + } + auto it = function_cache.find(seed); + if (it != function_cache.end()) { + return it->second; + } + auto func_type = std::make_shared(ret, std::move(params)); + function_cache[seed] = func_type; + return func_type; +} + Type::Kind Type::GetKind() const { return kind_; } bool Type::IsVoid() const { return kind_ == Kind::Void; } bool Type::IsInt32() const { return kind_ == Kind::Int32; } -bool Type::IsPtrInt32() const { return kind_ == Kind::PtrInt32; } +bool Type::IsFloat32() const { return kind_ == Kind::Float32; } + +bool Type::IsPointer() const { return kind_ == Kind::Pointer; } + +bool Type::IsArray() const { return kind_ == Kind::Array; } + +bool Type::IsFunction() const { return kind_ == Kind::Function; } + +bool Type::IsLabel() const { return kind_ == Kind::Label; } + +// 兼容旧代码，检查是否为 i32* 类型 +bool Type::IsPtrInt32() const { + if (!IsPointer()) return false; + const auto* ptr_ty = static_cast(this); + return ptr_ty->GetPointeeType()->IsInt32(); +} + +// 检查是否为 float32* 类型 +bool Type::IsPtrFloat32() const { + if (!IsPointer()) return false; + const auto* ptr_ty = static_cast(this); + return ptr_ty->GetPointeeType()->IsFloat32(); +} + +bool Type::operator==(const Type& other) const { + if (kind_ != other.kind_) return false; + + switch (kind_) { + case Kind::Void: + case Kind::Int32: + case Kind::Float32: + case Kind::Label: + return true; + case Kind::Pointer: { + const auto* this_ptr = static_cast(this); + const auto* other_ptr = static_cast(&other); + return *this_ptr->GetPointeeType() == *other_ptr->GetPointeeType(); + } + case Kind::Array: { + const auto* this_arr = static_cast(this); + const auto* other_arr = static_cast(&other); + return this_arr->GetSize() == other_arr->GetSize() && + *this_arr->GetElementType() == *other_arr->GetElementType(); + } + case Kind::Function: { + const auto* this_func = static_cast(this); + const auto* other_func = static_cast(&other); + if (*this_func->GetReturnType() != *other_func->GetReturnType()) return false; + const auto& this_params = this_func->GetParamTypes(); + const auto& other_params = other_func->GetParamTypes(); + if (this_params.size() != other_params.size()) return false; + for (size_t i = 0; i < this_params.size(); ++i) { + if (*this_params[i] != *other_params[i]) return false; + } + return true; + } + default: + return false; + } +} + +bool Type::operator!=(const Type& other) const { + return !(*this == other); +} -} // namespace ir +} // namespace ir \ No newline at end of file diff --git a/src/ir/Value.cpp b/src/ir/Value.cpp index 2e9f4c1..65af078 100644 --- a/src/ir/Value.cpp +++ b/src/ir/Value.cpp @@ -20,7 +20,19 @@ bool Value::IsVoid() const { return type_ && type_->IsVoid(); } bool Value::IsInt32() const { return type_ && type_->IsInt32(); } -bool Value::IsPtrInt32() const { return type_ && type_->IsPtrInt32(); } +bool Value::IsPtrInt32() const { + if (!type_ || !type_->IsPointer()) return false; + const auto* ptr_ty = static_cast(type_.get()); + return ptr_ty->GetPointeeType()->IsInt32(); +} + +bool Value::IsPtrFloat32() const { + if (!type_ || !type_->IsPointer()) return false; + const auto* ptr_ty = static_cast(type_.get()); + return ptr_ty->GetPointeeType()->IsFloat32(); +} + +bool Value::IsFloat32() const { return type_ && type_->IsFloat32(); } bool Value::IsConstant() const { return dynamic_cast(this) != nullptr; @@ -38,6 +50,10 @@ bool Value::IsFunction() const { return dynamic_cast(this) != nullptr; } +bool Value::IsGlobalValue() const { + return dynamic_cast(this) != nullptr; +} + void Value::AddUse(User* user, size_t operand_index) { if (!user) return; uses_.push_back(Use(this, user, operand_index)); @@ -80,4 +96,11 @@ ConstantValue::ConstantValue(std::shared_ptr ty, std::string name) ConstantInt::ConstantInt(std::shared_ptr ty, int v) : ConstantValue(std::move(ty), ""), value_(v) {} +ConstantFloat::ConstantFloat(std::shared_ptr ty, float v) + : ConstantValue(std::move(ty), ""), value_(v) {} + +ConstantArray::ConstantArray(std::shared_ptr ty, + std::vector elems) + : ConstantValue(std::move(ty), ""), elements_(std::move(elems)) {} + } // namespace ir diff --git a/src/irgen/IRGenDecl.cpp b/src/irgen/IRGenDecl.cpp index 0eb62ae..be7a356 100644 --- a/src/irgen/IRGenDecl.cpp +++ b/src/irgen/IRGenDecl.cpp @@ -6,25 +6,15 @@ #include "ir/IR.h" #include "utils/Log.h" -namespace { +// helper functions removed; VarDef uses Ident() directly per current grammar. -std::string GetLValueName(SysYParser::LValueContext& lvalue) { - if (!lvalue.ID()) { - throw std::runtime_error(FormatError("irgen", "非法左值")); - } - return lvalue.ID()->getText(); -} - -} // namespace - -std::any IRGenImpl::visitBlockStmt(SysYParser::BlockStmtContext* ctx) { +std::any IRGenImpl::visitBlock(SysYParser::BlockContext* ctx) { if (!ctx) { throw std::runtime_error(FormatError("irgen", "缺少语句块")); } for (auto* item : ctx->blockItem()) { if (item) { if (VisitBlockItemResult(*item) == BlockFlow::Terminated) { - // 当前语法要求 return 为块内最后一条语句；命中后可停止生成。 break; } } @@ -63,15 +53,17 @@ std::any IRGenImpl::visitDecl(SysYParser::DeclContext* ctx) { if (!ctx) { throw std::runtime_error(FormatError("irgen", "缺少变量声明")); } - if (!ctx->btype() || !ctx->btype()->INT()) { - throw std::runtime_error(FormatError("irgen", "当前仅支持局部 int 变量声明")); - } - auto* var_def = ctx->varDef(); - if (!var_def) { - throw std::runtime_error(FormatError("irgen", "非法变量声明")); + if (ctx->varDecl()) { + auto* vdecl = ctx->varDecl(); + if (!vdecl->bType() || vdecl->bType()->getText() != "int") { + throw std::runtime_error(FormatError("irgen", "当前仅支持局部 int 变量声明")); + } + for (auto* var_def : vdecl->varDef()) { + if (var_def) var_def->accept(this); + } + return {}; } - var_def->accept(this); - return {}; + throw std::runtime_error(FormatError("irgen", "暂不支持的声明类型")); } @@ -83,10 +75,9 @@ std::any IRGenImpl::visitVarDef(SysYParser::VarDefContext* ctx) { if (!ctx) { throw std::runtime_error(FormatError("irgen", "缺少变量定义")); } - if (!ctx->lValue()) { + if (!ctx->Ident()) { throw std::runtime_error(FormatError("irgen", "变量声明缺少名称")); } - GetLValueName(*ctx->lValue()); if (storage_map_.find(ctx) != storage_map_.end()) { throw std::runtime_error(FormatError("irgen", "声明重复生成存储槽位")); } @@ -94,7 +85,7 @@ std::any IRGenImpl::visitVarDef(SysYParser::VarDefContext* ctx) { storage_map_[ctx] = slot; ir::Value* init = nullptr; - if (auto* init_value = ctx->initValue()) { + if (auto* init_value = ctx->initVal()) { if (!init_value->exp()) { throw std::runtime_error(FormatError("irgen", "当前不支持聚合初始化")); } diff --git a/src/irgen/IRGenDriver.cpp b/src/irgen/IRGenDriver.cpp index ff94412..570e8e8 100644 --- a/src/irgen/IRGenDriver.cpp +++ b/src/irgen/IRGenDriver.cpp @@ -7,7 +7,7 @@ #include "utils/Log.h" std::unique_ptr GenerateIR(SysYParser::CompUnitContext& tree, - const SemanticContext& sema) { + IRGenContext& sema) { auto module = std::make_unique(); IRGenImpl gen(*module, sema); tree.accept(&gen); diff --git a/src/irgen/IRGenExp.cpp b/src/irgen/IRGenExp.cpp index cf4797c..4a189d9 100644 --- a/src/irgen/IRGenExp.cpp +++ b/src/irgen/IRGenExp.cpp @@ -25,20 +25,21 @@ ir::Value* IRGenImpl::EvalExpr(SysYParser::ExpContext& expr) { } -std::any IRGenImpl::visitParenExp(SysYParser::ParenExpContext* ctx) { - if (!ctx || !ctx->exp()) { - throw std::runtime_error(FormatError("irgen", "非法括号表达式")); - } - return EvalExpr(*ctx->exp()); +std::any IRGenImpl::visitPrimaryExp(SysYParser::PrimaryExpContext* ctx) { + if (!ctx) throw std::runtime_error(FormatError("irgen", "非法 primary 表达式")); + if (ctx->exp()) return EvalExpr(*ctx->exp()); + if (ctx->lVal()) return ctx->lVal()->accept(this); + if (ctx->number()) return ctx->number()->accept(this); + throw std::runtime_error(FormatError("irgen", "不支持的 primary 表达式")); } -std::any IRGenImpl::visitNumberExp(SysYParser::NumberExpContext* ctx) { - if (!ctx || !ctx->number() || !ctx->number()->ILITERAL()) { +std::any IRGenImpl::visitNumber(SysYParser::NumberContext* ctx) { + if (!ctx || !ctx->IntConst()) { throw std::runtime_error(FormatError("irgen", "当前仅支持整数字面量")); } return static_cast( - builder_.CreateConstInt(std::stoi(ctx->number()->getText()))); + builder_.CreateConstInt(std::stoi(ctx->getText()))); } // 变量使用的处理流程： @@ -47,33 +48,30 @@ std::any IRGenImpl::visitNumberExp(SysYParser::NumberExpContext* ctx) { // 3. 最后生成 load，把内存中的值读出来。 // // 因此当前 IRGen 自己不再做名字查找，而是直接消费 Sema 的绑定结果。 -std::any IRGenImpl::visitVarExp(SysYParser::VarExpContext* ctx) { - if (!ctx || !ctx->var() || !ctx->var()->ID()) { +std::any IRGenImpl::visitLVal(SysYParser::LValContext* ctx) { + if (!ctx || !ctx->Ident()) { throw std::runtime_error(FormatError("irgen", "当前仅支持普通整型变量")); } - auto* decl = sema_.ResolveVarUse(ctx->var()); - if (!decl) { - throw std::runtime_error( - FormatError("irgen", - "变量使用缺少语义绑定: " + ctx->var()->ID()->getText())); - } - auto it = storage_map_.find(decl); - if (it == storage_map_.end()) { - throw std::runtime_error( - FormatError("irgen", - "变量声明缺少存储槽位: " + ctx->var()->ID()->getText())); + // find storage by matching declaration node stored in Sema context + // Sema stores types/decl contexts in IRGenContext maps; here we search storage_map_ by name + std::string name = ctx->Ident()->getText(); + for (auto& kv : storage_map_) { + // kv.first is VarDefContext*, try to get Ident text + if (kv.first && kv.first->Ident() && kv.first->Ident()->getText() == name) { + return static_cast( + builder_.CreateLoad(kv.second, module_.GetContext().NextTemp())); + } } - return static_cast( - builder_.CreateLoad(it->second, module_.GetContext().NextTemp())); + throw std::runtime_error(FormatError("irgen", "变量声明缺少存储槽位: " + name)); } -std::any IRGenImpl::visitAdditiveExp(SysYParser::AdditiveExpContext* ctx) { - if (!ctx || !ctx->exp(0) || !ctx->exp(1)) { - throw std::runtime_error(FormatError("irgen", "非法加法表达式")); - } - ir::Value* lhs = EvalExpr(*ctx->exp(0)); - ir::Value* rhs = EvalExpr(*ctx->exp(1)); +std::any IRGenImpl::visitAddExp(SysYParser::AddExpContext* ctx) { + if (!ctx) throw std::runtime_error(FormatError("irgen", "非法加法表达式")); + // left-associative: evaluate first two mulExp as a simple binary add + if (ctx->mulExp().size() == 1) return ctx->mulExp(0)->accept(this); + ir::Value* lhs = std::any_cast(ctx->mulExp(0)->accept(this)); + ir::Value* rhs = std::any_cast(ctx->mulExp(1)->accept(this)); return static_cast( builder_.CreateBinary(ir::Opcode::Add, lhs, rhs, module_.GetContext().NextTemp())); diff --git a/src/irgen/IRGenFunc.cpp b/src/irgen/IRGenFunc.cpp index 4912d03..8fb2764 100644 --- a/src/irgen/IRGenFunc.cpp +++ b/src/irgen/IRGenFunc.cpp @@ -21,7 +21,7 @@ void VerifyFunctionStructure(const ir::Function& func) { } // namespace -IRGenImpl::IRGenImpl(ir::Module& module, const SemanticContext& sema) +IRGenImpl::IRGenImpl(ir::Module& module, IRGenContext& sema) : module_(module), sema_(sema), func_(nullptr), @@ -38,11 +38,11 @@ std::any IRGenImpl::visitCompUnit(SysYParser::CompUnitContext* ctx) { if (!ctx) { throw std::runtime_error(FormatError("irgen", "缺少编译单元")); } - auto* func = ctx->funcDef(); - if (!func) { + // for simplicity take first function definition + if (ctx->funcDef().empty()) { throw std::runtime_error(FormatError("irgen", "缺少函数定义")); } - func->accept(this); + ctx->funcDef(0)->accept(this); return {}; } @@ -66,21 +66,21 @@ std::any IRGenImpl::visitFuncDef(SysYParser::FuncDefContext* ctx) { if (!ctx) { throw std::runtime_error(FormatError("irgen", "缺少函数定义")); } - if (!ctx->blockStmt()) { + if (!ctx->block()) { throw std::runtime_error(FormatError("irgen", "函数体为空")); } - if (!ctx->ID()) { + if (!ctx->Ident()) { throw std::runtime_error(FormatError("irgen", "缺少函数名")); } - if (!ctx->funcType() || !ctx->funcType()->INT()) { + if (!ctx->funcType() || ctx->funcType()->getText() != "int") { throw std::runtime_error(FormatError("irgen", "当前仅支持无参 int 函数")); } - func_ = module_.CreateFunction(ctx->ID()->getText(), ir::Type::GetInt32Type()); + func_ = module_.CreateFunction(ctx->Ident()->getText(), ir::Type::GetInt32Type()); builder_.SetInsertPoint(func_->GetEntry()); storage_map_.clear(); - ctx->blockStmt()->accept(this); + ctx->block()->accept(this); // 语义正确性主要由 sema 保证，这里只兜底检查 IR 结构是否合法。 VerifyFunctionStructure(*func_); return {}; diff --git a/src/irgen/IRGenStmt.cpp b/src/irgen/IRGenStmt.cpp index 751550c..eb44f9a 100644 --- a/src/irgen/IRGenStmt.cpp +++ b/src/irgen/IRGenStmt.cpp @@ -19,21 +19,16 @@ std::any IRGenImpl::visitStmt(SysYParser::StmtContext* ctx) { if (!ctx) { throw std::runtime_error(FormatError("irgen", "缺少语句")); } - if (ctx->returnStmt()) { - return ctx->returnStmt()->accept(this); + // stmt can be many forms; handle return specifically + if (!ctx->getText().empty() && ctx->getText().find("return") != std::string::npos) { + if (ctx->exp()) { + ir::Value* v = EvalExpr(*ctx->exp()); + builder_.CreateRet(v); + } else { + builder_.CreateRet(nullptr); + } + return BlockFlow::Terminated; } throw std::runtime_error(FormatError("irgen", "暂不支持的语句类型")); } - -std::any IRGenImpl::visitReturnStmt(SysYParser::ReturnStmtContext* ctx) { - if (!ctx) { - throw std::runtime_error(FormatError("irgen", "缺少 return 语句")); - } - if (!ctx->exp()) { - throw std::runtime_error(FormatError("irgen", "return 缺少表达式")); - } - ir::Value* v = EvalExpr(*ctx->exp()); - builder_.CreateRet(v); - return BlockFlow::Terminated; -} diff --git a/src/sem/Sema.cpp b/src/sem/Sema.cpp index 7403a13..d88c713 100644 --- a/src/sem/Sema.cpp +++ b/src/sem/Sema.cpp @@ -1,5 +1,5 @@ #include "../../include/sem/Sema.h" -#include "../../generated/antlr4/SysYParser.h" +#include "SysYParser.h" #include #include #include @@ -437,4 +437,10 @@ void RunSemanticAnalysis(SysYParser::CompUnitContext* ctx, IRGenContext& ir_ctx) } SemaVisitor visitor(ir_ctx); visitor.visit(ctx); +} + +IRGenContext RunSema(SysYParser::CompUnitContext& ctx) { + IRGenContext ctx_obj; + RunSemanticAnalysis(&ctx, ctx_obj); + return ctx_obj; } \ No newline at end of file