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, BOOL_LIT = 60, StringLit = 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     TypeContext *type();\r
 223     BodyContext *body();\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     VarInitContext *varInit();\r
 423     std::vector<ExprContext *> expr();\r
 424     ExprContext* expr(size_t i);\r
 425     BodyContext *body();\r
 426 \r
 427    \r
 428   };\r
 429 \r
 430   ForStmtContext* forStmt();\r
 431 \r
 432   class  WhileStmtContext : public antlr4::ParserRuleContext {\r
 433   public:\r
 434     WhileStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 435     virtual size_t getRuleIndex() const override;\r
 436     ExprContext *expr();\r
 437     BodyContext *body();\r
 438 \r
 439    \r
 440   };\r
 441 \r
 442   WhileStmtContext* whileStmt();\r
 443 \r
 444   class  AssignStmtContext : public antlr4::ParserRuleContext {\r
 445   public:\r
 446     AssignStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 447     virtual size_t getRuleIndex() const override;\r
 448     std::vector<ExprContext *> expr();\r
 449     ExprContext* expr(size_t i);\r
 450 \r
 451    \r
 452   };\r
 453 \r
 454   AssignStmtContext* assignStmt();\r
 455 \r
 456   class  ReturnStmtContext : public antlr4::ParserRuleContext {\r
 457   public:\r
 458     ReturnStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 459     virtual size_t getRuleIndex() const override;\r
 460     ExprContext *expr();\r
 461 \r
 462    \r
 463   };\r
 464 \r
 465   ReturnStmtContext* returnStmt();\r
 466 \r
 467   class  ExprContext : public antlr4::ParserRuleContext {\r
 468   public:\r
 469     ExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 470    \r
 471     ExprContext() = default;\r
 472     void copyFrom(ExprContext *context);\r
 473     using antlr4::ParserRuleContext::copyFrom;\r
 474 \r
 475     virtual size_t getRuleIndex() const override;\r
 476 \r
 477    \r
 478   };\r
 479 \r
 480   class  DotExprContext : public ExprContext {\r
 481   public:\r
 482     DotExprContext(ExprContext *ctx);\r
 483 \r
 484     ExprContext *expr();\r
 485     VarNameContext *varName();\r
 486   };\r
 487 \r
 488   class  FuncExprContext : public ExprContext {\r
 489   public:\r
 490     FuncExprContext(ExprContext *ctx);\r
 491 \r
 492     FuncNameContext *funcName();\r
 493     std::vector<NamespaceSpecifierContext *> namespaceSpecifier();\r
 494     NamespaceSpecifierContext* namespaceSpecifier(size_t i);\r
 495     std::vector<ExprContext *> expr();\r
 496     ExprContext* expr(size_t i);\r
 497   };\r
 498 \r
 499   class  BracketExprContext : public ExprContext {\r
 500   public:\r
 501     BracketExprContext(ExprContext *ctx);\r
 502 \r
 503     std::vector<ExprContext *> expr();\r
 504     ExprContext* expr(size_t i);\r
 505   };\r
 506 \r
 507   class  PrefixOpExprContext : public ExprContext {\r
 508   public:\r
 509     PrefixOpExprContext(ExprContext *ctx);\r
 510 \r
 511     Prefix_opContext *prefix_op();\r
 512     ExprContext *expr();\r
 513   };\r
 514 \r
 515   class  MethodExprContext : public ExprContext {\r
 516   public:\r
 517     MethodExprContext(ExprContext *ctx);\r
 518 \r
 519     std::vector<ExprContext *> expr();\r
 520     ExprContext* expr(size_t i);\r
 521     FuncNameContext *funcName();\r
 522   };\r
 523 \r
 524   class  PostfixOpExprContext : public ExprContext {\r
 525   public:\r
 526     PostfixOpExprContext(ExprContext *ctx);\r
 527 \r
 528     ExprContext *expr();\r
 529     Postfix_opContext *postfix_op();\r
 530   };\r
 531 \r
 532   class  BinaryOpExprContext : public ExprContext {\r
 533   public:\r
 534     BinaryOpExprContext(ExprContext *ctx);\r
 535 \r
 536     std::vector<ExprContext *> expr();\r
 537     ExprContext* expr(size_t i);\r
 538     Binary_opContext *binary_op();\r
 539   };\r
 540 \r
 541   class  TernaryOpExprContext : public ExprContext {\r
 542   public:\r
 543     TernaryOpExprContext(ExprContext *ctx);\r
 544 \r
 545     std::vector<ExprContext *> expr();\r
 546     ExprContext* expr(size_t i);\r
 547   };\r
 548 \r
 549   class  LitExprContext : public ExprContext {\r
 550   public:\r
 551     LitExprContext(ExprContext *ctx);\r
 552 \r
 553     LiteralContext *literal();\r
 554   };\r
 555 \r
 556   class  ParenExprContext : public ExprContext {\r
 557   public:\r
 558     ParenExprContext(ExprContext *ctx);\r
 559 \r
 560     ExprContext *expr();\r
 561   };\r
 562 \r
 563   class  IdentifierExprContext : public ExprContext {\r
 564   public:\r
 565     IdentifierExprContext(ExprContext *ctx);\r
 566 \r
 567     VarNameContext *varName();\r
 568     std::vector<NamespaceSpecifierContext *> namespaceSpecifier();\r
 569     NamespaceSpecifierContext* namespaceSpecifier(size_t i);\r
 570   };\r
 571 \r
 572   ExprContext* expr();\r
 573   ExprContext* expr(int precedence);\r
 574   class  LiteralContext : public antlr4::ParserRuleContext {\r
 575   public:\r
 576     LiteralContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 577     virtual size_t getRuleIndex() const override;\r
 578     antlr4::tree::TerminalNode *INT_LIT();\r
 579     antlr4::tree::TerminalNode *DECIMAL_LIT();\r
 580     antlr4::tree::TerminalNode *StringLit();\r
 581     antlr4::tree::TerminalNode *BOOL_LIT();\r
 582 \r
 583    \r
 584   };\r
 585 \r
 586   LiteralContext* literal();\r
 587 \r
 588   class  FuncNameContext : public antlr4::ParserRuleContext {\r
 589   public:\r
 590     FuncNameContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 591     virtual size_t getRuleIndex() const override;\r
 592     antlr4::tree::TerminalNode *NAME();\r
 593 \r
 594    \r
 595   };\r
 596 \r
 597   FuncNameContext* funcName();\r
 598 \r
 599   class  VarNameContext : public antlr4::ParserRuleContext {\r
 600   public:\r
 601     VarNameContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 602     virtual size_t getRuleIndex() const override;\r
 603     antlr4::tree::TerminalNode *NAME();\r
 604 \r
 605    \r
 606   };\r
 607 \r
 608   VarNameContext* varName();\r
 609 \r
 610   class  TypeNameContext : public antlr4::ParserRuleContext {\r
 611   public:\r
 612     TypeNameContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 613     virtual size_t getRuleIndex() const override;\r
 614     antlr4::tree::TerminalNode *NAME();\r
 615 \r
 616    \r
 617   };\r
 618 \r
 619   TypeNameContext* typeName();\r
 620 \r
 621   class  StructNameContext : public antlr4::ParserRuleContext {\r
 622   public:\r
 623     StructNameContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 624     virtual size_t getRuleIndex() const override;\r
 625     antlr4::tree::TerminalNode *NAME();\r
 626 \r
 627    \r
 628   };\r
 629 \r
 630   StructNameContext* structName();\r
 631 \r
 632   class  Postfix_opContext : public antlr4::ParserRuleContext {\r
 633   public:\r
 634     Postfix_opContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 635     virtual size_t getRuleIndex() const override;\r
 636 \r
 637    \r
 638   };\r
 639 \r
 640   Postfix_opContext* postfix_op();\r
 641 \r
 642   class  Prefix_opContext : public antlr4::ParserRuleContext {\r
 643   public:\r
 644     Prefix_opContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 645     virtual size_t getRuleIndex() const override;\r
 646     Postfix_opContext *postfix_op();\r
 647 \r
 648    \r
 649   };\r
 650 \r
 651   Prefix_opContext* prefix_op();\r
 652 \r
 653   class  Binary_opContext : public antlr4::ParserRuleContext {\r
 654   public:\r
 655     Binary_opContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 656     virtual size_t getRuleIndex() const override;\r
 657 \r
 658    \r
 659   };\r
 660 \r
 661   Binary_opContext* binary_op();\r
 662 \r
 663 \r
 664   virtual bool sempred(antlr4::RuleContext *_localctx, size_t ruleIndex, size_t predicateIndex) override;\r
 665   bool exprSempred(ExprContext *_localctx, size_t predicateIndex);\r
 666 \r
 667 private:\r
 668   static std::vector<antlr4::dfa::DFA> _decisionToDFA;\r
 669   static antlr4::atn::PredictionContextCache _sharedContextCache;\r
 670   static std::vector<std::string> _ruleNames;\r
 671   static std::vector<std::string> _tokenNames;\r
 672 \r
 673   static std::vector<std::string> _literalNames;\r
 674   static std::vector<std::string> _symbolicNames;\r
 675   static antlr4::dfa::Vocabulary _vocabulary;\r
 676   static antlr4::atn::ATN _atn;\r
 677   static std::vector<uint16_t> _serializedATN;\r
 678 \r
 679 \r
 680   struct Initializer {\r
 681     Initializer();\r
 682   };\r
 683   static Initializer _init;\r
 684 };\r
 685 \r