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