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