754 lines
22 KiB
C++
754 lines
22 KiB
C++
|
|
// Generated from Sysy.g4 by ANTLR 4.12.0
|
|
|
|
#pragma once
|
|
|
|
|
|
#include "antlr4-runtime.h"
|
|
#include "llir_value.h"
|
|
#include <memory>
|
|
|
|
|
|
namespace CompSysY {
|
|
|
|
|
|
class SysyParser : public antlr4::Parser {
|
|
public:
|
|
enum {
|
|
CONST = 1, COMMA = 2, SEMICOLON = 3, INT = 4, LBRACKET = 5, RBRACKET = 6,
|
|
ASSIGN = 7, LBRACE = 8, RBRACE = 9, LPAREN = 10, RPAREN = 11, VOID = 12,
|
|
IF = 13, ELSE = 14, WHILE = 15, BREAK = 16, CONTINUE = 17, RETURN = 18,
|
|
ADD = 19, SUB = 20, NOT = 21, MUL = 22, DIV = 23, MOD = 24, LT = 25,
|
|
GT = 26, LE = 27, GE = 28, EQ = 29, NE = 30, AND = 31, OR = 32, DQUOTE = 33,
|
|
IDENT = 34, DECIMAL_CONST = 35, OCTAL_CONST = 36, HEXADECIMAL_CONST = 37,
|
|
WS = 38, SINGLELINE_COMMENT = 39, MULTILINE_COMMENT = 40, StringLiteral = 41
|
|
};
|
|
|
|
enum {
|
|
RuleProgram = 0, RuleCompUnit = 1, RuleDecl = 2, RuleConstDecl = 3,
|
|
RuleBType = 4, RuleConstDef = 5, RuleConstInitVal = 6, RuleVarDecl = 7,
|
|
RuleVarDef = 8, RuleInitVal = 9, RuleFuncDef = 10, RuleFuncType = 11,
|
|
RuleFuncFParams = 12, RuleFuncFParam = 13, RuleBlock = 14, RuleBlockItem = 15,
|
|
RuleStmt = 16, RuleExp = 17, RuleCond = 18, RuleLVal = 19, RulePrimaryExp = 20,
|
|
RuleNumber = 21, RuleIntConst = 22, RuleUnaryExp = 23, RuleUnaryOp = 24,
|
|
RuleFuncRParams = 25, RuleFuncRParam = 26, RuleMulExp = 27, RuleAddExp = 28,
|
|
RuleRelExp = 29, RuleEqExp = 30, RuleLAndExp = 31, RuleLOrExp = 32,
|
|
RuleConstExp = 33
|
|
};
|
|
|
|
explicit SysyParser(antlr4::TokenStream *input);
|
|
|
|
SysyParser(antlr4::TokenStream *input, const antlr4::atn::ParserATNSimulatorOptions &options);
|
|
|
|
~SysyParser() override;
|
|
|
|
std::string getGrammarFileName() const override;
|
|
|
|
const antlr4::atn::ATN& getATN() const override;
|
|
|
|
const std::vector<std::string>& getRuleNames() const override;
|
|
|
|
const antlr4::dfa::Vocabulary& getVocabulary() const override;
|
|
|
|
antlr4::atn::SerializedATNView getSerializedATN() const override;
|
|
|
|
|
|
class ProgramContext;
|
|
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 IntConstContext;
|
|
class UnaryExpContext;
|
|
class UnaryOpContext;
|
|
class FuncRParamsContext;
|
|
class FuncRParamContext;
|
|
class MulExpContext;
|
|
class AddExpContext;
|
|
class RelExpContext;
|
|
class EqExpContext;
|
|
class LAndExpContext;
|
|
class LOrExpContext;
|
|
class ConstExpContext;
|
|
|
|
class ProgramContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
ProgramContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
CompUnitContext *compUnit();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
ProgramContext* program();
|
|
|
|
class CompUnitContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
CompUnitContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
std::vector<FuncDefContext *> funcDef();
|
|
FuncDefContext* funcDef(size_t i);
|
|
std::vector<DeclContext *> decl();
|
|
DeclContext* decl(size_t i);
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
CompUnitContext* compUnit();
|
|
|
|
class DeclContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
ConstDeclContext *constDecl();
|
|
VarDeclContext *varDecl();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
DeclContext* decl();
|
|
|
|
class ConstDeclContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
ConstDeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *CONST();
|
|
BTypeContext *bType();
|
|
std::vector<ConstDefContext *> constDef();
|
|
ConstDefContext* constDef(size_t i);
|
|
antlr4::tree::TerminalNode *SEMICOLON();
|
|
std::vector<antlr4::tree::TerminalNode *> COMMA();
|
|
antlr4::tree::TerminalNode* COMMA(size_t i);
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
ConstDeclContext* constDecl();
|
|
|
|
class BTypeContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
BTypeContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *INT();
|
|
|
|
|
|
virtual std::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();
|
|
antlr4::tree::TerminalNode *ASSIGN();
|
|
ConstInitValContext *constInitVal();
|
|
std::vector<antlr4::tree::TerminalNode *> LBRACKET();
|
|
antlr4::tree::TerminalNode* LBRACKET(size_t i);
|
|
std::vector<ConstExpContext *> constExp();
|
|
ConstExpContext* constExp(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> RBRACKET();
|
|
antlr4::tree::TerminalNode* RBRACKET(size_t i);
|
|
|
|
|
|
virtual std::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();
|
|
antlr4::tree::TerminalNode *LBRACE();
|
|
antlr4::tree::TerminalNode *RBRACE();
|
|
std::vector<ConstInitValContext *> constInitVal();
|
|
ConstInitValContext* constInitVal(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> COMMA();
|
|
antlr4::tree::TerminalNode* COMMA(size_t i);
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
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<VarDefContext *> varDef();
|
|
VarDefContext* varDef(size_t i);
|
|
antlr4::tree::TerminalNode *SEMICOLON();
|
|
std::vector<antlr4::tree::TerminalNode *> COMMA();
|
|
antlr4::tree::TerminalNode* COMMA(size_t i);
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
VarDeclContext* varDecl();
|
|
|
|
class VarDefContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
VarDefContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *IDENT();
|
|
std::vector<antlr4::tree::TerminalNode *> LBRACKET();
|
|
antlr4::tree::TerminalNode* LBRACKET(size_t i);
|
|
std::vector<ConstExpContext *> constExp();
|
|
ConstExpContext* constExp(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> RBRACKET();
|
|
antlr4::tree::TerminalNode* RBRACKET(size_t i);
|
|
antlr4::tree::TerminalNode *ASSIGN();
|
|
InitValContext *initVal();
|
|
|
|
|
|
virtual std::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();
|
|
antlr4::tree::TerminalNode *LBRACE();
|
|
antlr4::tree::TerminalNode *RBRACE();
|
|
std::vector<InitValContext *> initVal();
|
|
InitValContext* initVal(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> COMMA();
|
|
antlr4::tree::TerminalNode* COMMA(size_t i);
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
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();
|
|
antlr4::tree::TerminalNode *LPAREN();
|
|
antlr4::tree::TerminalNode *RPAREN();
|
|
BlockContext *block();
|
|
FuncFParamsContext *funcFParams();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
FuncDefContext* funcDef();
|
|
|
|
class FuncTypeContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
FuncTypeContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *VOID();
|
|
antlr4::tree::TerminalNode *INT();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
FuncTypeContext* funcType();
|
|
|
|
class FuncFParamsContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
FuncFParamsContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
std::vector<FuncFParamContext *> funcFParam();
|
|
FuncFParamContext* funcFParam(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> COMMA();
|
|
antlr4::tree::TerminalNode* COMMA(size_t i);
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
FuncFParamsContext* funcFParams();
|
|
|
|
class FuncFParamContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
FuncFParamContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
BTypeContext *bType();
|
|
antlr4::tree::TerminalNode *IDENT();
|
|
std::vector<antlr4::tree::TerminalNode *> LBRACKET();
|
|
antlr4::tree::TerminalNode* LBRACKET(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> RBRACKET();
|
|
antlr4::tree::TerminalNode* RBRACKET(size_t i);
|
|
std::vector<ExpContext *> exp();
|
|
ExpContext* exp(size_t i);
|
|
|
|
|
|
virtual std::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;
|
|
antlr4::tree::TerminalNode *LBRACE();
|
|
antlr4::tree::TerminalNode *RBRACE();
|
|
std::vector<BlockItemContext *> blockItem();
|
|
BlockItemContext* blockItem(size_t i);
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
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 std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
BlockItemContext* blockItem();
|
|
|
|
class StmtContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
StmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
|
|
StmtContext() = default;
|
|
void copyFrom(StmtContext *context);
|
|
using antlr4::ParserRuleContext::copyFrom;
|
|
|
|
virtual size_t getRuleIndex() const override;
|
|
|
|
|
|
};
|
|
|
|
class WhileStmtContext : public StmtContext {
|
|
public:
|
|
WhileStmtContext(StmtContext *ctx);
|
|
|
|
antlr4::tree::TerminalNode *WHILE();
|
|
antlr4::tree::TerminalNode *LPAREN();
|
|
CondContext *cond();
|
|
antlr4::tree::TerminalNode *RPAREN();
|
|
StmtContext *stmt();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class IfStmtContext : public StmtContext {
|
|
public:
|
|
IfStmtContext(StmtContext *ctx);
|
|
|
|
antlr4::tree::TerminalNode *IF();
|
|
antlr4::tree::TerminalNode *LPAREN();
|
|
CondContext *cond();
|
|
antlr4::tree::TerminalNode *RPAREN();
|
|
std::vector<StmtContext *> stmt();
|
|
StmtContext* stmt(size_t i);
|
|
antlr4::tree::TerminalNode *ELSE();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class BlockStmtContext : public StmtContext {
|
|
public:
|
|
BlockStmtContext(StmtContext *ctx);
|
|
|
|
BlockContext *block();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class AssignStmtContext : public StmtContext {
|
|
public:
|
|
AssignStmtContext(StmtContext *ctx);
|
|
|
|
LValContext *lVal();
|
|
antlr4::tree::TerminalNode *ASSIGN();
|
|
ExpContext *exp();
|
|
antlr4::tree::TerminalNode *SEMICOLON();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class BreakStmtContext : public StmtContext {
|
|
public:
|
|
BreakStmtContext(StmtContext *ctx);
|
|
|
|
antlr4::tree::TerminalNode *BREAK();
|
|
antlr4::tree::TerminalNode *SEMICOLON();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ExpStmtContext : public StmtContext {
|
|
public:
|
|
ExpStmtContext(StmtContext *ctx);
|
|
|
|
antlr4::tree::TerminalNode *SEMICOLON();
|
|
ExpContext *exp();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ReturnStmtContext : public StmtContext {
|
|
public:
|
|
ReturnStmtContext(StmtContext *ctx);
|
|
|
|
antlr4::tree::TerminalNode *RETURN();
|
|
antlr4::tree::TerminalNode *SEMICOLON();
|
|
ExpContext *exp();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ContinueStmtContext : public StmtContext {
|
|
public:
|
|
ContinueStmtContext(StmtContext *ctx);
|
|
|
|
antlr4::tree::TerminalNode *CONTINUE();
|
|
antlr4::tree::TerminalNode *SEMICOLON();
|
|
|
|
virtual std::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 std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
ExpContext* exp();
|
|
|
|
class CondContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
CondContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
LOrExpContext *lOrExp();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
CondContext* cond();
|
|
|
|
class LValContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
LValContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *IDENT();
|
|
std::vector<antlr4::tree::TerminalNode *> LBRACKET();
|
|
antlr4::tree::TerminalNode* LBRACKET(size_t i);
|
|
std::vector<ExpContext *> exp();
|
|
ExpContext* exp(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> RBRACKET();
|
|
antlr4::tree::TerminalNode* RBRACKET(size_t i);
|
|
|
|
|
|
virtual std::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;
|
|
antlr4::tree::TerminalNode *LPAREN();
|
|
ExpContext *exp();
|
|
antlr4::tree::TerminalNode *RPAREN();
|
|
LValContext *lVal();
|
|
NumberContext *number();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
PrimaryExpContext* primaryExp();
|
|
|
|
class NumberContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
NumberContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
IntConstContext *intConst();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
NumberContext* number();
|
|
|
|
class IntConstContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
IntConstContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *DECIMAL_CONST();
|
|
antlr4::tree::TerminalNode *OCTAL_CONST();
|
|
antlr4::tree::TerminalNode *HEXADECIMAL_CONST();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
IntConstContext* intConst();
|
|
|
|
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();
|
|
antlr4::tree::TerminalNode *LPAREN();
|
|
antlr4::tree::TerminalNode *RPAREN();
|
|
FuncRParamsContext *funcRParams();
|
|
UnaryOpContext *unaryOp();
|
|
UnaryExpContext *unaryExp();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
UnaryExpContext* unaryExp();
|
|
|
|
class UnaryOpContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
UnaryOpContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *ADD();
|
|
antlr4::tree::TerminalNode *SUB();
|
|
antlr4::tree::TerminalNode *NOT();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
UnaryOpContext* unaryOp();
|
|
|
|
class FuncRParamsContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
FuncRParamsContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
std::vector<FuncRParamContext *> funcRParam();
|
|
FuncRParamContext* funcRParam(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> COMMA();
|
|
antlr4::tree::TerminalNode* COMMA(size_t i);
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
FuncRParamsContext* funcRParams();
|
|
|
|
class FuncRParamContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
FuncRParamContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
ExpContext *exp();
|
|
antlr4::tree::TerminalNode *StringLiteral();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
FuncRParamContext* funcRParam();
|
|
|
|
class MulExpContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
MulExpContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
UnaryExpContext *unaryExp();
|
|
MulExpContext *mulExp();
|
|
antlr4::tree::TerminalNode *MUL();
|
|
antlr4::tree::TerminalNode *DIV();
|
|
antlr4::tree::TerminalNode *MOD();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
MulExpContext* mulExp();
|
|
MulExpContext* mulExp(int precedence);
|
|
class AddExpContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
AddExpContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
MulExpContext *mulExp();
|
|
AddExpContext *addExp();
|
|
antlr4::tree::TerminalNode *ADD();
|
|
antlr4::tree::TerminalNode *SUB();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
AddExpContext* addExp();
|
|
AddExpContext* addExp(int precedence);
|
|
class RelExpContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
RelExpContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
AddExpContext *addExp();
|
|
RelExpContext *relExp();
|
|
antlr4::tree::TerminalNode *LT();
|
|
antlr4::tree::TerminalNode *GT();
|
|
antlr4::tree::TerminalNode *LE();
|
|
antlr4::tree::TerminalNode *GE();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
RelExpContext* relExp();
|
|
RelExpContext* relExp(int precedence);
|
|
class EqExpContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
EqExpContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
RelExpContext *relExp();
|
|
EqExpContext *eqExp();
|
|
antlr4::tree::TerminalNode *EQ();
|
|
antlr4::tree::TerminalNode *NE();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
EqExpContext* eqExp();
|
|
EqExpContext* eqExp(int precedence);
|
|
class LAndExpContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
LAndExpContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
std::vector<EqExpContext *> eqExp();
|
|
EqExpContext* eqExp(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> AND();
|
|
antlr4::tree::TerminalNode* AND(size_t i);
|
|
|
|
BasicBlockPtr_t true_block;
|
|
BasicBlockPtr_t false_block;
|
|
|
|
virtual std::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<LAndExpContext *> lAndExp();
|
|
LAndExpContext* lAndExp(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> OR();
|
|
antlr4::tree::TerminalNode* OR(size_t i);
|
|
|
|
BasicBlockPtr_t true_block;
|
|
BasicBlockPtr_t false_block;
|
|
|
|
virtual std::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 std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
ConstExpContext* constExp();
|
|
|
|
|
|
bool sempred(antlr4::RuleContext *_localctx, size_t ruleIndex, size_t predicateIndex) override;
|
|
|
|
bool mulExpSempred(MulExpContext *_localctx, size_t predicateIndex);
|
|
bool addExpSempred(AddExpContext *_localctx, size_t predicateIndex);
|
|
bool relExpSempred(RelExpContext *_localctx, size_t predicateIndex);
|
|
bool eqExpSempred(EqExpContext *_localctx, size_t predicateIndex);
|
|
|
|
// By default the static state used to implement the parser is lazily initialized during the first
|
|
// call to the constructor. You can call this function if you wish to initialize the static state
|
|
// ahead of time.
|
|
static void initialize();
|
|
|
|
private:
|
|
};
|
|
|
|
} // namespace CompSysY
|