850 lines
25 KiB
C++
850 lines
25 KiB
C++
|
|
// Generated from SysY.g4 by ANTLR 4.12.0
|
|
|
|
#pragma once
|
|
|
|
|
|
#include "antlr4-runtime.h"
|
|
|
|
|
|
namespace antlrSysY {
|
|
|
|
|
|
class SysYParser : public antlr4::Parser {
|
|
public:
|
|
enum {
|
|
CONST_KW = 1, INT_KW = 2, VOID_KW = 3, IF_KW = 4, ELSE_KW = 5, WHILE_KW = 6,
|
|
BREAK_KW = 7, CONTINUE_KW = 8, RETURN_KW = 9, IDENT = 10, DECIMAL_CONST = 11,
|
|
OCTAL_CONST = 12, HEXADECIMAL_CONST = 13, STRING = 14, PLUS = 15, MINUS = 16,
|
|
NOT = 17, MUL = 18, DIV = 19, MOD = 20, ASSIGN = 21, EQ = 22, NEQ = 23,
|
|
LT = 24, GT = 25, LE = 26, GE = 27, AND = 28, OR = 29, L_PAREN = 30,
|
|
R_PAREN = 31, L_BRACE = 32, R_BRACE = 33, L_BRACKT = 34, R_BRACKT = 35,
|
|
COMMA = 36, SEMICOLON = 37, DOUBLE_QUOTE = 38, WS = 39, LINE_COMMENT = 40,
|
|
MULTILINE_COMMENT = 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, RuleAssignStmt = 17, RuleExpStmt = 18, RuleConditionStmt = 19,
|
|
RuleWhileStmt = 20, RuleBreakStmt = 21, RuleContinueStmt = 22, RuleReturnStmt = 23,
|
|
RuleExp = 24, RuleCond = 25, RuleLVal = 26, RulePrimaryExp = 27, RuleNumber = 28,
|
|
RuleIntConst = 29, RuleUnaryExp = 30, RuleCallee = 31, RuleUnaryOp = 32,
|
|
RuleFuncRParams = 33, RuleParam = 34, RuleMulExp = 35, RuleMulOp = 36,
|
|
RuleAddExp = 37, RuleAddOp = 38, RuleRelExp = 39, RuleRelOp = 40, RuleEqExp = 41,
|
|
RuleEqOp = 42, RuleLAndExp = 43, RuleLOrExp = 44, RuleConstExp = 45
|
|
};
|
|
|
|
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 AssignStmtContext;
|
|
class ExpStmtContext;
|
|
class ConditionStmtContext;
|
|
class WhileStmtContext;
|
|
class BreakStmtContext;
|
|
class ContinueStmtContext;
|
|
class ReturnStmtContext;
|
|
class ExpContext;
|
|
class CondContext;
|
|
class LValContext;
|
|
class PrimaryExpContext;
|
|
class NumberContext;
|
|
class IntConstContext;
|
|
class UnaryExpContext;
|
|
class CalleeContext;
|
|
class UnaryOpContext;
|
|
class FuncRParamsContext;
|
|
class ParamContext;
|
|
class MulExpContext;
|
|
class MulOpContext;
|
|
class AddExpContext;
|
|
class AddOpContext;
|
|
class RelExpContext;
|
|
class RelOpContext;
|
|
class EqExpContext;
|
|
class EqOpContext;
|
|
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_KW();
|
|
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_KW();
|
|
|
|
|
|
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 *> L_BRACKT();
|
|
antlr4::tree::TerminalNode* L_BRACKT(size_t i);
|
|
std::vector<ConstExpContext *> constExp();
|
|
ConstExpContext* constExp(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> R_BRACKT();
|
|
antlr4::tree::TerminalNode* R_BRACKT(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 *L_BRACE();
|
|
antlr4::tree::TerminalNode *R_BRACE();
|
|
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 *> L_BRACKT();
|
|
antlr4::tree::TerminalNode* L_BRACKT(size_t i);
|
|
std::vector<ConstExpContext *> constExp();
|
|
ConstExpContext* constExp(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> R_BRACKT();
|
|
antlr4::tree::TerminalNode* R_BRACKT(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 *L_BRACE();
|
|
antlr4::tree::TerminalNode *R_BRACE();
|
|
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 *L_PAREN();
|
|
antlr4::tree::TerminalNode *R_PAREN();
|
|
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_KW();
|
|
antlr4::tree::TerminalNode *INT_KW();
|
|
|
|
|
|
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 *> L_BRACKT();
|
|
antlr4::tree::TerminalNode* L_BRACKT(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> R_BRACKT();
|
|
antlr4::tree::TerminalNode* R_BRACKT(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 *L_BRACE();
|
|
antlr4::tree::TerminalNode *R_BRACE();
|
|
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;
|
|
ConstDeclContext *constDecl();
|
|
VarDeclContext *varDecl();
|
|
StmtContext *stmt();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
BlockItemContext* blockItem();
|
|
|
|
class StmtContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
StmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
AssignStmtContext *assignStmt();
|
|
ExpStmtContext *expStmt();
|
|
BlockContext *block();
|
|
ConditionStmtContext *conditionStmt();
|
|
WhileStmtContext *whileStmt();
|
|
BreakStmtContext *breakStmt();
|
|
ContinueStmtContext *continueStmt();
|
|
ReturnStmtContext *returnStmt();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
StmtContext* stmt();
|
|
|
|
class AssignStmtContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
AssignStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
LValContext *lVal();
|
|
antlr4::tree::TerminalNode *ASSIGN();
|
|
ExpContext *exp();
|
|
antlr4::tree::TerminalNode *SEMICOLON();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
AssignStmtContext* assignStmt();
|
|
|
|
class ExpStmtContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
ExpStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *SEMICOLON();
|
|
ExpContext *exp();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
ExpStmtContext* expStmt();
|
|
|
|
class ConditionStmtContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
ConditionStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *IF_KW();
|
|
antlr4::tree::TerminalNode *L_PAREN();
|
|
CondContext *cond();
|
|
antlr4::tree::TerminalNode *R_PAREN();
|
|
std::vector<StmtContext *> stmt();
|
|
StmtContext* stmt(size_t i);
|
|
antlr4::tree::TerminalNode *ELSE_KW();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
ConditionStmtContext* conditionStmt();
|
|
|
|
class WhileStmtContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
WhileStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *WHILE_KW();
|
|
antlr4::tree::TerminalNode *L_PAREN();
|
|
CondContext *cond();
|
|
antlr4::tree::TerminalNode *R_PAREN();
|
|
StmtContext *stmt();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
WhileStmtContext* whileStmt();
|
|
|
|
class BreakStmtContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
BreakStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *BREAK_KW();
|
|
antlr4::tree::TerminalNode *SEMICOLON();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
BreakStmtContext* breakStmt();
|
|
|
|
class ContinueStmtContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
ContinueStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *CONTINUE_KW();
|
|
antlr4::tree::TerminalNode *SEMICOLON();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
ContinueStmtContext* continueStmt();
|
|
|
|
class ReturnStmtContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
ReturnStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *RETURN_KW();
|
|
antlr4::tree::TerminalNode *SEMICOLON();
|
|
ExpContext *exp();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
ReturnStmtContext* returnStmt();
|
|
|
|
class ExpContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
ExpContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
AddExpContext *addExp();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
ExpContext* exp();
|
|
|
|
class CondContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
CondContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
LOrExpContext *lOrExp();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
CondContext* cond();
|
|
|
|
class 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 *> L_BRACKT();
|
|
antlr4::tree::TerminalNode* L_BRACKT(size_t i);
|
|
std::vector<ExpContext *> exp();
|
|
ExpContext* exp(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> R_BRACKT();
|
|
antlr4::tree::TerminalNode* R_BRACKT(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 *L_PAREN();
|
|
ExpContext *exp();
|
|
antlr4::tree::TerminalNode *R_PAREN();
|
|
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();
|
|
CalleeContext *callee();
|
|
UnaryOpContext *unaryOp();
|
|
UnaryExpContext *unaryExp();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
UnaryExpContext* unaryExp();
|
|
|
|
class CalleeContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
CalleeContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *IDENT();
|
|
antlr4::tree::TerminalNode *L_PAREN();
|
|
antlr4::tree::TerminalNode *R_PAREN();
|
|
FuncRParamsContext *funcRParams();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
CalleeContext* callee();
|
|
|
|
class UnaryOpContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
UnaryOpContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *PLUS();
|
|
antlr4::tree::TerminalNode *MINUS();
|
|
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<ParamContext *> param();
|
|
ParamContext* param(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 ParamContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
ParamContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
ExpContext *exp();
|
|
antlr4::tree::TerminalNode *STRING();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
ParamContext* param();
|
|
|
|
class MulExpContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
MulExpContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
std::vector<UnaryExpContext *> unaryExp();
|
|
UnaryExpContext* unaryExp(size_t i);
|
|
std::vector<MulOpContext *> mulOp();
|
|
MulOpContext* mulOp(size_t i);
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
MulExpContext* mulExp();
|
|
|
|
class MulOpContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
MulOpContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *MUL();
|
|
antlr4::tree::TerminalNode *DIV();
|
|
antlr4::tree::TerminalNode *MOD();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
MulOpContext* mulOp();
|
|
|
|
class AddExpContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
AddExpContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
std::vector<MulExpContext *> mulExp();
|
|
MulExpContext* mulExp(size_t i);
|
|
std::vector<AddOpContext *> addOp();
|
|
AddOpContext* addOp(size_t i);
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
AddExpContext* addExp();
|
|
|
|
class AddOpContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
AddOpContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *PLUS();
|
|
antlr4::tree::TerminalNode *MINUS();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
AddOpContext* addOp();
|
|
|
|
class RelExpContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
RelExpContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
std::vector<AddExpContext *> addExp();
|
|
AddExpContext* addExp(size_t i);
|
|
std::vector<RelOpContext *> relOp();
|
|
RelOpContext* relOp(size_t i);
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
RelExpContext* relExp();
|
|
|
|
class RelOpContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
RelOpContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
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;
|
|
|
|
};
|
|
|
|
RelOpContext* relOp();
|
|
|
|
class EqExpContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
EqExpContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
std::vector<RelExpContext *> relExp();
|
|
RelExpContext* relExp(size_t i);
|
|
std::vector<EqOpContext *> eqOp();
|
|
EqOpContext* eqOp(size_t i);
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
EqExpContext* eqExp();
|
|
|
|
class EqOpContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
EqOpContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *EQ();
|
|
antlr4::tree::TerminalNode *NEQ();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
EqOpContext* eqOp();
|
|
|
|
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);
|
|
|
|
|
|
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);
|
|
|
|
|
|
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();
|
|
|
|
|
|
// 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 antlrSysY
|