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