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