668 lines
19 KiB
C++
668 lines
19 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 {
|
|
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,
|
|
IDENT = 33, DECIMAL_CONST = 34, OCTAL_CONST = 35, HEXADECIMAL_CONST = 36,
|
|
WS = 37, SINGLELINE_COMMENT = 38, MULTILINE_COMMENT = 39, StringLiteral = 40
|
|
};
|
|
|
|
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;
|
|
BTypeContext *bType();
|
|
std::vector<ConstDefContext *> constDef();
|
|
ConstDefContext* constDef(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;
|
|
|
|
|
|
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();
|
|
ConstInitValContext *constInitVal();
|
|
std::vector<ConstExpContext *> constExp();
|
|
ConstExpContext* constExp(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();
|
|
std::vector<ConstInitValContext *> constInitVal();
|
|
ConstInitValContext* constInitVal(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);
|
|
|
|
|
|
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<ConstExpContext *> constExp();
|
|
ConstExpContext* constExp(size_t i);
|
|
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();
|
|
std::vector<InitValContext *> initVal();
|
|
InitValContext* initVal(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();
|
|
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;
|
|
|
|
|
|
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);
|
|
|
|
|
|
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<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;
|
|
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);
|
|
|
|
CondContext *cond();
|
|
StmtContext *stmt();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class IfStmtContext : public StmtContext {
|
|
public:
|
|
IfStmtContext(StmtContext *ctx);
|
|
|
|
CondContext *cond();
|
|
std::vector<StmtContext *> stmt();
|
|
StmtContext* stmt(size_t i);
|
|
|
|
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();
|
|
ExpContext *exp();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class BreakStmtContext : public StmtContext {
|
|
public:
|
|
BreakStmtContext(StmtContext *ctx);
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ExpStmtContext : public StmtContext {
|
|
public:
|
|
ExpStmtContext(StmtContext *ctx);
|
|
|
|
ExpContext *exp();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ReturnStmtContext : public StmtContext {
|
|
public:
|
|
ReturnStmtContext(StmtContext *ctx);
|
|
|
|
ExpContext *exp();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ContinueStmtContext : public StmtContext {
|
|
public:
|
|
ContinueStmtContext(StmtContext *ctx);
|
|
|
|
|
|
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<ExpContext *> exp();
|
|
ExpContext* exp(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;
|
|
ExpContext *exp();
|
|
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();
|
|
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;
|
|
|
|
|
|
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);
|
|
|
|
|
|
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();
|
|
|
|
|
|
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();
|
|
|
|
|
|
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();
|
|
|
|
|
|
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();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
EqExpContext* eqExp();
|
|
EqExpContext* eqExp(int precedence);
|
|
class LAndExpContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
LAndExpContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
EqExpContext *eqExp();
|
|
LAndExpContext *lAndExp();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
LAndExpContext* lAndExp();
|
|
LAndExpContext* lAndExp(int precedence);
|
|
class LOrExpContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
LOrExpContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
LAndExpContext *lAndExp();
|
|
LOrExpContext *lOrExp();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
LOrExpContext* lOrExp();
|
|
LOrExpContext* lOrExp(int precedence);
|
|
class ConstExpContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
ConstExpContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
AddExpContext *addExp();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
ConstExpContext* constExp();
|
|
|
|
|
|
bool sempred(antlr4::RuleContext *_localctx, size_t ruleIndex, size_t predicateIndex) override;
|
|
|
|
bool mulExpSempred(MulExpContext *_localctx, size_t predicateIndex);
|
|
bool addExpSempred(AddExpContext *_localctx, size_t predicateIndex);
|
|
bool relExpSempred(RelExpContext *_localctx, size_t predicateIndex);
|
|
bool eqExpSempred(EqExpContext *_localctx, size_t predicateIndex);
|
|
bool lAndExpSempred(LAndExpContext *_localctx, size_t predicateIndex);
|
|
bool lOrExpSempred(LOrExpContext *_localctx, size_t predicateIndex);
|
|
|
|
// By default the static state used to implement the parser is lazily initialized during the first
|
|
// call to the constructor. You can call this function if you wish to initialize the static state
|
|
// ahead of time.
|
|
static void initialize();
|
|
|
|
private:
|
|
};
|
|
|
|
} // namespace antlrSysY
|