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    \r
 113   };\r
 114 \r
 115   ProgContext* prog();\r
 116 \r
 117   class  DeclContext : public antlr4::ParserRuleContext {\r
 118   public:\r
 119     DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 120     virtual size_t getRuleIndex() const override;\r
 121     VarDeclContext *varDecl();\r
 122     FuncDeclContext *funcDecl();\r
 123     StructDeclContext *structDecl();\r
 124 \r
 125    \r
 126   };\r
 127 \r
 128   DeclContext* decl();\r
 129 \r
 130   class  VarDeclContext : public antlr4::ParserRuleContext {\r
 131   public:\r
 132     VarDeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 133     virtual size_t getRuleIndex() const override;\r
 134     VarContext *var();\r
 135 \r
 136    \r
 137   };\r
 138 \r
 139   VarDeclContext* varDecl();\r
 140 \r
 141   class  VarContext : public antlr4::ParserRuleContext {\r
 142   public:\r
 143     VarContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 144     virtual size_t getRuleIndex() const override;\r
 145     VarNameContext *varName();\r
 146     TypeContext *type();\r
 147     ExprContext *expr();\r
 148 \r
 149    \r
 150   };\r
 151 \r
 152   VarContext* var();\r
 153 \r
 154   class  VarInitContext : public antlr4::ParserRuleContext {\r
 155   public:\r
 156     VarInitContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 157     virtual size_t getRuleIndex() const override;\r
 158     VarNameContext *varName();\r
 159     TypeContext *type();\r
 160     ExprContext *expr();\r
 161 \r
 162    \r
 163   };\r
 164 \r
 165   VarInitContext* varInit();\r
 166 \r
 167   class  TypeContext : public antlr4::ParserRuleContext {\r
 168   public:\r
 169     TypeContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 170     virtual size_t getRuleIndex() const override;\r
 171     TypeNameContext *typeName();\r
 172     std::vector<TypeModifierContext *> typeModifier();\r
 173     TypeModifierContext* typeModifier(size_t i);\r
 174 \r
 175    \r
 176   };\r
 177 \r
 178   TypeContext* type();\r
 179 \r
 180   class  TypeModifierContext : public antlr4::ParserRuleContext {\r
 181   public:\r
 182     TypeModifierContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 183     virtual size_t getRuleIndex() const override;\r
 184     antlr4::tree::TerminalNode *INT_LIT();\r
 185 \r
 186    \r
 187   };\r
 188 \r
 189   TypeModifierContext* typeModifier();\r
 190 \r
 191   class  FuncDeclContext : public antlr4::ParserRuleContext {\r
 192   public:\r
 193     FuncDeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 194     virtual size_t getRuleIndex() const override;\r
 195     FuncContext *func();\r
 196 \r
 197    \r
 198   };\r
 199 \r
 200   FuncDeclContext* funcDecl();\r
 201 \r
 202   class  FuncContext : public antlr4::ParserRuleContext {\r
 203   public:\r
 204     FuncContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 205     virtual size_t getRuleIndex() const override;\r
 206     FuncNameContext *funcName();\r
 207     ParameterContext *parameter();\r
 208     BodyContext *body();\r
 209     TypeContext *type();\r
 210 \r
 211    \r
 212   };\r
 213 \r
 214   FuncContext* func();\r
 215 \r
 216   class  ParameterContext : public antlr4::ParserRuleContext {\r
 217   public:\r
 218     ParameterContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 219     virtual size_t getRuleIndex() const override;\r
 220     std::vector<VarContext *> var();\r
 221     VarContext* var(size_t i);\r
 222 \r
 223    \r
 224   };\r
 225 \r
 226   ParameterContext* parameter();\r
 227 \r
 228   class  BodyContext : public antlr4::ParserRuleContext {\r
 229   public:\r
 230     BodyContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 231     virtual size_t getRuleIndex() const override;\r
 232     std::vector<StmtContext *> stmt();\r
 233     StmtContext* stmt(size_t i);\r
 234 \r
 235    \r
 236   };\r
 237 \r
 238   BodyContext* body();\r
 239 \r
 240   class  StructDeclContext : public antlr4::ParserRuleContext {\r
 241   public:\r
 242     StructDeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 243     virtual size_t getRuleIndex() const override;\r
 244     StructNameContext *structName();\r
 245     std::vector<StructMemberContext *> structMember();\r
 246     StructMemberContext* structMember(size_t i);\r
 247 \r
 248    \r
 249   };\r
 250 \r
 251   StructDeclContext* structDecl();\r
 252 \r
 253   class  StructMemberContext : public antlr4::ParserRuleContext {\r
 254   public:\r
 255     StructMemberContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 256     virtual size_t getRuleIndex() const override;\r
 257     StructVarContext *structVar();\r
 258     StructMethodContext *structMethod();\r
 259 \r
 260    \r
 261   };\r
 262 \r
 263   StructMemberContext* structMember();\r
 264 \r
 265   class  StructVarContext : public antlr4::ParserRuleContext {\r
 266   public:\r
 267     StructVarContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 268     virtual size_t getRuleIndex() const override;\r
 269     VarContext *var();\r
 270 \r
 271    \r
 272   };\r
 273 \r
 274   StructVarContext* structVar();\r
 275 \r
 276   class  StructMethodContext : public antlr4::ParserRuleContext {\r
 277   public:\r
 278     StructMethodContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 279     virtual size_t getRuleIndex() const override;\r
 280     FuncContext *func();\r
 281 \r
 282    \r
 283   };\r
 284 \r
 285   StructMethodContext* structMethod();\r
 286 \r
 287   class  StmtContext : public antlr4::ParserRuleContext {\r
 288   public:\r
 289     StmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 290     virtual size_t getRuleIndex() const override;\r
 291     VarDeclContext *varDecl();\r
 292     IfStmtContext *ifStmt();\r
 293     SwitchStmtContext *switchStmt();\r
 294     ForStmtContext *forStmt();\r
 295     WhileStmtContext *whileStmt();\r
 296     AssignStmtContext *assignStmt();\r
 297     ReturnStmtContext *returnStmt();\r
 298     ExprContext *expr();\r
 299 \r
 300    \r
 301   };\r
 302 \r
 303   StmtContext* stmt();\r
 304 \r
 305   class  IfStmtContext : public antlr4::ParserRuleContext {\r
 306   public:\r
 307     IfStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 308     virtual size_t getRuleIndex() const override;\r
 309     ExprContext *expr();\r
 310     BodyContext *body();\r
 311     std::vector<ElseIfStmtContext *> elseIfStmt();\r
 312     ElseIfStmtContext* elseIfStmt(size_t i);\r
 313     ElseStmtContext *elseStmt();\r
 314 \r
 315    \r
 316   };\r
 317 \r
 318   IfStmtContext* ifStmt();\r
 319 \r
 320   class  ElseIfStmtContext : public antlr4::ParserRuleContext {\r
 321   public:\r
 322     ElseIfStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 323     virtual size_t getRuleIndex() const override;\r
 324     ExprContext *expr();\r
 325     BodyContext *body();\r
 326 \r
 327    \r
 328   };\r
 329 \r
 330   ElseIfStmtContext* elseIfStmt();\r
 331 \r
 332   class  ElseStmtContext : public antlr4::ParserRuleContext {\r
 333   public:\r
 334     ElseStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 335     virtual size_t getRuleIndex() const override;\r
 336     BodyContext *body();\r
 337 \r
 338    \r
 339   };\r
 340 \r
 341   ElseStmtContext* elseStmt();\r
 342 \r
 343   class  SwitchStmtContext : public antlr4::ParserRuleContext {\r
 344   public:\r
 345     SwitchStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 346     virtual size_t getRuleIndex() const override;\r
 347     IdentifierExprContext *identifierExpr();\r
 348     SwitchBodyContext *switchBody();\r
 349 \r
 350    \r
 351   };\r
 352 \r
 353   SwitchStmtContext* switchStmt();\r
 354 \r
 355   class  SwitchBodyContext : public antlr4::ParserRuleContext {\r
 356   public:\r
 357     SwitchBodyContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 358     virtual size_t getRuleIndex() const override;\r
 359     std::vector<SwitchCaseContext *> switchCase();\r
 360     SwitchCaseContext* switchCase(size_t i);\r
 361 \r
 362    \r
 363   };\r
 364 \r
 365   SwitchBodyContext* switchBody();\r
 366 \r
 367   class  SwitchCaseContext : public antlr4::ParserRuleContext {\r
 368   public:\r
 369     SwitchCaseContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 370     virtual size_t getRuleIndex() const override;\r
 371     ExprContext *expr();\r
 372     BodyContext *body();\r
 373 \r
 374    \r
 375   };\r
 376 \r
 377   SwitchCaseContext* switchCase();\r
 378 \r
 379   class  ForStmtContext : public antlr4::ParserRuleContext {\r
 380   public:\r
 381     ForStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 382     virtual size_t getRuleIndex() const override;\r
 383     std::vector<ExprContext *> expr();\r
 384     ExprContext* expr(size_t i);\r
 385     BodyContext *body();\r
 386     VarInitContext *varInit();\r
 387     AssignStmtContext *assignStmt();\r
 388 \r
 389    \r
 390   };\r
 391 \r
 392   ForStmtContext* forStmt();\r
 393 \r
 394   class  WhileStmtContext : public antlr4::ParserRuleContext {\r
 395   public:\r
 396     WhileStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 397     virtual size_t getRuleIndex() const override;\r
 398     ExprContext *expr();\r
 399     BodyContext *body();\r
 400 \r
 401    \r
 402   };\r
 403 \r
 404   WhileStmtContext* whileStmt();\r
 405 \r
 406   class  AssignStmtContext : public antlr4::ParserRuleContext {\r
 407   public:\r
 408     AssignStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 409     virtual size_t getRuleIndex() const override;\r
 410     IdentifierExprContext *identifierExpr();\r
 411     ExprContext *expr();\r
 412 \r
 413    \r
 414   };\r
 415 \r
 416   AssignStmtContext* assignStmt();\r
 417 \r
 418   class  ReturnStmtContext : public antlr4::ParserRuleContext {\r
 419   public:\r
 420     ReturnStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 421     virtual size_t getRuleIndex() const override;\r
 422     ExprContext *expr();\r
 423 \r
 424    \r
 425   };\r
 426 \r
 427   ReturnStmtContext* returnStmt();\r
 428 \r
 429   class  ExprContext : public antlr4::ParserRuleContext {\r
 430   public:\r
 431     ExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 432     virtual size_t getRuleIndex() const override;\r
 433     FuncExprContext *funcExpr();\r
 434     LitExprContext *litExpr();\r
 435     IdentifierExprContext *identifierExpr();\r
 436     ParenExprContext *parenExpr();\r
 437     AccessExprContext *accessExpr();\r
 438     OpExprContext *opExpr();\r
 439 \r
 440    \r
 441   };\r
 442 \r
 443   ExprContext* expr();\r
 444 \r
 445   class  NonOpExprContext : public antlr4::ParserRuleContext {\r
 446   public:\r
 447     NonOpExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 448     virtual size_t getRuleIndex() const override;\r
 449     FuncExprContext *funcExpr();\r
 450     LitExprContext *litExpr();\r
 451     IdentifierExprContext *identifierExpr();\r
 452     ParenExprContext *parenExpr();\r
 453     AccessExprContext *accessExpr();\r
 454 \r
 455    \r
 456   };\r
 457 \r
 458   NonOpExprContext* nonOpExpr();\r
 459 \r
 460   class  NonAccessExprContext : public antlr4::ParserRuleContext {\r
 461   public:\r
 462     NonAccessExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 463     virtual size_t getRuleIndex() const override;\r
 464     FuncExprContext *funcExpr();\r
 465     IdentifierExprContext *identifierExpr();\r
 466     ParenExprContext *parenExpr();\r
 467 \r
 468    \r
 469   };\r
 470 \r
 471   NonAccessExprContext* nonAccessExpr();\r
 472 \r
 473   class  FuncExprContext : public antlr4::ParserRuleContext {\r
 474   public:\r
 475     FuncExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 476     virtual size_t getRuleIndex() const override;\r
 477     FuncNameContext *funcName();\r
 478     std::vector<ExprContext *> expr();\r
 479     ExprContext* expr(size_t i);\r
 480 \r
 481    \r
 482   };\r
 483 \r
 484   FuncExprContext* funcExpr();\r
 485 \r
 486   class  OpExprContext : public antlr4::ParserRuleContext {\r
 487   public:\r
 488     OpExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 489     virtual size_t getRuleIndex() const override;\r
 490     BinaryOpContext *binaryOp();\r
 491     PrefixOpContext *prefixOp();\r
 492     PostfixOpContext *postfixOp();\r
 493     TernaryOpContext *ternaryOp();\r
 494 \r
 495    \r
 496   };\r
 497 \r
 498   OpExprContext* opExpr();\r
 499 \r
 500   class  BinaryOpContext : public antlr4::ParserRuleContext {\r
 501   public:\r
 502     BinaryOpContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 503     virtual size_t getRuleIndex() const override;\r
 504     std::vector<NonOpExprContext *> nonOpExpr();\r
 505     NonOpExprContext* nonOpExpr(size_t i);\r
 506     std::vector<Binary_opContext *> binary_op();\r
 507     Binary_opContext* binary_op(size_t i);\r
 508 \r
 509    \r
 510   };\r
 511 \r
 512   BinaryOpContext* binaryOp();\r
 513 \r
 514   class  PrefixOpContext : public antlr4::ParserRuleContext {\r
 515   public:\r
 516     PrefixOpContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 517     virtual size_t getRuleIndex() const override;\r
 518     Prefix_opContext *prefix_op();\r
 519     NonOpExprContext *nonOpExpr();\r
 520 \r
 521    \r
 522   };\r
 523 \r
 524   PrefixOpContext* prefixOp();\r
 525 \r
 526   class  PostfixOpContext : public antlr4::ParserRuleContext {\r
 527   public:\r
 528     PostfixOpContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 529     virtual size_t getRuleIndex() const override;\r
 530     NonOpExprContext *nonOpExpr();\r
 531     Postfix_opContext *postfix_op();\r
 532 \r
 533    \r
 534   };\r
 535 \r
 536   PostfixOpContext* postfixOp();\r
 537 \r
 538   class  TernaryOpContext : public antlr4::ParserRuleContext {\r
 539   public:\r
 540     TernaryOpContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 541     virtual size_t getRuleIndex() const override;\r
 542     NonOpExprContext *nonOpExpr();\r
 543     std::vector<ExprContext *> expr();\r
 544     ExprContext* expr(size_t i);\r
 545 \r
 546    \r
 547   };\r
 548 \r
 549   TernaryOpContext* ternaryOp();\r
 550 \r
 551   class  IdentifierExprContext : public antlr4::ParserRuleContext {\r
 552   public:\r
 553     IdentifierExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 554     virtual size_t getRuleIndex() const override;\r
 555     VarNameContext *varName();\r
 556 \r
 557    \r
 558   };\r
 559 \r
 560   IdentifierExprContext* identifierExpr();\r
 561 \r
 562   class  LitExprContext : public antlr4::ParserRuleContext {\r
 563   public:\r
 564     LitExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 565     virtual size_t getRuleIndex() const override;\r
 566     antlr4::tree::TerminalNode *INT_LIT();\r
 567     antlr4::tree::TerminalNode *DECIMAL_LIT();\r
 568     antlr4::tree::TerminalNode *STRING_LIT();\r
 569     antlr4::tree::TerminalNode *BOOL_LIT();\r
 570 \r
 571    \r
 572   };\r
 573 \r
 574   LitExprContext* litExpr();\r
 575 \r
 576   class  AccessExprContext : public antlr4::ParserRuleContext {\r
 577   public:\r
 578     AccessExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 579     virtual size_t getRuleIndex() const override;\r
 580     NonAccessExprContext *nonAccessExpr();\r
 581     std::vector<AccessSubExprContext *> accessSubExpr();\r
 582     AccessSubExprContext* accessSubExpr(size_t i);\r
 583 \r
 584    \r
 585   };\r
 586 \r
 587   AccessExprContext* accessExpr();\r
 588 \r
 589   class  AccessSubExprContext : public antlr4::ParserRuleContext {\r
 590   public:\r
 591     AccessSubExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 592     virtual size_t getRuleIndex() const override;\r
 593     AccessMemberContext *accessMember();\r
 594     AccessBracketsContext *accessBrackets();\r
 595 \r
 596    \r
 597   };\r
 598 \r
 599   AccessSubExprContext* accessSubExpr();\r
 600 \r
 601   class  AccessMemberContext : public antlr4::ParserRuleContext {\r
 602   public:\r
 603     AccessMemberContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 604     virtual size_t getRuleIndex() const override;\r
 605     IdentifierExprContext *identifierExpr();\r
 606 \r
 607    \r
 608   };\r
 609 \r
 610   AccessMemberContext* accessMember();\r
 611 \r
 612   class  AccessBracketsContext : public antlr4::ParserRuleContext {\r
 613   public:\r
 614     AccessBracketsContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 615     virtual size_t getRuleIndex() const override;\r
 616     ExprContext *expr();\r
 617 \r
 618    \r
 619   };\r
 620 \r
 621   AccessBracketsContext* accessBrackets();\r
 622 \r
 623   class  ParenExprContext : public antlr4::ParserRuleContext {\r
 624   public:\r
 625     ParenExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 626     virtual size_t getRuleIndex() const override;\r
 627     ExprContext *expr();\r
 628 \r
 629    \r
 630   };\r
 631 \r
 632   ParenExprContext* parenExpr();\r
 633 \r
 634   class  FuncNameContext : public antlr4::ParserRuleContext {\r
 635   public:\r
 636     FuncNameContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 637     virtual size_t getRuleIndex() const override;\r
 638     antlr4::tree::TerminalNode *NAME();\r
 639 \r
 640    \r
 641   };\r
 642 \r
 643   FuncNameContext* funcName();\r
 644 \r
 645   class  VarNameContext : public antlr4::ParserRuleContext {\r
 646   public:\r
 647     VarNameContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 648     virtual size_t getRuleIndex() const override;\r
 649     antlr4::tree::TerminalNode *NAME();\r
 650 \r
 651    \r
 652   };\r
 653 \r
 654   VarNameContext* varName();\r
 655 \r
 656   class  TypeNameContext : public antlr4::ParserRuleContext {\r
 657   public:\r
 658     TypeNameContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 659     virtual size_t getRuleIndex() const override;\r
 660     antlr4::tree::TerminalNode *NAME();\r
 661 \r
 662    \r
 663   };\r
 664 \r
 665   TypeNameContext* typeName();\r
 666 \r
 667   class  StructNameContext : public antlr4::ParserRuleContext {\r
 668   public:\r
 669     StructNameContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 670     virtual size_t getRuleIndex() const override;\r
 671     antlr4::tree::TerminalNode *NAME();\r
 672 \r
 673    \r
 674   };\r
 675 \r
 676   StructNameContext* structName();\r
 677 \r
 678   class  Postfix_opContext : public antlr4::ParserRuleContext {\r
 679   public:\r
 680     Postfix_opContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 681     virtual size_t getRuleIndex() const override;\r
 682 \r
 683    \r
 684   };\r
 685 \r
 686   Postfix_opContext* postfix_op();\r
 687 \r
 688   class  Prefix_opContext : public antlr4::ParserRuleContext {\r
 689   public:\r
 690     Prefix_opContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 691     virtual size_t getRuleIndex() const override;\r
 692     Postfix_opContext *postfix_op();\r
 693 \r
 694    \r
 695   };\r
 696 \r
 697   Prefix_opContext* prefix_op();\r
 698 \r
 699   class  Binary_opContext : public antlr4::ParserRuleContext {\r
 700   public:\r
 701     Binary_opContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 702     virtual size_t getRuleIndex() const override;\r
 703 \r
 704    \r
 705   };\r
 706 \r
 707   Binary_opContext* binary_op();\r
 708 \r
 709 \r
 710 private:\r
 711   static std::vector<antlr4::dfa::DFA> _decisionToDFA;\r
 712   static antlr4::atn::PredictionContextCache _sharedContextCache;\r
 713   static std::vector<std::string> _ruleNames;\r
 714   static std::vector<std::string> _tokenNames;\r
 715 \r
 716   static std::vector<std::string> _literalNames;\r
 717   static std::vector<std::string> _symbolicNames;\r
 718   static antlr4::dfa::Vocabulary _vocabulary;\r
 719   static antlr4::atn::ATN _atn;\r
 720   static std::vector<uint16_t> _serializedATN;\r
 721 \r
 722 \r
 723   struct Initializer {\r
 724     Initializer();\r
 725   };\r
 726   static Initializer _init;\r
 727 };\r
 728 \r