From 45409c781a9e35df68c43b1e2f028d30bf90c0a0 Mon Sep 17 00:00:00 2001 From: Patrick Schönberger Date: Wed, 28 Jul 2021 09:07:53 +0200 Subject: Initial commit --- gen/TocParser.h | 625 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 625 insertions(+) create mode 100644 gen/TocParser.h (limited to 'gen/TocParser.h') 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& getTokenNames() const override { return _tokenNames; }; // deprecated: use vocabulary instead. + virtual const std::vector& 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 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 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 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 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 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 nonOpExpr(); + NonOpExprContext* nonOpExpr(size_t i); + std::vector 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 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 _decisionToDFA; + static antlr4::atn::PredictionContextCache _sharedContextCache; + static std::vector _ruleNames; + static std::vector _tokenNames; + + static std::vector _literalNames; + static std::vector _symbolicNames; + static antlr4::dfa::Vocabulary _vocabulary; + static antlr4::atn::ATN _atn; + static std::vector _serializedATN; + + + struct Initializer { + Initializer(); + }; + static Initializer _init; +}; + -- cgit v1.2.3