Пример #1
0
@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
public class MicroLexer extends Lexer {
  protected static final DFA[] _decisionToDFA;
  protected static final PredictionContextCache _sharedContextCache = new PredictionContextCache();
  public static final int T__30 = 1,
      T__29 = 2,
      T__28 = 3,
      T__27 = 4,
      T__26 = 5,
      T__25 = 6,
      T__24 = 7,
      T__23 = 8,
      T__22 = 9,
      T__21 = 10,
      T__20 = 11,
      T__19 = 12,
      T__18 = 13,
      T__17 = 14,
      T__16 = 15,
      T__15 = 16,
      T__14 = 17,
      T__13 = 18,
      T__12 = 19,
      T__11 = 20,
      T__10 = 21,
      T__9 = 22,
      T__8 = 23,
      T__7 = 24,
      T__6 = 25,
      T__5 = 26,
      T__4 = 27,
      T__3 = 28,
      T__2 = 29,
      T__1 = 30,
      T__0 = 31,
      KEYWORD = 32,
      IDENTIFIER = 33,
      FLOATLITERAL = 34,
      INTLITERAL = 35,
      STRINGLITERAL = 36,
      OPERATORS = 37,
      COMMENTS = 38,
      WHITESPACE = 39;
  public static String[] modeNames = {"DEFAULT_MODE"};

  public static final String[] tokenNames = {
    "<INVALID>",
    "','",
    "'ROF'",
    "'*'",
    "'-'",
    "'FI'",
    "'PROGRAM'",
    "'('",
    "'<'",
    "'READ'",
    "'END'",
    "'!='",
    "'<='",
    "'ELSE'",
    "'VOID'",
    "'STRING'",
    "'IF'",
    "'FOR'",
    "'WRITE'",
    "')'",
    "'+'",
    "'='",
    "';'",
    "'FUNCTION'",
    "'>'",
    "'FLOAT'",
    "':='",
    "'RETURN'",
    "'/'",
    "'BEGIN'",
    "'>='",
    "'INT'",
    "KEYWORD",
    "IDENTIFIER",
    "FLOATLITERAL",
    "INTLITERAL",
    "STRINGLITERAL",
    "OPERATORS",
    "COMMENTS",
    "WHITESPACE"
  };
  public static final String[] ruleNames = {
    "T__30",
    "T__29",
    "T__28",
    "T__27",
    "T__26",
    "T__25",
    "T__24",
    "T__23",
    "T__22",
    "T__21",
    "T__20",
    "T__19",
    "T__18",
    "T__17",
    "T__16",
    "T__15",
    "T__14",
    "T__13",
    "T__12",
    "T__11",
    "T__10",
    "T__9",
    "T__8",
    "T__7",
    "T__6",
    "T__5",
    "T__4",
    "T__3",
    "T__2",
    "T__1",
    "T__0",
    "ESCAPED_QUOTE",
    "ESCAPED_PERIOD",
    "NEW_LINE",
    "CARRIAGE_RETURN",
    "DOUBLE_DASH",
    "KEYWORD",
    "IDENTIFIER",
    "FLOATLITERAL",
    "INTLITERAL",
    "STRINGLITERAL",
    "OPERATORS",
    "COMMENTS",
    "WHITESPACE"
  };

  public MicroLexer(CharStream input) {
    super(input);
    _interp = new LexerATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache);
  }

  @Override
  public String getGrammarFileName() {
    return "Micro.g4";
  }

  @Override
  public String[] getTokenNames() {
    return tokenNames;
  }

  @Override
  public String[] getRuleNames() {
    return ruleNames;
  }

  @Override
  public String[] getModeNames() {
    return modeNames;
  }

  @Override
  public ATN getATN() {
    return _ATN;
  }

  @Override
  public void action(RuleContext _localctx, int ruleIndex, int actionIndex) {
    switch (ruleIndex) {
      case 42:
        COMMENTS_action((RuleContext) _localctx, actionIndex);
        break;

      case 43:
        WHITESPACE_action((RuleContext) _localctx, actionIndex);
        break;
    }
  }

  private void WHITESPACE_action(RuleContext _localctx, int actionIndex) {
    switch (actionIndex) {
      case 1:
        skip();
        break;
    }
  }

  private void COMMENTS_action(RuleContext _localctx, int actionIndex) {
    switch (actionIndex) {
      case 0:
        skip();
        break;
    }
  }

  public static final String _serializedATN =
      "\3\uacf5\uee8c\u4f5d\u8b0d\u4a45\u78bd\u1b2f\u3378\2)\u017b\b\1\4\2\t"
          + "\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13"
          + "\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"
          + "\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"
          + "\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"
          + "\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"
          + ",\t,\4-\t-\3\2\3\2\3\3\3\3\3\3\3\3\3\4\3\4\3\5\3\5\3\6\3\6\3\6\3\7\3\7"
          + "\3\7\3\7\3\7\3\7\3\7\3\7\3\b\3\b\3\t\3\t\3\n\3\n\3\n\3\n\3\n\3\13\3\13"
          + "\3\13\3\13\3\f\3\f\3\f\3\r\3\r\3\r\3\16\3\16\3\16\3\16\3\16\3\17\3\17"
          + "\3\17\3\17\3\17\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\21\3\21\3\21\3\22"
          + "\3\22\3\22\3\22\3\23\3\23\3\23\3\23\3\23\3\23\3\24\3\24\3\25\3\25\3\26"
          + "\3\26\3\27\3\27\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\31\3\31"
          + "\3\32\3\32\3\32\3\32\3\32\3\32\3\33\3\33\3\33\3\34\3\34\3\34\3\34\3\34"
          + "\3\34\3\34\3\35\3\35\3\36\3\36\3\36\3\36\3\36\3\36\3\37\3\37\3\37\3 \3"
          + " \3 \3 \3!\3!\3!\3\"\3\"\3\"\3#\3#\3$\3$\3%\3%\3%\3&\3&\3&\3&\3&\3&\3"
          + "&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3"
          + "&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3"
          + "&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3"
          + "&\3&\3&\3&\3&\3&\3&\3&\5&\u0134\n&\3\'\6\'\u0137\n\'\r\'\16\'\u0138\3"
          + "\'\3\'\6\'\u013d\n\'\r\'\16\'\u013e\5\'\u0141\n\'\3(\7(\u0144\n(\f(\16"
          + "(\u0147\13(\3(\3(\6(\u014b\n(\r(\16(\u014c\3)\6)\u0150\n)\r)\16)\u0151"
          + "\3*\3*\3*\7*\u0157\n*\f*\16*\u015a\13*\3*\3*\3+\3+\3+\3+\3+\3+\3+\3+\3"
          + "+\3+\5+\u0168\n+\3,\3,\3,\3,\7,\u016e\n,\f,\16,\u0171\13,\3,\3,\3-\6-"
          + "\u0176\n-\r-\16-\u0177\3-\3-\3\u0158.\3\3\1\5\4\1\7\5\1\t\6\1\13\7\1\r"
          + "\b\1\17\t\1\21\n\1\23\13\1\25\f\1\27\r\1\31\16\1\33\17\1\35\20\1\37\21"
          + "\1!\22\1#\23\1%\24\1\'\25\1)\26\1+\27\1-\30\1/\31\1\61\32\1\63\33\1\65"
          + "\34\1\67\35\19\36\1;\37\1= \1?!\1A\2\1C\2\1E\2\1G\2\1I\2\1K\"\1M#\1O$"
          + "\1Q%\1S&\1U\'\1W(\2Y)\3\3\2\n\4\2C\\c|\3\2C|\5\2\62;C\\c|\3\2\62;\4\2"
          + "\f\f\17\17\6\2,-//\61\61??\6\2*+..=>@@\5\2\13\f\17\17\"\"\u0195\2\3\3"
          + "\2\2\2\2\5\3\2\2\2\2\7\3\2\2\2\2\t\3\2\2\2\2\13\3\2\2\2\2\r\3\2\2\2\2"
          + "\17\3\2\2\2\2\21\3\2\2\2\2\23\3\2\2\2\2\25\3\2\2\2\2\27\3\2\2\2\2\31\3"
          + "\2\2\2\2\33\3\2\2\2\2\35\3\2\2\2\2\37\3\2\2\2\2!\3\2\2\2\2#\3\2\2\2\2"
          + "%\3\2\2\2\2\'\3\2\2\2\2)\3\2\2\2\2+\3\2\2\2\2-\3\2\2\2\2/\3\2\2\2\2\61"
          + "\3\2\2\2\2\63\3\2\2\2\2\65\3\2\2\2\2\67\3\2\2\2\29\3\2\2\2\2;\3\2\2\2"
          + "\2=\3\2\2\2\2?\3\2\2\2\2K\3\2\2\2\2M\3\2\2\2\2O\3\2\2\2\2Q\3\2\2\2\2S"
          + "\3\2\2\2\2U\3\2\2\2\2W\3\2\2\2\2Y\3\2\2\2\3[\3\2\2\2\5]\3\2\2\2\7a\3\2"
          + "\2\2\tc\3\2\2\2\13e\3\2\2\2\rh\3\2\2\2\17p\3\2\2\2\21r\3\2\2\2\23t\3\2"
          + "\2\2\25y\3\2\2\2\27}\3\2\2\2\31\u0080\3\2\2\2\33\u0083\3\2\2\2\35\u0088"
          + "\3\2\2\2\37\u008d\3\2\2\2!\u0094\3\2\2\2#\u0097\3\2\2\2%\u009b\3\2\2\2"
          + "\'\u00a1\3\2\2\2)\u00a3\3\2\2\2+\u00a5\3\2\2\2-\u00a7\3\2\2\2/\u00a9\3"
          + "\2\2\2\61\u00b2\3\2\2\2\63\u00b4\3\2\2\2\65\u00ba\3\2\2\2\67\u00bd\3\2"
          + "\2\29\u00c4\3\2\2\2;\u00c6\3\2\2\2=\u00cc\3\2\2\2?\u00cf\3\2\2\2A\u00d3"
          + "\3\2\2\2C\u00d6\3\2\2\2E\u00d9\3\2\2\2G\u00db\3\2\2\2I\u00dd\3\2\2\2K"
          + "\u0133\3\2\2\2M\u0140\3\2\2\2O\u0145\3\2\2\2Q\u014f\3\2\2\2S\u0153\3\2"
          + "\2\2U\u0167\3\2\2\2W\u0169\3\2\2\2Y\u0175\3\2\2\2[\\\7.\2\2\\\4\3\2\2"
          + "\2]^\7T\2\2^_\7Q\2\2_`\7H\2\2`\6\3\2\2\2ab\7,\2\2b\b\3\2\2\2cd\7/\2\2"
          + "d\n\3\2\2\2ef\7H\2\2fg\7K\2\2g\f\3\2\2\2hi\7R\2\2ij\7T\2\2jk\7Q\2\2kl"
          + "\7I\2\2lm\7T\2\2mn\7C\2\2no\7O\2\2o\16\3\2\2\2pq\7*\2\2q\20\3\2\2\2rs"
          + "\7>\2\2s\22\3\2\2\2tu\7T\2\2uv\7G\2\2vw\7C\2\2wx\7F\2\2x\24\3\2\2\2yz"
          + "\7G\2\2z{\7P\2\2{|\7F\2\2|\26\3\2\2\2}~\7#\2\2~\177\7?\2\2\177\30\3\2"
          + "\2\2\u0080\u0081\7>\2\2\u0081\u0082\7?\2\2\u0082\32\3\2\2\2\u0083\u0084"
          + "\7G\2\2\u0084\u0085\7N\2\2\u0085\u0086\7U\2\2\u0086\u0087\7G\2\2\u0087"
          + "\34\3\2\2\2\u0088\u0089\7X\2\2\u0089\u008a\7Q\2\2\u008a\u008b\7K\2\2\u008b"
          + "\u008c\7F\2\2\u008c\36\3\2\2\2\u008d\u008e\7U\2\2\u008e\u008f\7V\2\2\u008f"
          + "\u0090\7T\2\2\u0090\u0091\7K\2\2\u0091\u0092\7P\2\2\u0092\u0093\7I\2\2"
          + "\u0093 \3\2\2\2\u0094\u0095\7K\2\2\u0095\u0096\7H\2\2\u0096\"\3\2\2\2"
          + "\u0097\u0098\7H\2\2\u0098\u0099\7Q\2\2\u0099\u009a\7T\2\2\u009a$\3\2\2"
          + "\2\u009b\u009c\7Y\2\2\u009c\u009d\7T\2\2\u009d\u009e\7K\2\2\u009e\u009f"
          + "\7V\2\2\u009f\u00a0\7G\2\2\u00a0&\3\2\2\2\u00a1\u00a2\7+\2\2\u00a2(\3"
          + "\2\2\2\u00a3\u00a4\7-\2\2\u00a4*\3\2\2\2\u00a5\u00a6\7?\2\2\u00a6,\3\2"
          + "\2\2\u00a7\u00a8\7=\2\2\u00a8.\3\2\2\2\u00a9\u00aa\7H\2\2\u00aa\u00ab"
          + "\7W\2\2\u00ab\u00ac\7P\2\2\u00ac\u00ad\7E\2\2\u00ad\u00ae\7V\2\2\u00ae"
          + "\u00af\7K\2\2\u00af\u00b0\7Q\2\2\u00b0\u00b1\7P\2\2\u00b1\60\3\2\2\2\u00b2"
          + "\u00b3\7@\2\2\u00b3\62\3\2\2\2\u00b4\u00b5\7H\2\2\u00b5\u00b6\7N\2\2\u00b6"
          + "\u00b7\7Q\2\2\u00b7\u00b8\7C\2\2\u00b8\u00b9\7V\2\2\u00b9\64\3\2\2\2\u00ba"
          + "\u00bb\7<\2\2\u00bb\u00bc\7?\2\2\u00bc\66\3\2\2\2\u00bd\u00be\7T\2\2\u00be"
          + "\u00bf\7G\2\2\u00bf\u00c0\7V\2\2\u00c0\u00c1\7W\2\2\u00c1\u00c2\7T\2\2"
          + "\u00c2\u00c3\7P\2\2\u00c38\3\2\2\2\u00c4\u00c5\7\61\2\2\u00c5:\3\2\2\2"
          + "\u00c6\u00c7\7D\2\2\u00c7\u00c8\7G\2\2\u00c8\u00c9\7I\2\2\u00c9\u00ca"
          + "\7K\2\2\u00ca\u00cb\7P\2\2\u00cb<\3\2\2\2\u00cc\u00cd\7@\2\2\u00cd\u00ce"
          + "\7?\2\2\u00ce>\3\2\2\2\u00cf\u00d0\7K\2\2\u00d0\u00d1\7P\2\2\u00d1\u00d2"
          + "\7V\2\2\u00d2@\3\2\2\2\u00d3\u00d4\7^\2\2\u00d4\u00d5\7$\2\2\u00d5B\3"
          + "\2\2\2\u00d6\u00d7\7^\2\2\u00d7\u00d8\7\60\2\2\u00d8D\3\2\2\2\u00d9\u00da"
          + "\7\f\2\2\u00daF\3\2\2\2\u00db\u00dc\7\17\2\2\u00dcH\3\2\2\2\u00dd\u00de"
          + "\7/\2\2\u00de\u00df\7/\2\2\u00dfJ\3\2\2\2\u00e0\u00e1\7R\2\2\u00e1\u00e2"
          + "\7T\2\2\u00e2\u00e3\7Q\2\2\u00e3\u00e4\7I\2\2\u00e4\u00e5\7T\2\2\u00e5"
          + "\u00e6\7C\2\2\u00e6\u0134\7O\2\2\u00e7\u00e8\7D\2\2\u00e8\u00e9\7G\2\2"
          + "\u00e9\u00ea\7I\2\2\u00ea\u00eb\7K\2\2\u00eb\u0134\7P\2\2\u00ec\u00ed"
          + "\7G\2\2\u00ed\u00ee\7P\2\2\u00ee\u0134\7F\2\2\u00ef\u00f0\7H\2\2\u00f0"
          + "\u00f1\7W\2\2\u00f1\u00f2\7P\2\2\u00f2\u00f3\7E\2\2\u00f3\u00f4\7V\2\2"
          + "\u00f4\u00f5\7K\2\2\u00f5\u00f6\7Q\2\2\u00f6\u0134\7P\2\2\u00f7\u00f8"
          + "\7T\2\2\u00f8\u00f9\7G\2\2\u00f9\u00fa\7C\2\2\u00fa\u0134\7F\2\2\u00fb"
          + "\u00fc\7Y\2\2\u00fc\u00fd\7T\2\2\u00fd\u00fe\7K\2\2\u00fe\u00ff\7V\2\2"
          + "\u00ff\u0134\7G\2\2\u0100\u0101\7K\2\2\u0101\u0134\7H\2\2\u0102\u0103"
          + "\7G\2\2\u0103\u0104\7N\2\2\u0104\u0105\7U\2\2\u0105\u0134\7G\2\2\u0106"
          + "\u0107\7H\2\2\u0107\u0134\7K\2\2\u0108\u0109\7H\2\2\u0109\u010a\7Q\2\2"
          + "\u010a\u0134\7T\2\2\u010b\u010c\7T\2\2\u010c\u010d\7Q\2\2\u010d\u0134"
          + "\7H\2\2\u010e\u010f\7E\2\2\u010f\u0110\7Q\2\2\u0110\u0111\7P\2\2\u0111"
          + "\u0112\7V\2\2\u0112\u0113\7K\2\2\u0113\u0114\7P\2\2\u0114\u0115\7W\2\2"
          + "\u0115\u0134\7G\2\2\u0116\u0117\7D\2\2\u0117\u0118\7T\2\2\u0118\u0119"
          + "\7G\2\2\u0119\u011a\7C\2\2\u011a\u0134\7M\2\2\u011b\u011c\7T\2\2\u011c"
          + "\u011d\7G\2\2\u011d\u011e\7V\2\2\u011e\u011f\7W\2\2\u011f\u0120\7T\2\2"
          + "\u0120\u0134\7P\2\2\u0121\u0122\7K\2\2\u0122\u0123\7P\2\2\u0123\u0134"
          + "\7V\2\2\u0124\u0125\7X\2\2\u0125\u0126\7Q\2\2\u0126\u0127\7K\2\2\u0127"
          + "\u0134\7F\2\2\u0128\u0129\7U\2\2\u0129\u012a\7V\2\2\u012a\u012b\7T\2\2"
          + "\u012b\u012c\7K\2\2\u012c\u012d\7P\2\2\u012d\u0134\7I\2\2\u012e\u012f"
          + "\7H\2\2\u012f\u0130\7N\2\2\u0130\u0131\7Q\2\2\u0131\u0132\7C\2\2\u0132"
          + "\u0134\7V\2\2\u0133\u00e0\3\2\2\2\u0133\u00e7\3\2\2\2\u0133\u00ec\3\2"
          + "\2\2\u0133\u00ef\3\2\2\2\u0133\u00f7\3\2\2\2\u0133\u00fb\3\2\2\2\u0133"
          + "\u0100\3\2\2\2\u0133\u0102\3\2\2\2\u0133\u0106\3\2\2\2\u0133\u0108\3\2"
          + "\2\2\u0133\u010b\3\2\2\2\u0133\u010e\3\2\2\2\u0133\u0116\3\2\2\2\u0133"
          + "\u011b\3\2\2\2\u0133\u0121\3\2\2\2\u0133\u0124\3\2\2\2\u0133\u0128\3\2"
          + "\2\2\u0133\u012e\3\2\2\2\u0134L\3\2\2\2\u0135\u0137\t\2\2\2\u0136\u0135"
          + "\3\2\2\2\u0137\u0138\3\2\2\2\u0138\u0136\3\2\2\2\u0138\u0139\3\2\2\2\u0139"
          + "\u0141\3\2\2\2\u013a\u013c\t\3\2\2\u013b\u013d\t\4\2\2\u013c\u013b\3\2"
          + "\2\2\u013d\u013e\3\2\2\2\u013e\u013c\3\2\2\2\u013e\u013f\3\2\2\2\u013f"
          + "\u0141\3\2\2\2\u0140\u0136\3\2\2\2\u0140\u013a\3\2\2\2\u0141N\3\2\2\2"
          + "\u0142\u0144\t\5\2\2\u0143\u0142\3\2\2\2\u0144\u0147\3\2\2\2\u0145\u0143"
          + "\3\2\2\2\u0145\u0146\3\2\2\2\u0146\u0148\3\2\2\2\u0147\u0145\3\2\2\2\u0148"
          + "\u014a\7\60\2\2\u0149\u014b\t\5\2\2\u014a\u0149\3\2\2\2\u014b\u014c\3"
          + "\2\2\2\u014c\u014a\3\2\2\2\u014c\u014d\3\2\2\2\u014dP\3\2\2\2\u014e\u0150"
          + "\t\5\2\2\u014f\u014e\3\2\2\2\u0150\u0151\3\2\2\2\u0151\u014f\3\2\2\2\u0151"
          + "\u0152\3\2\2\2\u0152R\3\2\2\2\u0153\u0158\7$\2\2\u0154\u0157\5A!\2\u0155"
          + "\u0157\n\6\2\2\u0156\u0154\3\2\2\2\u0156\u0155\3\2\2\2\u0157\u015a\3\2"
          + "\2\2\u0158\u0159\3\2\2\2\u0158\u0156\3\2\2\2\u0159\u015b\3\2\2\2\u015a"
          + "\u0158\3\2\2\2\u015b\u015c\7$\2\2\u015cT\3\2\2\2\u015d\u015e\7<\2\2\u015e"
          + "\u0168\7?\2\2\u015f\u0168\t\7\2\2\u0160\u0161\7#\2\2\u0161\u0168\7?\2"
          + "\2\u0162\u0168\t\b\2\2\u0163\u0164\7>\2\2\u0164\u0168\7?\2\2\u0165\u0166"
          + "\7@\2\2\u0166\u0168\7?\2\2\u0167\u015d\3\2\2\2\u0167\u015f\3\2\2\2\u0167"
          + "\u0160\3\2\2\2\u0167\u0162\3\2\2\2\u0167\u0163\3\2\2\2\u0167\u0165\3\2"
          + "\2\2\u0168V\3\2\2\2\u0169\u016a\7/\2\2\u016a\u016b\7/\2\2\u016b\u016f"
          + "\3\2\2\2\u016c\u016e\n\6\2\2\u016d\u016c\3\2\2\2\u016e\u0171\3\2\2\2\u016f"
          + "\u016d\3\2\2\2\u016f\u0170\3\2\2\2\u0170\u0172\3\2\2\2\u0171\u016f\3\2"
          + "\2\2\u0172\u0173\b,\2\2\u0173X\3\2\2\2\u0174\u0176\t\t\2\2\u0175\u0174"
          + "\3\2\2\2\u0176\u0177\3\2\2\2\u0177\u0175\3\2\2\2\u0177\u0178\3\2\2\2\u0178"
          + "\u0179\3\2\2\2\u0179\u017a\b-\3\2\u017aZ\3\2\2\2\17\2\u0133\u0138\u013e"
          + "\u0140\u0145\u014c\u0151\u0156\u0158\u0167\u016f\u0177";
  public static final ATN _ATN = ATNSimulator.deserialize(_serializedATN.toCharArray());

  static {
    _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
    for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
      _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
    }
  }
}
Пример #2
0
@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
public class ETPParser extends Parser {
  protected static final DFA[] _decisionToDFA;
  protected static final PredictionContextCache _sharedContextCache = new PredictionContextCache();
  public static final int FUN = 1,
      REF = 2,
      COMMA = 3,
      LSQUARE = 4,
      RSQUARE = 5,
      LCURLY = 6,
      RCURLY = 7,
      LESSTHAN = 8,
      GREATERTHAN = 9,
      COLON = 10,
      BINSTART = 11,
      BINEND = 12,
      TRUE = 13,
      FALSE = 14,
      AT = 15,
      HASH = 16,
      DOT = 17,
      ID = 18,
      IDSTRING = 19,
      INT = 20,
      FLOAT = 21,
      PID = 22,
      REFID = 23,
      STRING = 24,
      LINE_COMMENT = 25,
      WS = 26;
  public static final String[] tokenNames = {
    "<INVALID>",
    "'Fun'",
    "'Ref'",
    "','",
    "'['",
    "']'",
    "'{'",
    "'}'",
    "'<'",
    "'>'",
    "':'",
    "'<<'",
    "'>>'",
    "'true'",
    "'false'",
    "'@'",
    "'#'",
    "'.'",
    "ID",
    "IDSTRING",
    "INT",
    "FLOAT",
    "PID",
    "REFID",
    "STRING",
    "LINE_COMMENT",
    "WS"
  };
  public static final int RULE_etp_term = 0,
      RULE_etp_int = 1,
      RULE_etp_float = 2,
      RULE_etp_string = 3,
      RULE_etp_atom = 4,
      RULE_etp_bool = 5,
      RULE_etp_list = 6,
      RULE_etp_tuple = 7,
      RULE_etp_pid = 8,
      RULE_etp_fun = 9,
      RULE_etp_binary = 10,
      RULE_etp_binary_item = 11,
      RULE_etp_ref = 12;
  public static final String[] ruleNames = {
    "etp_term", "etp_int", "etp_float", "etp_string", "etp_atom", "etp_bool",
    "etp_list", "etp_tuple", "etp_pid", "etp_fun", "etp_binary", "etp_binary_item",
    "etp_ref"
  };

  @Override
  public String getGrammarFileName() {
    return "ETP.g4";
  }

  @Override
  public String[] getTokenNames() {
    return tokenNames;
  }

  @Override
  public String[] getRuleNames() {
    return ruleNames;
  }

  @Override
  public ATN getATN() {
    return _ATN;
  }

  public ETPParser(TokenStream input) {
    super(input);
    _interp = new ParserATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache);
  }

  public static class Etp_termContext extends ParserRuleContext {
    public Etp_refContext etp_ref() {
      return getRuleContext(Etp_refContext.class, 0);
    }

    public Etp_floatContext etp_float() {
      return getRuleContext(Etp_floatContext.class, 0);
    }

    public Etp_pidContext etp_pid() {
      return getRuleContext(Etp_pidContext.class, 0);
    }

    public Etp_binaryContext etp_binary() {
      return getRuleContext(Etp_binaryContext.class, 0);
    }

    public Etp_tupleContext etp_tuple() {
      return getRuleContext(Etp_tupleContext.class, 0);
    }

    public Etp_atomContext etp_atom() {
      return getRuleContext(Etp_atomContext.class, 0);
    }

    public Etp_stringContext etp_string() {
      return getRuleContext(Etp_stringContext.class, 0);
    }

    public Etp_funContext etp_fun() {
      return getRuleContext(Etp_funContext.class, 0);
    }

    public Etp_boolContext etp_bool() {
      return getRuleContext(Etp_boolContext.class, 0);
    }

    public Etp_listContext etp_list() {
      return getRuleContext(Etp_listContext.class, 0);
    }

    public Etp_intContext etp_int() {
      return getRuleContext(Etp_intContext.class, 0);
    }

    public Etp_termContext(ParserRuleContext parent, int invokingState) {
      super(parent, invokingState);
    }

    @Override
    public int getRuleIndex() {
      return RULE_etp_term;
    }

    @Override
    public void enterRule(ParseTreeListener listener) {
      if (listener instanceof ETPListener) ((ETPListener) listener).enterEtp_term(this);
    }

    @Override
    public void exitRule(ParseTreeListener listener) {
      if (listener instanceof ETPListener) ((ETPListener) listener).exitEtp_term(this);
    }
  }

  public final Etp_termContext etp_term() throws RecognitionException {
    Etp_termContext _localctx = new Etp_termContext(_ctx, getState());
    enterRule(_localctx, 0, RULE_etp_term);
    try {
      setState(37);
      switch (getInterpreter().adaptivePredict(_input, 0, _ctx)) {
        case 1:
          enterOuterAlt(_localctx, 1);
          {
            setState(26);
            etp_atom();
          }
          break;

        case 2:
          enterOuterAlt(_localctx, 2);
          {
            setState(27);
            etp_int();
          }
          break;

        case 3:
          enterOuterAlt(_localctx, 3);
          {
            setState(28);
            etp_float();
          }
          break;

        case 4:
          enterOuterAlt(_localctx, 4);
          {
            setState(29);
            etp_string();
          }
          break;

        case 5:
          enterOuterAlt(_localctx, 5);
          {
            setState(30);
            etp_bool();
          }
          break;

        case 6:
          enterOuterAlt(_localctx, 6);
          {
            setState(31);
            etp_list();
          }
          break;

        case 7:
          enterOuterAlt(_localctx, 7);
          {
            setState(32);
            etp_tuple();
          }
          break;

        case 8:
          enterOuterAlt(_localctx, 8);
          {
            setState(33);
            etp_binary();
          }
          break;

        case 9:
          enterOuterAlt(_localctx, 9);
          {
            setState(34);
            etp_pid();
          }
          break;

        case 10:
          enterOuterAlt(_localctx, 10);
          {
            setState(35);
            etp_fun();
          }
          break;

        case 11:
          enterOuterAlt(_localctx, 11);
          {
            setState(36);
            etp_ref();
          }
          break;
      }
    } catch (RecognitionException re) {
      _localctx.exception = re;
      _errHandler.reportError(this, re);
      _errHandler.recover(this, re);
    } finally {
      exitRule();
    }
    return _localctx;
  }

  public static class Etp_intContext extends ParserRuleContext {
    public TerminalNode INT() {
      return getToken(ETPParser.INT, 0);
    }

    public Etp_intContext(ParserRuleContext parent, int invokingState) {
      super(parent, invokingState);
    }

    @Override
    public int getRuleIndex() {
      return RULE_etp_int;
    }

    @Override
    public void enterRule(ParseTreeListener listener) {
      if (listener instanceof ETPListener) ((ETPListener) listener).enterEtp_int(this);
    }

    @Override
    public void exitRule(ParseTreeListener listener) {
      if (listener instanceof ETPListener) ((ETPListener) listener).exitEtp_int(this);
    }
  }

  public final Etp_intContext etp_int() throws RecognitionException {
    Etp_intContext _localctx = new Etp_intContext(_ctx, getState());
    enterRule(_localctx, 2, RULE_etp_int);
    try {
      enterOuterAlt(_localctx, 1);
      {
        setState(39);
        match(INT);
      }
    } catch (RecognitionException re) {
      _localctx.exception = re;
      _errHandler.reportError(this, re);
      _errHandler.recover(this, re);
    } finally {
      exitRule();
    }
    return _localctx;
  }

  public static class Etp_floatContext extends ParserRuleContext {
    public TerminalNode FLOAT() {
      return getToken(ETPParser.FLOAT, 0);
    }

    public Etp_floatContext(ParserRuleContext parent, int invokingState) {
      super(parent, invokingState);
    }

    @Override
    public int getRuleIndex() {
      return RULE_etp_float;
    }

    @Override
    public void enterRule(ParseTreeListener listener) {
      if (listener instanceof ETPListener) ((ETPListener) listener).enterEtp_float(this);
    }

    @Override
    public void exitRule(ParseTreeListener listener) {
      if (listener instanceof ETPListener) ((ETPListener) listener).exitEtp_float(this);
    }
  }

  public final Etp_floatContext etp_float() throws RecognitionException {
    Etp_floatContext _localctx = new Etp_floatContext(_ctx, getState());
    enterRule(_localctx, 4, RULE_etp_float);
    try {
      enterOuterAlt(_localctx, 1);
      {
        setState(41);
        match(FLOAT);
      }
    } catch (RecognitionException re) {
      _localctx.exception = re;
      _errHandler.reportError(this, re);
      _errHandler.recover(this, re);
    } finally {
      exitRule();
    }
    return _localctx;
  }

  public static class Etp_stringContext extends ParserRuleContext {
    public TerminalNode STRING() {
      return getToken(ETPParser.STRING, 0);
    }

    public Etp_stringContext(ParserRuleContext parent, int invokingState) {
      super(parent, invokingState);
    }

    @Override
    public int getRuleIndex() {
      return RULE_etp_string;
    }

    @Override
    public void enterRule(ParseTreeListener listener) {
      if (listener instanceof ETPListener) ((ETPListener) listener).enterEtp_string(this);
    }

    @Override
    public void exitRule(ParseTreeListener listener) {
      if (listener instanceof ETPListener) ((ETPListener) listener).exitEtp_string(this);
    }
  }

  public final Etp_stringContext etp_string() throws RecognitionException {
    Etp_stringContext _localctx = new Etp_stringContext(_ctx, getState());
    enterRule(_localctx, 6, RULE_etp_string);
    try {
      enterOuterAlt(_localctx, 1);
      {
        setState(43);
        match(STRING);
      }
    } catch (RecognitionException re) {
      _localctx.exception = re;
      _errHandler.reportError(this, re);
      _errHandler.recover(this, re);
    } finally {
      exitRule();
    }
    return _localctx;
  }

  public static class Etp_atomContext extends ParserRuleContext {
    public TerminalNode ID() {
      return getToken(ETPParser.ID, 0);
    }

    public TerminalNode IDSTRING() {
      return getToken(ETPParser.IDSTRING, 0);
    }

    public Etp_atomContext(ParserRuleContext parent, int invokingState) {
      super(parent, invokingState);
    }

    @Override
    public int getRuleIndex() {
      return RULE_etp_atom;
    }

    @Override
    public void enterRule(ParseTreeListener listener) {
      if (listener instanceof ETPListener) ((ETPListener) listener).enterEtp_atom(this);
    }

    @Override
    public void exitRule(ParseTreeListener listener) {
      if (listener instanceof ETPListener) ((ETPListener) listener).exitEtp_atom(this);
    }
  }

  public final Etp_atomContext etp_atom() throws RecognitionException {
    Etp_atomContext _localctx = new Etp_atomContext(_ctx, getState());
    enterRule(_localctx, 8, RULE_etp_atom);
    int _la;
    try {
      enterOuterAlt(_localctx, 1);
      {
        setState(45);
        _la = _input.LA(1);
        if (!(_la == ID || _la == IDSTRING)) {
          _errHandler.recoverInline(this);
        }
        consume();
      }
    } catch (RecognitionException re) {
      _localctx.exception = re;
      _errHandler.reportError(this, re);
      _errHandler.recover(this, re);
    } finally {
      exitRule();
    }
    return _localctx;
  }

  public static class Etp_boolContext extends ParserRuleContext {
    public TerminalNode FALSE() {
      return getToken(ETPParser.FALSE, 0);
    }

    public TerminalNode TRUE() {
      return getToken(ETPParser.TRUE, 0);
    }

    public Etp_boolContext(ParserRuleContext parent, int invokingState) {
      super(parent, invokingState);
    }

    @Override
    public int getRuleIndex() {
      return RULE_etp_bool;
    }

    @Override
    public void enterRule(ParseTreeListener listener) {
      if (listener instanceof ETPListener) ((ETPListener) listener).enterEtp_bool(this);
    }

    @Override
    public void exitRule(ParseTreeListener listener) {
      if (listener instanceof ETPListener) ((ETPListener) listener).exitEtp_bool(this);
    }
  }

  public final Etp_boolContext etp_bool() throws RecognitionException {
    Etp_boolContext _localctx = new Etp_boolContext(_ctx, getState());
    enterRule(_localctx, 10, RULE_etp_bool);
    int _la;
    try {
      enterOuterAlt(_localctx, 1);
      {
        setState(47);
        _la = _input.LA(1);
        if (!(_la == TRUE || _la == FALSE)) {
          _errHandler.recoverInline(this);
        }
        consume();
      }
    } catch (RecognitionException re) {
      _localctx.exception = re;
      _errHandler.reportError(this, re);
      _errHandler.recover(this, re);
    } finally {
      exitRule();
    }
    return _localctx;
  }

  public static class Etp_listContext extends ParserRuleContext {
    public Etp_termContext etp_term;
    public List<Etp_termContext> listitems = new ArrayList<Etp_termContext>();

    public List<Etp_termContext> etp_term() {
      return getRuleContexts(Etp_termContext.class);
    }

    public TerminalNode COMMA(int i) {
      return getToken(ETPParser.COMMA, i);
    }

    public TerminalNode LSQUARE() {
      return getToken(ETPParser.LSQUARE, 0);
    }

    public TerminalNode RSQUARE() {
      return getToken(ETPParser.RSQUARE, 0);
    }

    public List<TerminalNode> COMMA() {
      return getTokens(ETPParser.COMMA);
    }

    public Etp_termContext etp_term(int i) {
      return getRuleContext(Etp_termContext.class, i);
    }

    public Etp_listContext(ParserRuleContext parent, int invokingState) {
      super(parent, invokingState);
    }

    @Override
    public int getRuleIndex() {
      return RULE_etp_list;
    }

    @Override
    public void enterRule(ParseTreeListener listener) {
      if (listener instanceof ETPListener) ((ETPListener) listener).enterEtp_list(this);
    }

    @Override
    public void exitRule(ParseTreeListener listener) {
      if (listener instanceof ETPListener) ((ETPListener) listener).exitEtp_list(this);
    }
  }

  public final Etp_listContext etp_list() throws RecognitionException {
    Etp_listContext _localctx = new Etp_listContext(_ctx, getState());
    enterRule(_localctx, 12, RULE_etp_list);
    int _la;
    try {
      enterOuterAlt(_localctx, 1);
      {
        setState(49);
        match(LSQUARE);
        setState(58);
        _la = _input.LA(1);
        if ((((_la) & ~0x3f) == 0
            && ((1L << _la)
                    & ((1L << LSQUARE)
                        | (1L << LCURLY)
                        | (1L << LESSTHAN)
                        | (1L << BINSTART)
                        | (1L << TRUE)
                        | (1L << FALSE)
                        | (1L << HASH)
                        | (1L << ID)
                        | (1L << IDSTRING)
                        | (1L << INT)
                        | (1L << FLOAT)
                        | (1L << STRING)))
                != 0)) {
          {
            setState(50);
            ((Etp_listContext) _localctx).etp_term = etp_term();
            ((Etp_listContext) _localctx).listitems.add(((Etp_listContext) _localctx).etp_term);
            setState(55);
            _errHandler.sync(this);
            _la = _input.LA(1);
            while (_la == COMMA) {
              {
                {
                  setState(51);
                  match(COMMA);
                  setState(52);
                  ((Etp_listContext) _localctx).etp_term = etp_term();
                  ((Etp_listContext) _localctx)
                      .listitems.add(((Etp_listContext) _localctx).etp_term);
                }
              }
              setState(57);
              _errHandler.sync(this);
              _la = _input.LA(1);
            }
          }
        }

        setState(60);
        match(RSQUARE);
      }
    } catch (RecognitionException re) {
      _localctx.exception = re;
      _errHandler.reportError(this, re);
      _errHandler.recover(this, re);
    } finally {
      exitRule();
    }
    return _localctx;
  }

  public static class Etp_tupleContext extends ParserRuleContext {
    public Etp_termContext etp_term;
    public List<Etp_termContext> tupleitems = new ArrayList<Etp_termContext>();

    public List<Etp_termContext> etp_term() {
      return getRuleContexts(Etp_termContext.class);
    }

    public TerminalNode LCURLY() {
      return getToken(ETPParser.LCURLY, 0);
    }

    public TerminalNode COMMA(int i) {
      return getToken(ETPParser.COMMA, i);
    }

    public List<TerminalNode> COMMA() {
      return getTokens(ETPParser.COMMA);
    }

    public Etp_termContext etp_term(int i) {
      return getRuleContext(Etp_termContext.class, i);
    }

    public TerminalNode RCURLY() {
      return getToken(ETPParser.RCURLY, 0);
    }

    public Etp_tupleContext(ParserRuleContext parent, int invokingState) {
      super(parent, invokingState);
    }

    @Override
    public int getRuleIndex() {
      return RULE_etp_tuple;
    }

    @Override
    public void enterRule(ParseTreeListener listener) {
      if (listener instanceof ETPListener) ((ETPListener) listener).enterEtp_tuple(this);
    }

    @Override
    public void exitRule(ParseTreeListener listener) {
      if (listener instanceof ETPListener) ((ETPListener) listener).exitEtp_tuple(this);
    }
  }

  public final Etp_tupleContext etp_tuple() throws RecognitionException {
    Etp_tupleContext _localctx = new Etp_tupleContext(_ctx, getState());
    enterRule(_localctx, 14, RULE_etp_tuple);
    int _la;
    try {
      enterOuterAlt(_localctx, 1);
      {
        setState(62);
        match(LCURLY);
        setState(71);
        _la = _input.LA(1);
        if ((((_la) & ~0x3f) == 0
            && ((1L << _la)
                    & ((1L << LSQUARE)
                        | (1L << LCURLY)
                        | (1L << LESSTHAN)
                        | (1L << BINSTART)
                        | (1L << TRUE)
                        | (1L << FALSE)
                        | (1L << HASH)
                        | (1L << ID)
                        | (1L << IDSTRING)
                        | (1L << INT)
                        | (1L << FLOAT)
                        | (1L << STRING)))
                != 0)) {
          {
            setState(63);
            ((Etp_tupleContext) _localctx).etp_term = etp_term();
            ((Etp_tupleContext) _localctx).tupleitems.add(((Etp_tupleContext) _localctx).etp_term);
            setState(68);
            _errHandler.sync(this);
            _la = _input.LA(1);
            while (_la == COMMA) {
              {
                {
                  setState(64);
                  match(COMMA);
                  setState(65);
                  ((Etp_tupleContext) _localctx).etp_term = etp_term();
                  ((Etp_tupleContext) _localctx)
                      .tupleitems.add(((Etp_tupleContext) _localctx).etp_term);
                }
              }
              setState(70);
              _errHandler.sync(this);
              _la = _input.LA(1);
            }
          }
        }

        setState(73);
        match(RCURLY);
      }
    } catch (RecognitionException re) {
      _localctx.exception = re;
      _errHandler.reportError(this, re);
      _errHandler.recover(this, re);
    } finally {
      exitRule();
    }
    return _localctx;
  }

  public static class Etp_pidContext extends ParserRuleContext {
    public TerminalNode LESSTHAN() {
      return getToken(ETPParser.LESSTHAN, 0);
    }

    public TerminalNode PID() {
      return getToken(ETPParser.PID, 0);
    }

    public TerminalNode GREATERTHAN() {
      return getToken(ETPParser.GREATERTHAN, 0);
    }

    public Etp_pidContext(ParserRuleContext parent, int invokingState) {
      super(parent, invokingState);
    }

    @Override
    public int getRuleIndex() {
      return RULE_etp_pid;
    }

    @Override
    public void enterRule(ParseTreeListener listener) {
      if (listener instanceof ETPListener) ((ETPListener) listener).enterEtp_pid(this);
    }

    @Override
    public void exitRule(ParseTreeListener listener) {
      if (listener instanceof ETPListener) ((ETPListener) listener).exitEtp_pid(this);
    }
  }

  public final Etp_pidContext etp_pid() throws RecognitionException {
    Etp_pidContext _localctx = new Etp_pidContext(_ctx, getState());
    enterRule(_localctx, 16, RULE_etp_pid);
    try {
      enterOuterAlt(_localctx, 1);
      {
        setState(75);
        match(LESSTHAN);
        setState(76);
        match(PID);
        setState(77);
        match(GREATERTHAN);
      }
    } catch (RecognitionException re) {
      _localctx.exception = re;
      _errHandler.reportError(this, re);
      _errHandler.recover(this, re);
    } finally {
      exitRule();
    }
    return _localctx;
  }

  public static class Etp_funContext extends ParserRuleContext {
    public TerminalNode HASH() {
      return getToken(ETPParser.HASH, 0);
    }

    public TerminalNode LESSTHAN() {
      return getToken(ETPParser.LESSTHAN, 0);
    }

    public TerminalNode FUN() {
      return getToken(ETPParser.FUN, 0);
    }

    public TerminalNode GREATERTHAN() {
      return getToken(ETPParser.GREATERTHAN, 0);
    }

    public Etp_funContext(ParserRuleContext parent, int invokingState) {
      super(parent, invokingState);
    }

    @Override
    public int getRuleIndex() {
      return RULE_etp_fun;
    }

    @Override
    public void enterRule(ParseTreeListener listener) {
      if (listener instanceof ETPListener) ((ETPListener) listener).enterEtp_fun(this);
    }

    @Override
    public void exitRule(ParseTreeListener listener) {
      if (listener instanceof ETPListener) ((ETPListener) listener).exitEtp_fun(this);
    }
  }

  public final Etp_funContext etp_fun() throws RecognitionException {
    Etp_funContext _localctx = new Etp_funContext(_ctx, getState());
    enterRule(_localctx, 18, RULE_etp_fun);
    try {
      int _alt;
      enterOuterAlt(_localctx, 1);
      {
        setState(79);
        match(HASH);
        setState(80);
        match(FUN);
        setState(81);
        match(LESSTHAN);
        setState(85);
        _errHandler.sync(this);
        _alt = getInterpreter().adaptivePredict(_input, 5, _ctx);
        while (_alt != 1 && _alt != -1) {
          if (_alt == 1 + 1) {
            {
              {
                setState(82);
                matchWildcard();
              }
            }
          }
          setState(87);
          _errHandler.sync(this);
          _alt = getInterpreter().adaptivePredict(_input, 5, _ctx);
        }
        setState(88);
        match(GREATERTHAN);
      }
    } catch (RecognitionException re) {
      _localctx.exception = re;
      _errHandler.reportError(this, re);
      _errHandler.recover(this, re);
    } finally {
      exitRule();
    }
    return _localctx;
  }

  public static class Etp_binaryContext extends ParserRuleContext {
    public Etp_binary_itemContext etp_binary_item;
    public List<Etp_binary_itemContext> segments = new ArrayList<Etp_binary_itemContext>();

    public TerminalNode COMMA(int i) {
      return getToken(ETPParser.COMMA, i);
    }

    public TerminalNode BINSTART() {
      return getToken(ETPParser.BINSTART, 0);
    }

    public List<TerminalNode> COMMA() {
      return getTokens(ETPParser.COMMA);
    }

    public TerminalNode BINEND() {
      return getToken(ETPParser.BINEND, 0);
    }

    public List<Etp_binary_itemContext> etp_binary_item() {
      return getRuleContexts(Etp_binary_itemContext.class);
    }

    public Etp_binary_itemContext etp_binary_item(int i) {
      return getRuleContext(Etp_binary_itemContext.class, i);
    }

    public Etp_binaryContext(ParserRuleContext parent, int invokingState) {
      super(parent, invokingState);
    }

    @Override
    public int getRuleIndex() {
      return RULE_etp_binary;
    }

    @Override
    public void enterRule(ParseTreeListener listener) {
      if (listener instanceof ETPListener) ((ETPListener) listener).enterEtp_binary(this);
    }

    @Override
    public void exitRule(ParseTreeListener listener) {
      if (listener instanceof ETPListener) ((ETPListener) listener).exitEtp_binary(this);
    }
  }

  public final Etp_binaryContext etp_binary() throws RecognitionException {
    Etp_binaryContext _localctx = new Etp_binaryContext(_ctx, getState());
    enterRule(_localctx, 20, RULE_etp_binary);
    int _la;
    try {
      enterOuterAlt(_localctx, 1);
      {
        setState(90);
        match(BINSTART);
        setState(99);
        _la = _input.LA(1);
        if (_la == INT || _la == STRING) {
          {
            setState(91);
            ((Etp_binaryContext) _localctx).etp_binary_item = etp_binary_item();
            ((Etp_binaryContext) _localctx)
                .segments.add(((Etp_binaryContext) _localctx).etp_binary_item);
            setState(96);
            _errHandler.sync(this);
            _la = _input.LA(1);
            while (_la == COMMA) {
              {
                {
                  setState(92);
                  match(COMMA);
                  setState(93);
                  ((Etp_binaryContext) _localctx).etp_binary_item = etp_binary_item();
                  ((Etp_binaryContext) _localctx)
                      .segments.add(((Etp_binaryContext) _localctx).etp_binary_item);
                }
              }
              setState(98);
              _errHandler.sync(this);
              _la = _input.LA(1);
            }
          }
        }

        setState(101);
        match(BINEND);
      }
    } catch (RecognitionException re) {
      _localctx.exception = re;
      _errHandler.reportError(this, re);
      _errHandler.recover(this, re);
    } finally {
      exitRule();
    }
    return _localctx;
  }

  public static class Etp_binary_itemContext extends ParserRuleContext {
    public Token val;
    public Token size;

    public TerminalNode COLON() {
      return getToken(ETPParser.COLON, 0);
    }

    public List<TerminalNode> INT() {
      return getTokens(ETPParser.INT);
    }

    public TerminalNode INT(int i) {
      return getToken(ETPParser.INT, i);
    }

    public TerminalNode STRING() {
      return getToken(ETPParser.STRING, 0);
    }

    public Etp_binary_itemContext(ParserRuleContext parent, int invokingState) {
      super(parent, invokingState);
    }

    @Override
    public int getRuleIndex() {
      return RULE_etp_binary_item;
    }

    @Override
    public void enterRule(ParseTreeListener listener) {
      if (listener instanceof ETPListener) ((ETPListener) listener).enterEtp_binary_item(this);
    }

    @Override
    public void exitRule(ParseTreeListener listener) {
      if (listener instanceof ETPListener) ((ETPListener) listener).exitEtp_binary_item(this);
    }
  }

  public final Etp_binary_itemContext etp_binary_item() throws RecognitionException {
    Etp_binary_itemContext _localctx = new Etp_binary_itemContext(_ctx, getState());
    enterRule(_localctx, 22, RULE_etp_binary_item);
    int _la;
    try {
      setState(109);
      switch (_input.LA(1)) {
        case INT:
          enterOuterAlt(_localctx, 1);
          {
            setState(103);
            ((Etp_binary_itemContext) _localctx).val = match(INT);
            setState(106);
            _la = _input.LA(1);
            if (_la == COLON) {
              {
                setState(104);
                match(COLON);
                setState(105);
                ((Etp_binary_itemContext) _localctx).size = match(INT);
              }
            }
          }
          break;
        case STRING:
          enterOuterAlt(_localctx, 2);
          {
            setState(108);
            match(STRING);
          }
          break;
        default:
          throw new NoViableAltException(this);
      }
    } catch (RecognitionException re) {
      _localctx.exception = re;
      _errHandler.reportError(this, re);
      _errHandler.recover(this, re);
    } finally {
      exitRule();
    }
    return _localctx;
  }

  public static class Etp_refContext extends ParserRuleContext {
    public TerminalNode HASH() {
      return getToken(ETPParser.HASH, 0);
    }

    public TerminalNode LESSTHAN() {
      return getToken(ETPParser.LESSTHAN, 0);
    }

    public TerminalNode REFID() {
      return getToken(ETPParser.REFID, 0);
    }

    public TerminalNode REF() {
      return getToken(ETPParser.REF, 0);
    }

    public TerminalNode GREATERTHAN() {
      return getToken(ETPParser.GREATERTHAN, 0);
    }

    public Etp_refContext(ParserRuleContext parent, int invokingState) {
      super(parent, invokingState);
    }

    @Override
    public int getRuleIndex() {
      return RULE_etp_ref;
    }

    @Override
    public void enterRule(ParseTreeListener listener) {
      if (listener instanceof ETPListener) ((ETPListener) listener).enterEtp_ref(this);
    }

    @Override
    public void exitRule(ParseTreeListener listener) {
      if (listener instanceof ETPListener) ((ETPListener) listener).exitEtp_ref(this);
    }
  }

  public final Etp_refContext etp_ref() throws RecognitionException {
    Etp_refContext _localctx = new Etp_refContext(_ctx, getState());
    enterRule(_localctx, 24, RULE_etp_ref);
    try {
      enterOuterAlt(_localctx, 1);
      {
        setState(111);
        match(HASH);
        setState(112);
        match(REF);
        setState(113);
        match(LESSTHAN);
        setState(114);
        match(REFID);
        setState(115);
        match(GREATERTHAN);
      }
    } catch (RecognitionException re) {
      _localctx.exception = re;
      _errHandler.reportError(this, re);
      _errHandler.recover(this, re);
    } finally {
      exitRule();
    }
    return _localctx;
  }

  public static final String _serializedATN =
      "\2\3\34x\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t"
          + "\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16\t\16\3\2\3\2\3\2\3\2\3\2\3\2"
          + "\3\2\3\2\3\2\3\2\3\2\5\2(\n\2\3\3\3\3\3\4\3\4\3\5\3\5\3\6\3\6\3\7\3\7"
          + "\3\b\3\b\3\b\3\b\7\b8\n\b\f\b\16\b;\13\b\5\b=\n\b\3\b\3\b\3\t\3\t\3\t"
          + "\3\t\7\tE\n\t\f\t\16\tH\13\t\5\tJ\n\t\3\t\3\t\3\n\3\n\3\n\3\n\3\13\3\13"
          + "\3\13\3\13\7\13V\n\13\f\13\16\13Y\13\13\3\13\3\13\3\f\3\f\3\f\3\f\7\f"
          + "a\n\f\f\f\16\fd\13\f\5\ff\n\f\3\f\3\f\3\r\3\r\3\r\5\rm\n\r\3\r\5\rp\n"
          + "\r\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3W\17\2\4\6\b\n\f\16\20\22\24\26"
          + "\30\32\2\4\3\24\25\3\17\20}\2\'\3\2\2\2\4)\3\2\2\2\6+\3\2\2\2\b-\3\2\2"
          + "\2\n/\3\2\2\2\f\61\3\2\2\2\16\63\3\2\2\2\20@\3\2\2\2\22M\3\2\2\2\24Q\3"
          + "\2\2\2\26\\\3\2\2\2\30o\3\2\2\2\32q\3\2\2\2\34(\5\n\6\2\35(\5\4\3\2\36"
          + "(\5\6\4\2\37(\5\b\5\2 (\5\f\7\2!(\5\16\b\2\"(\5\20\t\2#(\5\26\f\2$(\5"
          + "\22\n\2%(\5\24\13\2&(\5\32\16\2\'\34\3\2\2\2\'\35\3\2\2\2\'\36\3\2\2\2"
          + "\'\37\3\2\2\2\' \3\2\2\2\'!\3\2\2\2\'\"\3\2\2\2\'#\3\2\2\2\'$\3\2\2\2"
          + "\'%\3\2\2\2\'&\3\2\2\2(\3\3\2\2\2)*\7\26\2\2*\5\3\2\2\2+,\7\27\2\2,\7"
          + "\3\2\2\2-.\7\32\2\2.\t\3\2\2\2/\60\t\2\2\2\60\13\3\2\2\2\61\62\t\3\2\2"
          + "\62\r\3\2\2\2\63<\7\6\2\2\649\5\2\2\2\65\66\7\5\2\2\668\5\2\2\2\67\65"
          + "\3\2\2\28;\3\2\2\29\67\3\2\2\29:\3\2\2\2:=\3\2\2\2;9\3\2\2\2<\64\3\2\2"
          + "\2<=\3\2\2\2=>\3\2\2\2>?\7\7\2\2?\17\3\2\2\2@I\7\b\2\2AF\5\2\2\2BC\7\5"
          + "\2\2CE\5\2\2\2DB\3\2\2\2EH\3\2\2\2FD\3\2\2\2FG\3\2\2\2GJ\3\2\2\2HF\3\2"
          + "\2\2IA\3\2\2\2IJ\3\2\2\2JK\3\2\2\2KL\7\t\2\2L\21\3\2\2\2MN\7\n\2\2NO\7"
          + "\30\2\2OP\7\13\2\2P\23\3\2\2\2QR\7\22\2\2RS\7\3\2\2SW\7\n\2\2TV\13\2\2"
          + "\2UT\3\2\2\2VY\3\2\2\2WX\3\2\2\2WU\3\2\2\2XZ\3\2\2\2YW\3\2\2\2Z[\7\13"
          + "\2\2[\25\3\2\2\2\\e\7\r\2\2]b\5\30\r\2^_\7\5\2\2_a\5\30\r\2`^\3\2\2\2"
          + "ad\3\2\2\2b`\3\2\2\2bc\3\2\2\2cf\3\2\2\2db\3\2\2\2e]\3\2\2\2ef\3\2\2\2"
          + "fg\3\2\2\2gh\7\16\2\2h\27\3\2\2\2il\7\26\2\2jk\7\f\2\2km\7\26\2\2lj\3"
          + "\2\2\2lm\3\2\2\2mp\3\2\2\2np\7\32\2\2oi\3\2\2\2on\3\2\2\2p\31\3\2\2\2"
          + "qr\7\22\2\2rs\7\4\2\2st\7\n\2\2tu\7\31\2\2uv\7\13\2\2v\33\3\2\2\2\f\'"
          + "9<FIWbelo";
  public static final ATN _ATN = ATNSimulator.deserialize(_serializedATN.toCharArray());

  static {
    _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
  }
}
Пример #3
0
@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
public class calculatorLexer extends Lexer {
  protected static final DFA[] _decisionToDFA;
  protected static final PredictionContextCache _sharedContextCache = new PredictionContextCache();
  public static final int INT = 1,
      FLOAT = 2,
      MUL = 3,
      DIV = 4,
      ADD = 5,
      SUB = 6,
      EXP = 7,
      WHITESPACE = 8,
      NEWLINE = 9,
      ASSIGN = 10,
      BLOCK_START = 11,
      BLOCK_END = 12,
      IF = 13,
      ELSE = 14,
      WHILE = 15,
      DO = 16,
      AND = 17,
      OR = 18,
      NOT = 19,
      PAREN_OPEN = 20,
      PAREN_CLOSE = 21,
      STRING = 22,
      LT = 23,
      LTE = 24,
      GT = 25,
      GTE = 26,
      EQ = 27,
      NEQ = 28;
  public static String[] modeNames = {"DEFAULT_MODE"};

  public static final String[] tokenNames = {
    "<INVALID>",
    "INT",
    "FLOAT",
    "'*'",
    "'/'",
    "'+'",
    "'-'",
    "'^'",
    "WHITESPACE",
    "'\n'",
    "'='",
    "'{'",
    "'}'",
    "'if'",
    "'else'",
    "'while'",
    "'do'",
    "'and'",
    "'or'",
    "'not'",
    "'('",
    "')'",
    "STRING",
    "'<'",
    "'<='",
    "'>'",
    "'>='",
    "'=='",
    "'!='"
  };
  public static final String[] ruleNames = {
    "INT",
    "FLOAT",
    "MUL",
    "DIV",
    "ADD",
    "SUB",
    "EXP",
    "WHITESPACE",
    "NEWLINE",
    "ASSIGN",
    "BLOCK_START",
    "BLOCK_END",
    "IF",
    "ELSE",
    "WHILE",
    "DO",
    "AND",
    "OR",
    "NOT",
    "PAREN_OPEN",
    "PAREN_CLOSE",
    "STRING",
    "LT",
    "LTE",
    "GT",
    "GTE",
    "EQ",
    "NEQ",
    "DIGIT"
  };

  public calculatorLexer(CharStream input) {
    super(input);
    _interp = new LexerATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache);
  }

  @Override
  public String getGrammarFileName() {
    return "calculator.g4";
  }

  @Override
  public String[] getTokenNames() {
    return tokenNames;
  }

  @Override
  public String[] getRuleNames() {
    return ruleNames;
  }

  @Override
  public String[] getModeNames() {
    return modeNames;
  }

  @Override
  public ATN getATN() {
    return _ATN;
  }

  @Override
  public void action(RuleContext _localctx, int ruleIndex, int actionIndex) {
    switch (ruleIndex) {
      case 7:
        WHITESPACE_action((RuleContext) _localctx, actionIndex);
        break;
    }
  }

  private void WHITESPACE_action(RuleContext _localctx, int actionIndex) {
    switch (actionIndex) {
      case 0:
        skip();
        break;
    }
  }

  public static final String _serializedATN =
      "\3\uacf5\uee8c\u4f5d\u8b0d\u4a45\u78bd\u1b2f\u3378\2\36\u009d\b\1\4\2"
          + "\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4"
          + "\13\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22"
          + "\t\22\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31"
          + "\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\3\2\6\2?\n\2\r"
          + "\2\16\2@\3\3\6\3D\n\3\r\3\16\3E\3\3\3\3\7\3J\n\3\f\3\16\3M\13\3\3\4\3"
          + "\4\3\5\3\5\3\6\3\6\3\7\3\7\3\b\3\b\3\t\3\t\3\t\3\t\3\n\3\n\3\13\3\13\3"
          + "\f\3\f\3\r\3\r\3\16\3\16\3\16\3\17\3\17\3\17\3\17\3\17\3\20\3\20\3\20"
          + "\3\20\3\20\3\20\3\21\3\21\3\21\3\22\3\22\3\22\3\22\3\23\3\23\3\23\3\24"
          + "\3\24\3\24\3\24\3\25\3\25\3\26\3\26\3\27\3\27\7\27\u0087\n\27\f\27\16"
          + "\27\u008a\13\27\3\30\3\30\3\31\3\31\3\31\3\32\3\32\3\33\3\33\3\33\3\34"
          + "\3\34\3\34\3\35\3\35\3\35\3\36\3\36\2\37\3\3\1\5\4\1\7\5\1\t\6\1\13\7"
          + "\1\r\b\1\17\t\1\21\n\2\23\13\1\25\f\1\27\r\1\31\16\1\33\17\1\35\20\1\37"
          + "\21\1!\22\1#\23\1%\24\1\'\25\1)\26\1+\27\1-\30\1/\31\1\61\32\1\63\33\1"
          + "\65\34\1\67\35\19\36\1;\2\1\3\2\6\4\2\13\13\"\"\4\2C\\c|\5\2\62;C\\c|"
          + "\3\2\62;\u009f\2\3\3\2\2\2\2\5\3\2\2\2\2\7\3\2\2\2\2\t\3\2\2\2\2\13\3"
          + "\2\2\2\2\r\3\2\2\2\2\17\3\2\2\2\2\21\3\2\2\2\2\23\3\2\2\2\2\25\3\2\2\2"
          + "\2\27\3\2\2\2\2\31\3\2\2\2\2\33\3\2\2\2\2\35\3\2\2\2\2\37\3\2\2\2\2!\3"
          + "\2\2\2\2#\3\2\2\2\2%\3\2\2\2\2\'\3\2\2\2\2)\3\2\2\2\2+\3\2\2\2\2-\3\2"
          + "\2\2\2/\3\2\2\2\2\61\3\2\2\2\2\63\3\2\2\2\2\65\3\2\2\2\2\67\3\2\2\2\2"
          + "9\3\2\2\2\3>\3\2\2\2\5C\3\2\2\2\7N\3\2\2\2\tP\3\2\2\2\13R\3\2\2\2\rT\3"
          + "\2\2\2\17V\3\2\2\2\21X\3\2\2\2\23\\\3\2\2\2\25^\3\2\2\2\27`\3\2\2\2\31"
          + "b\3\2\2\2\33d\3\2\2\2\35g\3\2\2\2\37l\3\2\2\2!r\3\2\2\2#u\3\2\2\2%y\3"
          + "\2\2\2\'|\3\2\2\2)\u0080\3\2\2\2+\u0082\3\2\2\2-\u0084\3\2\2\2/\u008b"
          + "\3\2\2\2\61\u008d\3\2\2\2\63\u0090\3\2\2\2\65\u0092\3\2\2\2\67\u0095\3"
          + "\2\2\29\u0098\3\2\2\2;\u009b\3\2\2\2=?\5;\36\2>=\3\2\2\2?@\3\2\2\2@>\3"
          + "\2\2\2@A\3\2\2\2A\4\3\2\2\2BD\5;\36\2CB\3\2\2\2DE\3\2\2\2EC\3\2\2\2EF"
          + "\3\2\2\2FG\3\2\2\2GK\7\60\2\2HJ\5;\36\2IH\3\2\2\2JM\3\2\2\2KI\3\2\2\2"
          + "KL\3\2\2\2L\6\3\2\2\2MK\3\2\2\2NO\7,\2\2O\b\3\2\2\2PQ\7\61\2\2Q\n\3\2"
          + "\2\2RS\7-\2\2S\f\3\2\2\2TU\7/\2\2U\16\3\2\2\2VW\7`\2\2W\20\3\2\2\2XY\t"
          + "\2\2\2YZ\3\2\2\2Z[\b\t\2\2[\22\3\2\2\2\\]\7\f\2\2]\24\3\2\2\2^_\7?\2\2"
          + "_\26\3\2\2\2`a\7}\2\2a\30\3\2\2\2bc\7\177\2\2c\32\3\2\2\2de\7k\2\2ef\7"
          + "h\2\2f\34\3\2\2\2gh\7g\2\2hi\7n\2\2ij\7u\2\2jk\7g\2\2k\36\3\2\2\2lm\7"
          + "y\2\2mn\7j\2\2no\7k\2\2op\7n\2\2pq\7g\2\2q \3\2\2\2rs\7f\2\2st\7q\2\2"
          + "t\"\3\2\2\2uv\7c\2\2vw\7p\2\2wx\7f\2\2x$\3\2\2\2yz\7q\2\2z{\7t\2\2{&\3"
          + "\2\2\2|}\7p\2\2}~\7q\2\2~\177\7v\2\2\177(\3\2\2\2\u0080\u0081\7*\2\2\u0081"
          + "*\3\2\2\2\u0082\u0083\7+\2\2\u0083,\3\2\2\2\u0084\u0088\t\3\2\2\u0085"
          + "\u0087\t\4\2\2\u0086\u0085\3\2\2\2\u0087\u008a\3\2\2\2\u0088\u0086\3\2"
          + "\2\2\u0088\u0089\3\2\2\2\u0089.\3\2\2\2\u008a\u0088\3\2\2\2\u008b\u008c"
          + "\7>\2\2\u008c\60\3\2\2\2\u008d\u008e\7>\2\2\u008e\u008f\7?\2\2\u008f\62"
          + "\3\2\2\2\u0090\u0091\7@\2\2\u0091\64\3\2\2\2\u0092\u0093\7@\2\2\u0093"
          + "\u0094\7?\2\2\u0094\66\3\2\2\2\u0095\u0096\7?\2\2\u0096\u0097\7?\2\2\u0097"
          + "8\3\2\2\2\u0098\u0099\7#\2\2\u0099\u009a\7?\2\2\u009a:\3\2\2\2\u009b\u009c"
          + "\t\5\2\2\u009c<\3\2\2\2\7\2@EK\u0088";
  public static final ATN _ATN = ATNSimulator.deserialize(_serializedATN.toCharArray());

  static {
    _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
    for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
      _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
    }
  }
}
Пример #4
0
@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
public class ExprParser extends Parser {
  protected static final DFA[] _decisionToDFA;
  protected static final PredictionContextCache _sharedContextCache = new PredictionContextCache();
  public static final int T__6 = 1,
      T__5 = 2,
      T__4 = 3,
      T__3 = 4,
      T__2 = 5,
      T__1 = 6,
      T__0 = 7,
      ID = 8,
      INT = 9,
      NEWLINE = 10,
      WS = 11;
  public static final String[] tokenNames = {
    "<INVALID>", "')'", "'+'", "'*'", "'-'", "'('", "'/'", "'='", "ID", "INT", "NEWLINE", "WS"
  };
  public static final int RULE_prog = 0, RULE_stat = 1, RULE_expr = 2;
  public static final String[] ruleNames = {"prog", "stat", "expr"};

  @Override
  public String getGrammarFileName() {
    return "Expr.g4";
  }

  @Override
  public String[] getTokenNames() {
    return tokenNames;
  }

  @Override
  public String[] getRuleNames() {
    return ruleNames;
  }

  @Override
  public ATN getATN() {
    return _ATN;
  }

  public ExprParser(TokenStream input) {
    super(input);
    _interp = new ParserATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache);
  }

  public static class ProgContext extends ParserRuleContext {
    public StatContext stat(int i) {
      return getRuleContext(StatContext.class, i);
    }

    public List<StatContext> stat() {
      return getRuleContexts(StatContext.class);
    }

    public ProgContext(ParserRuleContext parent, int invokingState) {
      super(parent, invokingState);
    }

    @Override
    public int getRuleIndex() {
      return RULE_prog;
    }

    @Override
    public void enterRule(ParseTreeListener listener) {
      if (listener instanceof ExprListener) ((ExprListener) listener).enterProg(this);
    }

    @Override
    public void exitRule(ParseTreeListener listener) {
      if (listener instanceof ExprListener) ((ExprListener) listener).exitProg(this);
    }
  }

  public final ProgContext prog() throws RecognitionException {
    ProgContext _localctx = new ProgContext(_ctx, getState());
    enterRule(_localctx, 0, RULE_prog);
    int _la;
    try {
      enterOuterAlt(_localctx, 1);
      {
        setState(7);
        _errHandler.sync(this);
        _la = _input.LA(1);
        do {
          {
            {
              setState(6);
              stat();
            }
          }
          setState(9);
          _errHandler.sync(this);
          _la = _input.LA(1);
        } while ((((_la) & ~0x3f) == 0
            && ((1L << _la) & ((1L << 5) | (1L << ID) | (1L << INT) | (1L << NEWLINE))) != 0));
      }
    } catch (RecognitionException re) {
      _localctx.exception = re;
      _errHandler.reportError(this, re);
      _errHandler.recover(this, re);
    } finally {
      exitRule();
    }
    return _localctx;
  }

  public static class StatContext extends ParserRuleContext {
    public TerminalNode NEWLINE() {
      return getToken(ExprParser.NEWLINE, 0);
    }

    public ExprContext expr() {
      return getRuleContext(ExprContext.class, 0);
    }

    public TerminalNode ID() {
      return getToken(ExprParser.ID, 0);
    }

    public StatContext(ParserRuleContext parent, int invokingState) {
      super(parent, invokingState);
    }

    @Override
    public int getRuleIndex() {
      return RULE_stat;
    }

    @Override
    public void enterRule(ParseTreeListener listener) {
      if (listener instanceof ExprListener) ((ExprListener) listener).enterStat(this);
    }

    @Override
    public void exitRule(ParseTreeListener listener) {
      if (listener instanceof ExprListener) ((ExprListener) listener).exitStat(this);
    }
  }

  public final StatContext stat() throws RecognitionException {
    StatContext _localctx = new StatContext(_ctx, getState());
    enterRule(_localctx, 2, RULE_stat);
    try {
      setState(20);
      switch (getInterpreter().adaptivePredict(_input, 1, _ctx)) {
        case 1:
          enterOuterAlt(_localctx, 1);
          {
            setState(11);
            expr(0);
            setState(12);
            match(NEWLINE);
          }
          break;

        case 2:
          enterOuterAlt(_localctx, 2);
          {
            setState(14);
            match(ID);
            setState(15);
            match(7);
            setState(16);
            expr(0);
            setState(17);
            match(NEWLINE);
          }
          break;

        case 3:
          enterOuterAlt(_localctx, 3);
          {
            setState(19);
            match(NEWLINE);
          }
          break;
      }
    } catch (RecognitionException re) {
      _localctx.exception = re;
      _errHandler.reportError(this, re);
      _errHandler.recover(this, re);
    } finally {
      exitRule();
    }
    return _localctx;
  }

  public static class ExprContext extends ParserRuleContext {
    public int _p;

    public TerminalNode INT() {
      return getToken(ExprParser.INT, 0);
    }

    public List<ExprContext> expr() {
      return getRuleContexts(ExprContext.class);
    }

    public ExprContext expr(int i) {
      return getRuleContext(ExprContext.class, i);
    }

    public TerminalNode ID() {
      return getToken(ExprParser.ID, 0);
    }

    public ExprContext(ParserRuleContext parent, int invokingState) {
      super(parent, invokingState);
    }

    public ExprContext(ParserRuleContext parent, int invokingState, int _p) {
      super(parent, invokingState);
      this._p = _p;
    }

    @Override
    public int getRuleIndex() {
      return RULE_expr;
    }

    @Override
    public void enterRule(ParseTreeListener listener) {
      if (listener instanceof ExprListener) ((ExprListener) listener).enterExpr(this);
    }

    @Override
    public void exitRule(ParseTreeListener listener) {
      if (listener instanceof ExprListener) ((ExprListener) listener).exitExpr(this);
    }
  }

  public final ExprContext expr(int _p) throws RecognitionException {
    ParserRuleContext _parentctx = _ctx;
    int _parentState = getState();
    ExprContext _localctx = new ExprContext(_ctx, _parentState, _p);
    ExprContext _prevctx = _localctx;
    int _startState = 4;
    enterRecursionRule(_localctx, RULE_expr);
    int _la;
    try {
      int _alt;
      enterOuterAlt(_localctx, 1);
      {
        setState(29);
        switch (_input.LA(1)) {
          case INT:
            {
              setState(23);
              match(INT);
            }
            break;
          case ID:
            {
              setState(24);
              match(ID);
            }
            break;
          case 5:
            {
              setState(25);
              match(5);
              setState(26);
              expr(0);
              setState(27);
              match(1);
            }
            break;
          default:
            throw new NoViableAltException(this);
        }
        _ctx.stop = _input.LT(-1);
        setState(39);
        _errHandler.sync(this);
        _alt = getInterpreter().adaptivePredict(_input, 4, _ctx);
        while (_alt != 2 && _alt != -1) {
          if (_alt == 1) {
            if (_parseListeners != null) triggerExitRuleEvent();
            _prevctx = _localctx;
            {
              setState(37);
              switch (getInterpreter().adaptivePredict(_input, 3, _ctx)) {
                case 1:
                  {
                    _localctx = new ExprContext(_parentctx, _parentState, _p);
                    pushNewRecursionContext(_localctx, _startState, RULE_expr);
                    setState(31);
                    if (!(5 >= _localctx._p)) throw new FailedPredicateException(this, "5 >= $_p");
                    setState(32);
                    _la = _input.LA(1);
                    if (!(_la == 3 || _la == 6)) {
                      _errHandler.recoverInline(this);
                    }
                    consume();
                    setState(33);
                    expr(6);
                  }
                  break;

                case 2:
                  {
                    _localctx = new ExprContext(_parentctx, _parentState, _p);
                    pushNewRecursionContext(_localctx, _startState, RULE_expr);
                    setState(34);
                    if (!(4 >= _localctx._p)) throw new FailedPredicateException(this, "4 >= $_p");
                    setState(35);
                    _la = _input.LA(1);
                    if (!(_la == 2 || _la == 4)) {
                      _errHandler.recoverInline(this);
                    }
                    consume();
                    setState(36);
                    expr(5);
                  }
                  break;
              }
            }
          }
          setState(41);
          _errHandler.sync(this);
          _alt = getInterpreter().adaptivePredict(_input, 4, _ctx);
        }
      }
    } catch (RecognitionException re) {
      _localctx.exception = re;
      _errHandler.reportError(this, re);
      _errHandler.recover(this, re);
    } finally {
      unrollRecursionContexts(_parentctx);
    }
    return _localctx;
  }

  public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
    switch (ruleIndex) {
      case 2:
        return expr_sempred((ExprContext) _localctx, predIndex);
    }
    return true;
  }

  private boolean expr_sempred(ExprContext _localctx, int predIndex) {
    switch (predIndex) {
      case 0:
        return 5 >= _localctx._p;

      case 1:
        return 4 >= _localctx._p;
    }
    return true;
  }

  public static final String _serializedATN =
      "\3\uacf5\uee8c\u4f5d\u8b0d\u4a45\u78bd\u1b2f\u3378\3\r-\4\2\t\2\4\3\t"
          + "\3\4\4\t\4\3\2\6\2\n\n\2\r\2\16\2\13\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3"
          + "\3\5\3\27\n\3\3\4\3\4\3\4\3\4\3\4\3\4\3\4\5\4 \n\4\3\4\3\4\3\4\3\4\3\4"
          + "\3\4\7\4(\n\4\f\4\16\4+\13\4\3\4\2\5\2\4\6\2\4\4\2\5\5\b\b\4\2\4\4\6\6"
          + "\60\2\t\3\2\2\2\4\26\3\2\2\2\6\37\3\2\2\2\b\n\5\4\3\2\t\b\3\2\2\2\n\13"
          + "\3\2\2\2\13\t\3\2\2\2\13\f\3\2\2\2\f\3\3\2\2\2\r\16\5\6\4\2\16\17\7\f"
          + "\2\2\17\27\3\2\2\2\20\21\7\n\2\2\21\22\7\t\2\2\22\23\5\6\4\2\23\24\7\f"
          + "\2\2\24\27\3\2\2\2\25\27\7\f\2\2\26\r\3\2\2\2\26\20\3\2\2\2\26\25\3\2"
          + "\2\2\27\5\3\2\2\2\30\31\b\4\1\2\31 \7\13\2\2\32 \7\n\2\2\33\34\7\7\2\2"
          + "\34\35\5\6\4\2\35\36\7\3\2\2\36 \3\2\2\2\37\30\3\2\2\2\37\32\3\2\2\2\37"
          + "\33\3\2\2\2 )\3\2\2\2!\"\6\4\2\3\"#\t\2\2\2#(\5\6\4\2$%\6\4\3\3%&\t\3"
          + "\2\2&(\5\6\4\2\'!\3\2\2\2\'$\3\2\2\2(+\3\2\2\2)\'\3\2\2\2)*\3\2\2\2*\7"
          + "\3\2\2\2+)\3\2\2\2\7\13\26\37\')";
  public static final ATN _ATN = ATNSimulator.deserialize(_serializedATN.toCharArray());

  static {
    _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
    for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
      _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
    }
  }
}
Пример #5
0
@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
public class TURTLELexer extends Lexer {
  protected static final DFA[] _decisionToDFA;
  protected static final PredictionContextCache _sharedContextCache = new PredictionContextCache();
  public static final int T__12 = 1,
      T__11 = 2,
      T__10 = 3,
      T__9 = 4,
      T__8 = 5,
      T__7 = 6,
      T__6 = 7,
      T__5 = 8,
      T__4 = 9,
      T__3 = 10,
      T__2 = 11,
      T__1 = 12,
      T__0 = 13,
      NumericLiteral = 14,
      BooleanLiteral = 15,
      String = 16,
      BlankNode = 17,
      WS = 18,
      PN_PREFIX = 19,
      IRIREF = 20,
      PNAME_NS = 21,
      PrefixedName = 22,
      PNAME_LN = 23,
      BLANK_NODE_LABEL = 24,
      LANGTAG = 25,
      INTEGER = 26,
      DECIMAL = 27,
      DOUBLE = 28,
      EXPONENT = 29,
      STRING_LITERAL_LONG_SINGLE_QUOTE = 30,
      STRING_LITERAL_LONG_QUOTE = 31,
      STRING_LITERAL_QUOTE = 32,
      STRING_LITERAL_SINGLE_QUOTE = 33,
      UCHAR = 34,
      ECHAR = 35,
      ANON_WS = 36,
      ANON = 37,
      SC = 38,
      PN_CHARS_BASE = 39,
      PN_CHARS_U = 40,
      PN_CHARS = 41,
      PN_LOCAL = 42,
      PLX = 43,
      PERCENT = 44,
      HEX = 45,
      PN_LOCAL_ESC = 46;
  public static String[] modeNames = {"DEFAULT_MODE"};

  public static final String[] tokenNames = {
    "<INVALID>",
    "']'",
    "'PREFIX'",
    "'a'",
    "')'",
    "'.'",
    "','",
    "'['",
    "'('",
    "'@base'",
    "';'",
    "'BASE'",
    "'@prefix'",
    "'^^'",
    "NumericLiteral",
    "BooleanLiteral",
    "String",
    "BlankNode",
    "WS",
    "PN_PREFIX",
    "IRIREF",
    "PNAME_NS",
    "PrefixedName",
    "PNAME_LN",
    "BLANK_NODE_LABEL",
    "LANGTAG",
    "INTEGER",
    "DECIMAL",
    "DOUBLE",
    "EXPONENT",
    "STRING_LITERAL_LONG_SINGLE_QUOTE",
    "STRING_LITERAL_LONG_QUOTE",
    "STRING_LITERAL_QUOTE",
    "STRING_LITERAL_SINGLE_QUOTE",
    "UCHAR",
    "ECHAR",
    "ANON_WS",
    "ANON",
    "SC",
    "PN_CHARS_BASE",
    "PN_CHARS_U",
    "PN_CHARS",
    "PN_LOCAL",
    "PLX",
    "PERCENT",
    "HEX",
    "PN_LOCAL_ESC"
  };
  public static final String[] ruleNames = {
    "T__12",
    "T__11",
    "T__10",
    "T__9",
    "T__8",
    "T__7",
    "T__6",
    "T__5",
    "T__4",
    "T__3",
    "T__2",
    "T__1",
    "T__0",
    "NumericLiteral",
    "BooleanLiteral",
    "String",
    "BlankNode",
    "WS",
    "PN_PREFIX",
    "IRIREF",
    "PNAME_NS",
    "PrefixedName",
    "PNAME_LN",
    "BLANK_NODE_LABEL",
    "LANGTAG",
    "INTEGER",
    "DECIMAL",
    "DOUBLE",
    "EXPONENT",
    "STRING_LITERAL_LONG_SINGLE_QUOTE",
    "STRING_LITERAL_LONG_QUOTE",
    "STRING_LITERAL_QUOTE",
    "STRING_LITERAL_SINGLE_QUOTE",
    "UCHAR",
    "ECHAR",
    "ANON_WS",
    "ANON",
    "SC",
    "PN_CHARS_BASE",
    "PN_CHARS_U",
    "PN_CHARS",
    "PN_LOCAL",
    "PLX",
    "PERCENT",
    "HEX",
    "PN_LOCAL_ESC"
  };

  public TURTLELexer(CharStream input) {
    super(input);
    _interp = new LexerATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache);
  }

  @Override
  public String getGrammarFileName() {
    return "TURTLE.g4";
  }

  @Override
  public String[] getTokenNames() {
    return tokenNames;
  }

  @Override
  public String[] getRuleNames() {
    return ruleNames;
  }

  @Override
  public String[] getModeNames() {
    return modeNames;
  }

  @Override
  public ATN getATN() {
    return _ATN;
  }

  @Override
  public void action(RuleContext _localctx, int ruleIndex, int actionIndex) {
    switch (ruleIndex) {
      case 17:
        WS_action((RuleContext) _localctx, actionIndex);
        break;
    }
  }

  private void WS_action(RuleContext _localctx, int actionIndex) {
    switch (actionIndex) {
      case 0:
        skip();
        break;
    }
  }

  public static final String _serializedATN =
      "\3\uacf5\uee8c\u4f5d\u8b0d\u4a45\u78bd\u1b2f\u3378\2\60\u01cd\b\1\4\2"
          + "\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4"
          + "\13\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22"
          + "\t\22\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31"
          + "\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t"
          + " \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t"
          + "+\4,\t,\4-\t-\4.\t.\4/\t/\3\2\3\2\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\4\3\4"
          + "\3\5\3\5\3\6\3\6\3\7\3\7\3\b\3\b\3\t\3\t\3\n\3\n\3\n\3\n\3\n\3\n\3\13"
          + "\3\13\3\f\3\f\3\f\3\f\3\f\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\16\3\16\3"
          + "\16\3\17\3\17\3\17\5\17\u0090\n\17\3\20\3\20\3\20\3\20\3\20\3\20\3\20"
          + "\3\20\3\20\5\20\u009b\n\20\3\21\3\21\3\21\3\21\5\21\u00a1\n\21\3\22\3"
          + "\22\5\22\u00a5\n\22\3\23\6\23\u00a8\n\23\r\23\16\23\u00a9\3\23\3\23\3"
          + "\24\3\24\3\24\7\24\u00b1\n\24\f\24\16\24\u00b4\13\24\3\24\5\24\u00b7\n"
          + "\24\3\25\3\25\3\25\3\25\7\25\u00bd\n\25\f\25\16\25\u00c0\13\25\3\25\3"
          + "\25\3\26\5\26\u00c5\n\26\3\26\3\26\3\27\3\27\5\27\u00cb\n\27\3\30\3\30"
          + "\3\30\3\31\3\31\3\31\3\31\3\31\5\31\u00d5\n\31\3\31\3\31\7\31\u00d9\n"
          + "\31\f\31\16\31\u00dc\13\31\3\31\5\31\u00df\n\31\3\32\3\32\6\32\u00e3\n"
          + "\32\r\32\16\32\u00e4\3\32\3\32\6\32\u00e9\n\32\r\32\16\32\u00ea\7\32\u00ed"
          + "\n\32\f\32\16\32\u00f0\13\32\3\33\5\33\u00f3\n\33\3\33\6\33\u00f6\n\33"
          + "\r\33\16\33\u00f7\3\34\5\34\u00fb\n\34\3\34\7\34\u00fe\n\34\f\34\16\34"
          + "\u0101\13\34\3\34\3\34\6\34\u0105\n\34\r\34\16\34\u0106\3\35\5\35\u010a"
          + "\n\35\3\35\6\35\u010d\n\35\r\35\16\35\u010e\3\35\3\35\7\35\u0113\n\35"
          + "\f\35\16\35\u0116\13\35\3\35\3\35\3\35\6\35\u011b\n\35\r\35\16\35\u011c"
          + "\3\35\3\35\6\35\u0121\n\35\r\35\16\35\u0122\3\35\5\35\u0126\n\35\3\36"
          + "\3\36\5\36\u012a\n\36\3\36\6\36\u012d\n\36\r\36\16\36\u012e\3\37\3\37"
          + "\3\37\3\37\3\37\3\37\3\37\5\37\u0138\n\37\3\37\3\37\3\37\3\37\5\37\u013e"
          + "\n\37\7\37\u0140\n\37\f\37\16\37\u0143\13\37\3\37\3\37\3\37\3\37\3 \3"
          + " \3 \3 \3 \3 \3 \5 \u0150\n \3 \3 \3 \3 \5 \u0156\n \7 \u0158\n \f \16"
          + " \u015b\13 \3 \3 \3 \3 \3!\3!\3!\3!\3!\7!\u0166\n!\f!\16!\u0169\13!\3"
          + "!\3!\3\"\3\"\3\"\3\"\3\"\7\"\u0172\n\"\f\"\16\"\u0175\13\"\3\"\3\"\3#"
          + "\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\5#\u018d\n#"
          + "\3$\3$\3$\3%\3%\3&\3&\7&\u0196\n&\f&\16&\u0199\13&\3&\3&\3\'\6\'\u019e"
          + "\n\'\r\'\16\'\u019f\3(\3(\3)\3)\5)\u01a6\n)\3*\3*\5*\u01aa\n*\3+\3+\3"
          + "+\5+\u01af\n+\3+\3+\3+\7+\u01b4\n+\f+\16+\u01b7\13+\3+\3+\3+\5+\u01bc"
          + "\n+\5+\u01be\n+\3,\3,\5,\u01c2\n,\3-\3-\3-\3-\3.\5.\u01c9\n.\3/\3/\3/"
          + "\2\60\3\3\1\5\4\1\7\5\1\t\6\1\13\7\1\r\b\1\17\t\1\21\n\1\23\13\1\25\f"
          + "\1\27\r\1\31\16\1\33\17\1\35\20\1\37\21\1!\22\1#\23\1%\24\2\'\25\1)\26"
          + "\1+\27\1-\30\1/\31\1\61\32\1\63\33\1\65\34\1\67\35\19\36\1;\37\1= \1?"
          + "!\1A\"\1C#\1E$\1G%\1I&\1K\'\1M(\1O)\1Q*\1S+\1U,\1W-\1Y.\1[/\1]\60\1\3"
          + "\2\25\5\2\13\f\16\17\"\"\b\2%%\'(\60\61<<BB^^\3\2\62;\4\2C\\c|\5\2\62"
          + ";C\\c|\4\2--//\4\2GGgg\5\2))^^``\4\2$$^^\7\2\f\f\17\17$$))^^\6\2\f\f\17"
          + "\17))^^\n\2$$))^^ddhhppttvv\5\2\13\f\17\17\"\"\4\2YY^^\17\2C\\c|\u00c2"
          + "\u00d8\u00da\u00f8\u00fa\u0301\u0372\u037f\u0381\u2001\u200e\u200f\u2072"
          + "\u2191\u2c02\u2ff1\u3003\ud801\uf902\ufdd1\ufdf2\uffff\7\2//\62;\u00b9"
          + "\u00b9\u0302\u0371\u2041\u2042\4\2\60\60<<\5\2\62;CHch\t\2##%\61==??A"
          + "Baa\u0080\u0080\u0212\2\3\3\2\2\2\2\5\3\2\2\2\2\7\3\2\2\2\2\t\3\2\2\2"
          + "\2\13\3\2\2\2\2\r\3\2\2\2\2\17\3\2\2\2\2\21\3\2\2\2\2\23\3\2\2\2\2\25"
          + "\3\2\2\2\2\27\3\2\2\2\2\31\3\2\2\2\2\33\3\2\2\2\2\35\3\2\2\2\2\37\3\2"
          + "\2\2\2!\3\2\2\2\2#\3\2\2\2\2%\3\2\2\2\2\'\3\2\2\2\2)\3\2\2\2\2+\3\2\2"
          + "\2\2-\3\2\2\2\2/\3\2\2\2\2\61\3\2\2\2\2\63\3\2\2\2\2\65\3\2\2\2\2\67\3"
          + "\2\2\2\29\3\2\2\2\2;\3\2\2\2\2=\3\2\2\2\2?\3\2\2\2\2A\3\2\2\2\2C\3\2\2"
          + "\2\2E\3\2\2\2\2G\3\2\2\2\2I\3\2\2\2\2K\3\2\2\2\2M\3\2\2\2\2O\3\2\2\2\2"
          + "Q\3\2\2\2\2S\3\2\2\2\2U\3\2\2\2\2W\3\2\2\2\2Y\3\2\2\2\2[\3\2\2\2\2]\3"
          + "\2\2\2\3_\3\2\2\2\5a\3\2\2\2\7h\3\2\2\2\tj\3\2\2\2\13l\3\2\2\2\rn\3\2"
          + "\2\2\17p\3\2\2\2\21r\3\2\2\2\23t\3\2\2\2\25z\3\2\2\2\27|\3\2\2\2\31\u0081"
          + "\3\2\2\2\33\u0089\3\2\2\2\35\u008f\3\2\2\2\37\u009a\3\2\2\2!\u00a0\3\2"
          + "\2\2#\u00a4\3\2\2\2%\u00a7\3\2\2\2\'\u00ad\3\2\2\2)\u00b8\3\2\2\2+\u00c4"
          + "\3\2\2\2-\u00ca\3\2\2\2/\u00cc\3\2\2\2\61\u00cf\3\2\2\2\63\u00e0\3\2\2"
          + "\2\65\u00f2\3\2\2\2\67\u00fa\3\2\2\29\u0109\3\2\2\2;\u0127\3\2\2\2=\u0130"
          + "\3\2\2\2?\u0148\3\2\2\2A\u0160\3\2\2\2C\u016c\3\2\2\2E\u018c\3\2\2\2G"
          + "\u018e\3\2\2\2I\u0191\3\2\2\2K\u0193\3\2\2\2M\u019d\3\2\2\2O\u01a1\3\2"
          + "\2\2Q\u01a5\3\2\2\2S\u01a9\3\2\2\2U\u01ae\3\2\2\2W\u01c1\3\2\2\2Y\u01c3"
          + "\3\2\2\2[\u01c8\3\2\2\2]\u01ca\3\2\2\2_`\7_\2\2`\4\3\2\2\2ab\7R\2\2bc"
          + "\7T\2\2cd\7G\2\2de\7H\2\2ef\7K\2\2fg\7Z\2\2g\6\3\2\2\2hi\7c\2\2i\b\3\2"
          + "\2\2jk\7+\2\2k\n\3\2\2\2lm\7\60\2\2m\f\3\2\2\2no\7.\2\2o\16\3\2\2\2pq"
          + "\7]\2\2q\20\3\2\2\2rs\7*\2\2s\22\3\2\2\2tu\7B\2\2uv\7d\2\2vw\7c\2\2wx"
          + "\7u\2\2xy\7g\2\2y\24\3\2\2\2z{\7=\2\2{\26\3\2\2\2|}\7D\2\2}~\7C\2\2~\177"
          + "\7U\2\2\177\u0080\7G\2\2\u0080\30\3\2\2\2\u0081\u0082\7B\2\2\u0082\u0083"
          + "\7r\2\2\u0083\u0084\7t\2\2\u0084\u0085\7g\2\2\u0085\u0086\7h\2\2\u0086"
          + "\u0087\7k\2\2\u0087\u0088\7z\2\2\u0088\32\3\2\2\2\u0089\u008a\7`\2\2\u008a"
          + "\u008b\7`\2\2\u008b\34\3\2\2\2\u008c\u0090\5\65\33\2\u008d\u0090\5\67"
          + "\34\2\u008e\u0090\59\35\2\u008f\u008c\3\2\2\2\u008f\u008d\3\2\2\2\u008f"
          + "\u008e\3\2\2\2\u0090\36\3\2\2\2\u0091\u0092\7v\2\2\u0092\u0093\7t\2\2"
          + "\u0093\u0094\7w\2\2\u0094\u009b\7g\2\2\u0095\u0096\7h\2\2\u0096\u0097"
          + "\7c\2\2\u0097\u0098\7n\2\2\u0098\u0099\7u\2\2\u0099\u009b\7g\2\2\u009a"
          + "\u0091\3\2\2\2\u009a\u0095\3\2\2\2\u009b \3\2\2\2\u009c\u00a1\5A!\2\u009d"
          + "\u00a1\5C\"\2\u009e\u00a1\5=\37\2\u009f\u00a1\5? \2\u00a0\u009c\3\2\2"
          + "\2\u00a0\u009d\3\2\2\2\u00a0\u009e\3\2\2\2\u00a0\u009f\3\2\2\2\u00a1\""
          + "\3\2\2\2\u00a2\u00a5\5\61\31\2\u00a3\u00a5\5K&\2\u00a4\u00a2\3\2\2\2\u00a4"
          + "\u00a3\3\2\2\2\u00a5$\3\2\2\2\u00a6\u00a8\t\2\2\2\u00a7\u00a6\3\2\2\2"
          + "\u00a8\u00a9\3\2\2\2\u00a9\u00a7\3\2\2\2\u00a9\u00aa\3\2\2\2\u00aa\u00ab"
          + "\3\2\2\2\u00ab\u00ac\b\23\2\2\u00ac&\3\2\2\2\u00ad\u00b6\5O(\2\u00ae\u00b1"
          + "\5S*\2\u00af\u00b1\7\60\2\2\u00b0\u00ae\3\2\2\2\u00b0\u00af\3\2\2\2\u00b1"
          + "\u00b4\3\2\2\2\u00b2\u00b0\3\2\2\2\u00b2\u00b3\3\2\2\2\u00b3\u00b5\3\2"
          + "\2\2\u00b4\u00b2\3\2\2\2\u00b5\u00b7\5S*\2\u00b6\u00b2\3\2\2\2\u00b6\u00b7"
          + "\3\2\2\2\u00b7(\3\2\2\2\u00b8\u00be\7>\2\2\u00b9\u00bd\5S*\2\u00ba\u00bd"
          + "\t\3\2\2\u00bb\u00bd\5E#\2\u00bc\u00b9\3\2\2\2\u00bc\u00ba\3\2\2\2\u00bc"
          + "\u00bb\3\2\2\2\u00bd\u00c0\3\2\2\2\u00be\u00bc\3\2\2\2\u00be\u00bf\3\2"
          + "\2\2\u00bf\u00c1\3\2\2\2\u00c0\u00be\3\2\2\2\u00c1\u00c2\7@\2\2\u00c2"
          + "*\3\2\2\2\u00c3\u00c5\5\'\24\2\u00c4\u00c3\3\2\2\2\u00c4\u00c5\3\2\2\2"
          + "\u00c5\u00c6\3\2\2\2\u00c6\u00c7\7<\2\2\u00c7,\3\2\2\2\u00c8\u00cb\5/"
          + "\30\2\u00c9\u00cb\5+\26\2\u00ca\u00c8\3\2\2\2\u00ca\u00c9\3\2\2\2\u00cb"
          + ".\3\2\2\2\u00cc\u00cd\5+\26\2\u00cd\u00ce\5U+\2\u00ce\60\3\2\2\2\u00cf"
          + "\u00d0\7a\2\2\u00d0\u00d1\7<\2\2\u00d1\u00d4\3\2\2\2\u00d2\u00d5\5Q)\2"
          + "\u00d3\u00d5\t\4\2\2\u00d4\u00d2\3\2\2\2\u00d4\u00d3\3\2\2\2\u00d5\u00de"
          + "\3\2\2\2\u00d6\u00d9\5S*\2\u00d7\u00d9\7\60\2\2\u00d8\u00d6\3\2\2\2\u00d8"
          + "\u00d7\3\2\2\2\u00d9\u00dc\3\2\2\2\u00da\u00d8\3\2\2\2\u00da\u00db\3\2"
          + "\2\2\u00db\u00dd\3\2\2\2\u00dc\u00da\3\2\2\2\u00dd\u00df\5S*\2\u00de\u00da"
          + "\3\2\2\2\u00de\u00df\3\2\2\2\u00df\62\3\2\2\2\u00e0\u00e2\7B\2\2\u00e1"
          + "\u00e3\t\5\2\2\u00e2\u00e1\3\2\2\2\u00e3\u00e4\3\2\2\2\u00e4\u00e2\3\2"
          + "\2\2\u00e4\u00e5\3\2\2\2\u00e5\u00ee\3\2\2\2\u00e6\u00e8\7/\2\2\u00e7"
          + "\u00e9\t\6\2\2\u00e8\u00e7\3\2\2\2\u00e9\u00ea\3\2\2\2\u00ea\u00e8\3\2"
          + "\2\2\u00ea\u00eb\3\2\2\2\u00eb\u00ed\3\2\2\2\u00ec\u00e6\3\2\2\2\u00ed"
          + "\u00f0\3\2\2\2\u00ee\u00ec\3\2\2\2\u00ee\u00ef\3\2\2\2\u00ef\64\3\2\2"
          + "\2\u00f0\u00ee\3\2\2\2\u00f1\u00f3\t\7\2\2\u00f2\u00f1\3\2\2\2\u00f2\u00f3"
          + "\3\2\2\2\u00f3\u00f5\3\2\2\2\u00f4\u00f6\t\4\2\2\u00f5\u00f4\3\2\2\2\u00f6"
          + "\u00f7\3\2\2\2\u00f7\u00f5\3\2\2\2\u00f7\u00f8\3\2\2\2\u00f8\66\3\2\2"
          + "\2\u00f9\u00fb\t\7\2\2\u00fa\u00f9\3\2\2\2\u00fa\u00fb\3\2\2\2\u00fb\u00ff"
          + "\3\2\2\2\u00fc\u00fe\t\4\2\2\u00fd\u00fc\3\2\2\2\u00fe\u0101\3\2\2\2\u00ff"
          + "\u00fd\3\2\2\2\u00ff\u0100\3\2\2\2\u0100\u0102\3\2\2\2\u0101\u00ff\3\2"
          + "\2\2\u0102\u0104\7\60\2\2\u0103\u0105\t\4\2\2\u0104\u0103\3\2\2\2\u0105"
          + "\u0106\3\2\2\2\u0106\u0104\3\2\2\2\u0106\u0107\3\2\2\2\u01078\3\2\2\2"
          + "\u0108\u010a\t\7\2\2\u0109\u0108\3\2\2\2\u0109\u010a\3\2\2\2\u010a\u0125"
          + "\3\2\2\2\u010b\u010d\t\4\2\2\u010c\u010b\3\2\2\2\u010d\u010e\3\2\2\2\u010e"
          + "\u010c\3\2\2\2\u010e\u010f\3\2\2\2\u010f\u0110\3\2\2\2\u0110\u0114\7\60"
          + "\2\2\u0111\u0113\t\4\2\2\u0112\u0111\3\2\2\2\u0113\u0116\3\2\2\2\u0114"
          + "\u0112\3\2\2\2\u0114\u0115\3\2\2\2\u0115\u0117\3\2\2\2\u0116\u0114\3\2"
          + "\2\2\u0117\u0126\5;\36\2\u0118\u011a\7\60\2\2\u0119\u011b\t\4\2\2\u011a"
          + "\u0119\3\2\2\2\u011b\u011c\3\2\2\2\u011c\u011a\3\2\2\2\u011c\u011d\3\2"
          + "\2\2\u011d\u011e\3\2\2\2\u011e\u0126\5;\36\2\u011f\u0121\t\4\2\2\u0120"
          + "\u011f\3\2\2\2\u0121\u0122\3\2\2\2\u0122\u0120\3\2\2\2\u0122\u0123\3\2"
          + "\2\2\u0123\u0124\3\2\2\2\u0124\u0126\5;\36\2\u0125\u010c\3\2\2\2\u0125"
          + "\u0118\3\2\2\2\u0125\u0120\3\2\2\2\u0126:\3\2\2\2\u0127\u0129\t\b\2\2"
          + "\u0128\u012a\t\7\2\2\u0129\u0128\3\2\2\2\u0129\u012a\3\2\2\2\u012a\u012c"
          + "\3\2\2\2\u012b\u012d\t\4\2\2\u012c\u012b\3\2\2\2\u012d\u012e\3\2\2\2\u012e"
          + "\u012c\3\2\2\2\u012e\u012f\3\2\2\2\u012f<\3\2\2\2\u0130\u0131\7)\2\2\u0131"
          + "\u0132\7)\2\2\u0132\u0133\7)\2\2\u0133\u0141\3\2\2\2\u0134\u0138\7)\2"
          + "\2\u0135\u0136\7)\2\2\u0136\u0138\7)\2\2\u0137\u0134\3\2\2\2\u0137\u0135"
          + "\3\2\2\2\u0137\u0138\3\2\2\2\u0138\u013d\3\2\2\2\u0139\u013e\t\t\2\2\u013a"
          + "\u013e\5G$\2\u013b\u013e\5E#\2\u013c\u013e\7$\2\2\u013d\u0139\3\2\2\2"
          + "\u013d\u013a\3\2\2\2\u013d\u013b\3\2\2\2\u013d\u013c\3\2\2\2\u013e\u0140"
          + "\3\2\2\2\u013f\u0137\3\2\2\2\u0140\u0143\3\2\2\2\u0141\u013f\3\2\2\2\u0141"
          + "\u0142\3\2\2\2\u0142\u0144\3\2\2\2\u0143\u0141\3\2\2\2\u0144\u0145\7)"
          + "\2\2\u0145\u0146\7)\2\2\u0146\u0147\7)\2\2\u0147>\3\2\2\2\u0148\u0149"
          + "\7$\2\2\u0149\u014a\7$\2\2\u014a\u014b\7$\2\2\u014b\u0159\3\2\2\2\u014c"
          + "\u0150\7$\2\2\u014d\u014e\7$\2\2\u014e\u0150\7$\2\2\u014f\u014c\3\2\2"
          + "\2\u014f\u014d\3\2\2\2\u014f\u0150\3\2\2\2\u0150\u0155\3\2\2\2\u0151\u0156"
          + "\n\n\2\2\u0152\u0156\5G$\2\u0153\u0156\5E#\2\u0154\u0156\7)\2\2\u0155"
          + "\u0151\3\2\2\2\u0155\u0152\3\2\2\2\u0155\u0153\3\2\2\2\u0155\u0154\3\2"
          + "\2\2\u0156\u0158\3\2\2\2\u0157\u014f\3\2\2\2\u0158\u015b\3\2\2\2\u0159"
          + "\u0157\3\2\2\2\u0159\u015a\3\2\2\2\u015a\u015c\3\2\2\2\u015b\u0159\3\2"
          + "\2\2\u015c\u015d\7$\2\2\u015d\u015e\7$\2\2\u015e\u015f\7$\2\2\u015f@\3"
          + "\2\2\2\u0160\u0167\7$\2\2\u0161\u0166\n\13\2\2\u0162\u0166\7)\2\2\u0163"
          + "\u0164\7^\2\2\u0164\u0166\7$\2\2\u0165\u0161\3\2\2\2\u0165\u0162\3\2\2"
          + "\2\u0165\u0163\3\2\2\2\u0166\u0169\3\2\2\2\u0167\u0165\3\2\2\2\u0167\u0168"
          + "\3\2\2\2\u0168\u016a\3\2\2\2\u0169\u0167\3\2\2\2\u016a\u016b\7$\2\2\u016b"
          + "B\3\2\2\2\u016c\u0173\7)\2\2\u016d\u0172\n\f\2\2\u016e\u0172\5G$\2\u016f"
          + "\u0172\5E#\2\u0170\u0172\7$\2\2\u0171\u016d\3\2\2\2\u0171\u016e\3\2\2"
          + "\2\u0171\u016f\3\2\2\2\u0171\u0170\3\2\2\2\u0172\u0175\3\2\2\2\u0173\u0171"
          + "\3\2\2\2\u0173\u0174\3\2\2\2\u0174\u0176\3\2\2\2\u0175\u0173\3\2\2\2\u0176"
          + "\u0177\7)\2\2\u0177D\3\2\2\2\u0178\u0179\7^\2\2\u0179\u017a\7w\2\2\u017a"
          + "\u017b\3\2\2\2\u017b\u017c\5[.\2\u017c\u017d\5[.\2\u017d\u017e\5[.\2\u017e"
          + "\u017f\5[.\2\u017f\u018d\3\2\2\2\u0180\u0181\7^\2\2\u0181\u0182\7W\2\2"
          + "\u0182\u0183\3\2\2\2\u0183\u0184\5[.\2\u0184\u0185\5[.\2\u0185\u0186\5"
          + "[.\2\u0186\u0187\5[.\2\u0187\u0188\5[.\2\u0188\u0189\5[.\2\u0189\u018a"
          + "\5[.\2\u018a\u018b\5[.\2\u018b\u018d\3\2\2\2\u018c\u0178\3\2\2\2\u018c"
          + "\u0180\3\2\2\2\u018dF\3\2\2\2\u018e\u018f\7^\2\2\u018f\u0190\t\r\2\2\u0190"
          + "H\3\2\2\2\u0191\u0192\t\16\2\2\u0192J\3\2\2\2\u0193\u0197\7]\2\2\u0194"
          + "\u0196\5I%\2\u0195\u0194\3\2\2\2\u0196\u0199\3\2\2\2\u0197\u0195\3\2\2"
          + "\2\u0197\u0198\3\2\2\2\u0198\u019a\3\2\2\2\u0199\u0197\3\2\2\2\u019a\u019b"
          + "\7_\2\2\u019bL\3\2\2\2\u019c\u019e\t\17\2\2\u019d\u019c\3\2\2\2\u019e"
          + "\u019f\3\2\2\2\u019f\u019d\3\2\2\2\u019f\u01a0\3\2\2\2\u01a0N\3\2\2\2"
          + "\u01a1\u01a2\t\20\2\2\u01a2P\3\2\2\2\u01a3\u01a6\5O(\2\u01a4\u01a6\7a"
          + "\2\2\u01a5\u01a3\3\2\2\2\u01a5\u01a4\3\2\2\2\u01a6R\3\2\2\2\u01a7\u01aa"
          + "\5Q)\2\u01a8\u01aa\t\21\2\2\u01a9\u01a7\3\2\2\2\u01a9\u01a8\3\2\2\2\u01aa"
          + "T\3\2\2\2\u01ab\u01af\5Q)\2\u01ac\u01af\4\62<\2\u01ad\u01af\5W,\2\u01ae"
          + "\u01ab\3\2\2\2\u01ae\u01ac\3\2\2\2\u01ae\u01ad\3\2\2\2\u01af\u01bd\3\2"
          + "\2\2\u01b0\u01b4\5S*\2\u01b1\u01b4\t\22\2\2\u01b2\u01b4\5W,\2\u01b3\u01b0"
          + "\3\2\2\2\u01b3\u01b1\3\2\2\2\u01b3\u01b2\3\2\2\2\u01b4\u01b7\3\2\2\2\u01b5"
          + "\u01b3\3\2\2\2\u01b5\u01b6\3\2\2\2\u01b6\u01bb\3\2\2\2\u01b7\u01b5\3\2"
          + "\2\2\u01b8\u01bc\5S*\2\u01b9\u01bc\7<\2\2\u01ba\u01bc\5W,\2\u01bb\u01b8"
          + "\3\2\2\2\u01bb\u01b9\3\2\2\2\u01bb\u01ba\3\2\2\2\u01bc\u01be\3\2\2\2\u01bd"
          + "\u01b5\3\2\2\2\u01bd\u01be\3\2\2\2\u01beV\3\2\2\2\u01bf\u01c2\5Y-\2\u01c0"
          + "\u01c2\5]/\2\u01c1\u01bf\3\2\2\2\u01c1\u01c0\3\2\2\2\u01c2X\3\2\2\2\u01c3"
          + "\u01c4\7\'\2\2\u01c4\u01c5\5[.\2\u01c5\u01c6\5[.\2\u01c6Z\3\2\2\2\u01c7"
          + "\u01c9\t\23\2\2\u01c8\u01c7\3\2\2\2\u01c9\\\3\2\2\2\u01ca\u01cb\7^\2\2"
          + "\u01cb\u01cc\t\24\2\2\u01cc^\3\2\2\2:\2\u008f\u009a\u00a0\u00a4\u00a7"
          + "\u00a9\u00b0\u00b2\u00b6\u00bc\u00be\u00c4\u00ca\u00d4\u00d8\u00da\u00de"
          + "\u00e4\u00ea\u00ee\u00f2\u00f7\u00fa\u00ff\u0106\u0109\u010e\u0114\u011c"
          + "\u0122\u0125\u0129\u012e\u0137\u013d\u0141\u014f\u0155\u0159\u0165\u0167"
          + "\u0171\u0173\u018c\u0197\u019f\u01a5\u01a9\u01ae\u01b3\u01b5\u01bb\u01bd"
          + "\u01c1\u01c8";
  public static final ATN _ATN = ATNSimulator.deserialize(_serializedATN.toCharArray());

  static {
    _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
    for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
      _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
    }
  }
}
@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
public class ExtractedLittleParser extends Parser {
  protected static final DFA[] _decisionToDFA;
  protected static final PredictionContextCache _sharedContextCache = new PredictionContextCache();
  public static final int T__1 = 1, T__0 = 2;
  public static final String[] tokenNames = {"<INVALID>", "'+'", "'e'"};
  public static final int RULE_s = 0, RULE_e = 1;
  public static final String[] ruleNames = {"s", "e"};

  @Override
  public String getGrammarFileName() {
    return "ExtractedLittle.g4";
  }

  @Override
  public String[] getTokenNames() {
    return tokenNames;
  }

  @Override
  public String[] getRuleNames() {
    return ruleNames;
  }

  @Override
  public ATN getATN() {
    return _ATN;
  }

  public ExtractedLittleParser(TokenStream input) {
    super(input);
    _interp = new ParserATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache);
  }

  public static class SContext extends ParserRuleContext {
    public EContext e() {
      return getRuleContext(EContext.class, 0);
    }

    public SContext(ParserRuleContext parent, int invokingState) {
      super(parent, invokingState);
    }

    @Override
    public int getRuleIndex() {
      return RULE_s;
    }

    @Override
    public void enterRule(ParseTreeListener listener) {
      if (listener instanceof ExtractedLittleListener)
        ((ExtractedLittleListener) listener).enterS(this);
    }

    @Override
    public void exitRule(ParseTreeListener listener) {
      if (listener instanceof ExtractedLittleListener)
        ((ExtractedLittleListener) listener).exitS(this);
    }

    @Override
    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
      if (visitor instanceof ExtractedLittleVisitor)
        return ((ExtractedLittleVisitor<? extends T>) visitor).visitS(this);
      else return visitor.visitChildren(this);
    }
  }

  public final SContext s() throws RecognitionException {
    SContext _localctx = new SContext(_ctx, getState());
    enterRule(_localctx, 0, RULE_s);
    try {
      enterOuterAlt(_localctx, 1);
      {
        setState(4);
        e(0);
      }
    } catch (RecognitionException re) {
      _localctx.exception = re;
      _errHandler.reportError(this, re);
      _errHandler.recover(this, re);
    } finally {
      exitRule();
    }
    return _localctx;
  }

  public static class EContext extends ParserRuleContext {
    public int _p;

    public EContext e(int i) {
      return getRuleContext(EContext.class, i);
    }

    public List<EContext> e() {
      return getRuleContexts(EContext.class);
    }

    public EContext(ParserRuleContext parent, int invokingState) {
      super(parent, invokingState);
    }

    public EContext(ParserRuleContext parent, int invokingState, int _p) {
      super(parent, invokingState);
      this._p = _p;
    }

    @Override
    public int getRuleIndex() {
      return RULE_e;
    }

    @Override
    public void enterRule(ParseTreeListener listener) {
      if (listener instanceof ExtractedLittleListener)
        ((ExtractedLittleListener) listener).enterE(this);
    }

    @Override
    public void exitRule(ParseTreeListener listener) {
      if (listener instanceof ExtractedLittleListener)
        ((ExtractedLittleListener) listener).exitE(this);
    }

    @Override
    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
      if (visitor instanceof ExtractedLittleVisitor)
        return ((ExtractedLittleVisitor<? extends T>) visitor).visitE(this);
      else return visitor.visitChildren(this);
    }
  }

  public final EContext e(int _p) throws RecognitionException {
    ParserRuleContext _parentctx = _ctx;
    int _parentState = getState();
    EContext _localctx = new EContext(_ctx, _parentState, _p);
    EContext _prevctx = _localctx;
    int _startState = 2;
    enterRecursionRule(_localctx, RULE_e);
    try {
      int _alt;
      enterOuterAlt(_localctx, 1);
      {
        {
          setState(7);
          match(2);
        }
        _ctx.stop = _input.LT(-1);
        setState(14);
        _errHandler.sync(this);
        _alt = getInterpreter().adaptivePredict(_input, 0, _ctx);
        while (_alt != 2 && _alt != -1) {
          if (_alt == 1) {
            if (_parseListeners != null) triggerExitRuleEvent();
            _prevctx = _localctx;
            {
              {
                _localctx = new EContext(_parentctx, _parentState, _p);
                pushNewRecursionContext(_localctx, _startState, RULE_e);
                setState(9);
                if (!(2 >= _localctx._p)) throw new FailedPredicateException(this, "2 >= $_p");
                setState(10);
                match(1);
                setState(11);
                e(3);
              }
            }
          }
          setState(16);
          _errHandler.sync(this);
          _alt = getInterpreter().adaptivePredict(_input, 0, _ctx);
        }
      }
    } catch (RecognitionException re) {
      _localctx.exception = re;
      _errHandler.reportError(this, re);
      _errHandler.recover(this, re);
    } finally {
      unrollRecursionContexts(_parentctx);
    }
    return _localctx;
  }

  public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
    switch (ruleIndex) {
      case 1:
        return e_sempred((EContext) _localctx, predIndex);
    }
    return true;
  }

  private boolean e_sempred(EContext _localctx, int predIndex) {
    switch (predIndex) {
      case 0:
        return 2 >= _localctx._p;
    }
    return true;
  }

  public static final String _serializedATN =
      "\3\uacf5\uee8c\u4f5d\u8b0d\u4a45\u78bd\u1b2f\u3378\3\4\24\4\2\t\2\4\3"
          + "\t\3\3\2\3\2\3\3\3\3\3\3\3\3\3\3\3\3\7\3\17\n\3\f\3\16\3\22\13\3\3\3\2"
          + "\4\2\4\2\2\22\2\6\3\2\2\2\4\b\3\2\2\2\6\7\5\4\3\2\7\3\3\2\2\2\b\t\b\3"
          + "\1\2\t\n\7\4\2\2\n\20\3\2\2\2\13\f\6\3\2\3\f\r\7\3\2\2\r\17\5\4\3\2\16"
          + "\13\3\2\2\2\17\22\3\2\2\2\20\16\3\2\2\2\20\21\3\2\2\2\21\5\3\2\2\2\22"
          + "\20\3\2\2\2\3\20";
  public static final ATN _ATN = ATNSimulator.deserialize(_serializedATN.toCharArray());

  static {
    _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
    for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
      _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
    }
  }
}
Пример #7
0
@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
public class SQLCommonLexer extends Lexer {
  protected static final DFA[] _decisionToDFA;
  protected static final PredictionContextCache _sharedContextCache = new PredictionContextCache();
  public static final int ARMSCII8 = 1,
      ASCII = 2,
      BIG5 = 3,
      BINARY = 4,
      CP1250 = 5,
      CP1251 = 6,
      CP1256 = 7,
      CP1257 = 8,
      CP850 = 9,
      CP852 = 10,
      CP866 = 11,
      CP932 = 12,
      DEC8 = 13,
      EUCJPMS = 14,
      EUCKR = 15,
      GB2312 = 16,
      GBK = 17,
      GEOSTD8 = 18,
      GREEK = 19,
      HEBREW = 20,
      HP8 = 21,
      KEYBCS2 = 22,
      KOI8R = 23,
      KOI8U = 24,
      LATIN1 = 25,
      LATIN2 = 26,
      LATIN5 = 27,
      LATIN7 = 28,
      MACCE = 29,
      MACROMAN = 30,
      SJIS = 31,
      SWE7 = 32,
      TIS620 = 33,
      UCS2 = 34,
      UJIS = 35,
      UTF8 = 36,
      CHARSET_NAME = 37,
      E_SYM = 38,
      SELECT = 39,
      INSERT = 40,
      UPDATE = 41,
      DELETE = 42,
      INTO = 43,
      SET = 44,
      FROM = 45,
      UNION = 46,
      UNION_ALL = 47,
      ALL = 48,
      DISTINCT = 49,
      GROUP_BY = 50,
      HAVING = 51,
      WHERE = 52,
      ON = 53,
      ORDER_BY = 54,
      LIMIT = 55,
      AS = 56,
      CASE = 57,
      WHEN = 58,
      ELSE = 59,
      THEN = 60,
      INNER = 61,
      JOIN = 62,
      ASC = 63,
      DESC = 64,
      END = 65,
      LEFT = 66,
      RIGHT = 67,
      OUTER = 68,
      NOT = 69,
      AND = 70,
      OR = 71,
      IN = 72,
      EXIST = 73,
      BETWEEN = 74,
      NULL = 75,
      VALUES = 76,
      DOT = 77,
      VERTICAL_BAR = 78,
      DOUBLE_VERTICAL_BAR = 79,
      PLUS = 80,
      DIV = 81,
      MINUS = 82,
      PERCENT = 83,
      COMMA = 84,
      SEMI = 85,
      COLON = 86,
      RBRACK = 87,
      LBRACK = 88,
      NEGATION = 89,
      BITAND = 90,
      POWER_OP = 91,
      LPAREN = 92,
      RPAREN = 93,
      ASTERISK = 94,
      GT = 95,
      GE = 96,
      EQ = 97,
      LT = 98,
      LE = 99,
      LIKE = 100,
      ID = 101,
      INT = 102,
      FLOAT = 103,
      CHAR_LITERAL = 104,
      HEX = 105,
      BIT = 106,
      BOOLEAN = 107,
      NEWLINE = 108,
      WS = 109;
  public static String[] modeNames = {"DEFAULT_MODE"};

  public static final String[] tokenNames = {
    "<INVALID>",
    "ARMSCII8",
    "ASCII",
    "BIG5",
    "BINARY",
    "CP1250",
    "CP1251",
    "CP1256",
    "CP1257",
    "CP850",
    "CP852",
    "CP866",
    "CP932",
    "DEC8",
    "EUCJPMS",
    "EUCKR",
    "GB2312",
    "GBK",
    "GEOSTD8",
    "GREEK",
    "HEBREW",
    "HP8",
    "KEYBCS2",
    "KOI8R",
    "KOI8U",
    "LATIN1",
    "LATIN2",
    "LATIN5",
    "LATIN7",
    "MACCE",
    "MACROMAN",
    "SJIS",
    "SWE7",
    "TIS620",
    "UCS2",
    "UJIS",
    "UTF8",
    "CHARSET_NAME",
    "E_SYM",
    "SELECT",
    "INSERT",
    "UPDATE",
    "DELETE",
    "INTO",
    "SET",
    "FROM",
    "UNION",
    "UNION_ALL",
    "ALL",
    "DISTINCT",
    "GROUP_BY",
    "HAVING",
    "WHERE",
    "ON",
    "ORDER_BY",
    "LIMIT",
    "AS",
    "CASE",
    "WHEN",
    "ELSE",
    "THEN",
    "INNER",
    "JOIN",
    "ASC",
    "DESC",
    "END",
    "LEFT",
    "RIGHT",
    "OUTER",
    "NOT",
    "AND",
    "OR",
    "IN",
    "EXIST",
    "BETWEEN",
    "NULL",
    "VALUES",
    "DOT",
    "'|'",
    "'||'",
    "'+'",
    "'/'",
    "'-'",
    "'%'",
    "','",
    "';'",
    "':'",
    "']'",
    "'['",
    "'~'",
    "'&'",
    "'^'",
    "'('",
    "')'",
    "'*'",
    "'>'",
    "'>='",
    "'='",
    "'<'",
    "'<='",
    "LIKE",
    "ID",
    "INT",
    "FLOAT",
    "CHAR_LITERAL",
    "HEX",
    "BIT",
    "BOOLEAN",
    "NEWLINE",
    "WS"
  };
  public static final String[] ruleNames = {
    "DIGIT",
    "FIRST_ID_CHAR",
    "ID_CHAR",
    "HEX_DIGIT",
    "APOSTROPHE",
    "QUOT",
    "A_",
    "B_",
    "C_",
    "D_",
    "E_",
    "F_",
    "G_",
    "H_",
    "I_",
    "J_",
    "K_",
    "L_",
    "M_",
    "N_",
    "O_",
    "P_",
    "Q_",
    "R_",
    "S_",
    "T_",
    "U_",
    "V_",
    "W_",
    "X_",
    "Y_",
    "Z_",
    "ARMSCII8",
    "ASCII",
    "BIG5",
    "BINARY",
    "CP1250",
    "CP1251",
    "CP1256",
    "CP1257",
    "CP850",
    "CP852",
    "CP866",
    "CP932",
    "DEC8",
    "EUCJPMS",
    "EUCKR",
    "GB2312",
    "GBK",
    "GEOSTD8",
    "GREEK",
    "HEBREW",
    "HP8",
    "KEYBCS2",
    "KOI8R",
    "KOI8U",
    "LATIN1",
    "LATIN2",
    "LATIN5",
    "LATIN7",
    "MACCE",
    "MACROMAN",
    "SJIS",
    "SWE7",
    "TIS620",
    "UCS2",
    "UJIS",
    "UTF8",
    "CHARSET_NAME",
    "E_SYM",
    "SELECT",
    "INSERT",
    "UPDATE",
    "DELETE",
    "INTO",
    "SET",
    "FROM",
    "UNION",
    "UNION_ALL",
    "ALL",
    "DISTINCT",
    "GROUP_BY",
    "HAVING",
    "WHERE",
    "ON",
    "ORDER_BY",
    "LIMIT",
    "AS",
    "CASE",
    "WHEN",
    "ELSE",
    "THEN",
    "INNER",
    "JOIN",
    "ASC",
    "DESC",
    "END",
    "LEFT",
    "RIGHT",
    "OUTER",
    "NOT",
    "AND",
    "OR",
    "IN",
    "EXIST",
    "BETWEEN",
    "NULL",
    "VALUES",
    "DOT",
    "VERTICAL_BAR",
    "DOUBLE_VERTICAL_BAR",
    "PLUS",
    "DIV",
    "MINUS",
    "PERCENT",
    "COMMA",
    "SEMI",
    "COLON",
    "RBRACK",
    "LBRACK",
    "NEGATION",
    "BITAND",
    "POWER_OP",
    "LPAREN",
    "RPAREN",
    "ASTERISK",
    "GT",
    "GE",
    "EQ",
    "LT",
    "LE",
    "LIKE",
    "ID",
    "INT",
    "FLOAT",
    "CHAR_LITERAL",
    "HEX",
    "BIT",
    "BOOLEAN",
    "NEWLINE",
    "WS"
  };

  public SQLCommonLexer(CharStream input) {
    super(input);
    _interp = new LexerATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache);
  }

  @Override
  public String getGrammarFileName() {
    return "SQLCommon.g";
  }

  @Override
  public String[] getTokenNames() {
    return tokenNames;
  }

  @Override
  public String[] getRuleNames() {
    return ruleNames;
  }

  @Override
  public String[] getModeNames() {
    return modeNames;
  }

  @Override
  public ATN getATN() {
    return _ATN;
  }

  @Override
  public void action(RuleContext _localctx, int ruleIndex, int actionIndex) {
    switch (ruleIndex) {
      case 140:
        WS_action((RuleContext) _localctx, actionIndex);
        break;
    }
  }

  private void WS_action(RuleContext _localctx, int actionIndex) {
    switch (actionIndex) {
      case 0:
        skip();
        break;
    }
  }

  public static final String _serializedATN =
      "\3\uacf5\uee8c\u4f5d\u8b0d\u4a45\u78bd\u1b2f\u3378\2o\u0406\b\1\4\2\t"
          + "\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13"
          + "\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"
          + "\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"
          + "\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"
          + "\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"
          + ",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"
          + "\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t="
          + "\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"
          + "\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT"
          + "\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4_\t_\4"
          + "`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4h\th\4i\ti\4j\tj\4k\t"
          + "k\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4"
          + "w\tw\4x\tx\4y\ty\4z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080\t\u0080"
          + "\4\u0081\t\u0081\4\u0082\t\u0082\4\u0083\t\u0083\4\u0084\t\u0084\4\u0085"
          + "\t\u0085\4\u0086\t\u0086\4\u0087\t\u0087\4\u0088\t\u0088\4\u0089\t\u0089"
          + "\4\u008a\t\u008a\4\u008b\t\u008b\4\u008c\t\u008c\4\u008d\t\u008d\4\u008e"
          + "\t\u008e\3\2\3\2\3\3\3\3\3\4\3\4\3\5\3\5\3\6\3\6\3\7\3\7\3\b\3\b\3\t\3"
          + "\t\3\n\3\n\3\13\3\13\3\f\3\f\3\r\3\r\3\16\3\16\3\17\3\17\3\20\3\20\3\21"
          + "\3\21\3\22\3\22\3\23\3\23\3\24\3\24\3\25\3\25\3\26\3\26\3\27\3\27\3\30"
          + "\3\30\3\31\3\31\3\32\3\32\3\33\3\33\3\34\3\34\3\35\3\35\3\36\3\36\3\37"
          + "\3\37\3 \3 \3!\3!\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3#\3#\3#\3#\3#\3"
          + "#\3$\3$\3$\3$\3$\3%\3%\3%\3%\3%\3%\3%\3&\3&\3&\3&\3&\3&\3&\3\'\3\'\3\'"
          + "\3\'\3\'\3\'\3\'\3(\3(\3(\3(\3(\3(\3(\3)\3)\3)\3)\3)\3)\3)\3*\3*\3*\3"
          + "*\3*\3*\3+\3+\3+\3+\3+\3+\3,\3,\3,\3,\3,\3,\3-\3-\3-\3-\3-\3-\3.\3.\3"
          + ".\3.\3.\3/\3/\3/\3/\3/\3/\3/\3/\3\60\3\60\3\60\3\60\3\60\3\60\3\61\3\61"
          + "\3\61\3\61\3\61\3\61\3\61\3\62\3\62\3\62\3\62\3\63\3\63\3\63\3\63\3\63"
          + "\3\63\3\63\3\63\3\64\3\64\3\64\3\64\3\64\3\64\3\65\3\65\3\65\3\65\3\65"
          + "\3\65\3\65\3\66\3\66\3\66\3\66\3\67\3\67\3\67\3\67\3\67\3\67\3\67\3\67"
          + "\38\38\38\38\38\38\39\39\39\39\39\39\3:\3:\3:\3:\3:\3:\3:\3;\3;\3;\3;"
          + "\3;\3;\3;\3<\3<\3<\3<\3<\3<\3<\3=\3=\3=\3=\3=\3=\3=\3>\3>\3>\3>\3>\3>"
          + "\3?\3?\3?\3?\3?\3?\3?\3?\3?\3@\3@\3@\3@\3@\3A\3A\3A\3A\3A\3B\3B\3B\3B"
          + "\3B\3B\3B\3C\3C\3C\3C\3C\3D\3D\3D\3D\3D\3E\3E\3E\3E\3E\3F\3F\3F\3F\3F"
          + "\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F"
          + "\3F\3F\3F\3F\3F\3F\3F\3F\5F\u0267\nF\3G\3G\3H\3H\3H\3H\3H\3H\3H\3I\3I"
          + "\3I\3I\3I\3I\3I\3J\3J\3J\3J\3J\3J\3J\3K\3K\3K\3K\3K\3K\3K\3L\3L\3L\3L"
          + "\3L\3M\3M\3M\3M\3N\3N\3N\3N\3N\3O\3O\3O\3O\3O\3O\3P\3P\3P\3P\3P\3P\6P"
          + "\u02a1\nP\rP\16P\u02a2\3P\3P\3P\3P\3Q\3Q\3Q\3Q\3R\3R\3R\3R\3R\3R\3R\3"
          + "R\3R\3S\3S\3S\3S\3S\3S\6S\u02bc\nS\rS\16S\u02bd\3S\3S\3S\3T\3T\3T\3T\3"
          + "T\3T\3T\3U\3U\3U\3U\3U\3U\3V\3V\3V\3W\3W\3W\3W\3W\3W\6W\u02d9\nW\rW\16"
          + "W\u02da\3W\3W\3W\3X\3X\3X\3X\3X\3X\3Y\3Y\3Y\3Z\3Z\3Z\3Z\3Z\3[\3[\3[\3"
          + "[\3[\3\\\3\\\3\\\3\\\3\\\3]\3]\3]\3]\3]\3^\3^\3^\3^\3^\3^\3_\3_\3_\3_"
          + "\3_\3`\3`\3`\3`\3a\3a\3a\3a\3a\3b\3b\3b\3b\3c\3c\3c\3c\3c\3d\3d\3d\3d"
          + "\3d\3d\3e\3e\3e\3e\3e\3e\3f\3f\3f\3f\3g\3g\3g\3g\3h\3h\3h\3i\3i\3i\3j"
          + "\3j\3j\3j\3j\3j\3k\3k\3k\3k\3k\3k\3k\3k\3l\3l\3l\3l\3l\3m\3m\3m\3m\3m"
          + "\3m\3m\3n\3n\3o\3o\3p\3p\3p\3q\3q\3r\3r\3s\3s\3t\3t\3u\3u\3v\3v\3w\3w"
          + "\3x\3x\3y\3y\3z\3z\3{\3{\3|\3|\3}\3}\3~\3~\3\177\3\177\3\u0080\3\u0080"
          + "\3\u0081\3\u0081\3\u0081\3\u0082\3\u0082\3\u0083\3\u0083\3\u0084\3\u0084"
          + "\3\u0084\3\u0085\3\u0085\3\u0085\3\u0085\3\u0085\3\u0085\3\u0085\3\u0085"
          + "\5\u0085\u0387\n\u0085\3\u0086\6\u0086\u038a\n\u0086\r\u0086\16\u0086"
          + "\u038b\3\u0086\7\u0086\u038f\n\u0086\f\u0086\16\u0086\u0392\13\u0086\3"
          + "\u0087\6\u0087\u0395\n\u0087\r\u0087\16\u0087\u0396\3\u0088\6\u0088\u039a"
          + "\n\u0088\r\u0088\16\u0088\u039b\3\u0088\3\u0088\6\u0088\u03a0\n\u0088"
          + "\r\u0088\16\u0088\u03a1\3\u0089\3\u0089\3\u0089\3\u0089\3\u0089\3\u0089"
          + "\3\u0089\3\u0089\7\u0089\u03ac\n\u0089\f\u0089\16\u0089\u03af\13\u0089"
          + "\3\u0089\3\u0089\3\u0089\3\u0089\3\u0089\3\u0089\3\u0089\3\u0089\3\u0089"
          + "\7\u0089\u03ba\n\u0089\f\u0089\16\u0089\u03bd\13\u0089\3\u0089\5\u0089"
          + "\u03c0\n\u0089\3\u008a\3\u008a\3\u008a\3\u008a\6\u008a\u03c6\n\u008a\r"
          + "\u008a\16\u008a\u03c7\3\u008a\3\u008a\3\u008a\6\u008a\u03cd\n\u008a\r"
          + "\u008a\16\u008a\u03ce\3\u008a\3\u008a\5\u008a\u03d3\n\u008a\3\u008b\3"
          + "\u008b\3\u008b\3\u008b\6\u008b\u03d9\n\u008b\r\u008b\16\u008b\u03da\3"
          + "\u008b\3\u008b\3\u008b\6\u008b\u03e0\n\u008b\r\u008b\16\u008b\u03e1\3"
          + "\u008b\5\u008b\u03e5\n\u008b\3\u008c\3\u008c\3\u008c\3\u008c\3\u008c\3"
          + "\u008c\3\u008c\3\u008c\3\u008c\3\u008c\3\u008c\3\u008c\3\u008c\3\u008c"
          + "\3\u008c\3\u008c\3\u008c\3\u008c\5\u008c\u03f9\n\u008c\3\u008d\5\u008d"
          + "\u03fc\n\u008d\3\u008d\3\u008d\3\u008e\6\u008e\u0401\n\u008e\r\u008e\16"
          + "\u008e\u0402\3\u008e\3\u008e\2\u008f\3\2\1\5\2\1\7\2\1\t\2\1\13\2\1\r"
          + "\2\1\17\2\1\21\2\1\23\2\1\25\2\1\27\2\1\31\2\1\33\2\1\35\2\1\37\2\1!\2"
          + "\1#\2\1%\2\1\'\2\1)\2\1+\2\1-\2\1/\2\1\61\2\1\63\2\1\65\2\1\67\2\19\2"
          + "\1;\2\1=\2\1?\2\1A\2\1C\3\1E\4\1G\5\1I\6\1K\7\1M\b\1O\t\1Q\n\1S\13\1U"
          + "\f\1W\r\1Y\16\1[\17\1]\20\1_\21\1a\22\1c\23\1e\24\1g\25\1i\26\1k\27\1"
          + "m\30\1o\31\1q\32\1s\33\1u\34\1w\35\1y\36\1{\37\1} \1\177!\1\u0081\"\1"
          + "\u0083#\1\u0085$\1\u0087%\1\u0089&\1\u008b\'\1\u008d(\1\u008f)\1\u0091"
          + "*\1\u0093+\1\u0095,\1\u0097-\1\u0099.\1\u009b/\1\u009d\60\1\u009f\61\1"
          + "\u00a1\62\1\u00a3\63\1\u00a5\64\1\u00a7\65\1\u00a9\66\1\u00ab\67\1\u00ad"
          + "8\1\u00af9\1\u00b1:\1\u00b3;\1\u00b5<\1\u00b7=\1\u00b9>\1\u00bb?\1\u00bd"
          + "@\1\u00bfA\1\u00c1B\1\u00c3C\1\u00c5D\1\u00c7E\1\u00c9F\1\u00cbG\1\u00cd"
          + "H\1\u00cfI\1\u00d1J\1\u00d3K\1\u00d5L\1\u00d7M\1\u00d9N\1\u00dbO\1\u00dd"
          + "P\1\u00dfQ\1\u00e1R\1\u00e3S\1\u00e5T\1\u00e7U\1\u00e9V\1\u00ebW\1\u00ed"
          + "X\1\u00efY\1\u00f1Z\1\u00f3[\1\u00f5\\\1\u00f7]\1\u00f9^\1\u00fb_\1\u00fd"
          + "`\1\u00ffa\1\u0101b\1\u0103c\1\u0105d\1\u0107e\1\u0109f\1\u010bg\1\u010d"
          + "h\1\u010fi\1\u0111j\1\u0113k\1\u0115l\1\u0117m\1\u0119n\1\u011bo\2\3\2"
          + "$\3\2\62;\6\2&&C\\aac|\6\2\62;C\\aac|\5\2\62;CHch\4\2CCcc\4\2DDdd\4\2"
          + "EEee\4\2FFff\4\2GGgg\4\2HHhh\4\2IIii\4\2JJjj\4\2KKkk\4\2LLll\4\2MMmm\4"
          + "\2NNnn\4\2OOoo\4\2PPpp\4\2QQqq\4\2RRrr\4\2SSss\4\2TTtt\4\2UUuu\4\2VVv"
          + "v\4\2WWww\4\2XXxx\4\2YYyy\4\2ZZzz\4\2[[{{\4\2\\\\||\4\2\13\13\"\"\3\2"
          + "))\3\2$$\6\2\13\f\17\17\"\"~~\u0425\2C\3\2\2\2\2E\3\2\2\2\2G\3\2\2\2\2"
          + "I\3\2\2\2\2K\3\2\2\2\2M\3\2\2\2\2O\3\2\2\2\2Q\3\2\2\2\2S\3\2\2\2\2U\3"
          + "\2\2\2\2W\3\2\2\2\2Y\3\2\2\2\2[\3\2\2\2\2]\3\2\2\2\2_\3\2\2\2\2a\3\2\2"
          + "\2\2c\3\2\2\2\2e\3\2\2\2\2g\3\2\2\2\2i\3\2\2\2\2k\3\2\2\2\2m\3\2\2\2\2"
          + "o\3\2\2\2\2q\3\2\2\2\2s\3\2\2\2\2u\3\2\2\2\2w\3\2\2\2\2y\3\2\2\2\2{\3"
          + "\2\2\2\2}\3\2\2\2\2\177\3\2\2\2\2\u0081\3\2\2\2\2\u0083\3\2\2\2\2\u0085"
          + "\3\2\2\2\2\u0087\3\2\2\2\2\u0089\3\2\2\2\2\u008b\3\2\2\2\2\u008d\3\2\2"
          + "\2\2\u008f\3\2\2\2\2\u0091\3\2\2\2\2\u0093\3\2\2\2\2\u0095\3\2\2\2\2\u0097"
          + "\3\2\2\2\2\u0099\3\2\2\2\2\u009b\3\2\2\2\2\u009d\3\2\2\2\2\u009f\3\2\2"
          + "\2\2\u00a1\3\2\2\2\2\u00a3\3\2\2\2\2\u00a5\3\2\2\2\2\u00a7\3\2\2\2\2\u00a9"
          + "\3\2\2\2\2\u00ab\3\2\2\2\2\u00ad\3\2\2\2\2\u00af\3\2\2\2\2\u00b1\3\2\2"
          + "\2\2\u00b3\3\2\2\2\2\u00b5\3\2\2\2\2\u00b7\3\2\2\2\2\u00b9\3\2\2\2\2\u00bb"
          + "\3\2\2\2\2\u00bd\3\2\2\2\2\u00bf\3\2\2\2\2\u00c1\3\2\2\2\2\u00c3\3\2\2"
          + "\2\2\u00c5\3\2\2\2\2\u00c7\3\2\2\2\2\u00c9\3\2\2\2\2\u00cb\3\2\2\2\2\u00cd"
          + "\3\2\2\2\2\u00cf\3\2\2\2\2\u00d1\3\2\2\2\2\u00d3\3\2\2\2\2\u00d5\3\2\2"
          + "\2\2\u00d7\3\2\2\2\2\u00d9\3\2\2\2\2\u00db\3\2\2\2\2\u00dd\3\2\2\2\2\u00df"
          + "\3\2\2\2\2\u00e1\3\2\2\2\2\u00e3\3\2\2\2\2\u00e5\3\2\2\2\2\u00e7\3\2\2"
          + "\2\2\u00e9\3\2\2\2\2\u00eb\3\2\2\2\2\u00ed\3\2\2\2\2\u00ef\3\2\2\2\2\u00f1"
          + "\3\2\2\2\2\u00f3\3\2\2\2\2\u00f5\3\2\2\2\2\u00f7\3\2\2\2\2\u00f9\3\2\2"
          + "\2\2\u00fb\3\2\2\2\2\u00fd\3\2\2\2\2\u00ff\3\2\2\2\2\u0101\3\2\2\2\2\u0103"
          + "\3\2\2\2\2\u0105\3\2\2\2\2\u0107\3\2\2\2\2\u0109\3\2\2\2\2\u010b\3\2\2"
          + "\2\2\u010d\3\2\2\2\2\u010f\3\2\2\2\2\u0111\3\2\2\2\2\u0113\3\2\2\2\2\u0115"
          + "\3\2\2\2\2\u0117\3\2\2\2\2\u0119\3\2\2\2\2\u011b\3\2\2\2\3\u011d\3\2\2"
          + "\2\5\u011f\3\2\2\2\7\u0121\3\2\2\2\t\u0123\3\2\2\2\13\u0125\3\2\2\2\r"
          + "\u0127\3\2\2\2\17\u0129\3\2\2\2\21\u012b\3\2\2\2\23\u012d\3\2\2\2\25\u012f"
          + "\3\2\2\2\27\u0131\3\2\2\2\31\u0133\3\2\2\2\33\u0135\3\2\2\2\35\u0137\3"
          + "\2\2\2\37\u0139\3\2\2\2!\u013b\3\2\2\2#\u013d\3\2\2\2%\u013f\3\2\2\2\'"
          + "\u0141\3\2\2\2)\u0143\3\2\2\2+\u0145\3\2\2\2-\u0147\3\2\2\2/\u0149\3\2"
          + "\2\2\61\u014b\3\2\2\2\63\u014d\3\2\2\2\65\u014f\3\2\2\2\67\u0151\3\2\2"
          + "\29\u0153\3\2\2\2;\u0155\3\2\2\2=\u0157\3\2\2\2?\u0159\3\2\2\2A\u015b"
          + "\3\2\2\2C\u015d\3\2\2\2E\u0166\3\2\2\2G\u016c\3\2\2\2I\u0171\3\2\2\2K"
          + "\u0178\3\2\2\2M\u017f\3\2\2\2O\u0186\3\2\2\2Q\u018d\3\2\2\2S\u0194\3\2"
          + "\2\2U\u019a\3\2\2\2W\u01a0\3\2\2\2Y\u01a6\3\2\2\2[\u01ac\3\2\2\2]\u01b1"
          + "\3\2\2\2_\u01b9\3\2\2\2a\u01bf\3\2\2\2c\u01c6\3\2\2\2e\u01ca\3\2\2\2g"
          + "\u01d2\3\2\2\2i\u01d8\3\2\2\2k\u01df\3\2\2\2m\u01e3\3\2\2\2o\u01eb\3\2"
          + "\2\2q\u01f1\3\2\2\2s\u01f7\3\2\2\2u\u01fe\3\2\2\2w\u0205\3\2\2\2y\u020c"
          + "\3\2\2\2{\u0213\3\2\2\2}\u0219\3\2\2\2\177\u0222\3\2\2\2\u0081\u0227\3"
          + "\2\2\2\u0083\u022c\3\2\2\2\u0085\u0233\3\2\2\2\u0087\u0238\3\2\2\2\u0089"
          + "\u023d\3\2\2\2\u008b\u0266\3\2\2\2\u008d\u0268\3\2\2\2\u008f\u026a\3\2"
          + "\2\2\u0091\u0271\3\2\2\2\u0093\u0278\3\2\2\2\u0095\u027f\3\2\2\2\u0097"
          + "\u0286\3\2\2\2\u0099\u028b\3\2\2\2\u009b\u028f\3\2\2\2\u009d\u0294\3\2"
          + "\2\2\u009f\u029a\3\2\2\2\u00a1\u02a8\3\2\2\2\u00a3\u02ac\3\2\2\2\u00a5"
          + "\u02b5\3\2\2\2\u00a7\u02c2\3\2\2\2\u00a9\u02c9\3\2\2\2\u00ab\u02cf\3\2"
          + "\2\2\u00ad\u02d2\3\2\2\2\u00af\u02df\3\2\2\2\u00b1\u02e5\3\2\2\2\u00b3"
          + "\u02e8\3\2\2\2\u00b5\u02ed\3\2\2\2\u00b7\u02f2\3\2\2\2\u00b9\u02f7\3\2"
          + "\2\2\u00bb\u02fc\3\2\2\2\u00bd\u0302\3\2\2\2\u00bf\u0307\3\2\2\2\u00c1"
          + "\u030b\3\2\2\2\u00c3\u0310\3\2\2\2\u00c5\u0314\3\2\2\2\u00c7\u0319\3\2"
          + "\2\2\u00c9\u031f\3\2\2\2\u00cb\u0325\3\2\2\2\u00cd\u0329\3\2\2\2\u00cf"
          + "\u032d\3\2\2\2\u00d1\u0330\3\2\2\2\u00d3\u0333\3\2\2\2\u00d5\u0339\3\2"
          + "\2\2\u00d7\u0341\3\2\2\2\u00d9\u0346\3\2\2\2\u00db\u034d\3\2\2\2\u00dd"
          + "\u034f\3\2\2\2\u00df\u0351\3\2\2\2\u00e1\u0354\3\2\2\2\u00e3\u0356\3\2"
          + "\2\2\u00e5\u0358\3\2\2\2\u00e7\u035a\3\2\2\2\u00e9\u035c\3\2\2\2\u00eb"
          + "\u035e\3\2\2\2\u00ed\u0360\3\2\2\2\u00ef\u0362\3\2\2\2\u00f1\u0364\3\2"
          + "\2\2\u00f3\u0366\3\2\2\2\u00f5\u0368\3\2\2\2\u00f7\u036a\3\2\2\2\u00f9"
          + "\u036c\3\2\2\2\u00fb\u036e\3\2\2\2\u00fd\u0370\3\2\2\2\u00ff\u0372\3\2"
          + "\2\2\u0101\u0374\3\2\2\2\u0103\u0377\3\2\2\2\u0105\u0379\3\2\2\2\u0107"
          + "\u037b\3\2\2\2\u0109\u0386\3\2\2\2\u010b\u0389\3\2\2\2\u010d\u0394\3\2"
          + "\2\2\u010f\u0399\3\2\2\2\u0111\u03bf\3\2\2\2\u0113\u03d2\3\2\2\2\u0115"
          + "\u03e4\3\2\2\2\u0117\u03f8\3\2\2\2\u0119\u03fb\3\2\2\2\u011b\u0400\3\2"
          + "\2\2\u011d\u011e\t\2\2\2\u011e\4\3\2\2\2\u011f\u0120\t\3\2\2\u0120\6\3"
          + "\2\2\2\u0121\u0122\t\4\2\2\u0122\b\3\2\2\2\u0123\u0124\t\5\2\2\u0124\n"
          + "\3\2\2\2\u0125\u0126\7)\2\2\u0126\f\3\2\2\2\u0127\u0128\7$\2\2\u0128\16"
          + "\3\2\2\2\u0129\u012a\t\6\2\2\u012a\20\3\2\2\2\u012b\u012c\t\7\2\2\u012c"
          + "\22\3\2\2\2\u012d\u012e\t\b\2\2\u012e\24\3\2\2\2\u012f\u0130\t\t\2\2\u0130"
          + "\26\3\2\2\2\u0131\u0132\t\n\2\2\u0132\30\3\2\2\2\u0133\u0134\t\13\2\2"
          + "\u0134\32\3\2\2\2\u0135\u0136\t\f\2\2\u0136\34\3\2\2\2\u0137\u0138\t\r"
          + "\2\2\u0138\36\3\2\2\2\u0139\u013a\t\16\2\2\u013a \3\2\2\2\u013b\u013c"
          + "\t\17\2\2\u013c\"\3\2\2\2\u013d\u013e\t\20\2\2\u013e$\3\2\2\2\u013f\u0140"
          + "\t\21\2\2\u0140&\3\2\2\2\u0141\u0142\t\22\2\2\u0142(\3\2\2\2\u0143\u0144"
          + "\t\23\2\2\u0144*\3\2\2\2\u0145\u0146\t\24\2\2\u0146,\3\2\2\2\u0147\u0148"
          + "\t\25\2\2\u0148.\3\2\2\2\u0149\u014a\t\26\2\2\u014a\60\3\2\2\2\u014b\u014c"
          + "\t\27\2\2\u014c\62\3\2\2\2\u014d\u014e\t\30\2\2\u014e\64\3\2\2\2\u014f"
          + "\u0150\t\31\2\2\u0150\66\3\2\2\2\u0151\u0152\t\32\2\2\u01528\3\2\2\2\u0153"
          + "\u0154\t\33\2\2\u0154:\3\2\2\2\u0155\u0156\t\34\2\2\u0156<\3\2\2\2\u0157"
          + "\u0158\t\35\2\2\u0158>\3\2\2\2\u0159\u015a\t\36\2\2\u015a@\3\2\2\2\u015b"
          + "\u015c\t\37\2\2\u015cB\3\2\2\2\u015d\u015e\5\17\b\2\u015e\u015f\5\61\31"
          + "\2\u015f\u0160\5\'\24\2\u0160\u0161\5\63\32\2\u0161\u0162\5\23\n\2\u0162"
          + "\u0163\5\37\20\2\u0163\u0164\5\37\20\2\u0164\u0165\7:\2\2\u0165D\3\2\2"
          + "\2\u0166\u0167\5\17\b\2\u0167\u0168\5\63\32\2\u0168\u0169\5\23\n\2\u0169"
          + "\u016a\5\37\20\2\u016a\u016b\5\37\20\2\u016bF\3\2\2\2\u016c\u016d\5\21"
          + "\t\2\u016d\u016e\5\37\20\2\u016e\u016f\5\33\16\2\u016f\u0170\7\67\2\2"
          + "\u0170H\3\2\2\2\u0171\u0172\5\21\t\2\u0172\u0173\5\37\20\2\u0173\u0174"
          + "\5)\25\2\u0174\u0175\5\17\b\2\u0175\u0176\5\61\31\2\u0176\u0177\5? \2"
          + "\u0177J\3\2\2\2\u0178\u0179\5\23\n\2\u0179\u017a\5-\27\2\u017a\u017b\7"
          + "\63\2\2\u017b\u017c\7\64\2\2\u017c\u017d\7\67\2\2\u017d\u017e\7\62\2\2"
          + "\u017eL\3\2\2\2\u017f\u0180\5\23\n\2\u0180\u0181\5-\27\2\u0181\u0182\7"
          + "\63\2\2\u0182\u0183\7\64\2\2\u0183\u0184\7\67\2\2\u0184\u0185\7\63\2\2"
          + "\u0185N\3\2\2\2\u0186\u0187\5\23\n\2\u0187\u0188\5-\27\2\u0188\u0189\7"
          + "\63\2\2\u0189\u018a\7\64\2\2\u018a\u018b\7\67\2\2\u018b\u018c\78\2\2\u018c"
          + "P\3\2\2\2\u018d\u018e\5\23\n\2\u018e\u018f\5-\27\2\u018f\u0190\7\63\2"
          + "\2\u0190\u0191\7\64\2\2\u0191\u0192\7\67\2\2\u0192\u0193\79\2\2\u0193"
          + "R\3\2\2\2\u0194\u0195\5\23\n\2\u0195\u0196\5-\27\2\u0196\u0197\7:\2\2"
          + "\u0197\u0198\7\67\2\2\u0198\u0199\7\62\2\2\u0199T\3\2\2\2\u019a\u019b"
          + "\5\23\n\2\u019b\u019c\5-\27\2\u019c\u019d\7:\2\2\u019d\u019e\7\67\2\2"
          + "\u019e\u019f\7\64\2\2\u019fV\3\2\2\2\u01a0\u01a1\5\23\n\2\u01a1\u01a2"
          + "\5-\27\2\u01a2\u01a3\7:\2\2\u01a3\u01a4\78\2\2\u01a4\u01a5\78\2\2\u01a5"
          + "X\3\2\2\2\u01a6\u01a7\5\23\n\2\u01a7\u01a8\5-\27\2\u01a8\u01a9\7;\2\2"
          + "\u01a9\u01aa\7\65\2\2\u01aa\u01ab\7\64\2\2\u01abZ\3\2\2\2\u01ac\u01ad"
          + "\5\25\13\2\u01ad\u01ae\5\27\f\2\u01ae\u01af\5\23\n\2\u01af\u01b0\7:\2"
          + "\2\u01b0\\\3\2\2\2\u01b1\u01b2\5\27\f\2\u01b2\u01b3\5\67\34\2\u01b3\u01b4"
          + "\5\23\n\2\u01b4\u01b5\5!\21\2\u01b5\u01b6\5-\27\2\u01b6\u01b7\5\'\24\2"
          + "\u01b7\u01b8\5\63\32\2\u01b8^\3\2\2\2\u01b9\u01ba\5\27\f\2\u01ba\u01bb"
          + "\5\67\34\2\u01bb\u01bc\5\23\n\2\u01bc\u01bd\5#\22\2\u01bd\u01be\5\61\31"
          + "\2\u01be`\3\2\2\2\u01bf\u01c0\5\33\16\2\u01c0\u01c1\5\21\t\2\u01c1\u01c2"
          + "\7\64\2\2\u01c2\u01c3\7\65\2\2\u01c3\u01c4\7\63\2\2\u01c4\u01c5\7\64\2"
          + "\2\u01c5b\3\2\2\2\u01c6\u01c7\5\33\16\2\u01c7\u01c8\5\21\t\2\u01c8\u01c9"
          + "\5#\22\2\u01c9d\3\2\2\2\u01ca\u01cb\5\33\16\2\u01cb\u01cc\5\27\f\2\u01cc"
          + "\u01cd\5+\26\2\u01cd\u01ce\5\63\32\2\u01ce\u01cf\5\65\33\2\u01cf\u01d0"
          + "\5\25\13\2\u01d0\u01d1\7:\2\2\u01d1f\3\2\2\2\u01d2\u01d3\5\33\16\2\u01d3"
          + "\u01d4\5\61\31\2\u01d4\u01d5\5\27\f\2\u01d5\u01d6\5\27\f\2\u01d6\u01d7"
          + "\5#\22\2\u01d7h\3\2\2\2\u01d8\u01d9\5\35\17\2\u01d9\u01da\5\27\f\2\u01da"
          + "\u01db\5\21\t\2\u01db\u01dc\5\61\31\2\u01dc\u01dd\5\27\f\2\u01dd\u01de"
          + "\5;\36\2\u01dej\3\2\2\2\u01df\u01e0\5\35\17\2\u01e0\u01e1\5-\27\2\u01e1"
          + "\u01e2\7:\2\2\u01e2l\3\2\2\2\u01e3\u01e4\5#\22\2\u01e4\u01e5\5\27\f\2"
          + "\u01e5\u01e6\5? \2\u01e6\u01e7\5\21\t\2\u01e7\u01e8\5\23\n\2\u01e8\u01e9"
          + "\5\63\32\2\u01e9\u01ea\7\64\2\2\u01ean\3\2\2\2\u01eb\u01ec\5#\22\2\u01ec"
          + "\u01ed\5+\26\2\u01ed\u01ee\5\37\20\2\u01ee\u01ef\7:\2\2\u01ef\u01f0\5"
          + "\61\31\2\u01f0p\3\2\2\2\u01f1\u01f2\5#\22\2\u01f2\u01f3\5+\26\2\u01f3"
          + "\u01f4\5\37\20\2\u01f4\u01f5\7:\2\2\u01f5\u01f6\5\67\34\2\u01f6r\3\2\2"
          + "\2\u01f7\u01f8\5%\23\2\u01f8\u01f9\5\17\b\2\u01f9\u01fa\5\65\33\2\u01fa"
          + "\u01fb\5\37\20\2\u01fb\u01fc\5)\25\2\u01fc\u01fd\7\63\2\2\u01fdt\3\2\2"
          + "\2\u01fe\u01ff\5%\23\2\u01ff\u0200\5\17\b\2\u0200\u0201\5\65\33\2\u0201"
          + "\u0202\5\37\20\2\u0202\u0203\5)\25\2\u0203\u0204\7\64\2\2\u0204v\3\2\2"
          + "\2\u0205\u0206\5%\23\2\u0206\u0207\5\17\b\2\u0207\u0208\5\65\33\2\u0208"
          + "\u0209\5\37\20\2\u0209\u020a\5)\25\2\u020a\u020b\7\67\2\2\u020bx\3\2\2"
          + "\2\u020c\u020d\5%\23\2\u020d\u020e\5\17\b\2\u020e\u020f\5\65\33\2\u020f"
          + "\u0210\5\37\20\2\u0210\u0211\5)\25\2\u0211\u0212\79\2\2\u0212z\3\2\2\2"
          + "\u0213\u0214\5\'\24\2\u0214\u0215\5\17\b\2\u0215\u0216\5\23\n\2\u0216"
          + "\u0217\5\23\n\2\u0217\u0218\5\27\f\2\u0218|\3\2\2\2\u0219\u021a\5\'\24"
          + "\2\u021a\u021b\5\17\b\2\u021b\u021c\5\23\n\2\u021c\u021d\5\61\31\2\u021d"
          + "\u021e\5+\26\2\u021e\u021f\5\'\24\2\u021f\u0220\5\17\b\2\u0220\u0221\5"
          + ")\25\2\u0221~\3\2\2\2\u0222\u0223\5\63\32\2\u0223\u0224\5!\21\2\u0224"
          + "\u0225\5\37\20\2\u0225\u0226\5\63\32\2\u0226\u0080\3\2\2\2\u0227\u0228"
          + "\5\63\32\2\u0228\u0229\5;\36\2\u0229\u022a\5\27\f\2\u022a\u022b\79\2\2"
          + "\u022b\u0082\3\2\2\2\u022c\u022d\5\65\33\2\u022d\u022e\5\37\20\2\u022e"
          + "\u022f\5\63\32\2\u022f\u0230\78\2\2\u0230\u0231\7\64\2\2\u0231\u0232\7"
          + "\62\2\2\u0232\u0084\3\2\2\2\u0233\u0234\5\67\34\2\u0234\u0235\5\23\n\2"
          + "\u0235\u0236\5\63\32\2\u0236\u0237\7\64\2\2\u0237\u0086\3\2\2\2\u0238"
          + "\u0239\5\67\34\2\u0239\u023a\5!\21\2\u023a\u023b\5\37\20\2\u023b\u023c"
          + "\5\63\32\2\u023c\u0088\3\2\2\2\u023d\u023e\5\67\34\2\u023e\u023f\5\65"
          + "\33\2\u023f\u0240\5\31\r\2\u0240\u0241\7:\2\2\u0241\u008a\3\2\2\2\u0242"
          + "\u0267\5C\"\2\u0243\u0267\5E#\2\u0244\u0267\5G$\2\u0245\u0267\5I%\2\u0246"
          + "\u0267\5K&\2\u0247\u0267\5M\'\2\u0248\u0267\5O(\2\u0249\u0267\5Q)\2\u024a"
          + "\u0267\5S*\2\u024b\u0267\5U+\2\u024c\u0267\5W,\2\u024d\u0267\5Y-\2\u024e"
          + "\u0267\5[.\2\u024f\u0267\5]/\2\u0250\u0267\5_\60\2\u0251\u0267\5a\61\2"
          + "\u0252\u0267\5c\62\2\u0253\u0267\5e\63\2\u0254\u0267\5g\64\2\u0255\u0267"
          + "\5i\65\2\u0256\u0267\5k\66\2\u0257\u0267\5m\67\2\u0258\u0267\5o8\2\u0259"
          + "\u0267\5q9\2\u025a\u0267\5s:\2\u025b\u0267\5u;\2\u025c\u0267\5w<\2\u025d"
          + "\u0267\5y=\2\u025e\u0267\5{>\2\u025f\u0267\5}?\2\u0260\u0267\5\177@\2"
          + "\u0261\u0267\5\u0081A\2\u0262\u0267\5\u0083B\2\u0263\u0267\5\u0085C\2"
          + "\u0264\u0267\5\u0087D\2\u0265\u0267\5\u0089E\2\u0266\u0242\3\2\2\2\u0266"
          + "\u0243\3\2\2\2\u0266\u0244\3\2\2\2\u0266\u0245\3\2\2\2\u0266\u0246\3\2"
          + "\2\2\u0266\u0247\3\2\2\2\u0266\u0248\3\2\2\2\u0266\u0249\3\2\2\2\u0266"
          + "\u024a\3\2\2\2\u0266\u024b\3\2\2\2\u0266\u024c\3\2\2\2\u0266\u024d\3\2"
          + "\2\2\u0266\u024e\3\2\2\2\u0266\u024f\3\2\2\2\u0266\u0250\3\2\2\2\u0266"
          + "\u0251\3\2\2\2\u0266\u0252\3\2\2\2\u0266\u0253\3\2\2\2\u0266\u0254\3\2"
          + "\2\2\u0266\u0255\3\2\2\2\u0266\u0256\3\2\2\2\u0266\u0257\3\2\2\2\u0266"
          + "\u0258\3\2\2\2\u0266\u0259\3\2\2\2\u0266\u025a\3\2\2\2\u0266\u025b\3\2"
          + "\2\2\u0266\u025c\3\2\2\2\u0266\u025d\3\2\2\2\u0266\u025e\3\2\2\2\u0266"
          + "\u025f\3\2\2\2\u0266\u0260\3\2\2\2\u0266\u0261\3\2\2\2\u0266\u0262\3\2"
          + "\2\2\u0266\u0263\3\2\2\2\u0266\u0264\3\2\2\2\u0266\u0265\3\2\2\2\u0267"
          + "\u008c\3\2\2\2\u0268\u0269\5\27\f\2\u0269\u008e\3\2\2\2\u026a\u026b\5"
          + "\63\32\2\u026b\u026c\5\27\f\2\u026c\u026d\5%\23\2\u026d\u026e\5\27\f\2"
          + "\u026e\u026f\5\23\n\2\u026f\u0270\5\65\33\2\u0270\u0090\3\2\2\2\u0271"
          + "\u0272\5\37\20\2\u0272\u0273\5)\25\2\u0273\u0274\5\63\32\2\u0274\u0275"
          + "\5\27\f\2\u0275\u0276\5\61\31\2\u0276\u0277\5\65\33\2\u0277\u0092\3\2"
          + "\2\2\u0278\u0279\5\67\34\2\u0279\u027a\5-\27\2\u027a\u027b\5\25\13\2\u027b"
          + "\u027c\5\17\b\2\u027c\u027d\5\65\33\2\u027d\u027e\5\27\f\2\u027e\u0094"
          + "\3\2\2\2\u027f\u0280\5\25\13\2\u0280\u0281\5\27\f\2\u0281\u0282\5%\23"
          + "\2\u0282\u0283\5\27\f\2\u0283\u0284\5\65\33\2\u0284\u0285\5\27\f\2\u0285"
          + "\u0096\3\2\2\2\u0286\u0287\5\37\20\2\u0287\u0288\5)\25\2\u0288\u0289\5"
          + "\65\33\2\u0289\u028a\5+\26\2\u028a\u0098\3\2\2\2\u028b\u028c\5\63\32\2"
          + "\u028c\u028d\5\27\f\2\u028d\u028e\5\65\33\2\u028e\u009a\3\2\2\2\u028f"
          + "\u0290\5\31\r\2\u0290\u0291\5\61\31\2\u0291\u0292\5+\26\2\u0292\u0293"
          + "\5\'\24\2\u0293\u009c\3\2\2\2\u0294\u0295\5\67\34\2\u0295\u0296\5)\25"
          + "\2\u0296\u0297\5\37\20\2\u0297\u0298\5+\26\2\u0298\u0299\5)\25\2\u0299"
          + "\u009e\3\2\2\2\u029a\u029b\5\67\34\2\u029b\u029c\5)\25\2\u029c\u029d\5"
          + "\37\20\2\u029d\u029e\5+\26\2\u029e\u02a0\5)\25\2\u029f\u02a1\t \2\2\u02a0"
          + "\u029f\3\2\2\2\u02a1\u02a2\3\2\2\2\u02a2\u02a0\3\2\2\2\u02a2\u02a3\3\2"
          + "\2\2\u02a3\u02a4\3\2\2\2\u02a4\u02a5\5\17\b\2\u02a5\u02a6\5%\23\2\u02a6"
          + "\u02a7\5%\23\2\u02a7\u00a0\3\2\2\2\u02a8\u02a9\5\17\b\2\u02a9\u02aa\5"
          + "%\23\2\u02aa\u02ab\5%\23\2\u02ab\u00a2\3\2\2\2\u02ac\u02ad\5\25\13\2\u02ad"
          + "\u02ae\5\37\20\2\u02ae\u02af\5\63\32\2\u02af\u02b0\5\65\33\2\u02b0\u02b1"
          + "\5\37\20\2\u02b1\u02b2\5)\25\2\u02b2\u02b3\5\23\n\2\u02b3\u02b4\5\65\33"
          + "\2\u02b4\u00a4\3\2\2\2\u02b5\u02b6\5\33\16\2\u02b6\u02b7\5\61\31\2\u02b7"
          + "\u02b8\5+\26\2\u02b8\u02b9\5\67\34\2\u02b9\u02bb\5-\27\2\u02ba\u02bc\t"
          + " \2\2\u02bb\u02ba\3\2\2\2\u02bc\u02bd\3\2\2\2\u02bd\u02bb\3\2\2\2\u02bd"
          + "\u02be\3\2\2\2\u02be\u02bf\3\2\2\2\u02bf\u02c0\5\21\t\2\u02c0\u02c1\5"
          + "? \2\u02c1\u00a6\3\2\2\2\u02c2\u02c3\5\35\17\2\u02c3\u02c4\5\17\b\2\u02c4"
          + "\u02c5\59\35\2\u02c5\u02c6\5\37\20\2\u02c6\u02c7\5)\25\2\u02c7\u02c8\5"
          + "\33\16\2\u02c8\u00a8\3\2\2\2\u02c9\u02ca\5;\36\2\u02ca\u02cb\5\35\17\2"
          + "\u02cb\u02cc\5\27\f\2\u02cc\u02cd\5\61\31\2\u02cd\u02ce\5\27\f\2\u02ce"
          + "\u00aa\3\2\2\2\u02cf\u02d0\5+\26\2\u02d0\u02d1\5)\25\2\u02d1\u00ac\3\2"
          + "\2\2\u02d2\u02d3\5+\26\2\u02d3\u02d4\5\61\31\2\u02d4\u02d5\5\25\13\2\u02d5"
          + "\u02d6\5\27\f\2\u02d6\u02d8\5\61\31\2\u02d7\u02d9\t \2\2\u02d8\u02d7\3"
          + "\2\2\2\u02d9\u02da\3\2\2\2\u02da\u02d8\3\2\2\2\u02da\u02db\3\2\2\2\u02db"
          + "\u02dc\3\2\2\2\u02dc\u02dd\5\21\t\2\u02dd\u02de\5? \2\u02de\u00ae\3\2"
          + "\2\2\u02df\u02e0\5%\23\2\u02e0\u02e1\5\37\20\2\u02e1\u02e2\5\'\24\2\u02e2"
          + "\u02e3\5\37\20\2\u02e3\u02e4\5\65\33\2\u02e4\u00b0\3\2\2\2\u02e5\u02e6"
          + "\5\17\b\2\u02e6\u02e7\5\63\32\2\u02e7\u00b2\3\2\2\2\u02e8\u02e9\5\23\n"
          + "\2\u02e9\u02ea\5\17\b\2\u02ea\u02eb\5\63\32\2\u02eb\u02ec\5\27\f\2\u02ec"
          + "\u00b4\3\2\2\2\u02ed\u02ee\5;\36\2\u02ee\u02ef\5\35\17\2\u02ef\u02f0\5"
          + "\27\f\2\u02f0\u02f1\5)\25\2\u02f1\u00b6\3\2\2\2\u02f2\u02f3\5\27\f\2\u02f3"
          + "\u02f4\5%\23\2\u02f4\u02f5\5\63\32\2\u02f5\u02f6\5\27\f\2\u02f6\u00b8"
          + "\3\2\2\2\u02f7\u02f8\5\65\33\2\u02f8\u02f9\5\35\17\2\u02f9\u02fa\5\27"
          + "\f\2\u02fa\u02fb\5)\25\2\u02fb\u00ba\3\2\2\2\u02fc\u02fd\5\37\20\2\u02fd"
          + "\u02fe\5)\25\2\u02fe\u02ff\5)\25\2\u02ff\u0300\5\27\f\2\u0300\u0301\5"
          + "\61\31\2\u0301\u00bc\3\2\2\2\u0302\u0303\5!\21\2\u0303\u0304\5+\26\2\u0304"
          + "\u0305\5\37\20\2\u0305\u0306\5)\25\2\u0306\u00be\3\2\2\2\u0307\u0308\5"
          + "\17\b\2\u0308\u0309\5\63\32\2\u0309\u030a\5\23\n\2\u030a\u00c0\3\2\2\2"
          + "\u030b\u030c\5\25\13\2\u030c\u030d\5\27\f\2\u030d\u030e\5\63\32\2\u030e"
          + "\u030f\5\23\n\2\u030f\u00c2\3\2\2\2\u0310\u0311\5\27\f\2\u0311\u0312\5"
          + ")\25\2\u0312\u0313\5\25\13\2\u0313\u00c4\3\2\2\2\u0314\u0315\5%\23\2\u0315"
          + "\u0316\5\27\f\2\u0316\u0317\5\31\r\2\u0317\u0318\5\65\33\2\u0318\u00c6"
          + "\3\2\2\2\u0319\u031a\5\61\31\2\u031a\u031b\5\37\20\2\u031b\u031c\5\33"
          + "\16\2\u031c\u031d\5\35\17\2\u031d\u031e\5\65\33\2\u031e\u00c8\3\2\2\2"
          + "\u031f\u0320\5+\26\2\u0320\u0321\5\67\34\2\u0321\u0322\5\65\33\2\u0322"
          + "\u0323\5\27\f\2\u0323\u0324\5\61\31\2\u0324\u00ca\3\2\2\2\u0325\u0326"
          + "\5)\25\2\u0326\u0327\5+\26\2\u0327\u0328\5\65\33\2\u0328\u00cc\3\2\2\2"
          + "\u0329\u032a\5\17\b\2\u032a\u032b\5)\25\2\u032b\u032c\5\25\13\2\u032c"
          + "\u00ce\3\2\2\2\u032d\u032e\5+\26\2\u032e\u032f\5\61\31\2\u032f\u00d0\3"
          + "\2\2\2\u0330\u0331\5\37\20\2\u0331\u0332\5)\25\2\u0332\u00d2\3\2\2\2\u0333"
          + "\u0334\5\27\f\2\u0334\u0335\5=\37\2\u0335\u0336\5\37\20\2\u0336\u0337"
          + "\5\63\32\2\u0337\u0338\5\65\33\2\u0338\u00d4\3\2\2\2\u0339\u033a\5\21"
          + "\t\2\u033a\u033b\5\27\f\2\u033b\u033c\5\65\33\2\u033c\u033d\5;\36\2\u033d"
          + "\u033e\5\27\f\2\u033e\u033f\5\27\f\2\u033f\u0340\5)\25\2\u0340\u00d6\3"
          + "\2\2\2\u0341\u0342\5)\25\2\u0342\u0343\5\67\34\2\u0343\u0344\5%\23\2\u0344"
          + "\u0345\5%\23\2\u0345\u00d8\3\2\2\2\u0346\u0347\59\35\2\u0347\u0348\5\17"
          + "\b\2\u0348\u0349\5%\23\2\u0349\u034a\5\67\34\2\u034a\u034b\5\27\f\2\u034b"
          + "\u034c\5\63\32\2\u034c\u00da\3\2\2\2\u034d\u034e\7\60\2\2\u034e\u00dc"
          + "\3\2\2\2\u034f\u0350\7~\2\2\u0350\u00de\3\2\2\2\u0351\u0352\7~\2\2\u0352"
          + "\u0353\7~\2\2\u0353\u00e0\3\2\2\2\u0354\u0355\7-\2\2\u0355\u00e2\3\2\2"
          + "\2\u0356\u0357\7\61\2\2\u0357\u00e4\3\2\2\2\u0358\u0359\7/\2\2\u0359\u00e6"
          + "\3\2\2\2\u035a\u035b\7\'\2\2\u035b\u00e8\3\2\2\2\u035c\u035d\7.\2\2\u035d"
          + "\u00ea\3\2\2\2\u035e\u035f\7=\2\2\u035f\u00ec\3\2\2\2\u0360\u0361\7<\2"
          + "\2\u0361\u00ee\3\2\2\2\u0362\u0363\7_\2\2\u0363\u00f0\3\2\2\2\u0364\u0365"
          + "\7]\2\2\u0365\u00f2\3\2\2\2\u0366\u0367\7\u0080\2\2\u0367\u00f4\3\2\2"
          + "\2\u0368\u0369\7(\2\2\u0369\u00f6\3\2\2\2\u036a\u036b\7`\2\2\u036b\u00f8"
          + "\3\2\2\2\u036c\u036d\7*\2\2\u036d\u00fa\3\2\2\2\u036e\u036f\7+\2\2\u036f"
          + "\u00fc\3\2\2\2\u0370\u0371\7,\2\2\u0371\u00fe\3\2\2\2\u0372\u0373\7@\2"
          + "\2\u0373\u0100\3\2\2\2\u0374\u0375\7@\2\2\u0375\u0376\7?\2\2\u0376\u0102"
          + "\3\2\2\2\u0377\u0378\7?\2\2\u0378\u0104\3\2\2\2\u0379\u037a\7>\2\2\u037a"
          + "\u0106\3\2\2\2\u037b\u037c\7>\2\2\u037c\u037d\7?\2\2\u037d\u0108\3\2\2"
          + "\2\u037e\u037f\7n\2\2\u037f\u0380\7k\2\2\u0380\u0381\7m\2\2\u0381\u0387"
          + "\7g\2\2\u0382\u0383\7N\2\2\u0383\u0384\7K\2\2\u0384\u0385\7M\2\2\u0385"
          + "\u0387\7G\2\2\u0386\u037e\3\2\2\2\u0386\u0382\3\2\2\2\u0387\u010a\3\2"
          + "\2\2\u0388\u038a\5\5\3\2\u0389\u0388\3\2\2\2\u038a\u038b\3\2\2\2\u038b"
          + "\u0389\3\2\2\2\u038b\u038c\3\2\2\2\u038c\u0390\3\2\2\2\u038d\u038f\5\3"
          + "\2\2\u038e\u038d\3\2\2\2\u038f\u0392\3\2\2\2\u0390\u038e\3\2\2\2\u0390"
          + "\u0391\3\2\2\2\u0391\u010c\3\2\2\2\u0392\u0390\3\2\2\2\u0393\u0395\5\3"
          + "\2\2\u0394\u0393\3\2\2\2\u0395\u0396\3\2\2\2\u0396\u0394\3\2\2\2\u0396"
          + "\u0397\3\2\2\2\u0397\u010e\3\2\2\2\u0398\u039a\5\3\2\2\u0399\u0398\3\2"
          + "\2\2\u039a\u039b\3\2\2\2\u039b\u0399\3\2\2\2\u039b\u039c\3\2\2\2\u039c"
          + "\u039d\3\2\2\2\u039d\u039f\7\60\2\2\u039e\u03a0\5\3\2\2\u039f\u039e\3"
          + "\2\2\2\u03a0\u03a1\3\2\2\2\u03a1\u039f\3\2\2\2\u03a1\u03a2\3\2\2\2\u03a2"
          + "\u0110\3\2\2\2\u03a3\u03ad\7)\2\2\u03a4\u03a5\7^\2\2\u03a5\u03ac\7^\2"
          + "\2\u03a6\u03a7\7)\2\2\u03a7\u03ac\7)\2\2\u03a8\u03a9\7^\2\2\u03a9\u03ac"
          + "\7)\2\2\u03aa\u03ac\n!\2\2\u03ab\u03a4\3\2\2\2\u03ab\u03a6\3\2\2\2\u03ab"
          + "\u03a8\3\2\2\2\u03ab\u03aa\3\2\2\2\u03ac\u03af\3\2\2\2\u03ad\u03ab\3\2"
          + "\2\2\u03ad\u03ae\3\2\2\2\u03ae\u03b0\3\2\2\2\u03af\u03ad\3\2\2\2\u03b0"
          + "\u03c0\7)\2\2\u03b1\u03bb\7$\2\2\u03b2\u03b3\7^\2\2\u03b3\u03ba\7^\2\2"
          + "\u03b4\u03b5\7$\2\2\u03b5\u03ba\7$\2\2\u03b6\u03b7\7^\2\2\u03b7\u03ba"
          + "\7$\2\2\u03b8\u03ba\n\"\2\2\u03b9\u03b2\3\2\2\2\u03b9\u03b4\3\2\2\2\u03b9"
          + "\u03b6\3\2\2\2\u03b9\u03b8\3\2\2\2\u03ba\u03bd\3\2\2\2\u03bb\u03b9\3\2"
          + "\2\2\u03bb\u03bc\3\2\2\2\u03bc\u03be\3\2\2\2\u03bd\u03bb\3\2\2\2\u03be"
          + "\u03c0\7$\2\2\u03bf\u03a3\3\2\2\2\u03bf\u03b1\3\2\2\2\u03c0\u0112\3\2"
          + "\2\2\u03c1\u03c2\7\62\2\2\u03c2\u03c3\7z\2\2\u03c3\u03c5\3\2\2\2\u03c4"
          + "\u03c6\5\t\5\2\u03c5\u03c4\3\2\2\2\u03c6\u03c7\3\2\2\2\u03c7\u03c5\3\2"
          + "\2\2\u03c7\u03c8\3\2\2\2\u03c8\u03d3\3\2\2\2\u03c9\u03ca\7Z\2\2\u03ca"
          + "\u03cc\7)\2\2\u03cb\u03cd\5\t\5\2\u03cc\u03cb\3\2\2\2\u03cd\u03ce\3\2"
          + "\2\2\u03ce\u03cc\3\2\2\2\u03ce\u03cf\3\2\2\2\u03cf\u03d0\3\2\2\2\u03d0"
          + "\u03d1\7)\2\2\u03d1\u03d3\3\2\2\2\u03d2\u03c1\3\2\2\2\u03d2\u03c9\3\2"
          + "\2\2\u03d3\u0114\3\2\2\2\u03d4\u03d5\7\62\2\2\u03d5\u03d6\7d\2\2\u03d6"
          + "\u03d8\3\2\2\2\u03d7\u03d9\4\62\63\2\u03d8\u03d7\3\2\2\2\u03d9\u03da\3"
          + "\2\2\2\u03da\u03d8\3\2\2\2\u03da\u03db\3\2\2\2\u03db\u03e5\3\2\2\2\u03dc"
          + "\u03dd\7D\2\2\u03dd\u03df\7)\2\2\u03de\u03e0\4\62\63\2\u03df\u03de\3\2"
          + "\2\2\u03e0\u03e1\3\2\2\2\u03e1\u03df\3\2\2\2\u03e1\u03e2\3\2\2\2\u03e2"
          + "\u03e3\3\2\2\2\u03e3\u03e5\7)\2\2\u03e4\u03d4\3\2\2\2\u03e4\u03dc\3\2"
          + "\2\2\u03e5\u0116\3\2\2\2\u03e6\u03e7\7v\2\2\u03e7\u03e8\7t\2\2\u03e8\u03e9"
          + "\7w\2\2\u03e9\u03f9\7g\2\2\u03ea\u03eb\7V\2\2\u03eb\u03ec\7T\2\2\u03ec"
          + "\u03ed\7W\2\2\u03ed\u03f9\7G\2\2\u03ee\u03ef\7h\2\2\u03ef\u03f0\7c\2\2"
          + "\u03f0\u03f1\7n\2\2\u03f1\u03f2\7u\2\2\u03f2\u03f9\7g\2\2\u03f3\u03f4"
          + "\7H\2\2\u03f4\u03f5\7C\2\2\u03f5\u03f6\7N\2\2\u03f6\u03f7\7U\2\2\u03f7"
          + "\u03f9\7G\2\2\u03f8\u03e6\3\2\2\2\u03f8\u03ea\3\2\2\2\u03f8\u03ee\3\2"
          + "\2\2\u03f8\u03f3\3\2\2\2\u03f9\u0118\3\2\2\2\u03fa\u03fc\7\17\2\2\u03fb"
          + "\u03fa\3\2\2\2\u03fb\u03fc\3\2\2\2\u03fc\u03fd\3\2\2\2\u03fd\u03fe\7\f"
          + "\2\2\u03fe\u011a\3\2\2\2\u03ff\u0401\t#\2\2\u0400\u03ff\3\2\2\2\u0401"
          + "\u0402\3\2\2\2\u0402\u0400\3\2\2\2\u0402\u0403\3\2\2\2\u0403\u0404\3\2"
          + "\2\2\u0404\u0405\b\u008e\2\2\u0405\u011c\3\2\2\2\33\2\u0266\u02a2\u02bd"
          + "\u02da\u0386\u038b\u0390\u0396\u039b\u03a1\u03ab\u03ad\u03b9\u03bb\u03bf"
          + "\u03c7\u03ce\u03d2\u03da\u03e1\u03e4\u03f8\u03fb\u0402";
  public static final ATN _ATN = ATNSimulator.deserialize(_serializedATN.toCharArray());

  static {
    _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
    for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
      _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
    }
  }
}
Пример #8
0
@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
public class CymbolParser extends Parser {
  protected static final DFA[] _decisionToDFA;
  protected static final PredictionContextCache _sharedContextCache = new PredictionContextCache();
  public static final int T__20 = 1,
      T__19 = 2,
      T__18 = 3,
      T__17 = 4,
      T__16 = 5,
      T__15 = 6,
      T__14 = 7,
      T__13 = 8,
      T__12 = 9,
      T__11 = 10,
      T__10 = 11,
      T__9 = 12,
      T__8 = 13,
      T__7 = 14,
      T__6 = 15,
      T__5 = 16,
      T__4 = 17,
      T__3 = 18,
      T__2 = 19,
      T__1 = 20,
      T__0 = 21,
      ID = 22,
      INT = 23,
      WS = 24,
      SL_COMMENT = 25;
  public static final String[] tokenNames = {
    "<INVALID>",
    "']'",
    "')'",
    "','",
    "'+'",
    "'['",
    "'-'",
    "'*'",
    "'('",
    "'if'",
    "'int'",
    "'='",
    "'return'",
    "';'",
    "'void'",
    "'{'",
    "'then'",
    "'else'",
    "'=='",
    "'}'",
    "'float'",
    "'!'",
    "ID",
    "INT",
    "WS",
    "SL_COMMENT"
  };
  public static final int RULE_file = 0,
      RULE_varDecl = 1,
      RULE_type = 2,
      RULE_functionDecl = 3,
      RULE_formalParameters = 4,
      RULE_formalParameter = 5,
      RULE_block = 6,
      RULE_stat = 7,
      RULE_expr = 8,
      RULE_exprList = 9;
  public static final String[] ruleNames = {
    "file",
    "varDecl",
    "type",
    "functionDecl",
    "formalParameters",
    "formalParameter",
    "block",
    "stat",
    "expr",
    "exprList"
  };

  @Override
  public String getGrammarFileName() {
    return "Cymbol.g4";
  }

  @Override
  public String[] getTokenNames() {
    return tokenNames;
  }

  @Override
  public String[] getRuleNames() {
    return ruleNames;
  }

  @Override
  public ATN getATN() {
    return _ATN;
  }

  public CymbolParser(TokenStream input) {
    super(input);
    _interp = new ParserATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache);
  }

  public static class FileContext extends ParserRuleContext {
    public FunctionDeclContext functionDecl(int i) {
      return getRuleContext(FunctionDeclContext.class, i);
    }

    public VarDeclContext varDecl(int i) {
      return getRuleContext(VarDeclContext.class, i);
    }

    public List<VarDeclContext> varDecl() {
      return getRuleContexts(VarDeclContext.class);
    }

    public List<FunctionDeclContext> functionDecl() {
      return getRuleContexts(FunctionDeclContext.class);
    }

    public FileContext(ParserRuleContext parent, int invokingState) {
      super(parent, invokingState);
    }

    @Override
    public int getRuleIndex() {
      return RULE_file;
    }

    @Override
    public void enterRule(ParseTreeListener listener) {
      if (listener instanceof CymbolListener) ((CymbolListener) listener).enterFile(this);
    }

    @Override
    public void exitRule(ParseTreeListener listener) {
      if (listener instanceof CymbolListener) ((CymbolListener) listener).exitFile(this);
    }

    @Override
    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
      if (visitor instanceof CymbolVisitor)
        return ((CymbolVisitor<? extends T>) visitor).visitFile(this);
      else return visitor.visitChildren(this);
    }
  }

  public final FileContext file() throws RecognitionException {
    FileContext _localctx = new FileContext(_ctx, getState());
    enterRule(_localctx, 0, RULE_file);
    int _la;
    try {
      enterOuterAlt(_localctx, 1);
      {
        setState(22);
        _errHandler.sync(this);
        _la = _input.LA(1);
        do {
          {
            setState(22);
            switch (getInterpreter().adaptivePredict(_input, 0, _ctx)) {
              case 1:
                {
                  setState(20);
                  functionDecl();
                }
                break;

              case 2:
                {
                  setState(21);
                  varDecl();
                }
                break;
            }
          }
          setState(24);
          _errHandler.sync(this);
          _la = _input.LA(1);
        } while ((((_la) & ~0x3f) == 0
            && ((1L << _la) & ((1L << 10) | (1L << 14) | (1L << 20))) != 0));
      }
    } catch (RecognitionException re) {
      _localctx.exception = re;
      _errHandler.reportError(this, re);
      _errHandler.recover(this, re);
    } finally {
      exitRule();
    }
    return _localctx;
  }

  public static class VarDeclContext extends ParserRuleContext {
    public TerminalNode ID() {
      return getToken(CymbolParser.ID, 0);
    }

    public ExprContext expr() {
      return getRuleContext(ExprContext.class, 0);
    }

    public TypeContext type() {
      return getRuleContext(TypeContext.class, 0);
    }

    public VarDeclContext(ParserRuleContext parent, int invokingState) {
      super(parent, invokingState);
    }

    @Override
    public int getRuleIndex() {
      return RULE_varDecl;
    }

    @Override
    public void enterRule(ParseTreeListener listener) {
      if (listener instanceof CymbolListener) ((CymbolListener) listener).enterVarDecl(this);
    }

    @Override
    public void exitRule(ParseTreeListener listener) {
      if (listener instanceof CymbolListener) ((CymbolListener) listener).exitVarDecl(this);
    }

    @Override
    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
      if (visitor instanceof CymbolVisitor)
        return ((CymbolVisitor<? extends T>) visitor).visitVarDecl(this);
      else return visitor.visitChildren(this);
    }
  }

  public final VarDeclContext varDecl() throws RecognitionException {
    VarDeclContext _localctx = new VarDeclContext(_ctx, getState());
    enterRule(_localctx, 2, RULE_varDecl);
    int _la;
    try {
      enterOuterAlt(_localctx, 1);
      {
        setState(26);
        type();
        setState(27);
        match(ID);
        setState(30);
        _la = _input.LA(1);
        if (_la == 11) {
          {
            setState(28);
            match(11);
            setState(29);
            expr(0);
          }
        }

        setState(32);
        match(13);
      }
    } catch (RecognitionException re) {
      _localctx.exception = re;
      _errHandler.reportError(this, re);
      _errHandler.recover(this, re);
    } finally {
      exitRule();
    }
    return _localctx;
  }

  public static class TypeContext extends ParserRuleContext {
    public TypeContext(ParserRuleContext parent, int invokingState) {
      super(parent, invokingState);
    }

    @Override
    public int getRuleIndex() {
      return RULE_type;
    }

    @Override
    public void enterRule(ParseTreeListener listener) {
      if (listener instanceof CymbolListener) ((CymbolListener) listener).enterType(this);
    }

    @Override
    public void exitRule(ParseTreeListener listener) {
      if (listener instanceof CymbolListener) ((CymbolListener) listener).exitType(this);
    }

    @Override
    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
      if (visitor instanceof CymbolVisitor)
        return ((CymbolVisitor<? extends T>) visitor).visitType(this);
      else return visitor.visitChildren(this);
    }
  }

  public final TypeContext type() throws RecognitionException {
    TypeContext _localctx = new TypeContext(_ctx, getState());
    enterRule(_localctx, 4, RULE_type);
    int _la;
    try {
      enterOuterAlt(_localctx, 1);
      {
        setState(34);
        _la = _input.LA(1);
        if (!((((_la) & ~0x3f) == 0
            && ((1L << _la) & ((1L << 10) | (1L << 14) | (1L << 20))) != 0))) {
          _errHandler.recoverInline(this);
        }
        consume();
      }
    } catch (RecognitionException re) {
      _localctx.exception = re;
      _errHandler.reportError(this, re);
      _errHandler.recover(this, re);
    } finally {
      exitRule();
    }
    return _localctx;
  }

  public static class FunctionDeclContext extends ParserRuleContext {
    public FormalParametersContext formalParameters() {
      return getRuleContext(FormalParametersContext.class, 0);
    }

    public TerminalNode ID() {
      return getToken(CymbolParser.ID, 0);
    }

    public BlockContext block() {
      return getRuleContext(BlockContext.class, 0);
    }

    public TypeContext type() {
      return getRuleContext(TypeContext.class, 0);
    }

    public FunctionDeclContext(ParserRuleContext parent, int invokingState) {
      super(parent, invokingState);
    }

    @Override
    public int getRuleIndex() {
      return RULE_functionDecl;
    }

    @Override
    public void enterRule(ParseTreeListener listener) {
      if (listener instanceof CymbolListener) ((CymbolListener) listener).enterFunctionDecl(this);
    }

    @Override
    public void exitRule(ParseTreeListener listener) {
      if (listener instanceof CymbolListener) ((CymbolListener) listener).exitFunctionDecl(this);
    }

    @Override
    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
      if (visitor instanceof CymbolVisitor)
        return ((CymbolVisitor<? extends T>) visitor).visitFunctionDecl(this);
      else return visitor.visitChildren(this);
    }
  }

  public final FunctionDeclContext functionDecl() throws RecognitionException {
    FunctionDeclContext _localctx = new FunctionDeclContext(_ctx, getState());
    enterRule(_localctx, 6, RULE_functionDecl);
    try {
      enterOuterAlt(_localctx, 1);
      {
        setState(36);
        type();
        setState(37);
        match(ID);
        setState(38);
        match(8);
        setState(39);
        formalParameters();
        setState(40);
        match(2);
        setState(41);
        block();
      }
    } catch (RecognitionException re) {
      _localctx.exception = re;
      _errHandler.reportError(this, re);
      _errHandler.recover(this, re);
    } finally {
      exitRule();
    }
    return _localctx;
  }

  public static class FormalParametersContext extends ParserRuleContext {
    public FormalParameterContext formalParameter(int i) {
      return getRuleContext(FormalParameterContext.class, i);
    }

    public List<FormalParameterContext> formalParameter() {
      return getRuleContexts(FormalParameterContext.class);
    }

    public FormalParametersContext(ParserRuleContext parent, int invokingState) {
      super(parent, invokingState);
    }

    @Override
    public int getRuleIndex() {
      return RULE_formalParameters;
    }

    @Override
    public void enterRule(ParseTreeListener listener) {
      if (listener instanceof CymbolListener)
        ((CymbolListener) listener).enterFormalParameters(this);
    }

    @Override
    public void exitRule(ParseTreeListener listener) {
      if (listener instanceof CymbolListener)
        ((CymbolListener) listener).exitFormalParameters(this);
    }

    @Override
    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
      if (visitor instanceof CymbolVisitor)
        return ((CymbolVisitor<? extends T>) visitor).visitFormalParameters(this);
      else return visitor.visitChildren(this);
    }
  }

  public final FormalParametersContext formalParameters() throws RecognitionException {
    FormalParametersContext _localctx = new FormalParametersContext(_ctx, getState());
    enterRule(_localctx, 8, RULE_formalParameters);
    int _la;
    try {
      enterOuterAlt(_localctx, 1);
      {
        setState(43);
        formalParameter();
        setState(48);
        _errHandler.sync(this);
        _la = _input.LA(1);
        while (_la == 3) {
          {
            {
              setState(44);
              match(3);
              setState(45);
              formalParameter();
            }
          }
          setState(50);
          _errHandler.sync(this);
          _la = _input.LA(1);
        }
      }
    } catch (RecognitionException re) {
      _localctx.exception = re;
      _errHandler.reportError(this, re);
      _errHandler.recover(this, re);
    } finally {
      exitRule();
    }
    return _localctx;
  }

  public static class FormalParameterContext extends ParserRuleContext {
    public TerminalNode ID() {
      return getToken(CymbolParser.ID, 0);
    }

    public TypeContext type() {
      return getRuleContext(TypeContext.class, 0);
    }

    public FormalParameterContext(ParserRuleContext parent, int invokingState) {
      super(parent, invokingState);
    }

    @Override
    public int getRuleIndex() {
      return RULE_formalParameter;
    }

    @Override
    public void enterRule(ParseTreeListener listener) {
      if (listener instanceof CymbolListener)
        ((CymbolListener) listener).enterFormalParameter(this);
    }

    @Override
    public void exitRule(ParseTreeListener listener) {
      if (listener instanceof CymbolListener) ((CymbolListener) listener).exitFormalParameter(this);
    }

    @Override
    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
      if (visitor instanceof CymbolVisitor)
        return ((CymbolVisitor<? extends T>) visitor).visitFormalParameter(this);
      else return visitor.visitChildren(this);
    }
  }

  public final FormalParameterContext formalParameter() throws RecognitionException {
    FormalParameterContext _localctx = new FormalParameterContext(_ctx, getState());
    enterRule(_localctx, 10, RULE_formalParameter);
    try {
      enterOuterAlt(_localctx, 1);
      {
        setState(51);
        type();
        setState(52);
        match(ID);
      }
    } catch (RecognitionException re) {
      _localctx.exception = re;
      _errHandler.reportError(this, re);
      _errHandler.recover(this, re);
    } finally {
      exitRule();
    }
    return _localctx;
  }

  public static class BlockContext extends ParserRuleContext {
    public StatContext stat(int i) {
      return getRuleContext(StatContext.class, i);
    }

    public List<StatContext> stat() {
      return getRuleContexts(StatContext.class);
    }

    public BlockContext(ParserRuleContext parent, int invokingState) {
      super(parent, invokingState);
    }

    @Override
    public int getRuleIndex() {
      return RULE_block;
    }

    @Override
    public void enterRule(ParseTreeListener listener) {
      if (listener instanceof CymbolListener) ((CymbolListener) listener).enterBlock(this);
    }

    @Override
    public void exitRule(ParseTreeListener listener) {
      if (listener instanceof CymbolListener) ((CymbolListener) listener).exitBlock(this);
    }

    @Override
    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
      if (visitor instanceof CymbolVisitor)
        return ((CymbolVisitor<? extends T>) visitor).visitBlock(this);
      else return visitor.visitChildren(this);
    }
  }

  public final BlockContext block() throws RecognitionException {
    BlockContext _localctx = new BlockContext(_ctx, getState());
    enterRule(_localctx, 12, RULE_block);
    int _la;
    try {
      enterOuterAlt(_localctx, 1);
      {
        setState(54);
        match(15);
        setState(58);
        _errHandler.sync(this);
        _la = _input.LA(1);
        while ((((_la) & ~0x3f) == 0
            && ((1L << _la)
                    & ((1L << 6)
                        | (1L << 8)
                        | (1L << 9)
                        | (1L << 10)
                        | (1L << 12)
                        | (1L << 14)
                        | (1L << 15)
                        | (1L << 20)
                        | (1L << 21)
                        | (1L << ID)
                        | (1L << INT)))
                != 0)) {
          {
            {
              setState(55);
              stat();
            }
          }
          setState(60);
          _errHandler.sync(this);
          _la = _input.LA(1);
        }
        setState(61);
        match(19);
      }
    } catch (RecognitionException re) {
      _localctx.exception = re;
      _errHandler.reportError(this, re);
      _errHandler.recover(this, re);
    } finally {
      exitRule();
    }
    return _localctx;
  }

  public static class StatContext extends ParserRuleContext {
    public StatContext stat(int i) {
      return getRuleContext(StatContext.class, i);
    }

    public ExprContext expr(int i) {
      return getRuleContext(ExprContext.class, i);
    }

    public VarDeclContext varDecl() {
      return getRuleContext(VarDeclContext.class, 0);
    }

    public BlockContext block() {
      return getRuleContext(BlockContext.class, 0);
    }

    public List<ExprContext> expr() {
      return getRuleContexts(ExprContext.class);
    }

    public List<StatContext> stat() {
      return getRuleContexts(StatContext.class);
    }

    public StatContext(ParserRuleContext parent, int invokingState) {
      super(parent, invokingState);
    }

    @Override
    public int getRuleIndex() {
      return RULE_stat;
    }

    @Override
    public void enterRule(ParseTreeListener listener) {
      if (listener instanceof CymbolListener) ((CymbolListener) listener).enterStat(this);
    }

    @Override
    public void exitRule(ParseTreeListener listener) {
      if (listener instanceof CymbolListener) ((CymbolListener) listener).exitStat(this);
    }

    @Override
    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
      if (visitor instanceof CymbolVisitor)
        return ((CymbolVisitor<? extends T>) visitor).visitStat(this);
      else return visitor.visitChildren(this);
    }
  }

  public final StatContext stat() throws RecognitionException {
    StatContext _localctx = new StatContext(_ctx, getState());
    enterRule(_localctx, 14, RULE_stat);
    int _la;
    try {
      setState(86);
      switch (getInterpreter().adaptivePredict(_input, 7, _ctx)) {
        case 1:
          enterOuterAlt(_localctx, 1);
          {
            setState(63);
            block();
          }
          break;

        case 2:
          enterOuterAlt(_localctx, 2);
          {
            setState(64);
            varDecl();
          }
          break;

        case 3:
          enterOuterAlt(_localctx, 3);
          {
            setState(65);
            match(9);
            setState(66);
            expr(0);
            setState(67);
            match(16);
            setState(68);
            stat();
            setState(71);
            switch (getInterpreter().adaptivePredict(_input, 5, _ctx)) {
              case 1:
                {
                  setState(69);
                  match(17);
                  setState(70);
                  stat();
                }
                break;
            }
          }
          break;

        case 4:
          enterOuterAlt(_localctx, 4);
          {
            setState(73);
            match(12);
            setState(75);
            _la = _input.LA(1);
            if ((((_la) & ~0x3f) == 0
                && ((1L << _la) & ((1L << 6) | (1L << 8) | (1L << 21) | (1L << ID) | (1L << INT)))
                    != 0)) {
              {
                setState(74);
                expr(0);
              }
            }

            setState(77);
            match(13);
          }
          break;

        case 5:
          enterOuterAlt(_localctx, 5);
          {
            setState(78);
            expr(0);
            setState(79);
            match(11);
            setState(80);
            expr(0);
            setState(81);
            match(13);
          }
          break;

        case 6:
          enterOuterAlt(_localctx, 6);
          {
            setState(83);
            expr(0);
            setState(84);
            match(13);
          }
          break;
      }
    } catch (RecognitionException re) {
      _localctx.exception = re;
      _errHandler.reportError(this, re);
      _errHandler.recover(this, re);
    } finally {
      exitRule();
    }
    return _localctx;
  }

  public static class ExprContext extends ParserRuleContext {
    public int _p;

    public ExprContext(ParserRuleContext parent, int invokingState) {
      super(parent, invokingState);
    }

    public ExprContext(ParserRuleContext parent, int invokingState, int _p) {
      super(parent, invokingState);
      this._p = _p;
    }

    @Override
    public int getRuleIndex() {
      return RULE_expr;
    }

    public ExprContext() {}

    public void copyFrom(ExprContext ctx) {
      super.copyFrom(ctx);
      this._p = ctx._p;
    }
  }

  public static class MultContext extends ExprContext {
    public ExprContext expr(int i) {
      return getRuleContext(ExprContext.class, i);
    }

    public List<ExprContext> expr() {
      return getRuleContexts(ExprContext.class);
    }

    public MultContext(ExprContext ctx) {
      copyFrom(ctx);
    }

    @Override
    public void enterRule(ParseTreeListener listener) {
      if (listener instanceof CymbolListener) ((CymbolListener) listener).enterMult(this);
    }

    @Override
    public void exitRule(ParseTreeListener listener) {
      if (listener instanceof CymbolListener) ((CymbolListener) listener).exitMult(this);
    }

    @Override
    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
      if (visitor instanceof CymbolVisitor)
        return ((CymbolVisitor<? extends T>) visitor).visitMult(this);
      else return visitor.visitChildren(this);
    }
  }

  public static class ParensContext extends ExprContext {
    public ExprContext expr() {
      return getRuleContext(ExprContext.class, 0);
    }

    public ParensContext(ExprContext ctx) {
      copyFrom(ctx);
    }

    @Override
    public void enterRule(ParseTreeListener listener) {
      if (listener instanceof CymbolListener) ((CymbolListener) listener).enterParens(this);
    }

    @Override
    public void exitRule(ParseTreeListener listener) {
      if (listener instanceof CymbolListener) ((CymbolListener) listener).exitParens(this);
    }

    @Override
    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
      if (visitor instanceof CymbolVisitor)
        return ((CymbolVisitor<? extends T>) visitor).visitParens(this);
      else return visitor.visitChildren(this);
    }
  }

  public static class IndexContext extends ExprContext {
    public ExprContext expr(int i) {
      return getRuleContext(ExprContext.class, i);
    }

    public List<ExprContext> expr() {
      return getRuleContexts(ExprContext.class);
    }

    public IndexContext(ExprContext ctx) {
      copyFrom(ctx);
    }

    @Override
    public void enterRule(ParseTreeListener listener) {
      if (listener instanceof CymbolListener) ((CymbolListener) listener).enterIndex(this);
    }

    @Override
    public void exitRule(ParseTreeListener listener) {
      if (listener instanceof CymbolListener) ((CymbolListener) listener).exitIndex(this);
    }

    @Override
    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
      if (visitor instanceof CymbolVisitor)
        return ((CymbolVisitor<? extends T>) visitor).visitIndex(this);
      else return visitor.visitChildren(this);
    }
  }

  public static class CallContext extends ExprContext {
    public TerminalNode ID() {
      return getToken(CymbolParser.ID, 0);
    }

    public ExprListContext exprList() {
      return getRuleContext(ExprListContext.class, 0);
    }

    public CallContext(ExprContext ctx) {
      copyFrom(ctx);
    }

    @Override
    public void enterRule(ParseTreeListener listener) {
      if (listener instanceof CymbolListener) ((CymbolListener) listener).enterCall(this);
    }

    @Override
    public void exitRule(ParseTreeListener listener) {
      if (listener instanceof CymbolListener) ((CymbolListener) listener).exitCall(this);
    }

    @Override
    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
      if (visitor instanceof CymbolVisitor)
        return ((CymbolVisitor<? extends T>) visitor).visitCall(this);
      else return visitor.visitChildren(this);
    }
  }

  public static class AddSubContext extends ExprContext {
    public ExprContext expr(int i) {
      return getRuleContext(ExprContext.class, i);
    }

    public List<ExprContext> expr() {
      return getRuleContexts(ExprContext.class);
    }

    public AddSubContext(ExprContext ctx) {
      copyFrom(ctx);
    }

    @Override
    public void enterRule(ParseTreeListener listener) {
      if (listener instanceof CymbolListener) ((CymbolListener) listener).enterAddSub(this);
    }

    @Override
    public void exitRule(ParseTreeListener listener) {
      if (listener instanceof CymbolListener) ((CymbolListener) listener).exitAddSub(this);
    }

    @Override
    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
      if (visitor instanceof CymbolVisitor)
        return ((CymbolVisitor<? extends T>) visitor).visitAddSub(this);
      else return visitor.visitChildren(this);
    }
  }

  public static class EqualContext extends ExprContext {
    public ExprContext expr(int i) {
      return getRuleContext(ExprContext.class, i);
    }

    public List<ExprContext> expr() {
      return getRuleContexts(ExprContext.class);
    }

    public EqualContext(ExprContext ctx) {
      copyFrom(ctx);
    }

    @Override
    public void enterRule(ParseTreeListener listener) {
      if (listener instanceof CymbolListener) ((CymbolListener) listener).enterEqual(this);
    }

    @Override
    public void exitRule(ParseTreeListener listener) {
      if (listener instanceof CymbolListener) ((CymbolListener) listener).exitEqual(this);
    }

    @Override
    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
      if (visitor instanceof CymbolVisitor)
        return ((CymbolVisitor<? extends T>) visitor).visitEqual(this);
      else return visitor.visitChildren(this);
    }
  }

  public static class NegateContext extends ExprContext {
    public ExprContext expr() {
      return getRuleContext(ExprContext.class, 0);
    }

    public NegateContext(ExprContext ctx) {
      copyFrom(ctx);
    }

    @Override
    public void enterRule(ParseTreeListener listener) {
      if (listener instanceof CymbolListener) ((CymbolListener) listener).enterNegate(this);
    }

    @Override
    public void exitRule(ParseTreeListener listener) {
      if (listener instanceof CymbolListener) ((CymbolListener) listener).exitNegate(this);
    }

    @Override
    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
      if (visitor instanceof CymbolVisitor)
        return ((CymbolVisitor<? extends T>) visitor).visitNegate(this);
      else return visitor.visitChildren(this);
    }
  }

  public static class VarContext extends ExprContext {
    public TerminalNode ID() {
      return getToken(CymbolParser.ID, 0);
    }

    public VarContext(ExprContext ctx) {
      copyFrom(ctx);
    }

    @Override
    public void enterRule(ParseTreeListener listener) {
      if (listener instanceof CymbolListener) ((CymbolListener) listener).enterVar(this);
    }

    @Override
    public void exitRule(ParseTreeListener listener) {
      if (listener instanceof CymbolListener) ((CymbolListener) listener).exitVar(this);
    }

    @Override
    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
      if (visitor instanceof CymbolVisitor)
        return ((CymbolVisitor<? extends T>) visitor).visitVar(this);
      else return visitor.visitChildren(this);
    }
  }

  public static class IntContext extends ExprContext {
    public TerminalNode INT() {
      return getToken(CymbolParser.INT, 0);
    }

    public IntContext(ExprContext ctx) {
      copyFrom(ctx);
    }

    @Override
    public void enterRule(ParseTreeListener listener) {
      if (listener instanceof CymbolListener) ((CymbolListener) listener).enterInt(this);
    }

    @Override
    public void exitRule(ParseTreeListener listener) {
      if (listener instanceof CymbolListener) ((CymbolListener) listener).exitInt(this);
    }

    @Override
    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
      if (visitor instanceof CymbolVisitor)
        return ((CymbolVisitor<? extends T>) visitor).visitInt(this);
      else return visitor.visitChildren(this);
    }
  }

  public static class NotContext extends ExprContext {
    public ExprContext expr() {
      return getRuleContext(ExprContext.class, 0);
    }

    public NotContext(ExprContext ctx) {
      copyFrom(ctx);
    }

    @Override
    public void enterRule(ParseTreeListener listener) {
      if (listener instanceof CymbolListener) ((CymbolListener) listener).enterNot(this);
    }

    @Override
    public void exitRule(ParseTreeListener listener) {
      if (listener instanceof CymbolListener) ((CymbolListener) listener).exitNot(this);
    }

    @Override
    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
      if (visitor instanceof CymbolVisitor)
        return ((CymbolVisitor<? extends T>) visitor).visitNot(this);
      else return visitor.visitChildren(this);
    }
  }

  public final ExprContext expr(int _p) throws RecognitionException {
    ParserRuleContext _parentctx = _ctx;
    int _parentState = getState();
    ExprContext _localctx = new ExprContext(_ctx, _parentState, _p);
    ExprContext _prevctx = _localctx;
    int _startState = 16;
    enterRecursionRule(_localctx, RULE_expr);
    int _la;
    try {
      int _alt;
      enterOuterAlt(_localctx, 1);
      {
        setState(105);
        switch (getInterpreter().adaptivePredict(_input, 9, _ctx)) {
          case 1:
            {
              _localctx = new NegateContext(_localctx);
              _ctx = _localctx;
              _prevctx = _localctx;

              setState(89);
              match(6);
              setState(90);
              expr(8);
            }
            break;

          case 2:
            {
              _localctx = new NotContext(_localctx);
              _ctx = _localctx;
              _prevctx = _localctx;
              setState(91);
              match(21);
              setState(92);
              expr(7);
            }
            break;

          case 3:
            {
              _localctx = new CallContext(_localctx);
              _ctx = _localctx;
              _prevctx = _localctx;
              setState(93);
              match(ID);
              setState(94);
              match(8);
              setState(96);
              _la = _input.LA(1);
              if ((((_la) & ~0x3f) == 0
                  && ((1L << _la) & ((1L << 6) | (1L << 8) | (1L << 21) | (1L << ID) | (1L << INT)))
                      != 0)) {
                {
                  setState(95);
                  exprList();
                }
              }

              setState(98);
              match(2);
            }
            break;

          case 4:
            {
              _localctx = new VarContext(_localctx);
              _ctx = _localctx;
              _prevctx = _localctx;
              setState(99);
              match(ID);
            }
            break;

          case 5:
            {
              _localctx = new IntContext(_localctx);
              _ctx = _localctx;
              _prevctx = _localctx;
              setState(100);
              match(INT);
            }
            break;

          case 6:
            {
              _localctx = new ParensContext(_localctx);
              _ctx = _localctx;
              _prevctx = _localctx;
              setState(101);
              match(8);
              setState(102);
              expr(0);
              setState(103);
              match(2);
            }
            break;
        }
        _ctx.stop = _input.LT(-1);
        setState(123);
        _errHandler.sync(this);
        _alt = getInterpreter().adaptivePredict(_input, 11, _ctx);
        while (_alt != 2 && _alt != -1) {
          if (_alt == 1) {
            if (_parseListeners != null) triggerExitRuleEvent();
            _prevctx = _localctx;
            {
              setState(121);
              switch (getInterpreter().adaptivePredict(_input, 10, _ctx)) {
                case 1:
                  {
                    _localctx = new MultContext(new ExprContext(_parentctx, _parentState, _p));
                    pushNewRecursionContext(_localctx, _startState, RULE_expr);
                    setState(107);
                    if (!(6 >= _localctx._p)) throw new FailedPredicateException(this, "6 >= $_p");
                    setState(108);
                    match(7);
                    setState(109);
                    expr(7);
                  }
                  break;

                case 2:
                  {
                    _localctx = new AddSubContext(new ExprContext(_parentctx, _parentState, _p));
                    pushNewRecursionContext(_localctx, _startState, RULE_expr);
                    setState(110);
                    if (!(5 >= _localctx._p)) throw new FailedPredicateException(this, "5 >= $_p");
                    setState(111);
                    _la = _input.LA(1);
                    if (!(_la == 4 || _la == 6)) {
                      _errHandler.recoverInline(this);
                    }
                    consume();
                    setState(112);
                    expr(6);
                  }
                  break;

                case 3:
                  {
                    _localctx = new EqualContext(new ExprContext(_parentctx, _parentState, _p));
                    pushNewRecursionContext(_localctx, _startState, RULE_expr);
                    setState(113);
                    if (!(4 >= _localctx._p)) throw new FailedPredicateException(this, "4 >= $_p");
                    setState(114);
                    match(18);
                    setState(115);
                    expr(5);
                  }
                  break;

                case 4:
                  {
                    _localctx = new IndexContext(new ExprContext(_parentctx, _parentState, _p));
                    pushNewRecursionContext(_localctx, _startState, RULE_expr);
                    setState(116);
                    if (!(9 >= _localctx._p)) throw new FailedPredicateException(this, "9 >= $_p");
                    setState(117);
                    match(5);
                    setState(118);
                    expr(0);
                    setState(119);
                    match(1);
                  }
                  break;
              }
            }
          }
          setState(125);
          _errHandler.sync(this);
          _alt = getInterpreter().adaptivePredict(_input, 11, _ctx);
        }
      }
    } catch (RecognitionException re) {
      _localctx.exception = re;
      _errHandler.reportError(this, re);
      _errHandler.recover(this, re);
    } finally {
      unrollRecursionContexts(_parentctx);
    }
    return _localctx;
  }

  public static class ExprListContext extends ParserRuleContext {
    public ExprContext expr(int i) {
      return getRuleContext(ExprContext.class, i);
    }

    public List<ExprContext> expr() {
      return getRuleContexts(ExprContext.class);
    }

    public ExprListContext(ParserRuleContext parent, int invokingState) {
      super(parent, invokingState);
    }

    @Override
    public int getRuleIndex() {
      return RULE_exprList;
    }

    @Override
    public void enterRule(ParseTreeListener listener) {
      if (listener instanceof CymbolListener) ((CymbolListener) listener).enterExprList(this);
    }

    @Override
    public void exitRule(ParseTreeListener listener) {
      if (listener instanceof CymbolListener) ((CymbolListener) listener).exitExprList(this);
    }

    @Override
    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
      if (visitor instanceof CymbolVisitor)
        return ((CymbolVisitor<? extends T>) visitor).visitExprList(this);
      else return visitor.visitChildren(this);
    }
  }

  public final ExprListContext exprList() throws RecognitionException {
    ExprListContext _localctx = new ExprListContext(_ctx, getState());
    enterRule(_localctx, 18, RULE_exprList);
    int _la;
    try {
      enterOuterAlt(_localctx, 1);
      {
        setState(126);
        expr(0);
        setState(131);
        _errHandler.sync(this);
        _la = _input.LA(1);
        while (_la == 3) {
          {
            {
              setState(127);
              match(3);
              setState(128);
              expr(0);
            }
          }
          setState(133);
          _errHandler.sync(this);
          _la = _input.LA(1);
        }
      }
    } catch (RecognitionException re) {
      _localctx.exception = re;
      _errHandler.reportError(this, re);
      _errHandler.recover(this, re);
    } finally {
      exitRule();
    }
    return _localctx;
  }

  public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
    switch (ruleIndex) {
      case 8:
        return expr_sempred((ExprContext) _localctx, predIndex);
    }
    return true;
  }

  private boolean expr_sempred(ExprContext _localctx, int predIndex) {
    switch (predIndex) {
      case 0:
        return 6 >= _localctx._p;

      case 1:
        return 5 >= _localctx._p;

      case 2:
        return 4 >= _localctx._p;

      case 3:
        return 9 >= _localctx._p;
    }
    return true;
  }

  public static final String _serializedATN =
      "\2\3\33\u0089\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b"
          + "\4\t\t\t\4\n\t\n\4\13\t\13\3\2\3\2\6\2\31\n\2\r\2\16\2\32\3\3\3\3\3\3"
          + "\3\3\5\3!\n\3\3\3\3\3\3\4\3\4\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\6\3\6\3\6"
          + "\7\6\61\n\6\f\6\16\6\64\13\6\3\7\3\7\3\7\3\b\3\b\7\b;\n\b\f\b\16\b>\13"
          + "\b\3\b\3\b\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\5\tJ\n\t\3\t\3\t\5\tN\n\t\3"
          + "\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\5\tY\n\t\3\n\3\n\3\n\3\n\3\n\3\n\3"
          + "\n\3\n\5\nc\n\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\5\nl\n\n\3\n\3\n\3\n\3\n\3"
          + "\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\7\n|\n\n\f\n\16\n\177\13\n\3\13"
          + "\3\13\3\13\7\13\u0084\n\13\f\13\16\13\u0087\13\13\3\13\2\f\2\4\6\b\n\f"
          + "\16\20\22\24\2\4\5\f\f\20\20\26\26\4\6\6\b\b\u0095\2\30\3\2\2\2\4\34\3"
          + "\2\2\2\6$\3\2\2\2\b&\3\2\2\2\n-\3\2\2\2\f\65\3\2\2\2\168\3\2\2\2\20X\3"
          + "\2\2\2\22k\3\2\2\2\24\u0080\3\2\2\2\26\31\5\b\5\2\27\31\5\4\3\2\30\26"
          + "\3\2\2\2\30\27\3\2\2\2\31\32\3\2\2\2\32\30\3\2\2\2\32\33\3\2\2\2\33\3"
          + "\3\2\2\2\34\35\5\6\4\2\35 \7\30\2\2\36\37\7\r\2\2\37!\5\22\n\2 \36\3\2"
          + "\2\2 !\3\2\2\2!\"\3\2\2\2\"#\7\17\2\2#\5\3\2\2\2$%\t\2\2\2%\7\3\2\2\2"
          + "&\'\5\6\4\2\'(\7\30\2\2()\7\n\2\2)*\5\n\6\2*+\7\4\2\2+,\5\16\b\2,\t\3"
          + "\2\2\2-\62\5\f\7\2./\7\5\2\2/\61\5\f\7\2\60.\3\2\2\2\61\64\3\2\2\2\62"
          + "\60\3\2\2\2\62\63\3\2\2\2\63\13\3\2\2\2\64\62\3\2\2\2\65\66\5\6\4\2\66"
          + "\67\7\30\2\2\67\r\3\2\2\28<\7\21\2\29;\5\20\t\2:9\3\2\2\2;>\3\2\2\2<:"
          + "\3\2\2\2<=\3\2\2\2=?\3\2\2\2><\3\2\2\2?@\7\25\2\2@\17\3\2\2\2AY\5\16\b"
          + "\2BY\5\4\3\2CD\7\13\2\2DE\5\22\n\2EF\7\22\2\2FI\5\20\t\2GH\7\23\2\2HJ"
          + "\5\20\t\2IG\3\2\2\2IJ\3\2\2\2JY\3\2\2\2KM\7\16\2\2LN\5\22\n\2ML\3\2\2"
          + "\2MN\3\2\2\2NO\3\2\2\2OY\7\17\2\2PQ\5\22\n\2QR\7\r\2\2RS\5\22\n\2ST\7"
          + "\17\2\2TY\3\2\2\2UV\5\22\n\2VW\7\17\2\2WY\3\2\2\2XA\3\2\2\2XB\3\2\2\2"
          + "XC\3\2\2\2XK\3\2\2\2XP\3\2\2\2XU\3\2\2\2Y\21\3\2\2\2Z[\b\n\1\2[\\\7\b"
          + "\2\2\\l\5\22\n\2]^\7\27\2\2^l\5\22\n\2_`\7\30\2\2`b\7\n\2\2ac\5\24\13"
          + "\2ba\3\2\2\2bc\3\2\2\2cd\3\2\2\2dl\7\4\2\2el\7\30\2\2fl\7\31\2\2gh\7\n"
          + "\2\2hi\5\22\n\2ij\7\4\2\2jl\3\2\2\2kZ\3\2\2\2k]\3\2\2\2k_\3\2\2\2ke\3"
          + "\2\2\2kf\3\2\2\2kg\3\2\2\2l}\3\2\2\2mn\6\n\2\3no\7\t\2\2o|\5\22\n\2pq"
          + "\6\n\3\3qr\t\3\2\2r|\5\22\n\2st\6\n\4\3tu\7\24\2\2u|\5\22\n\2vw\6\n\5"
          + "\3wx\7\7\2\2xy\5\22\n\2yz\7\3\2\2z|\3\2\2\2{m\3\2\2\2{p\3\2\2\2{s\3\2"
          + "\2\2{v\3\2\2\2|\177\3\2\2\2}{\3\2\2\2}~\3\2\2\2~\23\3\2\2\2\177}\3\2\2"
          + "\2\u0080\u0085\5\22\n\2\u0081\u0082\7\5\2\2\u0082\u0084\5\22\n\2\u0083"
          + "\u0081\3\2\2\2\u0084\u0087\3\2\2\2\u0085\u0083\3\2\2\2\u0085\u0086\3\2"
          + "\2\2\u0086\25\3\2\2\2\u0087\u0085\3\2\2\2\17\30\32 \62<IMXbk{}\u0085";
  public static final ATN _ATN = ATNSimulator.deserialize(_serializedATN.toCharArray());

  static {
    _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
  }
}
@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
public class BooleanQueryLexer extends Lexer {
  protected static final DFA[] _decisionToDFA;
  protected static final PredictionContextCache _sharedContextCache = new PredictionContextCache();
  public static final int AND = 1, OR = 2, NOT = 3, STRING = 4, QSTRING = 5, WS = 6;
  public static String[] modeNames = {"DEFAULT_MODE"};

  public static final String[] tokenNames = {
    "<INVALID>", "AND", "OR", "NOT", "STRING", "QSTRING", "WS"
  };
  public static final String[] ruleNames = {"AND", "OR", "NOT", "STRING", "QSTRING", "WS"};

  public BooleanQueryLexer(CharStream input) {
    super(input);
    _interp = new LexerATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache);
  }

  @Override
  public String getGrammarFileName() {
    return "BooleanQuery.g4";
  }

  @Override
  public String[] getTokenNames() {
    return tokenNames;
  }

  @Override
  public String[] getRuleNames() {
    return ruleNames;
  }

  @Override
  public String[] getModeNames() {
    return modeNames;
  }

  @Override
  public ATN getATN() {
    return _ATN;
  }

  @Override
  public void action(RuleContext _localctx, int ruleIndex, int actionIndex) {
    switch (ruleIndex) {
      case 5:
        WS_action((RuleContext) _localctx, actionIndex);
        break;
    }
  }

  private void WS_action(RuleContext _localctx, int actionIndex) {
    switch (actionIndex) {
      case 0:
        skip();
        break;
    }
  }

  public static final String _serializedATN =
      "\3\uacf5\uee8c\u4f5d\u8b0d\u4a45\u78bd\u1b2f\u3378\2\bH\b\1\4\2\t\2\4"
          + "\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2"
          + "\5\2\30\n\2\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\5\3\"\n\3\3\4\3\4\3\4\3\4"
          + "\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\5\4\60\n\4\3\5\6\5\63\n\5\r\5\16\5\64"
          + "\3\6\3\6\3\6\3\6\7\6;\n\6\f\6\16\6>\13\6\3\6\3\6\3\7\6\7C\n\7\r\7\16\7"
          + "D\3\7\3\7\2\b\3\3\1\5\4\1\7\5\1\t\6\1\13\7\1\r\b\2\3\2\5\6\2\13\f\17\17"
          + "\"\"$$\3\2$$\5\2\13\f\17\17\"\"Q\2\3\3\2\2\2\2\5\3\2\2\2\2\7\3\2\2\2\2"
          + "\t\3\2\2\2\2\13\3\2\2\2\2\r\3\2\2\2\3\27\3\2\2\2\5!\3\2\2\2\7/\3\2\2\2"
          + "\t\62\3\2\2\2\13\66\3\2\2\2\rB\3\2\2\2\17\20\7C\2\2\20\21\7P\2\2\21\30"
          + "\7F\2\2\22\23\7G\2\2\23\30\7V\2\2\24\25\7W\2\2\25\26\7P\2\2\26\30\7F\2"
          + "\2\27\17\3\2\2\2\27\22\3\2\2\2\27\24\3\2\2\2\30\4\3\2\2\2\31\32\7Q\2\2"
          + "\32\"\7T\2\2\33\34\7Q\2\2\34\"\7W\2\2\35\36\7Q\2\2\36\37\7F\2\2\37 \7"
          + "G\2\2 \"\7T\2\2!\31\3\2\2\2!\33\3\2\2\2!\35\3\2\2\2\"\6\3\2\2\2#$\7P\2"
          + "\2$%\7Q\2\2%\60\7V\2\2&\'\7P\2\2\'(\7Q\2\2(\60\7P\2\2)*\7P\2\2*+\7K\2"
          + "\2+,\7E\2\2,-\7J\2\2-.\7V\2\2.\60\7U\2\2/#\3\2\2\2/&\3\2\2\2/)\3\2\2\2"
          + "\60\b\3\2\2\2\61\63\n\2\2\2\62\61\3\2\2\2\63\64\3\2\2\2\64\62\3\2\2\2"
          + "\64\65\3\2\2\2\65\n\3\2\2\2\66<\7$\2\2\678\7$\2\28;\7$\2\29;\n\3\2\2:"
          + "\67\3\2\2\2:9\3\2\2\2;>\3\2\2\2<:\3\2\2\2<=\3\2\2\2=?\3\2\2\2><\3\2\2"
          + "\2?@\7$\2\2@\f\3\2\2\2AC\t\4\2\2BA\3\2\2\2CD\3\2\2\2DB\3\2\2\2DE\3\2\2"
          + "\2EF\3\2\2\2FG\b\7\2\2G\16\3\2\2\2\n\2\27!/\64:<D";
  public static final ATN _ATN = ATNSimulator.deserialize(_serializedATN.toCharArray());

  static {
    _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
    for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
      _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
    }
  }
}
Пример #10
0
@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
public class bnfLexer extends Lexer {
  protected static final DFA[] _decisionToDFA;
  protected static final PredictionContextCache _sharedContextCache = new PredictionContextCache();
  public static final int ID = 1,
      ASSIGN = 2,
      LPAREN = 3,
      RPAREN = 4,
      LBRACE = 5,
      RBRACE = 6,
      LEND = 7,
      REND = 8,
      BAR = 9,
      CAPTEXT = 10,
      TEXT = 11,
      STRINGLITERAL = 12,
      WS = 13;
  public static String[] modeNames = {"DEFAULT_MODE"};

  public static final String[] tokenNames = {
    "<INVALID>",
    "ID",
    "'::='",
    "')'",
    "'('",
    "'}'",
    "'{'",
    "']'",
    "'['",
    "'|'",
    "CAPTEXT",
    "TEXT",
    "STRINGLITERAL",
    "WS"
  };
  public static final String[] ruleNames = {
    "ID",
    "ASSIGN",
    "LPAREN",
    "RPAREN",
    "LBRACE",
    "RBRACE",
    "LEND",
    "REND",
    "BAR",
    "CAPTEXT",
    "TEXT",
    "STRINGLITERAL",
    "UPPERCASE_LETTER",
    "LOWERCASE_LETTER",
    "DIGIT",
    "SYMBOL",
    "WS"
  };

  public bnfLexer(CharStream input) {
    super(input);
    _interp = new LexerATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache);
  }

  @Override
  public String getGrammarFileName() {
    return "bnf.g4";
  }

  @Override
  public String[] getTokenNames() {
    return tokenNames;
  }

  @Override
  public String[] getRuleNames() {
    return ruleNames;
  }

  @Override
  public String[] getModeNames() {
    return modeNames;
  }

  @Override
  public ATN getATN() {
    return _ATN;
  }

  @Override
  public void action(RuleContext _localctx, int ruleIndex, int actionIndex) {
    switch (ruleIndex) {
      case 16:
        WS_action((RuleContext) _localctx, actionIndex);
        break;
    }
  }

  private void WS_action(RuleContext _localctx, int actionIndex) {
    switch (actionIndex) {
      case 0:
        skip();
        break;
    }
  }

  public static final String _serializedATN =
      "\3\uacf5\uee8c\u4f5d\u8b0d\u4a45\u78bd\u1b2f\u3378\2\17`\b\1\4\2\t\2\4"
          + "\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t"
          + "\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"
          + "\3\2\3\2\7\2(\n\2\f\2\16\2+\13\2\3\2\3\2\3\3\3\3\3\3\3\3\3\4\3\4\3\5\3"
          + "\5\3\6\3\6\3\7\3\7\3\b\3\b\3\t\3\t\3\n\3\n\3\13\3\13\3\13\3\f\3\f\3\f"
          + "\3\f\6\fH\n\f\r\f\16\fI\3\r\3\r\7\rN\n\r\f\r\16\rQ\13\r\3\r\3\r\3\16\3"
          + "\16\3\17\3\17\3\20\3\20\3\21\3\21\3\22\3\22\3\22\3\22\4)O\23\3\3\1\5\4"
          + "\1\7\5\1\t\6\1\13\7\1\r\b\1\17\t\1\21\n\1\23\13\1\25\f\1\27\r\1\31\16"
          + "\1\33\2\1\35\2\1\37\2\1!\2\1#\17\2\3\2\4\n\2#),\61<B`b\u00a3\u0101\u0154"
          + "\u0194\u2015\u2124\u2192\u2301\5\2\13\f\17\17\"\"a\2\3\3\2\2\2\2\5\3\2"
          + "\2\2\2\7\3\2\2\2\2\t\3\2\2\2\2\13\3\2\2\2\2\r\3\2\2\2\2\17\3\2\2\2\2\21"
          + "\3\2\2\2\2\23\3\2\2\2\2\25\3\2\2\2\2\27\3\2\2\2\2\31\3\2\2\2\2#\3\2\2"
          + "\2\3%\3\2\2\2\5.\3\2\2\2\7\62\3\2\2\2\t\64\3\2\2\2\13\66\3\2\2\2\r8\3"
          + "\2\2\2\17:\3\2\2\2\21<\3\2\2\2\23>\3\2\2\2\25@\3\2\2\2\27G\3\2\2\2\31"
          + "K\3\2\2\2\33T\3\2\2\2\35V\3\2\2\2\37X\3\2\2\2!Z\3\2\2\2#\\\3\2\2\2%)\7"
          + ">\2\2&(\13\2\2\2\'&\3\2\2\2(+\3\2\2\2)*\3\2\2\2)\'\3\2\2\2*,\3\2\2\2+"
          + ")\3\2\2\2,-\7@\2\2-\4\3\2\2\2./\7<\2\2/\60\7<\2\2\60\61\7?\2\2\61\6\3"
          + "\2\2\2\62\63\7+\2\2\63\b\3\2\2\2\64\65\7*\2\2\65\n\3\2\2\2\66\67\7\177"
          + "\2\2\67\f\3\2\2\289\7}\2\29\16\3\2\2\2:;\7_\2\2;\20\3\2\2\2<=\7]\2\2="
          + "\22\3\2\2\2>?\7~\2\2?\24\3\2\2\2@A\5\33\16\2AB\5\27\f\2B\26\3\2\2\2CH"
          + "\5\33\16\2DH\5\35\17\2EH\5\37\20\2FH\5!\21\2GC\3\2\2\2GD\3\2\2\2GE\3\2"
          + "\2\2GF\3\2\2\2HI\3\2\2\2IG\3\2\2\2IJ\3\2\2\2J\30\3\2\2\2KO\7$\2\2LN\13"
          + "\2\2\2ML\3\2\2\2NQ\3\2\2\2OP\3\2\2\2OM\3\2\2\2PR\3\2\2\2QO\3\2\2\2RS\7"
          + "$\2\2S\32\3\2\2\2TU\4C\\\2U\34\3\2\2\2VW\4c|\2W\36\3\2\2\2XY\4\62;\2Y"
          + " \3\2\2\2Z[\t\2\2\2[\"\3\2\2\2\\]\t\3\2\2]^\3\2\2\2^_\b\22\2\2_$\3\2\2"
          + "\2\7\2)GIO";
  public static final ATN _ATN = ATNSimulator.deserialize(_serializedATN.toCharArray());

  static {
    _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
    for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
      _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
    }
  }
}