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, RuleNamespaceSpecifier = 8, \r
  31     RuleFuncDecl = 9, RuleFunc = 10, RuleParameter = 11, RuleBody = 12, \r
  32     RuleStructDecl = 13, RuleStructMember = 14, RuleStructVar = 15, RuleStructMethod = 16, \r
  33     RulePrivateDecl = 17, RuleGenericDecl = 18, RuleStmt = 19, RuleIfStmt = 20, \r
  34     RuleElseIfStmt = 21, RuleElseStmt = 22, RuleSwitchStmt = 23, RuleSwitchBody = 24, \r
  35     RuleSwitchCase = 25, RuleForStmt = 26, RuleWhileStmt = 27, RuleAssignStmt = 28, \r
  36     RuleReturnStmt = 29, RuleExpr = 30, RuleLiteral = 31, RuleFuncName = 32, \r
  37     RuleVarName = 33, RuleTypeName = 34, RuleStructName = 35, RulePostfix_op = 36, \r
  38     RulePrefix_op = 37, RuleBinary_op = 38\r
  39   };\r
  40 \r
  41   explicit TocParser(antlr4::TokenStream *input);\r
  42   ~TocParser();\r
  43 \r
  44   virtual std::string getGrammarFileName() const override;\r
  45   virtual const antlr4::atn::ATN& getATN() const override { return _atn; };\r
  46   virtual const std::vector<std::string>& getTokenNames() const override { return _tokenNames; }; // deprecated: use vocabulary instead.\r
  47   virtual const std::vector<std::string>& getRuleNames() const override;\r
  48   virtual antlr4::dfa::Vocabulary& getVocabulary() const override;\r
  49 \r
  50 \r
  51   class ProgContext;\r
  52   class DeclContext;\r
  53   class NamespaceDeclContext;\r
  54   class VarDeclContext;\r
  55   class VarContext;\r
  56   class VarInitContext;\r
  57   class TypeContext;\r
  58   class TypeModifierContext;\r
  59   class NamespaceSpecifierContext;\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 PrivateDeclContext;\r
  69   class GenericDeclContext;\r
  70   class StmtContext;\r
  71   class IfStmtContext;\r
  72   class ElseIfStmtContext;\r
  73   class ElseStmtContext;\r
  74   class SwitchStmtContext;\r
  75   class SwitchBodyContext;\r
  76   class SwitchCaseContext;\r
  77   class ForStmtContext;\r
  78   class WhileStmtContext;\r
  79   class AssignStmtContext;\r
  80   class ReturnStmtContext;\r
  81   class ExprContext;\r
  82   class LiteralContext;\r
  83   class FuncNameContext;\r
  84   class VarNameContext;\r
  85   class TypeNameContext;\r
  86   class StructNameContext;\r
  87   class Postfix_opContext;\r
  88   class Prefix_opContext;\r
  89   class Binary_opContext; \r
  90 \r
  91   class  ProgContext : public antlr4::ParserRuleContext {\r
  92   public:\r
  93     ProgContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
  94     virtual size_t getRuleIndex() const override;\r
  95     antlr4::tree::TerminalNode *EOF();\r
  96     std::vector<DeclContext *> decl();\r
  97     DeclContext* decl(size_t i);\r
  98 \r
  99    \r
 100   };\r
 101 \r
 102   ProgContext* prog();\r
 103 \r
 104   class  DeclContext : public antlr4::ParserRuleContext {\r
 105   public:\r
 106     DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 107     virtual size_t getRuleIndex() const override;\r
 108     VarDeclContext *varDecl();\r
 109     FuncDeclContext *funcDecl();\r
 110     StructDeclContext *structDecl();\r
 111     NamespaceDeclContext *namespaceDecl();\r
 112 \r
 113    \r
 114   };\r
 115 \r
 116   DeclContext* decl();\r
 117 \r
 118   class  NamespaceDeclContext : public antlr4::ParserRuleContext {\r
 119   public:\r
 120     NamespaceDeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 121     virtual size_t getRuleIndex() const override;\r
 122     TypeNameContext *typeName();\r
 123     std::vector<DeclContext *> decl();\r
 124     DeclContext* decl(size_t i);\r
 125 \r
 126    \r
 127   };\r
 128 \r
 129   NamespaceDeclContext* namespaceDecl();\r
 130 \r
 131   class  VarDeclContext : public antlr4::ParserRuleContext {\r
 132   public:\r
 133     VarDeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 134     virtual size_t getRuleIndex() const override;\r
 135     VarContext *var();\r
 136 \r
 137    \r
 138   };\r
 139 \r
 140   VarDeclContext* varDecl();\r
 141 \r
 142   class  VarContext : public antlr4::ParserRuleContext {\r
 143   public:\r
 144     VarContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 145     virtual size_t getRuleIndex() const override;\r
 146     VarNameContext *varName();\r
 147     TypeContext *type();\r
 148     ExprContext *expr();\r
 149 \r
 150    \r
 151   };\r
 152 \r
 153   VarContext* var();\r
 154 \r
 155   class  VarInitContext : public antlr4::ParserRuleContext {\r
 156   public:\r
 157     VarInitContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 158     virtual size_t getRuleIndex() const override;\r
 159     VarNameContext *varName();\r
 160     TypeContext *type();\r
 161     ExprContext *expr();\r
 162 \r
 163    \r
 164   };\r
 165 \r
 166   VarInitContext* varInit();\r
 167 \r
 168   class  TypeContext : public antlr4::ParserRuleContext {\r
 169   public:\r
 170     TypeContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 171     virtual size_t getRuleIndex() const override;\r
 172     TypeNameContext *typeName();\r
 173     std::vector<NamespaceSpecifierContext *> namespaceSpecifier();\r
 174     NamespaceSpecifierContext* namespaceSpecifier(size_t i);\r
 175     std::vector<TypeModifierContext *> typeModifier();\r
 176     TypeModifierContext* typeModifier(size_t i);\r
 177 \r
 178    \r
 179   };\r
 180 \r
 181   TypeContext* type();\r
 182 \r
 183   class  TypeModifierContext : public antlr4::ParserRuleContext {\r
 184   public:\r
 185     TypeModifierContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 186     virtual size_t getRuleIndex() const override;\r
 187     antlr4::tree::TerminalNode *INT_LIT();\r
 188 \r
 189    \r
 190   };\r
 191 \r
 192   TypeModifierContext* typeModifier();\r
 193 \r
 194   class  NamespaceSpecifierContext : public antlr4::ParserRuleContext {\r
 195   public:\r
 196     NamespaceSpecifierContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 197     virtual size_t getRuleIndex() const override;\r
 198     TypeNameContext *typeName();\r
 199 \r
 200    \r
 201   };\r
 202 \r
 203   NamespaceSpecifierContext* namespaceSpecifier();\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    \r
 212   };\r
 213 \r
 214   FuncDeclContext* funcDecl();\r
 215 \r
 216   class  FuncContext : public antlr4::ParserRuleContext {\r
 217   public:\r
 218     FuncContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 219     virtual size_t getRuleIndex() const override;\r
 220     FuncNameContext *funcName();\r
 221     ParameterContext *parameter();\r
 222     BodyContext *body();\r
 223     TypeContext *type();\r
 224     GenericDeclContext *genericDecl();\r
 225 \r
 226    \r
 227   };\r
 228 \r
 229   FuncContext* func();\r
 230 \r
 231   class  ParameterContext : public antlr4::ParserRuleContext {\r
 232   public:\r
 233     ParameterContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 234     virtual size_t getRuleIndex() const override;\r
 235     std::vector<VarContext *> var();\r
 236     VarContext* var(size_t i);\r
 237 \r
 238    \r
 239   };\r
 240 \r
 241   ParameterContext* parameter();\r
 242 \r
 243   class  BodyContext : public antlr4::ParserRuleContext {\r
 244   public:\r
 245     BodyContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 246     virtual size_t getRuleIndex() const override;\r
 247     std::vector<StmtContext *> stmt();\r
 248     StmtContext* stmt(size_t i);\r
 249 \r
 250    \r
 251   };\r
 252 \r
 253   BodyContext* body();\r
 254 \r
 255   class  StructDeclContext : public antlr4::ParserRuleContext {\r
 256   public:\r
 257     StructDeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 258     virtual size_t getRuleIndex() const override;\r
 259     StructNameContext *structName();\r
 260     GenericDeclContext *genericDecl();\r
 261     std::vector<StructMemberContext *> structMember();\r
 262     StructMemberContext* structMember(size_t i);\r
 263 \r
 264    \r
 265   };\r
 266 \r
 267   StructDeclContext* structDecl();\r
 268 \r
 269   class  StructMemberContext : public antlr4::ParserRuleContext {\r
 270   public:\r
 271     StructMemberContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 272     virtual size_t getRuleIndex() const override;\r
 273     StructVarContext *structVar();\r
 274     PrivateDeclContext *privateDecl();\r
 275     StructMethodContext *structMethod();\r
 276 \r
 277    \r
 278   };\r
 279 \r
 280   StructMemberContext* structMember();\r
 281 \r
 282   class  StructVarContext : public antlr4::ParserRuleContext {\r
 283   public:\r
 284     StructVarContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 285     virtual size_t getRuleIndex() const override;\r
 286     VarContext *var();\r
 287 \r
 288    \r
 289   };\r
 290 \r
 291   StructVarContext* structVar();\r
 292 \r
 293   class  StructMethodContext : public antlr4::ParserRuleContext {\r
 294   public:\r
 295     StructMethodContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 296     virtual size_t getRuleIndex() const override;\r
 297     FuncContext *func();\r
 298 \r
 299    \r
 300   };\r
 301 \r
 302   StructMethodContext* structMethod();\r
 303 \r
 304   class  PrivateDeclContext : public antlr4::ParserRuleContext {\r
 305   public:\r
 306     PrivateDeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 307     virtual size_t getRuleIndex() const override;\r
 308 \r
 309    \r
 310   };\r
 311 \r
 312   PrivateDeclContext* privateDecl();\r
 313 \r
 314   class  GenericDeclContext : public antlr4::ParserRuleContext {\r
 315   public:\r
 316     GenericDeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 317     virtual size_t getRuleIndex() const override;\r
 318     std::vector<TypeNameContext *> typeName();\r
 319     TypeNameContext* typeName(size_t i);\r
 320 \r
 321    \r
 322   };\r
 323 \r
 324   GenericDeclContext* genericDecl();\r
 325 \r
 326   class  StmtContext : public antlr4::ParserRuleContext {\r
 327   public:\r
 328     StmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 329     virtual size_t getRuleIndex() const override;\r
 330     VarDeclContext *varDecl();\r
 331     IfStmtContext *ifStmt();\r
 332     SwitchStmtContext *switchStmt();\r
 333     ForStmtContext *forStmt();\r
 334     WhileStmtContext *whileStmt();\r
 335     AssignStmtContext *assignStmt();\r
 336     ReturnStmtContext *returnStmt();\r
 337     ExprContext *expr();\r
 338 \r
 339    \r
 340   };\r
 341 \r
 342   StmtContext* stmt();\r
 343 \r
 344   class  IfStmtContext : public antlr4::ParserRuleContext {\r
 345   public:\r
 346     IfStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 347     virtual size_t getRuleIndex() const override;\r
 348     ExprContext *expr();\r
 349     BodyContext *body();\r
 350     std::vector<ElseIfStmtContext *> elseIfStmt();\r
 351     ElseIfStmtContext* elseIfStmt(size_t i);\r
 352     ElseStmtContext *elseStmt();\r
 353 \r
 354    \r
 355   };\r
 356 \r
 357   IfStmtContext* ifStmt();\r
 358 \r
 359   class  ElseIfStmtContext : public antlr4::ParserRuleContext {\r
 360   public:\r
 361     ElseIfStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 362     virtual size_t getRuleIndex() const override;\r
 363     ExprContext *expr();\r
 364     BodyContext *body();\r
 365 \r
 366    \r
 367   };\r
 368 \r
 369   ElseIfStmtContext* elseIfStmt();\r
 370 \r
 371   class  ElseStmtContext : public antlr4::ParserRuleContext {\r
 372   public:\r
 373     ElseStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 374     virtual size_t getRuleIndex() const override;\r
 375     BodyContext *body();\r
 376 \r
 377    \r
 378   };\r
 379 \r
 380   ElseStmtContext* elseStmt();\r
 381 \r
 382   class  SwitchStmtContext : public antlr4::ParserRuleContext {\r
 383   public:\r
 384     SwitchStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 385     virtual size_t getRuleIndex() const override;\r
 386     ExprContext *expr();\r
 387     SwitchBodyContext *switchBody();\r
 388 \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    \r
 402   };\r
 403 \r
 404   SwitchBodyContext* switchBody();\r
 405 \r
 406   class  SwitchCaseContext : public antlr4::ParserRuleContext {\r
 407   public:\r
 408     SwitchCaseContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 409     virtual size_t getRuleIndex() const override;\r
 410     ExprContext *expr();\r
 411     BodyContext *body();\r
 412 \r
 413    \r
 414   };\r
 415 \r
 416   SwitchCaseContext* switchCase();\r
 417 \r
 418   class  ForStmtContext : public antlr4::ParserRuleContext {\r
 419   public:\r
 420     ForStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 421     virtual size_t getRuleIndex() const override;\r
 422     std::vector<ExprContext *> expr();\r
 423     ExprContext* expr(size_t i);\r
 424     BodyContext *body();\r
 425     VarInitContext *varInit();\r
 426     AssignStmtContext *assignStmt();\r
 427 \r
 428    \r
 429   };\r
 430 \r
 431   ForStmtContext* forStmt();\r
 432 \r
 433   class  WhileStmtContext : public antlr4::ParserRuleContext {\r
 434   public:\r
 435     WhileStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 436     virtual size_t getRuleIndex() const override;\r
 437     ExprContext *expr();\r
 438     BodyContext *body();\r
 439 \r
 440    \r
 441   };\r
 442 \r
 443   WhileStmtContext* whileStmt();\r
 444 \r
 445   class  AssignStmtContext : public antlr4::ParserRuleContext {\r
 446   public:\r
 447     AssignStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 448     virtual size_t getRuleIndex() const override;\r
 449     std::vector<ExprContext *> expr();\r
 450     ExprContext* expr(size_t i);\r
 451 \r
 452    \r
 453   };\r
 454 \r
 455   AssignStmtContext* assignStmt();\r
 456 \r
 457   class  ReturnStmtContext : public antlr4::ParserRuleContext {\r
 458   public:\r
 459     ReturnStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 460     virtual size_t getRuleIndex() const override;\r
 461     ExprContext *expr();\r
 462 \r
 463    \r
 464   };\r
 465 \r
 466   ReturnStmtContext* returnStmt();\r
 467 \r
 468   class  ExprContext : public antlr4::ParserRuleContext {\r
 469   public:\r
 470     ExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 471    \r
 472     ExprContext() = default;\r
 473     void copyFrom(ExprContext *context);\r
 474     using antlr4::ParserRuleContext::copyFrom;\r
 475 \r
 476     virtual size_t getRuleIndex() const override;\r
 477 \r
 478    \r
 479   };\r
 480 \r
 481   class  DotExprContext : public ExprContext {\r
 482   public:\r
 483     DotExprContext(ExprContext *ctx);\r
 484 \r
 485     ExprContext *expr();\r
 486     VarNameContext *varName();\r
 487   };\r
 488 \r
 489   class  FuncExprContext : public ExprContext {\r
 490   public:\r
 491     FuncExprContext(ExprContext *ctx);\r
 492 \r
 493     FuncNameContext *funcName();\r
 494     std::vector<NamespaceSpecifierContext *> namespaceSpecifier();\r
 495     NamespaceSpecifierContext* namespaceSpecifier(size_t i);\r
 496     std::vector<ExprContext *> expr();\r
 497     ExprContext* expr(size_t i);\r
 498   };\r
 499 \r
 500   class  BracketExprContext : public ExprContext {\r
 501   public:\r
 502     BracketExprContext(ExprContext *ctx);\r
 503 \r
 504     std::vector<ExprContext *> expr();\r
 505     ExprContext* expr(size_t i);\r
 506   };\r
 507 \r
 508   class  PrefixOpExprContext : public ExprContext {\r
 509   public:\r
 510     PrefixOpExprContext(ExprContext *ctx);\r
 511 \r
 512     Prefix_opContext *prefix_op();\r
 513     ExprContext *expr();\r
 514   };\r
 515 \r
 516   class  MethodExprContext : public ExprContext {\r
 517   public:\r
 518     MethodExprContext(ExprContext *ctx);\r
 519 \r
 520     std::vector<ExprContext *> expr();\r
 521     ExprContext* expr(size_t i);\r
 522     FuncNameContext *funcName();\r
 523   };\r
 524 \r
 525   class  PostfixOpExprContext : public ExprContext {\r
 526   public:\r
 527     PostfixOpExprContext(ExprContext *ctx);\r
 528 \r
 529     ExprContext *expr();\r
 530     Postfix_opContext *postfix_op();\r
 531   };\r
 532 \r
 533   class  BinaryOpExprContext : public ExprContext {\r
 534   public:\r
 535     BinaryOpExprContext(ExprContext *ctx);\r
 536 \r
 537     std::vector<ExprContext *> expr();\r
 538     ExprContext* expr(size_t i);\r
 539     Binary_opContext *binary_op();\r
 540   };\r
 541 \r
 542   class  TernaryOpExprContext : public ExprContext {\r
 543   public:\r
 544     TernaryOpExprContext(ExprContext *ctx);\r
 545 \r
 546     std::vector<ExprContext *> expr();\r
 547     ExprContext* expr(size_t i);\r
 548   };\r
 549 \r
 550   class  LitExprContext : public ExprContext {\r
 551   public:\r
 552     LitExprContext(ExprContext *ctx);\r
 553 \r
 554     LiteralContext *literal();\r
 555   };\r
 556 \r
 557   class  ParenExprContext : public ExprContext {\r
 558   public:\r
 559     ParenExprContext(ExprContext *ctx);\r
 560 \r
 561     ExprContext *expr();\r
 562   };\r
 563 \r
 564   class  IdentifierExprContext : public ExprContext {\r
 565   public:\r
 566     IdentifierExprContext(ExprContext *ctx);\r
 567 \r
 568     VarNameContext *varName();\r
 569     std::vector<NamespaceSpecifierContext *> namespaceSpecifier();\r
 570     NamespaceSpecifierContext* namespaceSpecifier(size_t i);\r
 571   };\r
 572 \r
 573   ExprContext* expr();\r
 574   ExprContext* expr(int precedence);\r
 575   class  LiteralContext : public antlr4::ParserRuleContext {\r
 576   public:\r
 577     LiteralContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 578     virtual size_t getRuleIndex() const override;\r
 579     antlr4::tree::TerminalNode *INT_LIT();\r
 580     antlr4::tree::TerminalNode *DECIMAL_LIT();\r
 581     antlr4::tree::TerminalNode *STRING_LIT();\r
 582     antlr4::tree::TerminalNode *BOOL_LIT();\r
 583 \r
 584    \r
 585   };\r
 586 \r
 587   LiteralContext* literal();\r
 588 \r
 589   class  FuncNameContext : public antlr4::ParserRuleContext {\r
 590   public:\r
 591     FuncNameContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 592     virtual size_t getRuleIndex() const override;\r
 593     antlr4::tree::TerminalNode *NAME();\r
 594 \r
 595    \r
 596   };\r
 597 \r
 598   FuncNameContext* funcName();\r
 599 \r
 600   class  VarNameContext : public antlr4::ParserRuleContext {\r
 601   public:\r
 602     VarNameContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 603     virtual size_t getRuleIndex() const override;\r
 604     antlr4::tree::TerminalNode *NAME();\r
 605 \r
 606    \r
 607   };\r
 608 \r
 609   VarNameContext* varName();\r
 610 \r
 611   class  TypeNameContext : public antlr4::ParserRuleContext {\r
 612   public:\r
 613     TypeNameContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 614     virtual size_t getRuleIndex() const override;\r
 615     antlr4::tree::TerminalNode *NAME();\r
 616 \r
 617    \r
 618   };\r
 619 \r
 620   TypeNameContext* typeName();\r
 621 \r
 622   class  StructNameContext : public antlr4::ParserRuleContext {\r
 623   public:\r
 624     StructNameContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 625     virtual size_t getRuleIndex() const override;\r
 626     antlr4::tree::TerminalNode *NAME();\r
 627 \r
 628    \r
 629   };\r
 630 \r
 631   StructNameContext* structName();\r
 632 \r
 633   class  Postfix_opContext : public antlr4::ParserRuleContext {\r
 634   public:\r
 635     Postfix_opContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 636     virtual size_t getRuleIndex() const override;\r
 637 \r
 638    \r
 639   };\r
 640 \r
 641   Postfix_opContext* postfix_op();\r
 642 \r
 643   class  Prefix_opContext : public antlr4::ParserRuleContext {\r
 644   public:\r
 645     Prefix_opContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 646     virtual size_t getRuleIndex() const override;\r
 647     Postfix_opContext *postfix_op();\r
 648 \r
 649    \r
 650   };\r
 651 \r
 652   Prefix_opContext* prefix_op();\r
 653 \r
 654   class  Binary_opContext : public antlr4::ParserRuleContext {\r
 655   public:\r
 656     Binary_opContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 657     virtual size_t getRuleIndex() const override;\r
 658 \r
 659    \r
 660   };\r
 661 \r
 662   Binary_opContext* binary_op();\r
 663 \r
 664 \r
 665   virtual bool sempred(antlr4::RuleContext *_localctx, size_t ruleIndex, size_t predicateIndex) override;\r
 666   bool exprSempred(ExprContext *_localctx, size_t predicateIndex);\r
 667 \r
 668 private:\r
 669   static std::vector<antlr4::dfa::DFA> _decisionToDFA;\r
 670   static antlr4::atn::PredictionContextCache _sharedContextCache;\r
 671   static std::vector<std::string> _ruleNames;\r
 672   static std::vector<std::string> _tokenNames;\r
 673 \r
 674   static std::vector<std::string> _literalNames;\r
 675   static std::vector<std::string> _symbolicNames;\r
 676   static antlr4::dfa::Vocabulary _vocabulary;\r
 677   static antlr4::atn::ATN _atn;\r
 678   static std::vector<uint16_t> _serializedATN;\r
 679 \r
 680 \r
 681   struct Initializer {\r
 682     Initializer();\r
 683   };\r
 684   static Initializer _init;\r
 685 };\r
 686 \r