809 lines
24 KiB
C++
809 lines
24 KiB
C++
|
|
// Generated from SysY.g4 by ANTLR 4.13.2
|
|
|
|
#pragma once
|
|
|
|
|
|
#include "antlr4-runtime.h"
|
|
|
|
|
|
|
|
|
|
class SysYParser : public antlr4::Parser {
|
|
public:
|
|
enum {
|
|
CONST = 1, INT = 2, FLOAT = 3, VOID = 4, IF = 5, ELSE = 6, WHILE = 7,
|
|
BREAK = 8, CONTINUE = 9, RETURN = 10, ADD = 11, SUB = 12, MUL = 13,
|
|
DIV = 14, MOD = 15, EQ = 16, NE = 17, LT = 18, LE = 19, GT = 20, GE = 21,
|
|
AND = 22, OR = 23, NOT = 24, ASSIGN = 25, COMMA = 26, SEMICOLON = 27,
|
|
LPAREN = 28, RPAREN = 29, LBRACE = 30, RBRACE = 31, LBRACK = 32, RBRACK = 33,
|
|
Ident = 34, ILITERAL = 35, FLITERAL = 36, STRING = 37, WS = 38, LINECOMMENT = 39,
|
|
BLOCKCOMMENT = 40
|
|
};
|
|
|
|
enum {
|
|
RuleCompUnit = 0, RuleGlobalDecl = 1, RuleDecl = 2, RuleConstDecl = 3,
|
|
RuleBType = 4, RuleConstDef = 5, RuleConstInitVal = 6, RuleVarDecl = 7,
|
|
RuleVarDef = 8, RuleInitVal = 9, RuleFuncType = 10, RuleFuncDef = 11,
|
|
RuleFuncFParams = 12, RuleFuncFParam = 13, RuleBlockStmt = 14, RuleBlockItem = 15,
|
|
RuleStmt = 16, RuleExp = 17, RuleCond = 18, RuleLValue = 19, RulePrimaryExp = 20,
|
|
RuleNumber = 21, RuleCall = 22, RuleUnaryExp = 23, RuleUnaryOp = 24,
|
|
RuleFuncRParams = 25, RuleString = 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 CompUnitContext;
|
|
class GlobalDeclContext;
|
|
class DeclContext;
|
|
class ConstDeclContext;
|
|
class BTypeContext;
|
|
class ConstDefContext;
|
|
class ConstInitValContext;
|
|
class VarDeclContext;
|
|
class VarDefContext;
|
|
class InitValContext;
|
|
class FuncTypeContext;
|
|
class FuncDefContext;
|
|
class FuncFParamsContext;
|
|
class FuncFParamContext;
|
|
class BlockStmtContext;
|
|
class BlockItemContext;
|
|
class StmtContext;
|
|
class ExpContext;
|
|
class CondContext;
|
|
class LValueContext;
|
|
class PrimaryExpContext;
|
|
class NumberContext;
|
|
class CallContext;
|
|
class UnaryExpContext;
|
|
class UnaryOpContext;
|
|
class FuncRParamsContext;
|
|
class StringContext;
|
|
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<GlobalDeclContext *> globalDecl();
|
|
GlobalDeclContext* globalDecl(size_t i);
|
|
std::vector<FuncDefContext *> funcDef();
|
|
FuncDefContext* funcDef(size_t i);
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
CompUnitContext* compUnit();
|
|
|
|
class GlobalDeclContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
GlobalDeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
|
|
GlobalDeclContext() = default;
|
|
void copyFrom(GlobalDeclContext *context);
|
|
using antlr4::ParserRuleContext::copyFrom;
|
|
|
|
virtual size_t getRuleIndex() const override;
|
|
|
|
|
|
};
|
|
|
|
class GlobalConstDeclContext : public GlobalDeclContext {
|
|
public:
|
|
GlobalConstDeclContext(GlobalDeclContext *ctx);
|
|
|
|
ConstDeclContext *constDecl();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class GlobalVarDeclContext : public GlobalDeclContext {
|
|
public:
|
|
GlobalVarDeclContext(GlobalDeclContext *ctx);
|
|
|
|
VarDeclContext *varDecl();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
GlobalDeclContext* globalDecl();
|
|
|
|
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();
|
|
antlr4::tree::TerminalNode *FLOAT();
|
|
|
|
|
|
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 *> LBRACK();
|
|
antlr4::tree::TerminalNode* LBRACK(size_t i);
|
|
std::vector<ConstExpContext *> constExp();
|
|
ConstExpContext* constExp(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> RBRACK();
|
|
antlr4::tree::TerminalNode* RBRACK(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);
|
|
|
|
ConstInitValContext() = default;
|
|
void copyFrom(ConstInitValContext *context);
|
|
using antlr4::ParserRuleContext::copyFrom;
|
|
|
|
virtual size_t getRuleIndex() const override;
|
|
|
|
|
|
};
|
|
|
|
class ConstScalarInitValueContext : public ConstInitValContext {
|
|
public:
|
|
ConstScalarInitValueContext(ConstInitValContext *ctx);
|
|
|
|
ConstExpContext *constExp();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ConstArrayInitValueContext : public ConstInitValContext {
|
|
public:
|
|
ConstArrayInitValueContext(ConstInitValContext *ctx);
|
|
|
|
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 *> LBRACK();
|
|
antlr4::tree::TerminalNode* LBRACK(size_t i);
|
|
std::vector<ConstExpContext *> constExp();
|
|
ConstExpContext* constExp(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> RBRACK();
|
|
antlr4::tree::TerminalNode* RBRACK(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);
|
|
|
|
InitValContext() = default;
|
|
void copyFrom(InitValContext *context);
|
|
using antlr4::ParserRuleContext::copyFrom;
|
|
|
|
virtual size_t getRuleIndex() const override;
|
|
|
|
|
|
};
|
|
|
|
class ArrayInitValueContext : public InitValContext {
|
|
public:
|
|
ArrayInitValueContext(InitValContext *ctx);
|
|
|
|
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;
|
|
};
|
|
|
|
class ScalarInitValueContext : public InitValContext {
|
|
public:
|
|
ScalarInitValueContext(InitValContext *ctx);
|
|
|
|
ExpContext *exp();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
InitValContext* initVal();
|
|
|
|
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();
|
|
antlr4::tree::TerminalNode *FLOAT();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
FuncTypeContext* funcType();
|
|
|
|
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();
|
|
BlockStmtContext *blockStmt();
|
|
FuncFParamsContext *funcFParams();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
FuncDefContext* funcDef();
|
|
|
|
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 *> LBRACK();
|
|
antlr4::tree::TerminalNode* LBRACK(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> RBRACK();
|
|
antlr4::tree::TerminalNode* RBRACK(size_t i);
|
|
std::vector<ExpContext *> exp();
|
|
ExpContext* exp(size_t i);
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
FuncFParamContext* funcFParam();
|
|
|
|
class BlockStmtContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
BlockStmtContext(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;
|
|
|
|
};
|
|
|
|
BlockStmtContext* blockStmt();
|
|
|
|
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 BlkStmtContext : public StmtContext {
|
|
public:
|
|
BlkStmtContext(StmtContext *ctx);
|
|
|
|
BlockStmtContext *blockStmt();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) 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 AssignStmtContext : public StmtContext {
|
|
public:
|
|
AssignStmtContext(StmtContext *ctx);
|
|
|
|
LValueContext *lValue();
|
|
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 LValueContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
LValueContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *Ident();
|
|
std::vector<antlr4::tree::TerminalNode *> LBRACK();
|
|
antlr4::tree::TerminalNode* LBRACK(size_t i);
|
|
std::vector<ExpContext *> exp();
|
|
ExpContext* exp(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> RBRACK();
|
|
antlr4::tree::TerminalNode* RBRACK(size_t i);
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
LValueContext* lValue();
|
|
|
|
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();
|
|
LValueContext *lValue();
|
|
NumberContext *number();
|
|
StringContext *string();
|
|
|
|
|
|
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;
|
|
antlr4::tree::TerminalNode *ILITERAL();
|
|
antlr4::tree::TerminalNode *FLITERAL();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
NumberContext* number();
|
|
|
|
class CallContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
CallContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *Ident();
|
|
antlr4::tree::TerminalNode *LPAREN();
|
|
antlr4::tree::TerminalNode *RPAREN();
|
|
FuncRParamsContext *funcRParams();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
CallContext* call();
|
|
|
|
class UnaryExpContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
UnaryExpContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
PrimaryExpContext *primaryExp();
|
|
CallContext *call();
|
|
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<ExpContext *> exp();
|
|
ExpContext* exp(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 StringContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
StringContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *STRING();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
StringContext* string();
|
|
|
|
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<antlr4::tree::TerminalNode *> MUL();
|
|
antlr4::tree::TerminalNode* MUL(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> DIV();
|
|
antlr4::tree::TerminalNode* DIV(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> MOD();
|
|
antlr4::tree::TerminalNode* MOD(size_t i);
|
|
|
|
|
|
virtual std::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<MulExpContext *> mulExp();
|
|
MulExpContext* mulExp(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> ADD();
|
|
antlr4::tree::TerminalNode* ADD(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> SUB();
|
|
antlr4::tree::TerminalNode* SUB(size_t i);
|
|
|
|
|
|
virtual std::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<AddExpContext *> addExp();
|
|
AddExpContext* addExp(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> LT();
|
|
antlr4::tree::TerminalNode* LT(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> GT();
|
|
antlr4::tree::TerminalNode* GT(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> LE();
|
|
antlr4::tree::TerminalNode* LE(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> GE();
|
|
antlr4::tree::TerminalNode* GE(size_t i);
|
|
|
|
|
|
virtual std::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<RelExpContext *> relExp();
|
|
RelExpContext* relExp(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> EQ();
|
|
antlr4::tree::TerminalNode* EQ(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> NE();
|
|
antlr4::tree::TerminalNode* NE(size_t i);
|
|
|
|
|
|
virtual std::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<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:
|
|
};
|
|
|