diff options
| author | Patrick Schönberger | 2021-07-28 09:07:53 +0200 |
|---|---|---|
| committer | Patrick Schönberger | 2021-07-28 09:07:53 +0200 |
| commit | 45409c781a9e35df68c43b1e2f028d30bf90c0a0 (patch) | |
| tree | 0085614e19fdc136f664568e89f1686332ba8850 /gen/TocParser.h | |
| download | toc-45409c781a9e35df68c43b1e2f028d30bf90c0a0.tar.gz toc-45409c781a9e35df68c43b1e2f028d30bf90c0a0.zip | |
Initial commit
Diffstat (limited to 'gen/TocParser.h')
| -rw-r--r-- | gen/TocParser.h | 625 |
1 files changed, 625 insertions, 0 deletions
diff --git a/gen/TocParser.h b/gen/TocParser.h new file mode 100644 index 0000000..6dc941c --- /dev/null +++ b/gen/TocParser.h @@ -0,0 +1,625 @@ +
+// Generated from Toc.g4 by ANTLR 4.9.2
+
+#pragma once
+
+
+#include "antlr4-runtime.h"
+
+
+
+
+class TocParser : 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, BINARY_OPERATOR = 17, INTLIT = 18, NAME = 19,
+ WS = 20, NEWLINE = 21
+ };
+
+ enum {
+ RuleProg = 0, RuleDecl = 1, RuleVarDecl = 2, RuleVar = 3, RuleType = 4,
+ RuleFuncDecl = 5, RuleFunc = 6, RuleParameter = 7, RuleFirstParameter = 8,
+ RuleAdditionalParameter = 9, RuleBody = 10, RuleStructDecl = 11, RuleStructMember = 12,
+ RuleStructVar = 13, RuleStructMethod = 14, RuleStmt = 15, RuleConditional = 16,
+ RuleIfCond = 17, RuleLoop = 18, RuleWhileLoop = 19, RuleAssignment = 20,
+ RuleReturnStmt = 21, RuleExpr = 22, RuleNonOpExpr = 23, RuleNonSubscriptExpr = 24,
+ RuleFuncCall = 25, RuleOperatorExpr = 26, RuleBinaryOperator = 27, RuleIdentifier = 28,
+ RuleLiteral = 29, RuleSubscript = 30, RuleMemberAccess = 31, RuleParenExpr = 32,
+ RuleFuncName = 33, RuleVarName = 34, RuleTypeName = 35, RuleStructName = 36
+ };
+
+ explicit TocParser(antlr4::TokenStream *input);
+ ~TocParser();
+
+ virtual std::string getGrammarFileName() const override;
+ virtual const antlr4::atn::ATN& getATN() const override { return _atn; };
+ virtual const std::vector<std::string>& getTokenNames() const override { return _tokenNames; }; // deprecated: use vocabulary instead.
+ virtual const std::vector<std::string>& getRuleNames() const override;
+ virtual antlr4::dfa::Vocabulary& getVocabulary() const override;
+
+
+ class ProgContext;
+ class DeclContext;
+ class VarDeclContext;
+ class VarContext;
+ class TypeContext;
+ class FuncDeclContext;
+ class FuncContext;
+ class ParameterContext;
+ class FirstParameterContext;
+ class AdditionalParameterContext;
+ class BodyContext;
+ class StructDeclContext;
+ class StructMemberContext;
+ class StructVarContext;
+ class StructMethodContext;
+ class StmtContext;
+ class ConditionalContext;
+ class IfCondContext;
+ class LoopContext;
+ class WhileLoopContext;
+ class AssignmentContext;
+ class ReturnStmtContext;
+ class ExprContext;
+ class NonOpExprContext;
+ class NonSubscriptExprContext;
+ class FuncCallContext;
+ class OperatorExprContext;
+ class BinaryOperatorContext;
+ class IdentifierContext;
+ class LiteralContext;
+ class SubscriptContext;
+ class MemberAccessContext;
+ class ParenExprContext;
+ class FuncNameContext;
+ class VarNameContext;
+ class TypeNameContext;
+ class StructNameContext;
+
+ class ProgContext : public antlr4::ParserRuleContext {
+ public:
+ ProgContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+ virtual size_t getRuleIndex() const override;
+ antlr4::tree::TerminalNode *EOF();
+ std::vector<DeclContext *> decl();
+ DeclContext* decl(size_t i);
+
+ virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+ virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+
+ };
+
+ ProgContext* prog();
+
+ class DeclContext : public antlr4::ParserRuleContext {
+ public:
+ DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+ virtual size_t getRuleIndex() const override;
+ VarDeclContext *varDecl();
+ FuncDeclContext *funcDecl();
+ StructDeclContext *structDecl();
+
+ virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+ virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+
+ };
+
+ DeclContext* decl();
+
+ class VarDeclContext : public antlr4::ParserRuleContext {
+ public:
+ VarDeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+ virtual size_t getRuleIndex() const override;
+ VarContext *var();
+
+ virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+ virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+
+ };
+
+ VarDeclContext* varDecl();
+
+ class VarContext : public antlr4::ParserRuleContext {
+ public:
+ VarContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+ virtual size_t getRuleIndex() const override;
+ VarNameContext *varName();
+ TypeContext *type();
+ ExprContext *expr();
+
+ virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+ virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+
+ };
+
+ VarContext* var();
+
+ class TypeContext : public antlr4::ParserRuleContext {
+ public:
+ TypeContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+ virtual size_t getRuleIndex() const override;
+ TypeNameContext *typeName();
+
+ virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+ virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+
+ };
+
+ TypeContext* type();
+
+ class FuncDeclContext : public antlr4::ParserRuleContext {
+ public:
+ FuncDeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+ virtual size_t getRuleIndex() const override;
+ FuncContext *func();
+
+ virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+ virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+
+ };
+
+ FuncDeclContext* funcDecl();
+
+ class FuncContext : public antlr4::ParserRuleContext {
+ public:
+ FuncContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+ virtual size_t getRuleIndex() const override;
+ FuncNameContext *funcName();
+ ParameterContext *parameter();
+ BodyContext *body();
+ TypeContext *type();
+
+ virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+ virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+
+ };
+
+ FuncContext* func();
+
+ class ParameterContext : public antlr4::ParserRuleContext {
+ public:
+ ParameterContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+ virtual size_t getRuleIndex() const override;
+ FirstParameterContext *firstParameter();
+ std::vector<AdditionalParameterContext *> additionalParameter();
+ AdditionalParameterContext* additionalParameter(size_t i);
+
+ virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+ virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+
+ };
+
+ ParameterContext* parameter();
+
+ class FirstParameterContext : public antlr4::ParserRuleContext {
+ public:
+ FirstParameterContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+ virtual size_t getRuleIndex() const override;
+ VarContext *var();
+
+ virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+ virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+
+ };
+
+ FirstParameterContext* firstParameter();
+
+ class AdditionalParameterContext : public antlr4::ParserRuleContext {
+ public:
+ AdditionalParameterContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+ virtual size_t getRuleIndex() const override;
+ VarContext *var();
+
+ virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+ virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+
+ };
+
+ AdditionalParameterContext* additionalParameter();
+
+ class BodyContext : public antlr4::ParserRuleContext {
+ public:
+ BodyContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+ virtual size_t getRuleIndex() const override;
+ std::vector<StmtContext *> stmt();
+ StmtContext* stmt(size_t i);
+
+ virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+ virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+
+ };
+
+ BodyContext* body();
+
+ class StructDeclContext : public antlr4::ParserRuleContext {
+ public:
+ StructDeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+ virtual size_t getRuleIndex() const override;
+ StructNameContext *structName();
+ std::vector<StructMemberContext *> structMember();
+ StructMemberContext* structMember(size_t i);
+
+ virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+ virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+
+ };
+
+ StructDeclContext* structDecl();
+
+ class StructMemberContext : public antlr4::ParserRuleContext {
+ public:
+ StructMemberContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+ virtual size_t getRuleIndex() const override;
+ StructVarContext *structVar();
+ StructMethodContext *structMethod();
+
+ virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+ virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+
+ };
+
+ StructMemberContext* structMember();
+
+ class StructVarContext : public antlr4::ParserRuleContext {
+ public:
+ StructVarContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+ virtual size_t getRuleIndex() const override;
+ VarContext *var();
+
+ virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+ virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+
+ };
+
+ StructVarContext* structVar();
+
+ class StructMethodContext : public antlr4::ParserRuleContext {
+ public:
+ StructMethodContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+ virtual size_t getRuleIndex() const override;
+ FuncContext *func();
+
+ virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+ virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+
+ };
+
+ StructMethodContext* structMethod();
+
+ class StmtContext : public antlr4::ParserRuleContext {
+ public:
+ StmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+ virtual size_t getRuleIndex() const override;
+ VarDeclContext *varDecl();
+ ConditionalContext *conditional();
+ LoopContext *loop();
+ AssignmentContext *assignment();
+ ReturnStmtContext *returnStmt();
+ ExprContext *expr();
+
+ virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+ virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+
+ };
+
+ StmtContext* stmt();
+
+ class ConditionalContext : public antlr4::ParserRuleContext {
+ public:
+ ConditionalContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+ virtual size_t getRuleIndex() const override;
+ IfCondContext *ifCond();
+
+ virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+ virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+
+ };
+
+ ConditionalContext* conditional();
+
+ class IfCondContext : public antlr4::ParserRuleContext {
+ public:
+ IfCondContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+ virtual size_t getRuleIndex() const override;
+ ExprContext *expr();
+ BodyContext *body();
+
+ virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+ virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+
+ };
+
+ IfCondContext* ifCond();
+
+ class LoopContext : public antlr4::ParserRuleContext {
+ public:
+ LoopContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+ virtual size_t getRuleIndex() const override;
+ WhileLoopContext *whileLoop();
+
+ virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+ virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+
+ };
+
+ LoopContext* loop();
+
+ class WhileLoopContext : public antlr4::ParserRuleContext {
+ public:
+ WhileLoopContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+ virtual size_t getRuleIndex() const override;
+ ExprContext *expr();
+ BodyContext *body();
+
+ virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+ virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+
+ };
+
+ WhileLoopContext* whileLoop();
+
+ class AssignmentContext : public antlr4::ParserRuleContext {
+ public:
+ AssignmentContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+ virtual size_t getRuleIndex() const override;
+ IdentifierContext *identifier();
+ ExprContext *expr();
+
+ virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+ virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+
+ };
+
+ AssignmentContext* assignment();
+
+ class ReturnStmtContext : public antlr4::ParserRuleContext {
+ public:
+ ReturnStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+ virtual size_t getRuleIndex() const override;
+ ExprContext *expr();
+
+ virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+ virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+
+ };
+
+ ReturnStmtContext* returnStmt();
+
+ class ExprContext : public antlr4::ParserRuleContext {
+ public:
+ ExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+ virtual size_t getRuleIndex() const override;
+ FuncCallContext *funcCall();
+ LiteralContext *literal();
+ IdentifierContext *identifier();
+ SubscriptContext *subscript();
+ MemberAccessContext *memberAccess();
+ ParenExprContext *parenExpr();
+ OperatorExprContext *operatorExpr();
+
+ virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+ virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+
+ };
+
+ ExprContext* expr();
+
+ class NonOpExprContext : public antlr4::ParserRuleContext {
+ public:
+ NonOpExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+ virtual size_t getRuleIndex() const override;
+ FuncCallContext *funcCall();
+ LiteralContext *literal();
+ IdentifierContext *identifier();
+ SubscriptContext *subscript();
+ MemberAccessContext *memberAccess();
+ ParenExprContext *parenExpr();
+
+ virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+ virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+
+ };
+
+ NonOpExprContext* nonOpExpr();
+
+ class NonSubscriptExprContext : public antlr4::ParserRuleContext {
+ public:
+ NonSubscriptExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+ virtual size_t getRuleIndex() const override;
+ FuncCallContext *funcCall();
+ IdentifierContext *identifier();
+ MemberAccessContext *memberAccess();
+ ParenExprContext *parenExpr();
+
+ virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+ virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+
+ };
+
+ NonSubscriptExprContext* nonSubscriptExpr();
+
+ class FuncCallContext : public antlr4::ParserRuleContext {
+ public:
+ FuncCallContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+ virtual size_t getRuleIndex() const override;
+ FuncNameContext *funcName();
+ std::vector<ExprContext *> expr();
+ ExprContext* expr(size_t i);
+
+ virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+ virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+
+ };
+
+ FuncCallContext* funcCall();
+
+ class OperatorExprContext : public antlr4::ParserRuleContext {
+ public:
+ OperatorExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+ virtual size_t getRuleIndex() const override;
+ BinaryOperatorContext *binaryOperator();
+
+ virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+ virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+
+ };
+
+ OperatorExprContext* operatorExpr();
+
+ class BinaryOperatorContext : public antlr4::ParserRuleContext {
+ public:
+ BinaryOperatorContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+ virtual size_t getRuleIndex() const override;
+ std::vector<NonOpExprContext *> nonOpExpr();
+ NonOpExprContext* nonOpExpr(size_t i);
+ std::vector<antlr4::tree::TerminalNode *> BINARY_OPERATOR();
+ antlr4::tree::TerminalNode* BINARY_OPERATOR(size_t i);
+
+ virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+ virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+
+ };
+
+ BinaryOperatorContext* binaryOperator();
+
+ class IdentifierContext : public antlr4::ParserRuleContext {
+ public:
+ IdentifierContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+ virtual size_t getRuleIndex() const override;
+ VarNameContext *varName();
+
+ virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+ virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+
+ };
+
+ IdentifierContext* identifier();
+
+ class LiteralContext : public antlr4::ParserRuleContext {
+ public:
+ LiteralContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+ virtual size_t getRuleIndex() const override;
+ antlr4::tree::TerminalNode *INTLIT();
+
+ virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+ virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+
+ };
+
+ LiteralContext* literal();
+
+ class SubscriptContext : public antlr4::ParserRuleContext {
+ public:
+ SubscriptContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+ virtual size_t getRuleIndex() const override;
+ NonSubscriptExprContext *nonSubscriptExpr();
+ ExprContext *expr();
+
+ virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+ virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+
+ };
+
+ SubscriptContext* subscript();
+
+ class MemberAccessContext : public antlr4::ParserRuleContext {
+ public:
+ MemberAccessContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+ virtual size_t getRuleIndex() const override;
+ std::vector<IdentifierContext *> identifier();
+ IdentifierContext* identifier(size_t i);
+
+ virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+ virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+
+ };
+
+ MemberAccessContext* memberAccess();
+
+ class ParenExprContext : public antlr4::ParserRuleContext {
+ public:
+ ParenExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+ virtual size_t getRuleIndex() const override;
+ ExprContext *expr();
+
+ virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+ virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+
+ };
+
+ ParenExprContext* parenExpr();
+
+ class FuncNameContext : public antlr4::ParserRuleContext {
+ public:
+ FuncNameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+ virtual size_t getRuleIndex() const override;
+ antlr4::tree::TerminalNode *NAME();
+
+ virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+ virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+
+ };
+
+ FuncNameContext* funcName();
+
+ class VarNameContext : public antlr4::ParserRuleContext {
+ public:
+ VarNameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+ virtual size_t getRuleIndex() const override;
+ antlr4::tree::TerminalNode *NAME();
+
+ virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+ virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+
+ };
+
+ VarNameContext* varName();
+
+ class TypeNameContext : public antlr4::ParserRuleContext {
+ public:
+ TypeNameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+ virtual size_t getRuleIndex() const override;
+ antlr4::tree::TerminalNode *NAME();
+
+ virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+ virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+
+ };
+
+ TypeNameContext* typeName();
+
+ class StructNameContext : public antlr4::ParserRuleContext {
+ public:
+ StructNameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+ virtual size_t getRuleIndex() const override;
+ antlr4::tree::TerminalNode *NAME();
+
+ virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+ virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+
+ };
+
+ StructNameContext* structName();
+
+
+private:
+ static std::vector<antlr4::dfa::DFA> _decisionToDFA;
+ static antlr4::atn::PredictionContextCache _sharedContextCache;
+ static std::vector<std::string> _ruleNames;
+ static std::vector<std::string> _tokenNames;
+
+ static std::vector<std::string> _literalNames;
+ static std::vector<std::string> _symbolicNames;
+ static antlr4::dfa::Vocabulary _vocabulary;
+ static antlr4::atn::ATN _atn;
+ static std::vector<uint16_t> _serializedATN;
+
+
+ struct Initializer {
+ Initializer();
+ };
+ static Initializer _init;
+};
+
|