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, BINARY_OPERATOR = 17, INTLIT = 18, NAME = 19, \r
  18     WS = 20, NEWLINE = 21\r
  19   };\r
  20 \r
  21   enum {\r
  22     RuleProg = 0, RuleDecl = 1, RuleVarDecl = 2, RuleVar = 3, RuleType = 4, \r
  23     RuleFuncDecl = 5, RuleFunc = 6, RuleParameter = 7, RuleFirstParameter = 8, \r
  24     RuleAdditionalParameter = 9, RuleBody = 10, RuleStructDecl = 11, RuleStructMember = 12, \r
  25     RuleStructVar = 13, RuleStructMethod = 14, RuleStmt = 15, RuleConditional = 16, \r
  26     RuleIfCond = 17, RuleLoop = 18, RuleWhileLoop = 19, RuleAssignment = 20, \r
  27     RuleReturnStmt = 21, RuleExpr = 22, RuleNonOpExpr = 23, RuleNonSubscriptExpr = 24, \r
  28     RuleFuncCall = 25, RuleOperatorExpr = 26, RuleBinaryOperator = 27, RuleIdentifier = 28, \r
  29     RuleLiteral = 29, RuleSubscript = 30, RuleMemberAccess = 31, RuleParenExpr = 32, \r
  30     RuleFuncName = 33, RuleVarName = 34, RuleTypeName = 35, RuleStructName = 36\r
  31   };\r
  32 \r
  33   explicit TocParser(antlr4::TokenStream *input);\r
  34   ~TocParser();\r
  35 \r
  36   virtual std::string getGrammarFileName() const override;\r
  37   virtual const antlr4::atn::ATN& getATN() const override { return _atn; };\r
  38   virtual const std::vector<std::string>& getTokenNames() const override { return _tokenNames; }; // deprecated: use vocabulary instead.\r
  39   virtual const std::vector<std::string>& getRuleNames() const override;\r
  40   virtual antlr4::dfa::Vocabulary& getVocabulary() const override;\r
  41 \r
  42 \r
  43   class ProgContext;\r
  44   class DeclContext;\r
  45   class VarDeclContext;\r
  46   class VarContext;\r
  47   class TypeContext;\r
  48   class FuncDeclContext;\r
  49   class FuncContext;\r
  50   class ParameterContext;\r
  51   class FirstParameterContext;\r
  52   class AdditionalParameterContext;\r
  53   class BodyContext;\r
  54   class StructDeclContext;\r
  55   class StructMemberContext;\r
  56   class StructVarContext;\r
  57   class StructMethodContext;\r
  58   class StmtContext;\r
  59   class ConditionalContext;\r
  60   class IfCondContext;\r
  61   class LoopContext;\r
  62   class WhileLoopContext;\r
  63   class AssignmentContext;\r
  64   class ReturnStmtContext;\r
  65   class ExprContext;\r
  66   class NonOpExprContext;\r
  67   class NonSubscriptExprContext;\r
  68   class FuncCallContext;\r
  69   class OperatorExprContext;\r
  70   class BinaryOperatorContext;\r
  71   class IdentifierContext;\r
  72   class LiteralContext;\r
  73   class SubscriptContext;\r
  74   class MemberAccessContext;\r
  75   class ParenExprContext;\r
  76   class FuncNameContext;\r
  77   class VarNameContext;\r
  78   class TypeNameContext;\r
  79   class StructNameContext; \r
  80 \r
  81   class  ProgContext : public antlr4::ParserRuleContext {\r
  82   public:\r
  83     ProgContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
  84     virtual size_t getRuleIndex() const override;\r
  85     antlr4::tree::TerminalNode *EOF();\r
  86     std::vector<DeclContext *> decl();\r
  87     DeclContext* decl(size_t i);\r
  88 \r
  89     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
  90     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
  91    \r
  92   };\r
  93 \r
  94   ProgContext* prog();\r
  95 \r
  96   class  DeclContext : public antlr4::ParserRuleContext {\r
  97   public:\r
  98     DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
  99     virtual size_t getRuleIndex() const override;\r
 100     VarDeclContext *varDecl();\r
 101     FuncDeclContext *funcDecl();\r
 102     StructDeclContext *structDecl();\r
 103 \r
 104     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 105     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 106    \r
 107   };\r
 108 \r
 109   DeclContext* decl();\r
 110 \r
 111   class  VarDeclContext : public antlr4::ParserRuleContext {\r
 112   public:\r
 113     VarDeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 114     virtual size_t getRuleIndex() const override;\r
 115     VarContext *var();\r
 116 \r
 117     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 118     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 119    \r
 120   };\r
 121 \r
 122   VarDeclContext* varDecl();\r
 123 \r
 124   class  VarContext : public antlr4::ParserRuleContext {\r
 125   public:\r
 126     VarContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 127     virtual size_t getRuleIndex() const override;\r
 128     VarNameContext *varName();\r
 129     TypeContext *type();\r
 130     ExprContext *expr();\r
 131 \r
 132     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 133     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 134    \r
 135   };\r
 136 \r
 137   VarContext* var();\r
 138 \r
 139   class  TypeContext : public antlr4::ParserRuleContext {\r
 140   public:\r
 141     TypeContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 142     virtual size_t getRuleIndex() const override;\r
 143     TypeNameContext *typeName();\r
 144 \r
 145     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 146     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 147    \r
 148   };\r
 149 \r
 150   TypeContext* type();\r
 151 \r
 152   class  FuncDeclContext : public antlr4::ParserRuleContext {\r
 153   public:\r
 154     FuncDeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 155     virtual size_t getRuleIndex() const override;\r
 156     FuncContext *func();\r
 157 \r
 158     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 159     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 160    \r
 161   };\r
 162 \r
 163   FuncDeclContext* funcDecl();\r
 164 \r
 165   class  FuncContext : public antlr4::ParserRuleContext {\r
 166   public:\r
 167     FuncContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 168     virtual size_t getRuleIndex() const override;\r
 169     FuncNameContext *funcName();\r
 170     ParameterContext *parameter();\r
 171     BodyContext *body();\r
 172     TypeContext *type();\r
 173 \r
 174     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 175     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 176    \r
 177   };\r
 178 \r
 179   FuncContext* func();\r
 180 \r
 181   class  ParameterContext : public antlr4::ParserRuleContext {\r
 182   public:\r
 183     ParameterContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 184     virtual size_t getRuleIndex() const override;\r
 185     FirstParameterContext *firstParameter();\r
 186     std::vector<AdditionalParameterContext *> additionalParameter();\r
 187     AdditionalParameterContext* additionalParameter(size_t i);\r
 188 \r
 189     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 190     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 191    \r
 192   };\r
 193 \r
 194   ParameterContext* parameter();\r
 195 \r
 196   class  FirstParameterContext : public antlr4::ParserRuleContext {\r
 197   public:\r
 198     FirstParameterContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 199     virtual size_t getRuleIndex() const override;\r
 200     VarContext *var();\r
 201 \r
 202     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 203     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 204    \r
 205   };\r
 206 \r
 207   FirstParameterContext* firstParameter();\r
 208 \r
 209   class  AdditionalParameterContext : public antlr4::ParserRuleContext {\r
 210   public:\r
 211     AdditionalParameterContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 212     virtual size_t getRuleIndex() const override;\r
 213     VarContext *var();\r
 214 \r
 215     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 216     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 217    \r
 218   };\r
 219 \r
 220   AdditionalParameterContext* additionalParameter();\r
 221 \r
 222   class  BodyContext : public antlr4::ParserRuleContext {\r
 223   public:\r
 224     BodyContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 225     virtual size_t getRuleIndex() const override;\r
 226     std::vector<StmtContext *> stmt();\r
 227     StmtContext* stmt(size_t i);\r
 228 \r
 229     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 230     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 231    \r
 232   };\r
 233 \r
 234   BodyContext* body();\r
 235 \r
 236   class  StructDeclContext : public antlr4::ParserRuleContext {\r
 237   public:\r
 238     StructDeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 239     virtual size_t getRuleIndex() const override;\r
 240     StructNameContext *structName();\r
 241     std::vector<StructMemberContext *> structMember();\r
 242     StructMemberContext* structMember(size_t i);\r
 243 \r
 244     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 245     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 246    \r
 247   };\r
 248 \r
 249   StructDeclContext* structDecl();\r
 250 \r
 251   class  StructMemberContext : public antlr4::ParserRuleContext {\r
 252   public:\r
 253     StructMemberContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 254     virtual size_t getRuleIndex() const override;\r
 255     StructVarContext *structVar();\r
 256     StructMethodContext *structMethod();\r
 257 \r
 258     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 259     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\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     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 272     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 273    \r
 274   };\r
 275 \r
 276   StructVarContext* structVar();\r
 277 \r
 278   class  StructMethodContext : public antlr4::ParserRuleContext {\r
 279   public:\r
 280     StructMethodContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 281     virtual size_t getRuleIndex() const override;\r
 282     FuncContext *func();\r
 283 \r
 284     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 285     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 286    \r
 287   };\r
 288 \r
 289   StructMethodContext* structMethod();\r
 290 \r
 291   class  StmtContext : public antlr4::ParserRuleContext {\r
 292   public:\r
 293     StmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 294     virtual size_t getRuleIndex() const override;\r
 295     VarDeclContext *varDecl();\r
 296     ConditionalContext *conditional();\r
 297     LoopContext *loop();\r
 298     AssignmentContext *assignment();\r
 299     ReturnStmtContext *returnStmt();\r
 300     ExprContext *expr();\r
 301 \r
 302     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 303     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 304    \r
 305   };\r
 306 \r
 307   StmtContext* stmt();\r
 308 \r
 309   class  ConditionalContext : public antlr4::ParserRuleContext {\r
 310   public:\r
 311     ConditionalContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 312     virtual size_t getRuleIndex() const override;\r
 313     IfCondContext *ifCond();\r
 314 \r
 315     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 316     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 317    \r
 318   };\r
 319 \r
 320   ConditionalContext* conditional();\r
 321 \r
 322   class  IfCondContext : public antlr4::ParserRuleContext {\r
 323   public:\r
 324     IfCondContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 325     virtual size_t getRuleIndex() const override;\r
 326     ExprContext *expr();\r
 327     BodyContext *body();\r
 328 \r
 329     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 330     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 331    \r
 332   };\r
 333 \r
 334   IfCondContext* ifCond();\r
 335 \r
 336   class  LoopContext : public antlr4::ParserRuleContext {\r
 337   public:\r
 338     LoopContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 339     virtual size_t getRuleIndex() const override;\r
 340     WhileLoopContext *whileLoop();\r
 341 \r
 342     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 343     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 344    \r
 345   };\r
 346 \r
 347   LoopContext* loop();\r
 348 \r
 349   class  WhileLoopContext : public antlr4::ParserRuleContext {\r
 350   public:\r
 351     WhileLoopContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 352     virtual size_t getRuleIndex() const override;\r
 353     ExprContext *expr();\r
 354     BodyContext *body();\r
 355 \r
 356     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 357     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 358    \r
 359   };\r
 360 \r
 361   WhileLoopContext* whileLoop();\r
 362 \r
 363   class  AssignmentContext : public antlr4::ParserRuleContext {\r
 364   public:\r
 365     AssignmentContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 366     virtual size_t getRuleIndex() const override;\r
 367     IdentifierContext *identifier();\r
 368     ExprContext *expr();\r
 369 \r
 370     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 371     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 372    \r
 373   };\r
 374 \r
 375   AssignmentContext* assignment();\r
 376 \r
 377   class  ReturnStmtContext : public antlr4::ParserRuleContext {\r
 378   public:\r
 379     ReturnStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 380     virtual size_t getRuleIndex() const override;\r
 381     ExprContext *expr();\r
 382 \r
 383     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 384     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 385    \r
 386   };\r
 387 \r
 388   ReturnStmtContext* returnStmt();\r
 389 \r
 390   class  ExprContext : public antlr4::ParserRuleContext {\r
 391   public:\r
 392     ExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 393     virtual size_t getRuleIndex() const override;\r
 394     FuncCallContext *funcCall();\r
 395     LiteralContext *literal();\r
 396     IdentifierContext *identifier();\r
 397     SubscriptContext *subscript();\r
 398     MemberAccessContext *memberAccess();\r
 399     ParenExprContext *parenExpr();\r
 400     OperatorExprContext *operatorExpr();\r
 401 \r
 402     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 403     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 404    \r
 405   };\r
 406 \r
 407   ExprContext* expr();\r
 408 \r
 409   class  NonOpExprContext : public antlr4::ParserRuleContext {\r
 410   public:\r
 411     NonOpExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 412     virtual size_t getRuleIndex() const override;\r
 413     FuncCallContext *funcCall();\r
 414     LiteralContext *literal();\r
 415     IdentifierContext *identifier();\r
 416     SubscriptContext *subscript();\r
 417     MemberAccessContext *memberAccess();\r
 418     ParenExprContext *parenExpr();\r
 419 \r
 420     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 421     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 422    \r
 423   };\r
 424 \r
 425   NonOpExprContext* nonOpExpr();\r
 426 \r
 427   class  NonSubscriptExprContext : public antlr4::ParserRuleContext {\r
 428   public:\r
 429     NonSubscriptExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 430     virtual size_t getRuleIndex() const override;\r
 431     FuncCallContext *funcCall();\r
 432     IdentifierContext *identifier();\r
 433     MemberAccessContext *memberAccess();\r
 434     ParenExprContext *parenExpr();\r
 435 \r
 436     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 437     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 438    \r
 439   };\r
 440 \r
 441   NonSubscriptExprContext* nonSubscriptExpr();\r
 442 \r
 443   class  FuncCallContext : public antlr4::ParserRuleContext {\r
 444   public:\r
 445     FuncCallContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 446     virtual size_t getRuleIndex() const override;\r
 447     FuncNameContext *funcName();\r
 448     std::vector<ExprContext *> expr();\r
 449     ExprContext* expr(size_t i);\r
 450 \r
 451     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 452     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 453    \r
 454   };\r
 455 \r
 456   FuncCallContext* funcCall();\r
 457 \r
 458   class  OperatorExprContext : public antlr4::ParserRuleContext {\r
 459   public:\r
 460     OperatorExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 461     virtual size_t getRuleIndex() const override;\r
 462     BinaryOperatorContext *binaryOperator();\r
 463 \r
 464     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 465     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 466    \r
 467   };\r
 468 \r
 469   OperatorExprContext* operatorExpr();\r
 470 \r
 471   class  BinaryOperatorContext : public antlr4::ParserRuleContext {\r
 472   public:\r
 473     BinaryOperatorContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 474     virtual size_t getRuleIndex() const override;\r
 475     std::vector<NonOpExprContext *> nonOpExpr();\r
 476     NonOpExprContext* nonOpExpr(size_t i);\r
 477     std::vector<antlr4::tree::TerminalNode *> BINARY_OPERATOR();\r
 478     antlr4::tree::TerminalNode* BINARY_OPERATOR(size_t i);\r
 479 \r
 480     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 481     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 482    \r
 483   };\r
 484 \r
 485   BinaryOperatorContext* binaryOperator();\r
 486 \r
 487   class  IdentifierContext : public antlr4::ParserRuleContext {\r
 488   public:\r
 489     IdentifierContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 490     virtual size_t getRuleIndex() const override;\r
 491     VarNameContext *varName();\r
 492 \r
 493     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 494     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 495    \r
 496   };\r
 497 \r
 498   IdentifierContext* identifier();\r
 499 \r
 500   class  LiteralContext : public antlr4::ParserRuleContext {\r
 501   public:\r
 502     LiteralContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 503     virtual size_t getRuleIndex() const override;\r
 504     antlr4::tree::TerminalNode *INTLIT();\r
 505 \r
 506     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 507     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 508    \r
 509   };\r
 510 \r
 511   LiteralContext* literal();\r
 512 \r
 513   class  SubscriptContext : public antlr4::ParserRuleContext {\r
 514   public:\r
 515     SubscriptContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 516     virtual size_t getRuleIndex() const override;\r
 517     NonSubscriptExprContext *nonSubscriptExpr();\r
 518     ExprContext *expr();\r
 519 \r
 520     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 521     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 522    \r
 523   };\r
 524 \r
 525   SubscriptContext* subscript();\r
 526 \r
 527   class  MemberAccessContext : public antlr4::ParserRuleContext {\r
 528   public:\r
 529     MemberAccessContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 530     virtual size_t getRuleIndex() const override;\r
 531     std::vector<IdentifierContext *> identifier();\r
 532     IdentifierContext* identifier(size_t i);\r
 533 \r
 534     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 535     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 536    \r
 537   };\r
 538 \r
 539   MemberAccessContext* memberAccess();\r
 540 \r
 541   class  ParenExprContext : public antlr4::ParserRuleContext {\r
 542   public:\r
 543     ParenExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 544     virtual size_t getRuleIndex() const override;\r
 545     ExprContext *expr();\r
 546 \r
 547     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 548     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 549    \r
 550   };\r
 551 \r
 552   ParenExprContext* parenExpr();\r
 553 \r
 554   class  FuncNameContext : public antlr4::ParserRuleContext {\r
 555   public:\r
 556     FuncNameContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 557     virtual size_t getRuleIndex() const override;\r
 558     antlr4::tree::TerminalNode *NAME();\r
 559 \r
 560     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 561     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 562    \r
 563   };\r
 564 \r
 565   FuncNameContext* funcName();\r
 566 \r
 567   class  VarNameContext : public antlr4::ParserRuleContext {\r
 568   public:\r
 569     VarNameContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 570     virtual size_t getRuleIndex() const override;\r
 571     antlr4::tree::TerminalNode *NAME();\r
 572 \r
 573     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 574     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 575    \r
 576   };\r
 577 \r
 578   VarNameContext* varName();\r
 579 \r
 580   class  TypeNameContext : public antlr4::ParserRuleContext {\r
 581   public:\r
 582     TypeNameContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 583     virtual size_t getRuleIndex() const override;\r
 584     antlr4::tree::TerminalNode *NAME();\r
 585 \r
 586     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 587     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 588    \r
 589   };\r
 590 \r
 591   TypeNameContext* typeName();\r
 592 \r
 593   class  StructNameContext : public antlr4::ParserRuleContext {\r
 594   public:\r
 595     StructNameContext(antlr4::ParserRuleContext *parent, size_t invokingState);\r
 596     virtual size_t getRuleIndex() const override;\r
 597     antlr4::tree::TerminalNode *NAME();\r
 598 \r
 599     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;\r
 600     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;\r
 601    \r
 602   };\r
 603 \r
 604   StructNameContext* structName();\r
 605 \r
 606 \r
 607 private:\r
 608   static std::vector<antlr4::dfa::DFA> _decisionToDFA;\r
 609   static antlr4::atn::PredictionContextCache _sharedContextCache;\r
 610   static std::vector<std::string> _ruleNames;\r
 611   static std::vector<std::string> _tokenNames;\r
 612 \r
 613   static std::vector<std::string> _literalNames;\r
 614   static std::vector<std::string> _symbolicNames;\r
 615   static antlr4::dfa::Vocabulary _vocabulary;\r
 616   static antlr4::atn::ATN _atn;\r
 617   static std::vector<uint16_t> _serializedATN;\r
 618 \r
 619 \r
 620   struct Initializer {\r
 621     Initializer();\r
 622   };\r
 623   static Initializer _init;\r
 624 };\r
 625 \r