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