gitweb.ps.run Git - toc/blob - gen/TocParser.h

   1 \r
   2 // Generated from Toc.g4 by ANTLR 4.9.2\r
   3 \r
   4 #pragma once\r
   5 \r
   6 \r
   7 #include "antlr4-runtime.h"\r
   8 \r
   9 \r
  10 \r
  11 \r
  12 class  TocParser : public antlr4::Parser {\r
  13 public:\r
  14   enum {\r
  15     T__0 = 1, T__1 = 2, T__2 = 3, T__3 = 4, T__4 = 5, T__5 = 6, T__6 = 7, \r
  16     T__7 = 8, T__8 = 9, T__9 = 10, T__10 = 11, T__11 = 12, T__12 = 13, T__13 = 14, \r
  17     T__14 = 15, T__15 = 16, T__16 = 17, T__17 = 18, T__18 = 19, T__19 = 20, \r
  18     T__20 = 21, T__21 = 22, T__22 = 23, T__23 = 24, T__24 = 25, T__25 = 26, \r
  19     T__26 = 27, T__27 = 28, T__28 = 29, T__29 = 30, T__30 = 31, T__31 = 32, \r
  20     T__32 = 33, T__33 = 34, T__34 = 35, T__35 = 36, T__36 = 37, T__37 = 38, \r
  21     T__38 = 39, T__39 = 40, T__40 = 41, T__41 = 42, T__42 = 43, T__43 = 44, \r
  22     T__44 = 45, T__45 = 46, T__46 = 47, T__47 = 48, T__48 = 49, T__49 = 50, \r
  23     T__50 = 51, T__51 = 52, T__52 = 53, T__53 = 54, T__54 = 55, INT_LIT = 56, \r
  24     DECIMAL_LIT = 57, STRING_LIT = 58, BOOL_LIT = 59, NAME = 60, WS = 61, \r
  25     NEWLINE = 62\r
  26   };\r
  27 \r
  28   enum {\r
  29     RuleProg = 0, RuleDecl = 1, RuleVarDecl = 2, RuleVar = 3, RuleVarInit = 4, \r
  30     RuleType = 5, RuleTypeModifier = 6, RuleFuncDecl = 7, RuleFunc = 8, \r
  31     RuleParameter = 9, RuleBody = 10, RuleStructDecl = 11, RuleStructMember = 12, \r
  32     RuleStructVar = 13, RuleStructMethod = 14, RuleStmt = 15, RuleIfStmt = 16, \r
  33     RuleElseIfStmt = 17, RuleElseStmt = 18, RuleSwitchStmt = 19, RuleSwitchBody = 20, \r
  34     RuleSwitchCase = 21, RuleForStmt = 22, RuleWhileStmt = 23, RuleAssignStmt = 24, \r
  35     RuleReturnStmt = 25, RuleExpr = 26, RuleNonOpExpr = 27, RuleNonAccessExpr = 28, \r
  36     RuleFuncExpr = 29, RuleOpExpr = 30, RuleBinaryOp = 31, RulePrefixOp = 32, \r
  37     RulePostfixOp = 33, RuleTernaryOp = 34, RuleIdentifierExpr = 35, RuleLitExpr = 36, \r
  38     RuleAccessExpr = 37, RuleAccessSubExpr = 38, RuleAccessMember = 39, \r
  39     RuleAccessBrackets = 40, RuleParenExpr = 41, RuleFuncName = 42, RuleVarName = 43, \r
  40     RuleTypeName = 44, RuleStructName = 45, RulePostfix_op = 46, RulePrefix_op = 47, \r
  41     RuleBinary_op = 48\r
  42   };\r
  43 \r
  44   explicit TocParser(antlr4::TokenStream *input);\r
  45   ~TocParser();\r
  46 \r
  47   virtual std::string getGrammarFileName() const override;\r
  48   virtual const antlr4::atn::ATN& getATN() const override { return _atn; };\r
  49   virtual const std::vector<std::string>& getTokenNames() const override { return _tokenNames; }; // deprecated: use vocabulary instead.\r
  50   virtual const std::vector<std::string>& getRuleNames() const override;\r
  51   virtual antlr4::dfa::Vocabulary& getVocabulary() const override;\r
  52 \r
  53 \r
  54   class ProgContext;\r
  55   class DeclContext;\r
  56   class VarDeclContext;\r
  57   class VarContext;\r
  58   class VarInitContext;\r
  59   class TypeContext;\r
  60   class TypeModifierContext;\r
  61   class FuncDeclContext;\r
  62   class FuncContext;\r
  63   class ParameterContext;\r
  64   class BodyContext;\r
  65   class StructDeclContext;\r
  66   class StructMemberContext;\r
  67   class StructVarContext;\r
  68   class StructMethodContext;\r
  69   class StmtContext;\r
  70   class IfStmtContext;\r
  71   class ElseIfStmtContext;\r
  72   class ElseStmtContext;\r
  73   class SwitchStmtContext;\r
  74   class SwitchBodyContext;\r
  75   class SwitchCaseContext;\r
  76   class ForStmtContext;\r
  77   class WhileStmtContext;\r
  78   class AssignStmtContext;\r
  79   class ReturnStmtContext;\r
  80   class ExprContext;\r
  81   class NonOpExprContext;\r
  82   class NonAccessExprContext;\r
  83   class FuncExprContext;\r
  84   class OpExprContext;\r
  85   class BinaryOpContext;\r
  86   class PrefixOpContext;\r
  87   class PostfixOpContext;\r
  88   class TernaryOpContext;\r
  89   class IdentifierExprContext;\r
  90   class LitExprContext;\r
  91   class AccessExprContext;\r
  92   class AccessSubExprContext;\r
  93   class AccessMemberContext;\r
  94   class AccessBracketsContext;\r
  95   class ParenExprContext;\r
  96   class FuncNameContext;\r
  97   class VarNameContext;\r
  98   class TypeNameContext;\r
  99   class StructNameContext;\r
 100   class Postfix_opContext;\r
 101   class Prefix_opContext;\r
 102   class Binary_opContext; \r
 103 \r
 104   class  ProgContext : public antlr4::ParserRuleContext {\r
 105   public:\r
 106     ProgContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 107     virtual size_t getRuleIndex() const override;\r
 108     antlr4::tree::TerminalNode *EOF();\r
 109     std::vector<DeclContext *> decl();\r
 110     DeclContext* decl(size_t i);\r
 111 \r
 112     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 113     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 114    \r
 115   };\r
 116 \r
 117   ProgContext* prog();\r
 118 \r
 119   class  DeclContext : public antlr4::ParserRuleContext {\r
 120   public:\r
 121     DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 122     virtual size_t getRuleIndex() const override;\r
 123     VarDeclContext *varDecl();\r
 124     FuncDeclContext *funcDecl();\r
 125     StructDeclContext *structDecl();\r
 126 \r
 127     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 128     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 129    \r
 130   };\r
 131 \r
 132   DeclContext* decl();\r
 133 \r
 134   class  VarDeclContext : public antlr4::ParserRuleContext {\r
 135   public:\r
 136     VarDeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 137     virtual size_t getRuleIndex() const override;\r
 138     VarContext *var();\r
 139 \r
 140     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 141     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 142    \r
 143   };\r
 144 \r
 145   VarDeclContext* varDecl();\r
 146 \r
 147   class  VarContext : public antlr4::ParserRuleContext {\r
 148   public:\r
 149     VarContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 150     virtual size_t getRuleIndex() const override;\r
 151     VarNameContext *varName();\r
 152     TypeContext *type();\r
 153     ExprContext *expr();\r
 154 \r
 155     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 156     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 157    \r
 158   };\r
 159 \r
 160   VarContext* var();\r
 161 \r
 162   class  VarInitContext : public antlr4::ParserRuleContext {\r
 163   public:\r
 164     VarInitContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 165     virtual size_t getRuleIndex() const override;\r
 166     VarNameContext *varName();\r
 167     TypeContext *type();\r
 168     ExprContext *expr();\r
 169 \r
 170     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 171     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 172    \r
 173   };\r
 174 \r
 175   VarInitContext* varInit();\r
 176 \r
 177   class  TypeContext : public antlr4::ParserRuleContext {\r
 178   public:\r
 179     TypeContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 180     virtual size_t getRuleIndex() const override;\r
 181     TypeNameContext *typeName();\r
 182     std::vector<TypeModifierContext *> typeModifier();\r
 183     TypeModifierContext* typeModifier(size_t i);\r
 184 \r
 185     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 186     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 187    \r
 188   };\r
 189 \r
 190   TypeContext* type();\r
 191 \r
 192   class  TypeModifierContext : public antlr4::ParserRuleContext {\r
 193   public:\r
 194     TypeModifierContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 195     virtual size_t getRuleIndex() const override;\r
 196     antlr4::tree::TerminalNode *INT_LIT();\r
 197 \r
 198     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 199     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 200    \r
 201   };\r
 202 \r
 203   TypeModifierContext* typeModifier();\r
 204 \r
 205   class  FuncDeclContext : public antlr4::ParserRuleContext {\r
 206   public:\r
 207     FuncDeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 208     virtual size_t getRuleIndex() const override;\r
 209     FuncContext *func();\r
 210 \r
 211     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 212     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 213    \r
 214   };\r
 215 \r
 216   FuncDeclContext* funcDecl();\r
 217 \r
 218   class  FuncContext : public antlr4::ParserRuleContext {\r
 219   public:\r
 220     FuncContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 221     virtual size_t getRuleIndex() const override;\r
 222     FuncNameContext *funcName();\r
 223     ParameterContext *parameter();\r
 224     BodyContext *body();\r
 225     TypeContext *type();\r
 226 \r
 227     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 228     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 229    \r
 230   };\r
 231 \r
 232   FuncContext* func();\r
 233 \r
 234   class  ParameterContext : public antlr4::ParserRuleContext {\r
 235   public:\r
 236     ParameterContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 237     virtual size_t getRuleIndex() const override;\r
 238     std::vector<VarContext *> var();\r
 239     VarContext* var(size_t i);\r
 240 \r
 241     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 242     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 243    \r
 244   };\r
 245 \r
 246   ParameterContext* parameter();\r
 247 \r
 248   class  BodyContext : public antlr4::ParserRuleContext {\r
 249   public:\r
 250     BodyContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 251     virtual size_t getRuleIndex() const override;\r
 252     std::vector<StmtContext *> stmt();\r
 253     StmtContext* stmt(size_t i);\r
 254 \r
 255     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 256     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 257    \r
 258   };\r
 259 \r
 260   BodyContext* body();\r
 261 \r
 262   class  StructDeclContext : public antlr4::ParserRuleContext {\r
 263   public:\r
 264     StructDeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 265     virtual size_t getRuleIndex() const override;\r
 266     StructNameContext *structName();\r
 267     std::vector<StructMemberContext *> structMember();\r
 268     StructMemberContext* structMember(size_t i);\r
 269 \r
 270     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 271     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 272    \r
 273   };\r
 274 \r
 275   StructDeclContext* structDecl();\r
 276 \r
 277   class  StructMemberContext : public antlr4::ParserRuleContext {\r
 278   public:\r
 279     StructMemberContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 280     virtual size_t getRuleIndex() const override;\r
 281     StructVarContext *structVar();\r
 282     StructMethodContext *structMethod();\r
 283 \r
 284     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 285     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 286    \r
 287   };\r
 288 \r
 289   StructMemberContext* structMember();\r
 290 \r
 291   class  StructVarContext : public antlr4::ParserRuleContext {\r
 292   public:\r
 293     StructVarContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 294     virtual size_t getRuleIndex() const override;\r
 295     VarContext *var();\r
 296 \r
 297     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 298     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 299    \r
 300   };\r
 301 \r
 302   StructVarContext* structVar();\r
 303 \r
 304   class  StructMethodContext : public antlr4::ParserRuleContext {\r
 305   public:\r
 306     StructMethodContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 307     virtual size_t getRuleIndex() const override;\r
 308     FuncContext *func();\r
 309 \r
 310     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 311     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 312    \r
 313   };\r
 314 \r
 315   StructMethodContext* structMethod();\r
 316 \r
 317   class  StmtContext : public antlr4::ParserRuleContext {\r
 318   public:\r
 319     StmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 320     virtual size_t getRuleIndex() const override;\r
 321     VarDeclContext *varDecl();\r
 322     IfStmtContext *ifStmt();\r
 323     SwitchStmtContext *switchStmt();\r
 324     ForStmtContext *forStmt();\r
 325     WhileStmtContext *whileStmt();\r
 326     AssignStmtContext *assignStmt();\r
 327     ReturnStmtContext *returnStmt();\r
 328     ExprContext *expr();\r
 329 \r
 330     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 331     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 332    \r
 333   };\r
 334 \r
 335   StmtContext* stmt();\r
 336 \r
 337   class  IfStmtContext : public antlr4::ParserRuleContext {\r
 338   public:\r
 339     IfStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 340     virtual size_t getRuleIndex() const override;\r
 341     ExprContext *expr();\r
 342     BodyContext *body();\r
 343     std::vector<ElseIfStmtContext *> elseIfStmt();\r
 344     ElseIfStmtContext* elseIfStmt(size_t i);\r
 345     ElseStmtContext *elseStmt();\r
 346 \r
 347     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 348     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 349    \r
 350   };\r
 351 \r
 352   IfStmtContext* ifStmt();\r
 353 \r
 354   class  ElseIfStmtContext : public antlr4::ParserRuleContext {\r
 355   public:\r
 356     ElseIfStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 357     virtual size_t getRuleIndex() const override;\r
 358     ExprContext *expr();\r
 359     BodyContext *body();\r
 360 \r
 361     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 362     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 363    \r
 364   };\r
 365 \r
 366   ElseIfStmtContext* elseIfStmt();\r
 367 \r
 368   class  ElseStmtContext : public antlr4::ParserRuleContext {\r
 369   public:\r
 370     ElseStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 371     virtual size_t getRuleIndex() const override;\r
 372     BodyContext *body();\r
 373 \r
 374     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 375     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 376    \r
 377   };\r
 378 \r
 379   ElseStmtContext* elseStmt();\r
 380 \r
 381   class  SwitchStmtContext : public antlr4::ParserRuleContext {\r
 382   public:\r
 383     SwitchStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 384     virtual size_t getRuleIndex() const override;\r
 385     IdentifierExprContext *identifierExpr();\r
 386     SwitchBodyContext *switchBody();\r
 387 \r
 388     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 389     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 390    \r
 391   };\r
 392 \r
 393   SwitchStmtContext* switchStmt();\r
 394 \r
 395   class  SwitchBodyContext : public antlr4::ParserRuleContext {\r
 396   public:\r
 397     SwitchBodyContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 398     virtual size_t getRuleIndex() const override;\r
 399     std::vector<SwitchCaseContext *> switchCase();\r
 400     SwitchCaseContext* switchCase(size_t i);\r
 401 \r
 402     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 403     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 404    \r
 405   };\r
 406 \r
 407   SwitchBodyContext* switchBody();\r
 408 \r
 409   class  SwitchCaseContext : public antlr4::ParserRuleContext {\r
 410   public:\r
 411     SwitchCaseContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 412     virtual size_t getRuleIndex() const override;\r
 413     ExprContext *expr();\r
 414     BodyContext *body();\r
 415 \r
 416     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 417     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 418    \r
 419   };\r
 420 \r
 421   SwitchCaseContext* switchCase();\r
 422 \r
 423   class  ForStmtContext : public antlr4::ParserRuleContext {\r
 424   public:\r
 425     ForStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 426     virtual size_t getRuleIndex() const override;\r
 427     std::vector<ExprContext *> expr();\r
 428     ExprContext* expr(size_t i);\r
 429     BodyContext *body();\r
 430     VarInitContext *varInit();\r
 431     AssignStmtContext *assignStmt();\r
 432 \r
 433     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 434     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 435    \r
 436   };\r
 437 \r
 438   ForStmtContext* forStmt();\r
 439 \r
 440   class  WhileStmtContext : public antlr4::ParserRuleContext {\r
 441   public:\r
 442     WhileStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 443     virtual size_t getRuleIndex() const override;\r
 444     ExprContext *expr();\r
 445     BodyContext *body();\r
 446 \r
 447     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 448     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 449    \r
 450   };\r
 451 \r
 452   WhileStmtContext* whileStmt();\r
 453 \r
 454   class  AssignStmtContext : public antlr4::ParserRuleContext {\r
 455   public:\r
 456     AssignStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 457     virtual size_t getRuleIndex() const override;\r
 458     IdentifierExprContext *identifierExpr();\r
 459     ExprContext *expr();\r
 460 \r
 461     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 462     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 463    \r
 464   };\r
 465 \r
 466   AssignStmtContext* assignStmt();\r
 467 \r
 468   class  ReturnStmtContext : public antlr4::ParserRuleContext {\r
 469   public:\r
 470     ReturnStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 471     virtual size_t getRuleIndex() const override;\r
 472     ExprContext *expr();\r
 473 \r
 474     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 475     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 476    \r
 477   };\r
 478 \r
 479   ReturnStmtContext* returnStmt();\r
 480 \r
 481   class  ExprContext : public antlr4::ParserRuleContext {\r
 482   public:\r
 483     ExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 484     virtual size_t getRuleIndex() const override;\r
 485     FuncExprContext *funcExpr();\r
 486     LitExprContext *litExpr();\r
 487     IdentifierExprContext *identifierExpr();\r
 488     ParenExprContext *parenExpr();\r
 489     AccessExprContext *accessExpr();\r
 490     OpExprContext *opExpr();\r
 491 \r
 492     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 493     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 494    \r
 495   };\r
 496 \r
 497   ExprContext* expr();\r
 498 \r
 499   class  NonOpExprContext : public antlr4::ParserRuleContext {\r
 500   public:\r
 501     NonOpExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 502     virtual size_t getRuleIndex() const override;\r
 503     FuncExprContext *funcExpr();\r
 504     LitExprContext *litExpr();\r
 505     IdentifierExprContext *identifierExpr();\r
 506     ParenExprContext *parenExpr();\r
 507     AccessExprContext *accessExpr();\r
 508 \r
 509     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 510     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 511    \r
 512   };\r
 513 \r
 514   NonOpExprContext* nonOpExpr();\r
 515 \r
 516   class  NonAccessExprContext : public antlr4::ParserRuleContext {\r
 517   public:\r
 518     NonAccessExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 519     virtual size_t getRuleIndex() const override;\r
 520     FuncExprContext *funcExpr();\r
 521     IdentifierExprContext *identifierExpr();\r
 522     ParenExprContext *parenExpr();\r
 523 \r
 524     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 525     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 526    \r
 527   };\r
 528 \r
 529   NonAccessExprContext* nonAccessExpr();\r
 530 \r
 531   class  FuncExprContext : public antlr4::ParserRuleContext {\r
 532   public:\r
 533     FuncExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 534     virtual size_t getRuleIndex() const override;\r
 535     FuncNameContext *funcName();\r
 536     std::vector<ExprContext *> expr();\r
 537     ExprContext* expr(size_t i);\r
 538 \r
 539     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 540     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 541    \r
 542   };\r
 543 \r
 544   FuncExprContext* funcExpr();\r
 545 \r
 546   class  OpExprContext : public antlr4::ParserRuleContext {\r
 547   public:\r
 548     OpExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 549     virtual size_t getRuleIndex() const override;\r
 550     BinaryOpContext *binaryOp();\r
 551     PrefixOpContext *prefixOp();\r
 552     PostfixOpContext *postfixOp();\r
 553     TernaryOpContext *ternaryOp();\r
 554 \r
 555     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 556     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 557    \r
 558   };\r
 559 \r
 560   OpExprContext* opExpr();\r
 561 \r
 562   class  BinaryOpContext : public antlr4::ParserRuleContext {\r
 563   public:\r
 564     BinaryOpContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 565     virtual size_t getRuleIndex() const override;\r
 566     std::vector<NonOpExprContext *> nonOpExpr();\r
 567     NonOpExprContext* nonOpExpr(size_t i);\r
 568     std::vector<Binary_opContext *> binary_op();\r
 569     Binary_opContext* binary_op(size_t i);\r
 570 \r
 571     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 572     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 573    \r
 574   };\r
 575 \r
 576   BinaryOpContext* binaryOp();\r
 577 \r
 578   class  PrefixOpContext : public antlr4::ParserRuleContext {\r
 579   public:\r
 580     PrefixOpContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 581     virtual size_t getRuleIndex() const override;\r
 582     Prefix_opContext *prefix_op();\r
 583     NonOpExprContext *nonOpExpr();\r
 584 \r
 585     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 586     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 587    \r
 588   };\r
 589 \r
 590   PrefixOpContext* prefixOp();\r
 591 \r
 592   class  PostfixOpContext : public antlr4::ParserRuleContext {\r
 593   public:\r
 594     PostfixOpContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 595     virtual size_t getRuleIndex() const override;\r
 596     NonOpExprContext *nonOpExpr();\r
 597     Postfix_opContext *postfix_op();\r
 598 \r
 599     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 600     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 601    \r
 602   };\r
 603 \r
 604   PostfixOpContext* postfixOp();\r
 605 \r
 606   class  TernaryOpContext : public antlr4::ParserRuleContext {\r
 607   public:\r
 608     TernaryOpContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 609     virtual size_t getRuleIndex() const override;\r
 610     NonOpExprContext *nonOpExpr();\r
 611     std::vector<ExprContext *> expr();\r
 612     ExprContext* expr(size_t i);\r
 613 \r
 614     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 615     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 616    \r
 617   };\r
 618 \r
 619   TernaryOpContext* ternaryOp();\r
 620 \r
 621   class  IdentifierExprContext : public antlr4::ParserRuleContext {\r
 622   public:\r
 623     IdentifierExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 624     virtual size_t getRuleIndex() const override;\r
 625     VarNameContext *varName();\r
 626 \r
 627     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 628     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 629    \r
 630   };\r
 631 \r
 632   IdentifierExprContext* identifierExpr();\r
 633 \r
 634   class  LitExprContext : public antlr4::ParserRuleContext {\r
 635   public:\r
 636     LitExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 637     virtual size_t getRuleIndex() const override;\r
 638     antlr4::tree::TerminalNode *INT_LIT();\r
 639     antlr4::tree::TerminalNode *DECIMAL_LIT();\r
 640     antlr4::tree::TerminalNode *STRING_LIT();\r
 641     antlr4::tree::TerminalNode *BOOL_LIT();\r
 642 \r
 643     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 644     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 645    \r
 646   };\r
 647 \r
 648   LitExprContext* litExpr();\r
 649 \r
 650   class  AccessExprContext : public antlr4::ParserRuleContext {\r
 651   public:\r
 652     AccessExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 653     virtual size_t getRuleIndex() const override;\r
 654     NonAccessExprContext *nonAccessExpr();\r
 655     std::vector<AccessSubExprContext *> accessSubExpr();\r
 656     AccessSubExprContext* accessSubExpr(size_t i);\r
 657 \r
 658     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 659     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 660    \r
 661   };\r
 662 \r
 663   AccessExprContext* accessExpr();\r
 664 \r
 665   class  AccessSubExprContext : public antlr4::ParserRuleContext {\r
 666   public:\r
 667     AccessSubExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 668     virtual size_t getRuleIndex() const override;\r
 669     AccessMemberContext *accessMember();\r
 670     AccessBracketsContext *accessBrackets();\r
 671 \r
 672     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 673     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 674    \r
 675   };\r
 676 \r
 677   AccessSubExprContext* accessSubExpr();\r
 678 \r
 679   class  AccessMemberContext : public antlr4::ParserRuleContext {\r
 680   public:\r
 681     AccessMemberContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 682     virtual size_t getRuleIndex() const override;\r
 683     IdentifierExprContext *identifierExpr();\r
 684 \r
 685     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 686     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 687    \r
 688   };\r
 689 \r
 690   AccessMemberContext* accessMember();\r
 691 \r
 692   class  AccessBracketsContext : public antlr4::ParserRuleContext {\r
 693   public:\r
 694     AccessBracketsContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 695     virtual size_t getRuleIndex() const override;\r
 696     ExprContext *expr();\r
 697 \r
 698     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 699     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 700    \r
 701   };\r
 702 \r
 703   AccessBracketsContext* accessBrackets();\r
 704 \r
 705   class  ParenExprContext : public antlr4::ParserRuleContext {\r
 706   public:\r
 707     ParenExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 708     virtual size_t getRuleIndex() const override;\r
 709     ExprContext *expr();\r
 710 \r
 711     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 712     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 713    \r
 714   };\r
 715 \r
 716   ParenExprContext* parenExpr();\r
 717 \r
 718   class  FuncNameContext : public antlr4::ParserRuleContext {\r
 719   public:\r
 720     FuncNameContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 721     virtual size_t getRuleIndex() const override;\r
 722     antlr4::tree::TerminalNode *NAME();\r
 723 \r
 724     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 725     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 726    \r
 727   };\r
 728 \r
 729   FuncNameContext* funcName();\r
 730 \r
 731   class  VarNameContext : public antlr4::ParserRuleContext {\r
 732   public:\r
 733     VarNameContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 734     virtual size_t getRuleIndex() const override;\r
 735     antlr4::tree::TerminalNode *NAME();\r
 736 \r
 737     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 738     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 739    \r
 740   };\r
 741 \r
 742   VarNameContext* varName();\r
 743 \r
 744   class  TypeNameContext : public antlr4::ParserRuleContext {\r
 745   public:\r
 746     TypeNameContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 747     virtual size_t getRuleIndex() const override;\r
 748     antlr4::tree::TerminalNode *NAME();\r
 749 \r
 750     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 751     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 752    \r
 753   };\r
 754 \r
 755   TypeNameContext* typeName();\r
 756 \r
 757   class  StructNameContext : public antlr4::ParserRuleContext {\r
 758   public:\r
 759     StructNameContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 760     virtual size_t getRuleIndex() const override;\r
 761     antlr4::tree::TerminalNode *NAME();\r
 762 \r
 763     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 764     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 765    \r
 766   };\r
 767 \r
 768   StructNameContext* structName();\r
 769 \r
 770   class  Postfix_opContext : public antlr4::ParserRuleContext {\r
 771   public:\r
 772     Postfix_opContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 773     virtual size_t getRuleIndex() const override;\r
 774 \r
 775     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 776     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 777    \r
 778   };\r
 779 \r
 780   Postfix_opContext* postfix_op();\r
 781 \r
 782   class  Prefix_opContext : public antlr4::ParserRuleContext {\r
 783   public:\r
 784     Prefix_opContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 785     virtual size_t getRuleIndex() const override;\r
 786     Postfix_opContext *postfix_op();\r
 787 \r
 788     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 789     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 790    \r
 791   };\r
 792 \r
 793   Prefix_opContext* prefix_op();\r
 794 \r
 795   class  Binary_opContext : public antlr4::ParserRuleContext {\r
 796   public:\r
 797     Binary_opContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 798     virtual size_t getRuleIndex() const override;\r
 799 \r
 800     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 801     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 802    \r
 803   };\r
 804 \r
 805   Binary_opContext* binary_op();\r
 806 \r
 807 \r
 808 private:\r
 809   static std::vector<antlr4::dfa::DFA> _decisionToDFA;\r
 810   static antlr4::atn::PredictionContextCache _sharedContextCache;\r
 811   static std::vector<std::string> _ruleNames;\r
 812   static std::vector<std::string> _tokenNames;\r
 813 \r
 814   static std::vector<std::string> _literalNames;\r
 815   static std::vector<std::string> _symbolicNames;\r
 816   static antlr4::dfa::Vocabulary _vocabulary;\r
 817   static antlr4::atn::ATN _atn;\r
 818   static std::vector<uint16_t> _serializedATN;\r
 819 \r
 820 \r
 821   struct Initializer {\r
 822     Initializer();\r
 823   };\r
 824   static Initializer _init;\r
 825 };\r
 826 \r