Coverage for src/pyensae/languages/PigParser.py: 0%

Shortcuts on this page

r m x   toggle line displays

j k   next/prev highlighted chunk

0   (zero) top of page

1   (one) first highlighted chunk

2917 statements  

1# Generated from \Pig.g4 by ANTLR 4.9 

2# encoding: utf-8 

3from antlr4 import * 

4from io import StringIO 

5import sys 

6if sys.version_info[1] > 5: 

7 from typing import TextIO 

8else: 

9 from typing.io import TextIO 

10 

11 

12def serializedATN(): 

13 with StringIO() as buf: 

14 buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3f") 

15 buf.write("\u0202\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7") 

16 buf.write("\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") 

17 buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23") 

18 buf.write("\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31") 

19 buf.write("\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36") 

20 buf.write("\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t") 

21 buf.write("&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.\t.\4") 

22 buf.write("/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\3\2\3\2\3") 

23 buf.write("\2\3\3\3\3\7\3l\n\3\f\3\16\3o\13\3\3\3\3\3\5\3s\n\3\3") 

24 buf.write("\3\3\3\7\3w\n\3\f\3\16\3z\13\3\3\4\3\4\3\4\5\4\177\n\4") 

25 buf.write("\3\4\3\4\3\4\3\4\3\4\3\4\5\4\u0087\n\4\3\4\3\4\5\4\u008b") 

26 buf.write("\n\4\3\5\3\5\3\6\3\6\3\6\3\6\5\6\u0093\n\6\3\7\3\7\3\7") 

27 buf.write("\3\7\5\7\u0099\n\7\3\7\5\7\u009c\n\7\3\b\3\b\3\t\3\t\3") 

28 buf.write("\t\3\n\3\n\3\n\3\n\7\n\u00a7\n\n\f\n\16\n\u00aa\13\n\3") 

29 buf.write("\n\3\n\3\n\3\n\3\n\6\n\u00b1\n\n\r\n\16\n\u00b2\5\n\u00b5") 

30 buf.write("\n\n\3\13\3\13\3\13\5\13\u00ba\n\13\3\13\3\13\3\13\3\13") 

31 buf.write("\5\13\u00c0\n\13\5\13\u00c2\n\13\3\f\3\f\3\f\3\f\5\f\u00c8") 

32 buf.write("\n\f\3\r\3\r\3\16\3\16\3\16\3\17\3\17\3\17\3\20\3\20\3") 

33 buf.write("\20\3\20\3\21\3\21\3\21\5\21\u00d9\n\21\3\21\3\21\3\21") 

34 buf.write("\3\21\3\21\3\21\5\21\u00e1\n\21\5\21\u00e3\n\21\3\22\3") 

35 buf.write("\22\3\22\7\22\u00e8\n\22\f\22\16\22\u00eb\13\22\3\22\6") 

36 buf.write("\22\u00ee\n\22\r\22\16\22\u00ef\5\22\u00f2\n\22\3\23\3") 

37 buf.write("\23\3\23\7\23\u00f7\n\23\f\23\16\23\u00fa\13\23\3\23\6") 

38 buf.write("\23\u00fd\n\23\r\23\16\23\u00fe\5\23\u0101\n\23\3\24\3") 

39 buf.write("\24\3\24\3\24\3\24\3\24\5\24\u0109\n\24\3\25\3\25\3\25") 

40 buf.write("\3\25\3\25\3\26\3\26\3\27\3\27\3\27\7\27\u0115\n\27\f") 

41 buf.write("\27\16\27\u0118\13\27\3\30\3\30\3\30\7\30\u011d\n\30\f") 

42 buf.write("\30\16\30\u0120\13\30\3\31\3\31\3\31\3\31\3\31\3\31\3") 

43 buf.write("\31\3\31\3\31\3\31\3\31\5\31\u012d\n\31\3\32\3\32\3\32") 

44 buf.write("\3\33\3\33\3\33\5\33\u0135\n\33\3\33\3\33\3\34\3\34\3") 

45 buf.write("\35\3\35\3\35\7\35\u013e\n\35\f\35\16\35\u0141\13\35\3") 

46 buf.write("\36\3\36\3\36\7\36\u0146\n\36\f\36\16\36\u0149\13\36\3") 

47 buf.write("\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37") 

48 buf.write("\3\37\5\37\u0157\n\37\3 \3 \3 \3 \3 \3 \5 \u015f\n \3") 

49 buf.write("!\3!\5!\u0163\n!\3\"\3\"\3\"\7\"\u0168\n\"\f\"\16\"\u016b") 

50 buf.write("\13\"\3#\3#\3#\5#\u0170\n#\3$\3$\3$\3$\3$\3$\7$\u0178") 

51 buf.write("\n$\f$\16$\u017b\13$\3$\3$\5$\u017f\n$\3$\3$\3$\6$\u0184") 

52 buf.write("\n$\r$\16$\u0185\5$\u0188\n$\3%\3%\3%\3&\3&\3&\3&\3&\3") 

53 buf.write("&\3&\3&\3&\3&\3&\3&\3&\3&\5&\u019b\n&\3\'\3\'\3\'\3(\3") 

54 buf.write("(\3(\3)\3)\5)\u01a5\n)\3*\3*\3+\3+\3+\3,\3,\3-\3-\3-\3") 

55 buf.write("-\5-\u01b2\n-\3.\3.\3/\3/\3/\3/\7/\u01ba\n/\f/\16/\u01bd") 

56 buf.write("\13/\5/\u01bf\n/\3/\3/\3/\3/\6/\u01c5\n/\r/\16/\u01c6") 

57 buf.write("\5/\u01c9\n/\3\60\3\60\3\60\3\60\3\60\3\60\3\60\3\60\3") 

58 buf.write("\60\5\60\u01d4\n\60\3\61\3\61\3\62\3\62\3\62\3\62\7\62") 

59 buf.write("\u01dc\n\62\f\62\16\62\u01df\13\62\5\62\u01e1\n\62\3\62") 

60 buf.write("\3\62\3\62\3\62\6\62\u01e7\n\62\r\62\16\62\u01e8\5\62") 

61 buf.write("\u01eb\n\62\3\63\3\63\3\63\3\63\7\63\u01f1\n\63\f\63\16") 

62 buf.write("\63\u01f4\13\63\5\63\u01f6\n\63\3\63\3\63\3\63\3\63\6") 

63 buf.write("\63\u01fc\n\63\r\63\16\63\u01fd\5\63\u0200\n\63\3\63\2") 

64 buf.write("\3\4\64\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*") 

65 buf.write(",.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bd\2\b\3\2%*\3\2Z") 

66 buf.write("[\4\2XY^^\4\2//EE\4\2\34\34@@\6\2//AACEaa\2\u0215\2f\3") 

67 buf.write("\2\2\2\4r\3\2\2\2\6\u008a\3\2\2\2\b\u008c\3\2\2\2\n\u0092") 

68 buf.write("\3\2\2\2\f\u0094\3\2\2\2\16\u009d\3\2\2\2\20\u009f\3\2") 

69 buf.write("\2\2\22\u00b4\3\2\2\2\24\u00c1\3\2\2\2\26\u00c7\3\2\2") 

70 buf.write("\2\30\u00c9\3\2\2\2\32\u00cb\3\2\2\2\34\u00ce\3\2\2\2") 

71 buf.write("\36\u00d1\3\2\2\2 \u00e2\3\2\2\2\"\u00f1\3\2\2\2$\u0100") 

72 buf.write("\3\2\2\2&\u0102\3\2\2\2(\u010a\3\2\2\2*\u010f\3\2\2\2") 

73 buf.write(",\u0111\3\2\2\2.\u0119\3\2\2\2\60\u012c\3\2\2\2\62\u012e") 

74 buf.write("\3\2\2\2\64\u0131\3\2\2\2\66\u0138\3\2\2\28\u013a\3\2") 

75 buf.write("\2\2:\u0142\3\2\2\2<\u0156\3\2\2\2>\u015e\3\2\2\2@\u0162") 

76 buf.write("\3\2\2\2B\u0164\3\2\2\2D\u016f\3\2\2\2F\u0187\3\2\2\2") 

77 buf.write("H\u0189\3\2\2\2J\u019a\3\2\2\2L\u019c\3\2\2\2N\u019f\3") 

78 buf.write("\2\2\2P\u01a4\3\2\2\2R\u01a6\3\2\2\2T\u01a8\3\2\2\2V\u01ab") 

79 buf.write("\3\2\2\2X\u01b1\3\2\2\2Z\u01b3\3\2\2\2\\\u01c8\3\2\2\2") 

80 buf.write("^\u01d3\3\2\2\2`\u01d5\3\2\2\2b\u01ea\3\2\2\2d\u01ff\3") 

81 buf.write("\2\2\2fg\5\4\3\2gh\7\2\2\3h\3\3\2\2\2im\b\3\1\2jl\5\6") 

82 buf.write("\4\2kj\3\2\2\2lo\3\2\2\2mk\3\2\2\2mn\3\2\2\2ns\3\2\2\2") 

83 buf.write("om\3\2\2\2pq\7\37\2\2qs\5\6\4\2ri\3\2\2\2rp\3\2\2\2sx") 

84 buf.write("\3\2\2\2tu\f\3\2\2uw\5\6\4\2vt\3\2\2\2wz\3\2\2\2xv\3\2") 

85 buf.write("\2\2xy\3\2\2\2y\5\3\2\2\2zx\3\2\2\2{|\5\b\5\2|}\7U\2\2") 

86 buf.write("}\177\3\2\2\2~{\3\2\2\2~\177\3\2\2\2\177\u0080\3\2\2\2") 

87 buf.write("\u0080\u0081\5\n\6\2\u0081\u0082\7M\2\2\u0082\u008b\3") 

88 buf.write("\2\2\2\u0083\u0084\7\37\2\2\u0084\u0086\5\6\4\2\u0085") 

89 buf.write("\u0087\5\b\5\2\u0086\u0085\3\2\2\2\u0086\u0087\3\2\2\2") 

90 buf.write("\u0087\u0088\3\2\2\2\u0088\u0089\5\n\6\2\u0089\u008b\3") 

91 buf.write("\2\2\2\u008a~\3\2\2\2\u008a\u0083\3\2\2\2\u008b\7\3\2") 

92 buf.write("\2\2\u008c\u008d\7@\2\2\u008d\t\3\2\2\2\u008e\u0093\5") 

93 buf.write("\f\7\2\u008f\u0093\5&\24\2\u0090\u0093\5(\25\2\u0091\u0093") 

94 buf.write("\5N(\2\u0092\u008e\3\2\2\2\u0092\u008f\3\2\2\2\u0092\u0090") 

95 buf.write("\3\2\2\2\u0092\u0091\3\2\2\2\u0093\13\3\2\2\2\u0094\u0095") 

96 buf.write("\7\4\2\2\u0095\u0098\5\16\b\2\u0096\u0097\7\25\2\2\u0097") 

97 buf.write("\u0099\5 \21\2\u0098\u0096\3\2\2\2\u0098\u0099\3\2\2\2") 

98 buf.write("\u0099\u009b\3\2\2\2\u009a\u009c\5\20\t\2\u009b\u009a") 

99 buf.write("\3\2\2\2\u009b\u009c\3\2\2\2\u009c\r\3\2\2\2\u009d\u009e") 

100 buf.write("\7E\2\2\u009e\17\3\2\2\2\u009f\u00a0\7\23\2\2\u00a0\u00a1") 

101 buf.write("\5\22\n\2\u00a1\21\3\2\2\2\u00a2\u00a3\7N\2\2\u00a3\u00a8") 

102 buf.write("\5\24\13\2\u00a4\u00a5\7V\2\2\u00a5\u00a7\5\24\13\2\u00a6") 

103 buf.write("\u00a4\3\2\2\2\u00a7\u00aa\3\2\2\2\u00a8\u00a6\3\2\2\2") 

104 buf.write("\u00a8\u00a9\3\2\2\2\u00a9\u00ab\3\2\2\2\u00aa\u00a8\3") 

105 buf.write("\2\2\2\u00ab\u00ac\7O\2\2\u00ac\u00b5\3\2\2\2\u00ad\u00ae") 

106 buf.write("\7\37\2\2\u00ae\u00b0\5\22\n\2\u00af\u00b1\5\24\13\2\u00b0") 

107 buf.write("\u00af\3\2\2\2\u00b1\u00b2\3\2\2\2\u00b2\u00b0\3\2\2\2") 

108 buf.write("\u00b2\u00b3\3\2\2\2\u00b3\u00b5\3\2\2\2\u00b4\u00a2\3") 

109 buf.write("\2\2\2\u00b4\u00ad\3\2\2\2\u00b5\23\3\2\2\2\u00b6\u00b9") 

110 buf.write("\7@\2\2\u00b7\u00b8\7L\2\2\u00b8\u00ba\5\26\f\2\u00b9") 

111 buf.write("\u00b7\3\2\2\2\u00b9\u00ba\3\2\2\2\u00ba\u00c2\3\2\2\2") 

112 buf.write("\u00bb\u00bc\7\37\2\2\u00bc\u00bd\5\24\13\2\u00bd\u00bf") 

113 buf.write("\7@\2\2\u00be\u00c0\5\26\f\2\u00bf\u00be\3\2\2\2\u00bf") 

114 buf.write("\u00c0\3\2\2\2\u00c0\u00c2\3\2\2\2\u00c1\u00b6\3\2\2\2") 

115 buf.write("\u00c1\u00bb\3\2\2\2\u00c2\25\3\2\2\2\u00c3\u00c8\5\30") 

116 buf.write("\r\2\u00c4\u00c8\5\32\16\2\u00c5\u00c8\5\34\17\2\u00c6") 

117 buf.write("\u00c8\5\36\20\2\u00c7\u00c3\3\2\2\2\u00c7\u00c4\3\2\2") 

118 buf.write("\2\u00c7\u00c5\3\2\2\2\u00c7\u00c6\3\2\2\2\u00c8\27\3") 

119 buf.write("\2\2\2\u00c9\u00ca\t\2\2\2\u00ca\31\3\2\2\2\u00cb\u00cc") 

120 buf.write("\5d\63\2\u00cc\u00cd\5\22\n\2\u00cd\33\3\2\2\2\u00ce\u00cf") 

121 buf.write("\7+\2\2\u00cf\u00d0\5\22\n\2\u00d0\35\3\2\2\2\u00d1\u00d2") 

122 buf.write("\7-\2\2\u00d2\u00d3\7R\2\2\u00d3\u00d4\7S\2\2\u00d4\37") 

123 buf.write("\3\2\2\2\u00d5\u00d6\5\"\22\2\u00d6\u00d8\7N\2\2\u00d7") 

124 buf.write("\u00d9\5$\23\2\u00d8\u00d7\3\2\2\2\u00d8\u00d9\3\2\2\2") 

125 buf.write("\u00d9\u00da\3\2\2\2\u00da\u00db\7O\2\2\u00db\u00e3\3") 

126 buf.write("\2\2\2\u00dc\u00dd\7\37\2\2\u00dd\u00de\7]\2\2\u00de\u00e0") 

127 buf.write("\5\"\22\2\u00df\u00e1\5$\23\2\u00e0\u00df\3\2\2\2\u00e0") 

128 buf.write("\u00e1\3\2\2\2\u00e1\u00e3\3\2\2\2\u00e2\u00d5\3\2\2\2") 

129 buf.write("\u00e2\u00dc\3\2\2\2\u00e3!\3\2\2\2\u00e4\u00e9\7@\2\2") 

130 buf.write("\u00e5\u00e6\7W\2\2\u00e6\u00e8\7@\2\2\u00e7\u00e5\3\2") 

131 buf.write("\2\2\u00e8\u00eb\3\2\2\2\u00e9\u00e7\3\2\2\2\u00e9\u00ea") 

132 buf.write("\3\2\2\2\u00ea\u00f2\3\2\2\2\u00eb\u00e9\3\2\2\2\u00ec") 

133 buf.write("\u00ee\7@\2\2\u00ed\u00ec\3\2\2\2\u00ee\u00ef\3\2\2\2") 

134 buf.write("\u00ef\u00ed\3\2\2\2\u00ef\u00f0\3\2\2\2\u00f0\u00f2\3") 

135 buf.write("\2\2\2\u00f1\u00e4\3\2\2\2\u00f1\u00ed\3\2\2\2\u00f2#") 

136 buf.write("\3\2\2\2\u00f3\u00f8\7E\2\2\u00f4\u00f5\7V\2\2\u00f5\u00f7") 

137 buf.write("\7E\2\2\u00f6\u00f4\3\2\2\2\u00f7\u00fa\3\2\2\2\u00f8") 

138 buf.write("\u00f6\3\2\2\2\u00f8\u00f9\3\2\2\2\u00f9\u0101\3\2\2\2") 

139 buf.write("\u00fa\u00f8\3\2\2\2\u00fb\u00fd\7E\2\2\u00fc\u00fb\3") 

140 buf.write("\2\2\2\u00fd\u00fe\3\2\2\2\u00fe\u00fc\3\2\2\2\u00fe\u00ff") 

141 buf.write("\3\2\2\2\u00ff\u0101\3\2\2\2\u0100\u00f3\3\2\2\2\u0100") 

142 buf.write("\u00fc\3\2\2\2\u0101%\3\2\2\2\u0102\u0103\7\62\2\2\u0103") 

143 buf.write("\u0104\5\b\5\2\u0104\u0105\7\17\2\2\u0105\u0108\5\16\b") 

144 buf.write("\2\u0106\u0107\7\25\2\2\u0107\u0109\5 \21\2\u0108\u0106") 

145 buf.write("\3\2\2\2\u0108\u0109\3\2\2\2\u0109\'\3\2\2\2\u010a\u010b") 

146 buf.write("\7\5\2\2\u010b\u010c\5\b\5\2\u010c\u010d\7\24\2\2\u010d") 

147 buf.write("\u010e\5*\26\2\u010e)\3\2\2\2\u010f\u0110\5,\27\2\u0110") 

148 buf.write("+\3\2\2\2\u0111\u0116\5.\30\2\u0112\u0113\7\36\2\2\u0113") 

149 buf.write("\u0115\5.\30\2\u0114\u0112\3\2\2\2\u0115\u0118\3\2\2\2") 

150 buf.write("\u0116\u0114\3\2\2\2\u0116\u0117\3\2\2\2\u0117-\3\2\2") 

151 buf.write("\2\u0118\u0116\3\2\2\2\u0119\u011e\5\60\31\2\u011a\u011b") 

152 buf.write("\7\35\2\2\u011b\u011d\5\60\31\2\u011c\u011a\3\2\2\2\u011d") 

153 buf.write("\u0120\3\2\2\2\u011e\u011c\3\2\2\2\u011e\u011f\3\2\2\2") 

154 buf.write("\u011f/\3\2\2\2\u0120\u011e\3\2\2\2\u0121\u0122\7N\2\2") 

155 buf.write("\u0122\u0123\5*\26\2\u0123\u0124\7O\2\2\u0124\u012d\3") 

156 buf.write("\2\2\2\u0125\u0126\5\66\34\2\u0126\u0127\7K\2\2\u0127") 

157 buf.write("\u0128\5\66\34\2\u0128\u012d\3\2\2\2\u0129\u012d\5 \21") 

158 buf.write("\2\u012a\u012d\5\64\33\2\u012b\u012d\5\62\32\2\u012c\u0121") 

159 buf.write("\3\2\2\2\u012c\u0125\3\2\2\2\u012c\u0129\3\2\2\2\u012c") 

160 buf.write("\u012a\3\2\2\2\u012c\u012b\3\2\2\2\u012d\61\3\2\2\2\u012e") 

161 buf.write("\u012f\7\37\2\2\u012f\u0130\5\60\31\2\u0130\63\3\2\2\2") 

162 buf.write("\u0131\u0132\5\66\34\2\u0132\u0134\7.\2\2\u0133\u0135") 

163 buf.write("\7\37\2\2\u0134\u0133\3\2\2\2\u0134\u0135\3\2\2\2\u0135") 

164 buf.write("\u0136\3\2\2\2\u0136\u0137\7/\2\2\u0137\65\3\2\2\2\u0138") 

165 buf.write("\u0139\58\35\2\u0139\67\3\2\2\2\u013a\u013f\5:\36\2\u013b") 

166 buf.write("\u013c\t\3\2\2\u013c\u013e\5:\36\2\u013d\u013b\3\2\2\2") 

167 buf.write("\u013e\u0141\3\2\2\2\u013f\u013d\3\2\2\2\u013f\u0140\3") 

168 buf.write("\2\2\2\u01409\3\2\2\2\u0141\u013f\3\2\2\2\u0142\u0147") 

169 buf.write("\5<\37\2\u0143\u0144\t\4\2\2\u0144\u0146\5<\37\2\u0145") 

170 buf.write("\u0143\3\2\2\2\u0146\u0149\3\2\2\2\u0147\u0145\3\2\2\2") 

171 buf.write("\u0147\u0148\3\2\2\2\u0148;\3\2\2\2\u0149\u0147\3\2\2") 

172 buf.write("\2\u014a\u014b\7N\2\2\u014b\u014c\5\26\f\2\u014c\u014d") 

173 buf.write("\7O\2\2\u014d\u014e\3\2\2\2\u014e\u014f\5> \2\u014f\u0157") 

174 buf.write("\3\2\2\2\u0150\u0151\7\37\2\2\u0151\u0152\7_\2\2\u0152") 

175 buf.write("\u0153\5\26\f\2\u0153\u0154\5> \2\u0154\u0157\3\2\2\2") 

176 buf.write("\u0155\u0157\5> \2\u0156\u014a\3\2\2\2\u0156\u0150\3\2") 

177 buf.write("\2\2\u0156\u0155\3\2\2\2\u0157=\3\2\2\2\u0158\u015f\5") 

178 buf.write("@!\2\u0159\u015a\7N\2\2\u015a\u015b\5V,\2\u015b\u015c") 

179 buf.write("\7O\2\2\u015c\u015f\3\2\2\2\u015d\u015f\5L\'\2\u015e\u0158") 

180 buf.write("\3\2\2\2\u015e\u0159\3\2\2\2\u015e\u015d\3\2\2\2\u015f") 

181 buf.write("?\3\2\2\2\u0160\u0163\5X-\2\u0161\u0163\5B\"\2\u0162\u0160") 

182 buf.write("\3\2\2\2\u0162\u0161\3\2\2\2\u0163A\3\2\2\2\u0164\u0169") 

183 buf.write("\5D#\2\u0165\u0168\5F$\2\u0166\u0168\5H%\2\u0167\u0165") 

184 buf.write("\3\2\2\2\u0167\u0166\3\2\2\2\u0168\u016b\3\2\2\2\u0169") 

185 buf.write("\u0167\3\2\2\2\u0169\u016a\3\2\2\2\u016aC\3\2\2\2\u016b") 

186 buf.write("\u0169\3\2\2\2\u016c\u0170\5 \21\2\u016d\u0170\5P)\2\u016e") 

187 buf.write("\u0170\5J&\2\u016f\u016c\3\2\2\2\u016f\u016d\3\2\2\2\u016f") 

188 buf.write("\u016e\3\2\2\2\u0170E\3\2\2\2\u0171\u017e\7W\2\2\u0172") 

189 buf.write("\u017f\5P)\2\u0173\u0174\7N\2\2\u0174\u0179\5P)\2\u0175") 

190 buf.write("\u0176\7V\2\2\u0176\u0178\5P)\2\u0177\u0175\3\2\2\2\u0178") 

191 buf.write("\u017b\3\2\2\2\u0179\u0177\3\2\2\2\u0179\u017a\3\2\2\2") 

192 buf.write("\u017a\u017c\3\2\2\2\u017b\u0179\3\2\2\2\u017c\u017d\7") 

193 buf.write("O\2\2\u017d\u017f\3\2\2\2\u017e\u0172\3\2\2\2\u017e\u0173") 

194 buf.write("\3\2\2\2\u017f\u0188\3\2\2\2\u0180\u0181\7\37\2\2\u0181") 

195 buf.write("\u0183\7W\2\2\u0182\u0184\5P)\2\u0183\u0182\3\2\2\2\u0184") 

196 buf.write("\u0185\3\2\2\2\u0185\u0183\3\2\2\2\u0185\u0186\3\2\2\2") 

197 buf.write("\u0186\u0188\3\2\2\2\u0187\u0171\3\2\2\2\u0187\u0180\3") 

198 buf.write("\2\2\2\u0188G\3\2\2\2\u0189\u018a\7T\2\2\u018a\u018b\t") 

199 buf.write("\5\2\2\u018bI\3\2\2\2\u018c\u018d\7N\2\2\u018d\u018e\5") 

200 buf.write("*\26\2\u018e\u018f\7\\\2\2\u018f\u0190\5V,\2\u0190\u0191") 

201 buf.write("\7L\2\2\u0191\u0192\5V,\2\u0192\u0193\7O\2\2\u0193\u019b") 

202 buf.write("\3\2\2\2\u0194\u0195\7\37\2\2\u0195\u0196\7`\2\2\u0196") 

203 buf.write("\u0197\5*\26\2\u0197\u0198\5V,\2\u0198\u0199\5V,\2\u0199") 

204 buf.write("\u019b\3\2\2\2\u019a\u018c\3\2\2\2\u019a\u0194\3\2\2\2") 

205 buf.write("\u019bK\3\2\2\2\u019c\u019d\7[\2\2\u019d\u019e\5<\37\2") 

206 buf.write("\u019eM\3\2\2\2\u019f\u01a0\7\t\2\2\u01a0\u01a1\5\b\5") 

207 buf.write("\2\u01a1O\3\2\2\2\u01a2\u01a5\5R*\2\u01a3\u01a5\5T+\2") 

208 buf.write("\u01a4\u01a2\3\2\2\2\u01a4\u01a3\3\2\2\2\u01a5Q\3\2\2") 

209 buf.write("\2\u01a6\u01a7\t\6\2\2\u01a7S\3\2\2\2\u01a8\u01a9\7G\2") 

210 buf.write("\2\u01a9\u01aa\7A\2\2\u01aaU\3\2\2\2\u01ab\u01ac\58\35") 

211 buf.write("\2\u01acW\3\2\2\2\u01ad\u01b2\5Z.\2\u01ae\u01b2\5\\/\2") 

212 buf.write("\u01af\u01b2\5b\62\2\u01b0\u01b2\5d\63\2\u01b1\u01ad\3") 

213 buf.write("\2\2\2\u01b1\u01ae\3\2\2\2\u01b1\u01af\3\2\2\2\u01b1\u01b0") 

214 buf.write("\3\2\2\2\u01b2Y\3\2\2\2\u01b3\u01b4\t\7\2\2\u01b4[\3\2") 

215 buf.write("\2\2\u01b5\u01be\7R\2\2\u01b6\u01bb\5^\60\2\u01b7\u01b8") 

216 buf.write("\7V\2\2\u01b8\u01ba\5^\60\2\u01b9\u01b7\3\2\2\2\u01ba") 

217 buf.write("\u01bd\3\2\2\2\u01bb\u01b9\3\2\2\2\u01bb\u01bc\3\2\2\2") 

218 buf.write("\u01bc\u01bf\3\2\2\2\u01bd\u01bb\3\2\2\2\u01be\u01b6\3") 

219 buf.write("\2\2\2\u01be\u01bf\3\2\2\2\u01bf\u01c0\3\2\2\2\u01c0\u01c9") 

220 buf.write("\7S\2\2\u01c1\u01c2\7\37\2\2\u01c2\u01c4\7b\2\2\u01c3") 

221 buf.write("\u01c5\5^\60\2\u01c4\u01c3\3\2\2\2\u01c5\u01c6\3\2\2\2") 

222 buf.write("\u01c6\u01c4\3\2\2\2\u01c6\u01c7\3\2\2\2\u01c7\u01c9\3") 

223 buf.write("\2\2\2\u01c8\u01b5\3\2\2\2\u01c8\u01c1\3\2\2\2\u01c9]") 

224 buf.write("\3\2\2\2\u01ca\u01cb\5`\61\2\u01cb\u01cc\7T\2\2\u01cc") 

225 buf.write("\u01cd\5X-\2\u01cd\u01d4\3\2\2\2\u01ce\u01cf\7\37\2\2") 

226 buf.write("\u01cf\u01d0\7c\2\2\u01d0\u01d1\5`\61\2\u01d1\u01d2\5") 

227 buf.write("X-\2\u01d2\u01d4\3\2\2\2\u01d3\u01ca\3\2\2\2\u01d3\u01ce") 

228 buf.write("\3\2\2\2\u01d4_\3\2\2\2\u01d5\u01d6\t\5\2\2\u01d6a\3\2") 

229 buf.write("\2\2\u01d7\u01e0\7d\2\2\u01d8\u01dd\5d\63\2\u01d9\u01da") 

230 buf.write("\7V\2\2\u01da\u01dc\5d\63\2\u01db\u01d9\3\2\2\2\u01dc") 

231 buf.write("\u01df\3\2\2\2\u01dd\u01db\3\2\2\2\u01dd\u01de\3\2\2\2") 

232 buf.write("\u01de\u01e1\3\2\2\2\u01df\u01dd\3\2\2\2\u01e0\u01d8\3") 

233 buf.write("\2\2\2\u01e0\u01e1\3\2\2\2\u01e1\u01e2\3\2\2\2\u01e2\u01eb") 

234 buf.write("\7e\2\2\u01e3\u01e4\7\37\2\2\u01e4\u01e6\7f\2\2\u01e5") 

235 buf.write("\u01e7\5d\63\2\u01e6\u01e5\3\2\2\2\u01e7\u01e8\3\2\2\2") 

236 buf.write("\u01e8\u01e6\3\2\2\2\u01e8\u01e9\3\2\2\2\u01e9\u01eb\3") 

237 buf.write("\2\2\2\u01ea\u01d7\3\2\2\2\u01ea\u01e3\3\2\2\2\u01ebc") 

238 buf.write("\3\2\2\2\u01ec\u01f5\7N\2\2\u01ed\u01f2\5X-\2\u01ee\u01ef") 

239 buf.write("\7V\2\2\u01ef\u01f1\5X-\2\u01f0\u01ee\3\2\2\2\u01f1\u01f4") 

240 buf.write("\3\2\2\2\u01f2\u01f0\3\2\2\2\u01f2\u01f3\3\2\2\2\u01f3") 

241 buf.write("\u01f6\3\2\2\2\u01f4\u01f2\3\2\2\2\u01f5\u01ed\3\2\2\2") 

242 buf.write("\u01f5\u01f6\3\2\2\2\u01f6\u01f7\3\2\2\2\u01f7\u0200\7") 

243 buf.write("O\2\2\u01f8\u01f9\7\37\2\2\u01f9\u01fb\5d\63\2\u01fa\u01fc") 

244 buf.write("\5X-\2\u01fb\u01fa\3\2\2\2\u01fc\u01fd\3\2\2\2\u01fd\u01fb") 

245 buf.write("\3\2\2\2\u01fd\u01fe\3\2\2\2\u01fe\u0200\3\2\2\2\u01ff") 

246 buf.write("\u01ec\3\2\2\2\u01ff\u01f8\3\2\2\2\u0200e\3\2\2\2<mrx") 

247 buf.write("~\u0086\u008a\u0092\u0098\u009b\u00a8\u00b2\u00b4\u00b9") 

248 buf.write("\u00bf\u00c1\u00c7\u00d8\u00e0\u00e2\u00e9\u00ef\u00f1") 

249 buf.write("\u00f8\u00fe\u0100\u0108\u0116\u011e\u012c\u0134\u013f") 

250 buf.write("\u0147\u0156\u015e\u0162\u0167\u0169\u016f\u0179\u017e") 

251 buf.write("\u0185\u0187\u019a\u01a4\u01b1\u01bb\u01be\u01c6\u01c8") 

252 buf.write("\u01d3\u01dd\u01e0\u01e8\u01ea\u01f2\u01f5\u01fd\u01ff") 

253 return buf.getvalue() 

254 

255 

256class PigParser (Parser): 

257 

258 grammarFileName = "Pig.g4" 

259 

260 atn = ATNDeserializer().deserialize(serializedATN()) 

261 

262 decisionsToDFA = [DFA(ds, i) for i, ds in enumerate(atn.decisionToState)] 

263 

264 sharedContextCache = PredictionContextCache() 

265 

266 literalNames = ["<INVALID>", "'define'", "'load'", "'filter'", "'foreach'", 

267 "'order'", "'arrange'", "'distinct'", "'cogroup'", 

268 "'join'", "'cross'", "'union'", "'split'", "'into'", 

269 "'if'", "'all'", "'any'", "'as'", "'by'", "'using'", 

270 "'inner'", "'outer'", "'ONSCHEMA'", "'*'", "'parallel'", 

271 "'partition'", "'group'", "'and'", "'or'", "'not'", 

272 "'generate'", "'flatten'", "'eval'", "'asc'", "'desc'", 

273 "'int'", "'long'", "'float'", "'double'", "'chararray'", 

274 "'bytearray'", "'bag'", "'tuple'", "'map'", "'is'", 

275 "'null'", "'stream'", "'through'", "'store'", "'mapreduce'", 

276 "'ship'", "'cache'", "'input'", "'output'", "'stderr'", 

277 "'stdin'", "'stdout'", "'limit'", "'sample'", "'left'", 

278 "'right'", "'full'", "<INVALID>", "<INVALID>", "<INVALID>", 

279 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 

280 "'$'", "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 

281 "':'", "';'", "'('", "')'", "'{'", "'}'", "'['", "']'", 

282 "'#'", "'='", "','", "'.'", "'/'", "'%'", "'+'", "'-'", 

283 "'?'"] 

284 

285 symbolicNames = ["<INVALID>", "DEFINE", "LOAD", "FILTER", "FOREACH", 

286 "ORDER", "ARRANGE", "DISTINCT", "COGROUP", "JOIN", 

287 "CROSS", "UNION", "SPLIT", "INTO", "IF", "ALL", "ANY", 

288 "AS", "BY", "USING", "INNER", "OUTER", "ONSCHEMA", 

289 "STAR", "PARALLEL", "PARTITION", "GROUP", "AND", "OR", 

290 "NOT", "GENERATE", "FLATTEN", "EVAL", "ASC", "DESC", 

291 "INT", "LONG", "FLOAT", "DOUBLE", "CHARARRAY", "BYTEARRAY", 

292 "BAG", "TUPLE", "MAP", "IS", "NULL", "STREAM", "THROUGH", 

293 "STORE", "MAPREDUCE", "SHIP", "CACHE", "INPUT", "OUTPUT", 

294 "ERROR", "STDIN", "STDOUT", "LIMIT", "SAMPLE", "LEFT", 

295 "RIGHT", "FULL", "IDENTIFIER", "INTEGER", "LONGINTEGER", 

296 "DOUBLENUMBER", "FLOATNUMBER", "QUOTEDSTRING", "EXECCOMMAND", 

297 "DOLLAR", "WS", "SL_COMMENT", "ML_COMMENT", "FILTEROP", 

298 "COLON", "SEMI_COLON", "LEFT_PAREN", "RIGHT_PAREN", 

299 "LEFT_CURLYP", "RIGHT_CURLYP", "LEFT_BRACKET", "RIGHT_BRACKET", 

300 "POUND", "EQUAL", "COMMA", "PERIOD", "DIV", "PERCENT", 

301 "PLUS", "MINUS", "QMARK", "FUNC", "START", "CAST_EXPR", 

302 "BIN_EXPR", "LONGINEGER", "MAP_VAL", "KEY_VAL_PAIR", 

303 "LEFT_CURLY", "RIGHT_CURLY", "BAG_VAL"] 

304 

305 RULE_parse = 0 

306 RULE_query = 1 

307 RULE_statement = 2 

308 RULE_alias = 3 

309 RULE_op_clause = 4 

310 RULE_load_clause = 5 

311 RULE_filename = 6 

312 RULE_as_clause = 7 

313 RULE_tuple_def = 8 

314 RULE_field = 9 

315 RULE_type_ = 10 

316 RULE_simple_type = 11 

317 RULE_tuple_type = 12 

318 RULE_bag_type = 13 

319 RULE_map_type = 14 

320 RULE_func_clause = 15 

321 RULE_func_name = 16 

322 RULE_func_args = 17 

323 RULE_store_clause = 18 

324 RULE_filter_clause = 19 

325 RULE_cond = 20 

326 RULE_or_cond = 21 

327 RULE_and_cond = 22 

328 RULE_unary_cond = 23 

329 RULE_not_cond = 24 

330 RULE_null_check_cond = 25 

331 RULE_expr = 26 

332 RULE_add_expr = 27 

333 RULE_multi_expr = 28 

334 RULE_cast_expr = 29 

335 RULE_unary_expr = 30 

336 RULE_eval_expr = 31 

337 RULE_var_expr = 32 

338 RULE_projectable_expr = 33 

339 RULE_dot_proj = 34 

340 RULE_pound_proj = 35 

341 RULE_bin_expr = 36 

342 RULE_neg_expr = 37 

343 RULE_distinct_clause = 38 

344 RULE_col_ref = 39 

345 RULE_alias_col_ref = 40 

346 RULE_dollar_col_ref = 41 

347 RULE_infix_expr = 42 

348 RULE_const_expr = 43 

349 RULE_scalar = 44 

350 RULE_map_ = 45 

351 RULE_keyvalue = 46 

352 RULE_string_val = 47 

353 RULE_bag = 48 

354 RULE_tuple_ = 49 

355 

356 ruleNames = ["parse", "query", "statement", "alias", "op_clause", 

357 "load_clause", "filename", "as_clause", "tuple_def", 

358 "field", "type_", "simple_type", "tuple_type", "bag_type", 

359 "map_type", "func_clause", "func_name", "func_args", 

360 "store_clause", "filter_clause", "cond", "or_cond", "and_cond", 

361 "unary_cond", "not_cond", "null_check_cond", "expr", 

362 "add_expr", "multi_expr", "cast_expr", "unary_expr", 

363 "eval_expr", "var_expr", "projectable_expr", "dot_proj", 

364 "pound_proj", "bin_expr", "neg_expr", "distinct_clause", 

365 "col_ref", "alias_col_ref", "dollar_col_ref", "infix_expr", 

366 "const_expr", "scalar", "map_", "keyvalue", "string_val", 

367 "bag", "tuple_"] 

368 

369 EOF = Token.EOF 

370 DEFINE = 1 

371 LOAD = 2 

372 FILTER = 3 

373 FOREACH = 4 

374 ORDER = 5 

375 ARRANGE = 6 

376 DISTINCT = 7 

377 COGROUP = 8 

378 JOIN = 9 

379 CROSS = 10 

380 UNION = 11 

381 SPLIT = 12 

382 INTO = 13 

383 IF = 14 

384 ALL = 15 

385 ANY = 16 

386 AS = 17 

387 BY = 18 

388 USING = 19 

389 INNER = 20 

390 OUTER = 21 

391 ONSCHEMA = 22 

392 STAR = 23 

393 PARALLEL = 24 

394 PARTITION = 25 

395 GROUP = 26 

396 AND = 27 

397 OR = 28 

398 NOT = 29 

399 GENERATE = 30 

400 FLATTEN = 31 

401 EVAL = 32 

402 ASC = 33 

403 DESC = 34 

404 INT = 35 

405 LONG = 36 

406 FLOAT = 37 

407 DOUBLE = 38 

408 CHARARRAY = 39 

409 BYTEARRAY = 40 

410 BAG = 41 

411 TUPLE = 42 

412 MAP = 43 

413 IS = 44 

414 NULL = 45 

415 STREAM = 46 

416 THROUGH = 47 

417 STORE = 48 

418 MAPREDUCE = 49 

419 SHIP = 50 

420 CACHE = 51 

421 INPUT = 52 

422 OUTPUT = 53 

423 ERROR = 54 

424 STDIN = 55 

425 STDOUT = 56 

426 LIMIT = 57 

427 SAMPLE = 58 

428 LEFT = 59 

429 RIGHT = 60 

430 FULL = 61 

431 IDENTIFIER = 62 

432 INTEGER = 63 

433 LONGINTEGER = 64 

434 DOUBLENUMBER = 65 

435 FLOATNUMBER = 66 

436 QUOTEDSTRING = 67 

437 EXECCOMMAND = 68 

438 DOLLAR = 69 

439 WS = 70 

440 SL_COMMENT = 71 

441 ML_COMMENT = 72 

442 FILTEROP = 73 

443 COLON = 74 

444 SEMI_COLON = 75 

445 LEFT_PAREN = 76 

446 RIGHT_PAREN = 77 

447 LEFT_CURLYP = 78 

448 RIGHT_CURLYP = 79 

449 LEFT_BRACKET = 80 

450 RIGHT_BRACKET = 81 

451 POUND = 82 

452 EQUAL = 83 

453 COMMA = 84 

454 PERIOD = 85 

455 DIV = 86 

456 PERCENT = 87 

457 PLUS = 88 

458 MINUS = 89 

459 QMARK = 90 

460 FUNC = 91 

461 START = 92 

462 CAST_EXPR = 93 

463 BIN_EXPR = 94 

464 LONGINEGER = 95 

465 MAP_VAL = 96 

466 KEY_VAL_PAIR = 97 

467 LEFT_CURLY = 98 

468 RIGHT_CURLY = 99 

469 BAG_VAL = 100 

470 

471 def __init__(self, input: TokenStream, output: TextIO = sys.stdout): 

472 super().__init__(input, output) 

473 self.checkVersion("4.9") 

474 self._interp = ParserATNSimulator( 

475 self, self.atn, self.decisionsToDFA, self.sharedContextCache) 

476 self._predicates = None 

477 

478 class ParseContext(ParserRuleContext): 

479 

480 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

481 super().__init__(parent, invokingState) 

482 self.parser = parser 

483 

484 def query(self): 

485 return self.getTypedRuleContext(PigParser.QueryContext, 0) 

486 

487 def EOF(self): 

488 return self.getToken(PigParser.EOF, 0) 

489 

490 def getRuleIndex(self): 

491 return PigParser.RULE_parse 

492 

493 def enterRule(self, listener: ParseTreeListener): 

494 if hasattr(listener, "enterParse"): 

495 listener.enterParse(self) 

496 

497 def exitRule(self, listener: ParseTreeListener): 

498 if hasattr(listener, "exitParse"): 

499 listener.exitParse(self) 

500 

501 def parse(self): 

502 

503 localctx = PigParser.ParseContext(self, self._ctx, self.state) 

504 self.enterRule(localctx, 0, self.RULE_parse) 

505 try: 

506 self.enterOuterAlt(localctx, 1) 

507 self.state = 100 

508 self.query(0) 

509 self.state = 101 

510 self.match(PigParser.EOF) 

511 except RecognitionException as re: 

512 localctx.exception = re 

513 self._errHandler.reportError(self, re) 

514 self._errHandler.recover(self, re) 

515 finally: 

516 self.exitRule() 

517 return localctx 

518 

519 class QueryContext(ParserRuleContext): 

520 

521 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

522 super().__init__(parent, invokingState) 

523 self.parser = parser 

524 

525 def statement(self, i: int = None): 

526 if i is None: 

527 return self.getTypedRuleContexts(PigParser.StatementContext) 

528 else: 

529 return self.getTypedRuleContext(PigParser.StatementContext, i) 

530 

531 def NOT(self): 

532 return self.getToken(PigParser.NOT, 0) 

533 

534 def query(self): 

535 return self.getTypedRuleContext(PigParser.QueryContext, 0) 

536 

537 def getRuleIndex(self): 

538 return PigParser.RULE_query 

539 

540 def enterRule(self, listener: ParseTreeListener): 

541 if hasattr(listener, "enterQuery"): 

542 listener.enterQuery(self) 

543 

544 def exitRule(self, listener: ParseTreeListener): 

545 if hasattr(listener, "exitQuery"): 

546 listener.exitQuery(self) 

547 

548 def query(self, _p: int = 0): 

549 _parentctx = self._ctx 

550 _parentState = self.state 

551 localctx = PigParser.QueryContext(self, self._ctx, _parentState) 

552 _prevctx = localctx 

553 _startState = 2 

554 self.enterRecursionRule(localctx, 2, self.RULE_query, _p) 

555 try: 

556 self.enterOuterAlt(localctx, 1) 

557 self.state = 112 

558 self._errHandler.sync(self) 

559 la_ = self._interp.adaptivePredict(self._input, 1, self._ctx) 

560 if la_ == 1: 

561 self.state = 107 

562 self._errHandler.sync(self) 

563 _alt = self._interp.adaptivePredict(self._input, 0, self._ctx) 

564 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: 

565 if _alt == 1: 

566 self.state = 104 

567 self.statement() 

568 self.state = 109 

569 self._errHandler.sync(self) 

570 _alt = self._interp.adaptivePredict( 

571 self._input, 0, self._ctx) 

572 

573 pass 

574 

575 elif la_ == 2: 

576 self.state = 110 

577 self.match(PigParser.NOT) 

578 self.state = 111 

579 self.statement() 

580 pass 

581 

582 self._ctx.stop = self._input.LT(-1) 

583 self.state = 118 

584 self._errHandler.sync(self) 

585 _alt = self._interp.adaptivePredict(self._input, 2, self._ctx) 

586 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: 

587 if _alt == 1: 

588 if self._parseListeners is not None: 

589 self.triggerExitRuleEvent() 

590 _prevctx = localctx 

591 localctx = PigParser.QueryContext( 

592 self, _parentctx, _parentState) 

593 self.pushNewRecursionContext( 

594 localctx, _startState, self.RULE_query) 

595 self.state = 114 

596 if not self.precpred(self._ctx, 1): 

597 from antlr4.error.Errors import FailedPredicateException 

598 raise FailedPredicateException( 

599 self, "self.precpred(self._ctx, 1)") 

600 self.state = 115 

601 self.statement() 

602 self.state = 120 

603 self._errHandler.sync(self) 

604 _alt = self._interp.adaptivePredict(self._input, 2, self._ctx) 

605 

606 except RecognitionException as re: 

607 localctx.exception = re 

608 self._errHandler.reportError(self, re) 

609 self._errHandler.recover(self, re) 

610 finally: 

611 self.unrollRecursionContexts(_parentctx) 

612 return localctx 

613 

614 class StatementContext(ParserRuleContext): 

615 

616 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

617 super().__init__(parent, invokingState) 

618 self.parser = parser 

619 

620 def op_clause(self): 

621 return self.getTypedRuleContext(PigParser.Op_clauseContext, 0) 

622 

623 def SEMI_COLON(self): 

624 return self.getToken(PigParser.SEMI_COLON, 0) 

625 

626 def alias(self): 

627 return self.getTypedRuleContext(PigParser.AliasContext, 0) 

628 

629 def EQUAL(self): 

630 return self.getToken(PigParser.EQUAL, 0) 

631 

632 def NOT(self): 

633 return self.getToken(PigParser.NOT, 0) 

634 

635 def statement(self): 

636 return self.getTypedRuleContext(PigParser.StatementContext, 0) 

637 

638 def getRuleIndex(self): 

639 return PigParser.RULE_statement 

640 

641 def enterRule(self, listener: ParseTreeListener): 

642 if hasattr(listener, "enterStatement"): 

643 listener.enterStatement(self) 

644 

645 def exitRule(self, listener: ParseTreeListener): 

646 if hasattr(listener, "exitStatement"): 

647 listener.exitStatement(self) 

648 

649 def statement(self): 

650 

651 localctx = PigParser.StatementContext(self, self._ctx, self.state) 

652 self.enterRule(localctx, 4, self.RULE_statement) 

653 self._la = 0 # Token type 

654 try: 

655 self.state = 136 

656 self._errHandler.sync(self) 

657 token = self._input.LA(1) 

658 if token in [PigParser.LOAD, PigParser.FILTER, PigParser.DISTINCT, PigParser.STORE, PigParser.IDENTIFIER]: 

659 self.enterOuterAlt(localctx, 1) 

660 self.state = 124 

661 self._errHandler.sync(self) 

662 _la = self._input.LA(1) 

663 if _la == PigParser.IDENTIFIER: 

664 self.state = 121 

665 self.alias() 

666 self.state = 122 

667 self.match(PigParser.EQUAL) 

668 

669 self.state = 126 

670 self.op_clause() 

671 self.state = 127 

672 self.match(PigParser.SEMI_COLON) 

673 pass 

674 elif token in [PigParser.NOT]: 

675 self.enterOuterAlt(localctx, 2) 

676 self.state = 129 

677 self.match(PigParser.NOT) 

678 

679 self.state = 130 

680 self.statement() 

681 self.state = 132 

682 self._errHandler.sync(self) 

683 _la = self._input.LA(1) 

684 if _la == PigParser.IDENTIFIER: 

685 self.state = 131 

686 self.alias() 

687 

688 self.state = 134 

689 self.op_clause() 

690 pass 

691 else: 

692 raise NoViableAltException(self) 

693 

694 except RecognitionException as re: 

695 localctx.exception = re 

696 self._errHandler.reportError(self, re) 

697 self._errHandler.recover(self, re) 

698 finally: 

699 self.exitRule() 

700 return localctx 

701 

702 class AliasContext(ParserRuleContext): 

703 

704 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

705 super().__init__(parent, invokingState) 

706 self.parser = parser 

707 

708 def IDENTIFIER(self): 

709 return self.getToken(PigParser.IDENTIFIER, 0) 

710 

711 def getRuleIndex(self): 

712 return PigParser.RULE_alias 

713 

714 def enterRule(self, listener: ParseTreeListener): 

715 if hasattr(listener, "enterAlias"): 

716 listener.enterAlias(self) 

717 

718 def exitRule(self, listener: ParseTreeListener): 

719 if hasattr(listener, "exitAlias"): 

720 listener.exitAlias(self) 

721 

722 def alias(self): 

723 

724 localctx = PigParser.AliasContext(self, self._ctx, self.state) 

725 self.enterRule(localctx, 6, self.RULE_alias) 

726 try: 

727 self.enterOuterAlt(localctx, 1) 

728 self.state = 138 

729 self.match(PigParser.IDENTIFIER) 

730 except RecognitionException as re: 

731 localctx.exception = re 

732 self._errHandler.reportError(self, re) 

733 self._errHandler.recover(self, re) 

734 finally: 

735 self.exitRule() 

736 return localctx 

737 

738 class Op_clauseContext(ParserRuleContext): 

739 

740 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

741 super().__init__(parent, invokingState) 

742 self.parser = parser 

743 

744 def load_clause(self): 

745 return self.getTypedRuleContext(PigParser.Load_clauseContext, 0) 

746 

747 def store_clause(self): 

748 return self.getTypedRuleContext(PigParser.Store_clauseContext, 0) 

749 

750 def filter_clause(self): 

751 return self.getTypedRuleContext(PigParser.Filter_clauseContext, 0) 

752 

753 def distinct_clause(self): 

754 return self.getTypedRuleContext(PigParser.Distinct_clauseContext, 0) 

755 

756 def getRuleIndex(self): 

757 return PigParser.RULE_op_clause 

758 

759 def enterRule(self, listener: ParseTreeListener): 

760 if hasattr(listener, "enterOp_clause"): 

761 listener.enterOp_clause(self) 

762 

763 def exitRule(self, listener: ParseTreeListener): 

764 if hasattr(listener, "exitOp_clause"): 

765 listener.exitOp_clause(self) 

766 

767 def op_clause(self): 

768 

769 localctx = PigParser.Op_clauseContext(self, self._ctx, self.state) 

770 self.enterRule(localctx, 8, self.RULE_op_clause) 

771 try: 

772 self.state = 144 

773 self._errHandler.sync(self) 

774 token = self._input.LA(1) 

775 if token in [PigParser.LOAD]: 

776 self.enterOuterAlt(localctx, 1) 

777 self.state = 140 

778 self.load_clause() 

779 pass 

780 elif token in [PigParser.STORE]: 

781 self.enterOuterAlt(localctx, 2) 

782 self.state = 141 

783 self.store_clause() 

784 pass 

785 elif token in [PigParser.FILTER]: 

786 self.enterOuterAlt(localctx, 3) 

787 self.state = 142 

788 self.filter_clause() 

789 pass 

790 elif token in [PigParser.DISTINCT]: 

791 self.enterOuterAlt(localctx, 4) 

792 self.state = 143 

793 self.distinct_clause() 

794 pass 

795 else: 

796 raise NoViableAltException(self) 

797 

798 except RecognitionException as re: 

799 localctx.exception = re 

800 self._errHandler.reportError(self, re) 

801 self._errHandler.recover(self, re) 

802 finally: 

803 self.exitRule() 

804 return localctx 

805 

806 class Load_clauseContext(ParserRuleContext): 

807 

808 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

809 super().__init__(parent, invokingState) 

810 self.parser = parser 

811 

812 def LOAD(self): 

813 return self.getToken(PigParser.LOAD, 0) 

814 

815 def filename(self): 

816 return self.getTypedRuleContext(PigParser.FilenameContext, 0) 

817 

818 def USING(self): 

819 return self.getToken(PigParser.USING, 0) 

820 

821 def func_clause(self): 

822 return self.getTypedRuleContext(PigParser.Func_clauseContext, 0) 

823 

824 def as_clause(self): 

825 return self.getTypedRuleContext(PigParser.As_clauseContext, 0) 

826 

827 def getRuleIndex(self): 

828 return PigParser.RULE_load_clause 

829 

830 def enterRule(self, listener: ParseTreeListener): 

831 if hasattr(listener, "enterLoad_clause"): 

832 listener.enterLoad_clause(self) 

833 

834 def exitRule(self, listener: ParseTreeListener): 

835 if hasattr(listener, "exitLoad_clause"): 

836 listener.exitLoad_clause(self) 

837 

838 def load_clause(self): 

839 

840 localctx = PigParser.Load_clauseContext(self, self._ctx, self.state) 

841 self.enterRule(localctx, 10, self.RULE_load_clause) 

842 try: 

843 self.enterOuterAlt(localctx, 1) 

844 self.state = 146 

845 self.match(PigParser.LOAD) 

846 self.state = 147 

847 self.filename() 

848 self.state = 150 

849 self._errHandler.sync(self) 

850 la_ = self._interp.adaptivePredict(self._input, 7, self._ctx) 

851 if la_ == 1: 

852 self.state = 148 

853 self.match(PigParser.USING) 

854 self.state = 149 

855 self.func_clause() 

856 

857 self.state = 153 

858 self._errHandler.sync(self) 

859 la_ = self._interp.adaptivePredict(self._input, 8, self._ctx) 

860 if la_ == 1: 

861 self.state = 152 

862 self.as_clause() 

863 

864 except RecognitionException as re: 

865 localctx.exception = re 

866 self._errHandler.reportError(self, re) 

867 self._errHandler.recover(self, re) 

868 finally: 

869 self.exitRule() 

870 return localctx 

871 

872 class FilenameContext(ParserRuleContext): 

873 

874 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

875 super().__init__(parent, invokingState) 

876 self.parser = parser 

877 

878 def QUOTEDSTRING(self): 

879 return self.getToken(PigParser.QUOTEDSTRING, 0) 

880 

881 def getRuleIndex(self): 

882 return PigParser.RULE_filename 

883 

884 def enterRule(self, listener: ParseTreeListener): 

885 if hasattr(listener, "enterFilename"): 

886 listener.enterFilename(self) 

887 

888 def exitRule(self, listener: ParseTreeListener): 

889 if hasattr(listener, "exitFilename"): 

890 listener.exitFilename(self) 

891 

892 def filename(self): 

893 

894 localctx = PigParser.FilenameContext(self, self._ctx, self.state) 

895 self.enterRule(localctx, 12, self.RULE_filename) 

896 try: 

897 self.enterOuterAlt(localctx, 1) 

898 self.state = 155 

899 self.match(PigParser.QUOTEDSTRING) 

900 except RecognitionException as re: 

901 localctx.exception = re 

902 self._errHandler.reportError(self, re) 

903 self._errHandler.recover(self, re) 

904 finally: 

905 self.exitRule() 

906 return localctx 

907 

908 class As_clauseContext(ParserRuleContext): 

909 

910 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

911 super().__init__(parent, invokingState) 

912 self.parser = parser 

913 

914 def AS(self): 

915 return self.getToken(PigParser.AS, 0) 

916 

917 def tuple_def(self): 

918 return self.getTypedRuleContext(PigParser.Tuple_defContext, 0) 

919 

920 def getRuleIndex(self): 

921 return PigParser.RULE_as_clause 

922 

923 def enterRule(self, listener: ParseTreeListener): 

924 if hasattr(listener, "enterAs_clause"): 

925 listener.enterAs_clause(self) 

926 

927 def exitRule(self, listener: ParseTreeListener): 

928 if hasattr(listener, "exitAs_clause"): 

929 listener.exitAs_clause(self) 

930 

931 def as_clause(self): 

932 

933 localctx = PigParser.As_clauseContext(self, self._ctx, self.state) 

934 self.enterRule(localctx, 14, self.RULE_as_clause) 

935 try: 

936 self.enterOuterAlt(localctx, 1) 

937 self.state = 157 

938 self.match(PigParser.AS) 

939 self.state = 158 

940 self.tuple_def() 

941 except RecognitionException as re: 

942 localctx.exception = re 

943 self._errHandler.reportError(self, re) 

944 self._errHandler.recover(self, re) 

945 finally: 

946 self.exitRule() 

947 return localctx 

948 

949 class Tuple_defContext(ParserRuleContext): 

950 

951 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

952 super().__init__(parent, invokingState) 

953 self.parser = parser 

954 

955 def LEFT_PAREN(self): 

956 return self.getToken(PigParser.LEFT_PAREN, 0) 

957 

958 def field(self, i: int = None): 

959 if i is None: 

960 return self.getTypedRuleContexts(PigParser.FieldContext) 

961 else: 

962 return self.getTypedRuleContext(PigParser.FieldContext, i) 

963 

964 def RIGHT_PAREN(self): 

965 return self.getToken(PigParser.RIGHT_PAREN, 0) 

966 

967 def COMMA(self, i: int = None): 

968 if i is None: 

969 return self.getTokens(PigParser.COMMA) 

970 else: 

971 return self.getToken(PigParser.COMMA, i) 

972 

973 def NOT(self): 

974 return self.getToken(PigParser.NOT, 0) 

975 

976 def tuple_def(self): 

977 return self.getTypedRuleContext(PigParser.Tuple_defContext, 0) 

978 

979 def getRuleIndex(self): 

980 return PigParser.RULE_tuple_def 

981 

982 def enterRule(self, listener: ParseTreeListener): 

983 if hasattr(listener, "enterTuple_def"): 

984 listener.enterTuple_def(self) 

985 

986 def exitRule(self, listener: ParseTreeListener): 

987 if hasattr(listener, "exitTuple_def"): 

988 listener.exitTuple_def(self) 

989 

990 def tuple_def(self): 

991 

992 localctx = PigParser.Tuple_defContext(self, self._ctx, self.state) 

993 self.enterRule(localctx, 16, self.RULE_tuple_def) 

994 self._la = 0 # Token type 

995 try: 

996 self.state = 178 

997 self._errHandler.sync(self) 

998 token = self._input.LA(1) 

999 if token in [PigParser.LEFT_PAREN]: 

1000 self.enterOuterAlt(localctx, 1) 

1001 self.state = 160 

1002 self.match(PigParser.LEFT_PAREN) 

1003 self.state = 161 

1004 self.field() 

1005 self.state = 166 

1006 self._errHandler.sync(self) 

1007 _la = self._input.LA(1) 

1008 while _la == PigParser.COMMA: 

1009 self.state = 162 

1010 self.match(PigParser.COMMA) 

1011 self.state = 163 

1012 self.field() 

1013 self.state = 168 

1014 self._errHandler.sync(self) 

1015 _la = self._input.LA(1) 

1016 

1017 self.state = 169 

1018 self.match(PigParser.RIGHT_PAREN) 

1019 pass 

1020 elif token in [PigParser.NOT]: 

1021 self.enterOuterAlt(localctx, 2) 

1022 self.state = 171 

1023 self.match(PigParser.NOT) 

1024 

1025 self.state = 172 

1026 self.tuple_def() 

1027 self.state = 174 

1028 self._errHandler.sync(self) 

1029 _alt = 1 

1030 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: 

1031 if _alt == 1: 

1032 self.state = 173 

1033 self.field() 

1034 

1035 else: 

1036 raise NoViableAltException(self) 

1037 self.state = 176 

1038 self._errHandler.sync(self) 

1039 _alt = self._interp.adaptivePredict( 

1040 self._input, 10, self._ctx) 

1041 

1042 pass 

1043 else: 

1044 raise NoViableAltException(self) 

1045 

1046 except RecognitionException as re: 

1047 localctx.exception = re 

1048 self._errHandler.reportError(self, re) 

1049 self._errHandler.recover(self, re) 

1050 finally: 

1051 self.exitRule() 

1052 return localctx 

1053 

1054 class FieldContext(ParserRuleContext): 

1055 

1056 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

1057 super().__init__(parent, invokingState) 

1058 self.parser = parser 

1059 

1060 def IDENTIFIER(self): 

1061 return self.getToken(PigParser.IDENTIFIER, 0) 

1062 

1063 def COLON(self): 

1064 return self.getToken(PigParser.COLON, 0) 

1065 

1066 def type_(self): 

1067 return self.getTypedRuleContext(PigParser.Type_Context, 0) 

1068 

1069 def NOT(self): 

1070 return self.getToken(PigParser.NOT, 0) 

1071 

1072 def field(self): 

1073 return self.getTypedRuleContext(PigParser.FieldContext, 0) 

1074 

1075 def getRuleIndex(self): 

1076 return PigParser.RULE_field 

1077 

1078 def enterRule(self, listener: ParseTreeListener): 

1079 if hasattr(listener, "enterField"): 

1080 listener.enterField(self) 

1081 

1082 def exitRule(self, listener: ParseTreeListener): 

1083 if hasattr(listener, "exitField"): 

1084 listener.exitField(self) 

1085 

1086 def field(self): 

1087 

1088 localctx = PigParser.FieldContext(self, self._ctx, self.state) 

1089 self.enterRule(localctx, 18, self.RULE_field) 

1090 try: 

1091 self.state = 191 

1092 self._errHandler.sync(self) 

1093 token = self._input.LA(1) 

1094 if token in [PigParser.IDENTIFIER]: 

1095 self.enterOuterAlt(localctx, 1) 

1096 self.state = 180 

1097 self.match(PigParser.IDENTIFIER) 

1098 self.state = 183 

1099 self._errHandler.sync(self) 

1100 la_ = self._interp.adaptivePredict(self._input, 12, self._ctx) 

1101 if la_ == 1: 

1102 self.state = 181 

1103 self.match(PigParser.COLON) 

1104 self.state = 182 

1105 self.type_() 

1106 

1107 pass 

1108 elif token in [PigParser.NOT]: 

1109 self.enterOuterAlt(localctx, 2) 

1110 self.state = 185 

1111 self.match(PigParser.NOT) 

1112 

1113 self.state = 186 

1114 self.field() 

1115 self.state = 187 

1116 self.match(PigParser.IDENTIFIER) 

1117 self.state = 189 

1118 self._errHandler.sync(self) 

1119 la_ = self._interp.adaptivePredict(self._input, 13, self._ctx) 

1120 if la_ == 1: 

1121 self.state = 188 

1122 self.type_() 

1123 

1124 pass 

1125 else: 

1126 raise NoViableAltException(self) 

1127 

1128 except RecognitionException as re: 

1129 localctx.exception = re 

1130 self._errHandler.reportError(self, re) 

1131 self._errHandler.recover(self, re) 

1132 finally: 

1133 self.exitRule() 

1134 return localctx 

1135 

1136 class Type_Context(ParserRuleContext): 

1137 

1138 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

1139 super().__init__(parent, invokingState) 

1140 self.parser = parser 

1141 

1142 def simple_type(self): 

1143 return self.getTypedRuleContext(PigParser.Simple_typeContext, 0) 

1144 

1145 def tuple_type(self): 

1146 return self.getTypedRuleContext(PigParser.Tuple_typeContext, 0) 

1147 

1148 def bag_type(self): 

1149 return self.getTypedRuleContext(PigParser.Bag_typeContext, 0) 

1150 

1151 def map_type(self): 

1152 return self.getTypedRuleContext(PigParser.Map_typeContext, 0) 

1153 

1154 def getRuleIndex(self): 

1155 return PigParser.RULE_type_ 

1156 

1157 def enterRule(self, listener: ParseTreeListener): 

1158 if hasattr(listener, "enterType_"): 

1159 listener.enterType_(self) 

1160 

1161 def exitRule(self, listener: ParseTreeListener): 

1162 if hasattr(listener, "exitType_"): 

1163 listener.exitType_(self) 

1164 

1165 def type_(self): 

1166 

1167 localctx = PigParser.Type_Context(self, self._ctx, self.state) 

1168 self.enterRule(localctx, 20, self.RULE_type_) 

1169 try: 

1170 self.state = 197 

1171 self._errHandler.sync(self) 

1172 token = self._input.LA(1) 

1173 if token in [PigParser.INT, PigParser.LONG, PigParser.FLOAT, PigParser.DOUBLE, PigParser.CHARARRAY, PigParser.BYTEARRAY]: 

1174 self.enterOuterAlt(localctx, 1) 

1175 self.state = 193 

1176 self.simple_type() 

1177 pass 

1178 elif token in [PigParser.NOT, PigParser.LEFT_PAREN]: 

1179 self.enterOuterAlt(localctx, 2) 

1180 self.state = 194 

1181 self.tuple_type() 

1182 pass 

1183 elif token in [PigParser.BAG]: 

1184 self.enterOuterAlt(localctx, 3) 

1185 self.state = 195 

1186 self.bag_type() 

1187 pass 

1188 elif token in [PigParser.MAP]: 

1189 self.enterOuterAlt(localctx, 4) 

1190 self.state = 196 

1191 self.map_type() 

1192 pass 

1193 else: 

1194 raise NoViableAltException(self) 

1195 

1196 except RecognitionException as re: 

1197 localctx.exception = re 

1198 self._errHandler.reportError(self, re) 

1199 self._errHandler.recover(self, re) 

1200 finally: 

1201 self.exitRule() 

1202 return localctx 

1203 

1204 class Simple_typeContext(ParserRuleContext): 

1205 

1206 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

1207 super().__init__(parent, invokingState) 

1208 self.parser = parser 

1209 

1210 def INT(self): 

1211 return self.getToken(PigParser.INT, 0) 

1212 

1213 def LONG(self): 

1214 return self.getToken(PigParser.LONG, 0) 

1215 

1216 def FLOAT(self): 

1217 return self.getToken(PigParser.FLOAT, 0) 

1218 

1219 def DOUBLE(self): 

1220 return self.getToken(PigParser.DOUBLE, 0) 

1221 

1222 def CHARARRAY(self): 

1223 return self.getToken(PigParser.CHARARRAY, 0) 

1224 

1225 def BYTEARRAY(self): 

1226 return self.getToken(PigParser.BYTEARRAY, 0) 

1227 

1228 def getRuleIndex(self): 

1229 return PigParser.RULE_simple_type 

1230 

1231 def enterRule(self, listener: ParseTreeListener): 

1232 if hasattr(listener, "enterSimple_type"): 

1233 listener.enterSimple_type(self) 

1234 

1235 def exitRule(self, listener: ParseTreeListener): 

1236 if hasattr(listener, "exitSimple_type"): 

1237 listener.exitSimple_type(self) 

1238 

1239 def simple_type(self): 

1240 

1241 localctx = PigParser.Simple_typeContext(self, self._ctx, self.state) 

1242 self.enterRule(localctx, 22, self.RULE_simple_type) 

1243 self._la = 0 # Token type 

1244 try: 

1245 self.enterOuterAlt(localctx, 1) 

1246 self.state = 199 

1247 _la = self._input.LA(1) 

1248 if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << PigParser.INT) | (1 << PigParser.LONG) | (1 << PigParser.FLOAT) | (1 << PigParser.DOUBLE) | (1 << PigParser.CHARARRAY) | (1 << PigParser.BYTEARRAY))) != 0)): 

1249 self._errHandler.recoverInline(self) 

1250 else: 

1251 self._errHandler.reportMatch(self) 

1252 self.consume() 

1253 except RecognitionException as re: 

1254 localctx.exception = re 

1255 self._errHandler.reportError(self, re) 

1256 self._errHandler.recover(self, re) 

1257 finally: 

1258 self.exitRule() 

1259 return localctx 

1260 

1261 class Tuple_typeContext(ParserRuleContext): 

1262 

1263 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

1264 super().__init__(parent, invokingState) 

1265 self.parser = parser 

1266 

1267 def tuple_(self): 

1268 return self.getTypedRuleContext(PigParser.Tuple_Context, 0) 

1269 

1270 def tuple_def(self): 

1271 return self.getTypedRuleContext(PigParser.Tuple_defContext, 0) 

1272 

1273 def getRuleIndex(self): 

1274 return PigParser.RULE_tuple_type 

1275 

1276 def enterRule(self, listener: ParseTreeListener): 

1277 if hasattr(listener, "enterTuple_type"): 

1278 listener.enterTuple_type(self) 

1279 

1280 def exitRule(self, listener: ParseTreeListener): 

1281 if hasattr(listener, "exitTuple_type"): 

1282 listener.exitTuple_type(self) 

1283 

1284 def tuple_type(self): 

1285 

1286 localctx = PigParser.Tuple_typeContext(self, self._ctx, self.state) 

1287 self.enterRule(localctx, 24, self.RULE_tuple_type) 

1288 try: 

1289 self.enterOuterAlt(localctx, 1) 

1290 self.state = 201 

1291 self.tuple_() 

1292 self.state = 202 

1293 self.tuple_def() 

1294 except RecognitionException as re: 

1295 localctx.exception = re 

1296 self._errHandler.reportError(self, re) 

1297 self._errHandler.recover(self, re) 

1298 finally: 

1299 self.exitRule() 

1300 return localctx 

1301 

1302 class Bag_typeContext(ParserRuleContext): 

1303 

1304 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

1305 super().__init__(parent, invokingState) 

1306 self.parser = parser 

1307 

1308 def BAG(self): 

1309 return self.getToken(PigParser.BAG, 0) 

1310 

1311 def tuple_def(self): 

1312 return self.getTypedRuleContext(PigParser.Tuple_defContext, 0) 

1313 

1314 def getRuleIndex(self): 

1315 return PigParser.RULE_bag_type 

1316 

1317 def enterRule(self, listener: ParseTreeListener): 

1318 if hasattr(listener, "enterBag_type"): 

1319 listener.enterBag_type(self) 

1320 

1321 def exitRule(self, listener: ParseTreeListener): 

1322 if hasattr(listener, "exitBag_type"): 

1323 listener.exitBag_type(self) 

1324 

1325 def bag_type(self): 

1326 

1327 localctx = PigParser.Bag_typeContext(self, self._ctx, self.state) 

1328 self.enterRule(localctx, 26, self.RULE_bag_type) 

1329 try: 

1330 self.enterOuterAlt(localctx, 1) 

1331 self.state = 204 

1332 self.match(PigParser.BAG) 

1333 self.state = 205 

1334 self.tuple_def() 

1335 except RecognitionException as re: 

1336 localctx.exception = re 

1337 self._errHandler.reportError(self, re) 

1338 self._errHandler.recover(self, re) 

1339 finally: 

1340 self.exitRule() 

1341 return localctx 

1342 

1343 class Map_typeContext(ParserRuleContext): 

1344 

1345 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

1346 super().__init__(parent, invokingState) 

1347 self.parser = parser 

1348 

1349 def MAP(self): 

1350 return self.getToken(PigParser.MAP, 0) 

1351 

1352 def LEFT_BRACKET(self): 

1353 return self.getToken(PigParser.LEFT_BRACKET, 0) 

1354 

1355 def RIGHT_BRACKET(self): 

1356 return self.getToken(PigParser.RIGHT_BRACKET, 0) 

1357 

1358 def getRuleIndex(self): 

1359 return PigParser.RULE_map_type 

1360 

1361 def enterRule(self, listener: ParseTreeListener): 

1362 if hasattr(listener, "enterMap_type"): 

1363 listener.enterMap_type(self) 

1364 

1365 def exitRule(self, listener: ParseTreeListener): 

1366 if hasattr(listener, "exitMap_type"): 

1367 listener.exitMap_type(self) 

1368 

1369 def map_type(self): 

1370 

1371 localctx = PigParser.Map_typeContext(self, self._ctx, self.state) 

1372 self.enterRule(localctx, 28, self.RULE_map_type) 

1373 try: 

1374 self.enterOuterAlt(localctx, 1) 

1375 self.state = 207 

1376 self.match(PigParser.MAP) 

1377 self.state = 208 

1378 self.match(PigParser.LEFT_BRACKET) 

1379 self.state = 209 

1380 self.match(PigParser.RIGHT_BRACKET) 

1381 except RecognitionException as re: 

1382 localctx.exception = re 

1383 self._errHandler.reportError(self, re) 

1384 self._errHandler.recover(self, re) 

1385 finally: 

1386 self.exitRule() 

1387 return localctx 

1388 

1389 class Func_clauseContext(ParserRuleContext): 

1390 

1391 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

1392 super().__init__(parent, invokingState) 

1393 self.parser = parser 

1394 

1395 def func_name(self): 

1396 return self.getTypedRuleContext(PigParser.Func_nameContext, 0) 

1397 

1398 def LEFT_PAREN(self): 

1399 return self.getToken(PigParser.LEFT_PAREN, 0) 

1400 

1401 def RIGHT_PAREN(self): 

1402 return self.getToken(PigParser.RIGHT_PAREN, 0) 

1403 

1404 def func_args(self): 

1405 return self.getTypedRuleContext(PigParser.Func_argsContext, 0) 

1406 

1407 def NOT(self): 

1408 return self.getToken(PigParser.NOT, 0) 

1409 

1410 def FUNC(self): 

1411 return self.getToken(PigParser.FUNC, 0) 

1412 

1413 def getRuleIndex(self): 

1414 return PigParser.RULE_func_clause 

1415 

1416 def enterRule(self, listener: ParseTreeListener): 

1417 if hasattr(listener, "enterFunc_clause"): 

1418 listener.enterFunc_clause(self) 

1419 

1420 def exitRule(self, listener: ParseTreeListener): 

1421 if hasattr(listener, "exitFunc_clause"): 

1422 listener.exitFunc_clause(self) 

1423 

1424 def func_clause(self): 

1425 

1426 localctx = PigParser.Func_clauseContext(self, self._ctx, self.state) 

1427 self.enterRule(localctx, 30, self.RULE_func_clause) 

1428 self._la = 0 # Token type 

1429 try: 

1430 self.state = 224 

1431 self._errHandler.sync(self) 

1432 token = self._input.LA(1) 

1433 if token in [PigParser.IDENTIFIER]: 

1434 self.enterOuterAlt(localctx, 1) 

1435 self.state = 211 

1436 self.func_name() 

1437 self.state = 212 

1438 self.match(PigParser.LEFT_PAREN) 

1439 self.state = 214 

1440 self._errHandler.sync(self) 

1441 _la = self._input.LA(1) 

1442 if _la == PigParser.QUOTEDSTRING: 

1443 self.state = 213 

1444 self.func_args() 

1445 

1446 self.state = 216 

1447 self.match(PigParser.RIGHT_PAREN) 

1448 pass 

1449 elif token in [PigParser.NOT]: 

1450 self.enterOuterAlt(localctx, 2) 

1451 self.state = 218 

1452 self.match(PigParser.NOT) 

1453 

1454 self.state = 219 

1455 self.match(PigParser.FUNC) 

1456 self.state = 220 

1457 self.func_name() 

1458 self.state = 222 

1459 self._errHandler.sync(self) 

1460 la_ = self._interp.adaptivePredict(self._input, 17, self._ctx) 

1461 if la_ == 1: 

1462 self.state = 221 

1463 self.func_args() 

1464 

1465 pass 

1466 else: 

1467 raise NoViableAltException(self) 

1468 

1469 except RecognitionException as re: 

1470 localctx.exception = re 

1471 self._errHandler.reportError(self, re) 

1472 self._errHandler.recover(self, re) 

1473 finally: 

1474 self.exitRule() 

1475 return localctx 

1476 

1477 class Func_nameContext(ParserRuleContext): 

1478 

1479 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

1480 super().__init__(parent, invokingState) 

1481 self.parser = parser 

1482 

1483 def IDENTIFIER(self, i: int = None): 

1484 if i is None: 

1485 return self.getTokens(PigParser.IDENTIFIER) 

1486 else: 

1487 return self.getToken(PigParser.IDENTIFIER, i) 

1488 

1489 def PERIOD(self, i: int = None): 

1490 if i is None: 

1491 return self.getTokens(PigParser.PERIOD) 

1492 else: 

1493 return self.getToken(PigParser.PERIOD, i) 

1494 

1495 def getRuleIndex(self): 

1496 return PigParser.RULE_func_name 

1497 

1498 def enterRule(self, listener: ParseTreeListener): 

1499 if hasattr(listener, "enterFunc_name"): 

1500 listener.enterFunc_name(self) 

1501 

1502 def exitRule(self, listener: ParseTreeListener): 

1503 if hasattr(listener, "exitFunc_name"): 

1504 listener.exitFunc_name(self) 

1505 

1506 def func_name(self): 

1507 

1508 localctx = PigParser.Func_nameContext(self, self._ctx, self.state) 

1509 self.enterRule(localctx, 32, self.RULE_func_name) 

1510 try: 

1511 self.state = 239 

1512 self._errHandler.sync(self) 

1513 la_ = self._interp.adaptivePredict(self._input, 21, self._ctx) 

1514 if la_ == 1: 

1515 self.enterOuterAlt(localctx, 1) 

1516 self.state = 226 

1517 self.match(PigParser.IDENTIFIER) 

1518 self.state = 231 

1519 self._errHandler.sync(self) 

1520 _alt = self._interp.adaptivePredict(self._input, 19, self._ctx) 

1521 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: 

1522 if _alt == 1: 

1523 self.state = 227 

1524 self.match(PigParser.PERIOD) 

1525 self.state = 228 

1526 self.match(PigParser.IDENTIFIER) 

1527 self.state = 233 

1528 self._errHandler.sync(self) 

1529 _alt = self._interp.adaptivePredict( 

1530 self._input, 19, self._ctx) 

1531 

1532 pass 

1533 

1534 elif la_ == 2: 

1535 self.enterOuterAlt(localctx, 2) 

1536 self.state = 235 

1537 self._errHandler.sync(self) 

1538 _alt = 1 

1539 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: 

1540 if _alt == 1: 

1541 self.state = 234 

1542 self.match(PigParser.IDENTIFIER) 

1543 

1544 else: 

1545 raise NoViableAltException(self) 

1546 self.state = 237 

1547 self._errHandler.sync(self) 

1548 _alt = self._interp.adaptivePredict( 

1549 self._input, 20, self._ctx) 

1550 

1551 pass 

1552 

1553 except RecognitionException as re: 

1554 localctx.exception = re 

1555 self._errHandler.reportError(self, re) 

1556 self._errHandler.recover(self, re) 

1557 finally: 

1558 self.exitRule() 

1559 return localctx 

1560 

1561 class Func_argsContext(ParserRuleContext): 

1562 

1563 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

1564 super().__init__(parent, invokingState) 

1565 self.parser = parser 

1566 

1567 def QUOTEDSTRING(self, i: int = None): 

1568 if i is None: 

1569 return self.getTokens(PigParser.QUOTEDSTRING) 

1570 else: 

1571 return self.getToken(PigParser.QUOTEDSTRING, i) 

1572 

1573 def COMMA(self, i: int = None): 

1574 if i is None: 

1575 return self.getTokens(PigParser.COMMA) 

1576 else: 

1577 return self.getToken(PigParser.COMMA, i) 

1578 

1579 def getRuleIndex(self): 

1580 return PigParser.RULE_func_args 

1581 

1582 def enterRule(self, listener: ParseTreeListener): 

1583 if hasattr(listener, "enterFunc_args"): 

1584 listener.enterFunc_args(self) 

1585 

1586 def exitRule(self, listener: ParseTreeListener): 

1587 if hasattr(listener, "exitFunc_args"): 

1588 listener.exitFunc_args(self) 

1589 

1590 def func_args(self): 

1591 

1592 localctx = PigParser.Func_argsContext(self, self._ctx, self.state) 

1593 self.enterRule(localctx, 34, self.RULE_func_args) 

1594 try: 

1595 self.state = 254 

1596 self._errHandler.sync(self) 

1597 la_ = self._interp.adaptivePredict(self._input, 24, self._ctx) 

1598 if la_ == 1: 

1599 self.enterOuterAlt(localctx, 1) 

1600 self.state = 241 

1601 self.match(PigParser.QUOTEDSTRING) 

1602 self.state = 246 

1603 self._errHandler.sync(self) 

1604 _alt = self._interp.adaptivePredict(self._input, 22, self._ctx) 

1605 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: 

1606 if _alt == 1: 

1607 self.state = 242 

1608 self.match(PigParser.COMMA) 

1609 self.state = 243 

1610 self.match(PigParser.QUOTEDSTRING) 

1611 self.state = 248 

1612 self._errHandler.sync(self) 

1613 _alt = self._interp.adaptivePredict( 

1614 self._input, 22, self._ctx) 

1615 

1616 pass 

1617 

1618 elif la_ == 2: 

1619 self.enterOuterAlt(localctx, 2) 

1620 self.state = 250 

1621 self._errHandler.sync(self) 

1622 _alt = 1 

1623 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: 

1624 if _alt == 1: 

1625 self.state = 249 

1626 self.match(PigParser.QUOTEDSTRING) 

1627 

1628 else: 

1629 raise NoViableAltException(self) 

1630 self.state = 252 

1631 self._errHandler.sync(self) 

1632 _alt = self._interp.adaptivePredict( 

1633 self._input, 23, self._ctx) 

1634 

1635 pass 

1636 

1637 except RecognitionException as re: 

1638 localctx.exception = re 

1639 self._errHandler.reportError(self, re) 

1640 self._errHandler.recover(self, re) 

1641 finally: 

1642 self.exitRule() 

1643 return localctx 

1644 

1645 class Store_clauseContext(ParserRuleContext): 

1646 

1647 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

1648 super().__init__(parent, invokingState) 

1649 self.parser = parser 

1650 

1651 def STORE(self): 

1652 return self.getToken(PigParser.STORE, 0) 

1653 

1654 def alias(self): 

1655 return self.getTypedRuleContext(PigParser.AliasContext, 0) 

1656 

1657 def INTO(self): 

1658 return self.getToken(PigParser.INTO, 0) 

1659 

1660 def filename(self): 

1661 return self.getTypedRuleContext(PigParser.FilenameContext, 0) 

1662 

1663 def USING(self): 

1664 return self.getToken(PigParser.USING, 0) 

1665 

1666 def func_clause(self): 

1667 return self.getTypedRuleContext(PigParser.Func_clauseContext, 0) 

1668 

1669 def getRuleIndex(self): 

1670 return PigParser.RULE_store_clause 

1671 

1672 def enterRule(self, listener: ParseTreeListener): 

1673 if hasattr(listener, "enterStore_clause"): 

1674 listener.enterStore_clause(self) 

1675 

1676 def exitRule(self, listener: ParseTreeListener): 

1677 if hasattr(listener, "exitStore_clause"): 

1678 listener.exitStore_clause(self) 

1679 

1680 def store_clause(self): 

1681 

1682 localctx = PigParser.Store_clauseContext(self, self._ctx, self.state) 

1683 self.enterRule(localctx, 36, self.RULE_store_clause) 

1684 try: 

1685 self.enterOuterAlt(localctx, 1) 

1686 self.state = 256 

1687 self.match(PigParser.STORE) 

1688 self.state = 257 

1689 self.alias() 

1690 self.state = 258 

1691 self.match(PigParser.INTO) 

1692 self.state = 259 

1693 self.filename() 

1694 self.state = 262 

1695 self._errHandler.sync(self) 

1696 la_ = self._interp.adaptivePredict(self._input, 25, self._ctx) 

1697 if la_ == 1: 

1698 self.state = 260 

1699 self.match(PigParser.USING) 

1700 self.state = 261 

1701 self.func_clause() 

1702 

1703 except RecognitionException as re: 

1704 localctx.exception = re 

1705 self._errHandler.reportError(self, re) 

1706 self._errHandler.recover(self, re) 

1707 finally: 

1708 self.exitRule() 

1709 return localctx 

1710 

1711 class Filter_clauseContext(ParserRuleContext): 

1712 

1713 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

1714 super().__init__(parent, invokingState) 

1715 self.parser = parser 

1716 

1717 def FILTER(self): 

1718 return self.getToken(PigParser.FILTER, 0) 

1719 

1720 def alias(self): 

1721 return self.getTypedRuleContext(PigParser.AliasContext, 0) 

1722 

1723 def BY(self): 

1724 return self.getToken(PigParser.BY, 0) 

1725 

1726 def cond(self): 

1727 return self.getTypedRuleContext(PigParser.CondContext, 0) 

1728 

1729 def getRuleIndex(self): 

1730 return PigParser.RULE_filter_clause 

1731 

1732 def enterRule(self, listener: ParseTreeListener): 

1733 if hasattr(listener, "enterFilter_clause"): 

1734 listener.enterFilter_clause(self) 

1735 

1736 def exitRule(self, listener: ParseTreeListener): 

1737 if hasattr(listener, "exitFilter_clause"): 

1738 listener.exitFilter_clause(self) 

1739 

1740 def filter_clause(self): 

1741 

1742 localctx = PigParser.Filter_clauseContext(self, self._ctx, self.state) 

1743 self.enterRule(localctx, 38, self.RULE_filter_clause) 

1744 try: 

1745 self.enterOuterAlt(localctx, 1) 

1746 self.state = 264 

1747 self.match(PigParser.FILTER) 

1748 self.state = 265 

1749 self.alias() 

1750 self.state = 266 

1751 self.match(PigParser.BY) 

1752 self.state = 267 

1753 self.cond() 

1754 except RecognitionException as re: 

1755 localctx.exception = re 

1756 self._errHandler.reportError(self, re) 

1757 self._errHandler.recover(self, re) 

1758 finally: 

1759 self.exitRule() 

1760 return localctx 

1761 

1762 class CondContext(ParserRuleContext): 

1763 

1764 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

1765 super().__init__(parent, invokingState) 

1766 self.parser = parser 

1767 

1768 def or_cond(self): 

1769 return self.getTypedRuleContext(PigParser.Or_condContext, 0) 

1770 

1771 def getRuleIndex(self): 

1772 return PigParser.RULE_cond 

1773 

1774 def enterRule(self, listener: ParseTreeListener): 

1775 if hasattr(listener, "enterCond"): 

1776 listener.enterCond(self) 

1777 

1778 def exitRule(self, listener: ParseTreeListener): 

1779 if hasattr(listener, "exitCond"): 

1780 listener.exitCond(self) 

1781 

1782 def cond(self): 

1783 

1784 localctx = PigParser.CondContext(self, self._ctx, self.state) 

1785 self.enterRule(localctx, 40, self.RULE_cond) 

1786 try: 

1787 self.enterOuterAlt(localctx, 1) 

1788 self.state = 269 

1789 self.or_cond() 

1790 except RecognitionException as re: 

1791 localctx.exception = re 

1792 self._errHandler.reportError(self, re) 

1793 self._errHandler.recover(self, re) 

1794 finally: 

1795 self.exitRule() 

1796 return localctx 

1797 

1798 class Or_condContext(ParserRuleContext): 

1799 

1800 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

1801 super().__init__(parent, invokingState) 

1802 self.parser = parser 

1803 

1804 def and_cond(self, i: int = None): 

1805 if i is None: 

1806 return self.getTypedRuleContexts(PigParser.And_condContext) 

1807 else: 

1808 return self.getTypedRuleContext(PigParser.And_condContext, i) 

1809 

1810 def OR(self, i: int = None): 

1811 if i is None: 

1812 return self.getTokens(PigParser.OR) 

1813 else: 

1814 return self.getToken(PigParser.OR, i) 

1815 

1816 def getRuleIndex(self): 

1817 return PigParser.RULE_or_cond 

1818 

1819 def enterRule(self, listener: ParseTreeListener): 

1820 if hasattr(listener, "enterOr_cond"): 

1821 listener.enterOr_cond(self) 

1822 

1823 def exitRule(self, listener: ParseTreeListener): 

1824 if hasattr(listener, "exitOr_cond"): 

1825 listener.exitOr_cond(self) 

1826 

1827 def or_cond(self): 

1828 

1829 localctx = PigParser.Or_condContext(self, self._ctx, self.state) 

1830 self.enterRule(localctx, 42, self.RULE_or_cond) 

1831 try: 

1832 self.enterOuterAlt(localctx, 1) 

1833 self.state = 271 

1834 self.and_cond() 

1835 self.state = 276 

1836 self._errHandler.sync(self) 

1837 _alt = self._interp.adaptivePredict(self._input, 26, self._ctx) 

1838 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: 

1839 if _alt == 1: 

1840 self.state = 272 

1841 self.match(PigParser.OR) 

1842 self.state = 273 

1843 self.and_cond() 

1844 self.state = 278 

1845 self._errHandler.sync(self) 

1846 _alt = self._interp.adaptivePredict(self._input, 26, self._ctx) 

1847 

1848 except RecognitionException as re: 

1849 localctx.exception = re 

1850 self._errHandler.reportError(self, re) 

1851 self._errHandler.recover(self, re) 

1852 finally: 

1853 self.exitRule() 

1854 return localctx 

1855 

1856 class And_condContext(ParserRuleContext): 

1857 

1858 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

1859 super().__init__(parent, invokingState) 

1860 self.parser = parser 

1861 

1862 def unary_cond(self, i: int = None): 

1863 if i is None: 

1864 return self.getTypedRuleContexts(PigParser.Unary_condContext) 

1865 else: 

1866 return self.getTypedRuleContext(PigParser.Unary_condContext, i) 

1867 

1868 def AND(self, i: int = None): 

1869 if i is None: 

1870 return self.getTokens(PigParser.AND) 

1871 else: 

1872 return self.getToken(PigParser.AND, i) 

1873 

1874 def getRuleIndex(self): 

1875 return PigParser.RULE_and_cond 

1876 

1877 def enterRule(self, listener: ParseTreeListener): 

1878 if hasattr(listener, "enterAnd_cond"): 

1879 listener.enterAnd_cond(self) 

1880 

1881 def exitRule(self, listener: ParseTreeListener): 

1882 if hasattr(listener, "exitAnd_cond"): 

1883 listener.exitAnd_cond(self) 

1884 

1885 def and_cond(self): 

1886 

1887 localctx = PigParser.And_condContext(self, self._ctx, self.state) 

1888 self.enterRule(localctx, 44, self.RULE_and_cond) 

1889 try: 

1890 self.enterOuterAlt(localctx, 1) 

1891 self.state = 279 

1892 self.unary_cond() 

1893 self.state = 284 

1894 self._errHandler.sync(self) 

1895 _alt = self._interp.adaptivePredict(self._input, 27, self._ctx) 

1896 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: 

1897 if _alt == 1: 

1898 self.state = 280 

1899 self.match(PigParser.AND) 

1900 self.state = 281 

1901 self.unary_cond() 

1902 self.state = 286 

1903 self._errHandler.sync(self) 

1904 _alt = self._interp.adaptivePredict(self._input, 27, self._ctx) 

1905 

1906 except RecognitionException as re: 

1907 localctx.exception = re 

1908 self._errHandler.reportError(self, re) 

1909 self._errHandler.recover(self, re) 

1910 finally: 

1911 self.exitRule() 

1912 return localctx 

1913 

1914 class Unary_condContext(ParserRuleContext): 

1915 

1916 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

1917 super().__init__(parent, invokingState) 

1918 self.parser = parser 

1919 

1920 def LEFT_PAREN(self): 

1921 return self.getToken(PigParser.LEFT_PAREN, 0) 

1922 

1923 def cond(self): 

1924 return self.getTypedRuleContext(PigParser.CondContext, 0) 

1925 

1926 def RIGHT_PAREN(self): 

1927 return self.getToken(PigParser.RIGHT_PAREN, 0) 

1928 

1929 def expr(self, i: int = None): 

1930 if i is None: 

1931 return self.getTypedRuleContexts(PigParser.ExprContext) 

1932 else: 

1933 return self.getTypedRuleContext(PigParser.ExprContext, i) 

1934 

1935 def FILTEROP(self): 

1936 return self.getToken(PigParser.FILTEROP, 0) 

1937 

1938 def func_clause(self): 

1939 return self.getTypedRuleContext(PigParser.Func_clauseContext, 0) 

1940 

1941 def null_check_cond(self): 

1942 return self.getTypedRuleContext(PigParser.Null_check_condContext, 0) 

1943 

1944 def not_cond(self): 

1945 return self.getTypedRuleContext(PigParser.Not_condContext, 0) 

1946 

1947 def getRuleIndex(self): 

1948 return PigParser.RULE_unary_cond 

1949 

1950 def enterRule(self, listener: ParseTreeListener): 

1951 if hasattr(listener, "enterUnary_cond"): 

1952 listener.enterUnary_cond(self) 

1953 

1954 def exitRule(self, listener: ParseTreeListener): 

1955 if hasattr(listener, "exitUnary_cond"): 

1956 listener.exitUnary_cond(self) 

1957 

1958 def unary_cond(self): 

1959 

1960 localctx = PigParser.Unary_condContext(self, self._ctx, self.state) 

1961 self.enterRule(localctx, 46, self.RULE_unary_cond) 

1962 try: 

1963 self.state = 298 

1964 self._errHandler.sync(self) 

1965 la_ = self._interp.adaptivePredict(self._input, 28, self._ctx) 

1966 if la_ == 1: 

1967 self.enterOuterAlt(localctx, 1) 

1968 self.state = 287 

1969 self.match(PigParser.LEFT_PAREN) 

1970 self.state = 288 

1971 self.cond() 

1972 self.state = 289 

1973 self.match(PigParser.RIGHT_PAREN) 

1974 pass 

1975 

1976 elif la_ == 2: 

1977 self.enterOuterAlt(localctx, 2) 

1978 self.state = 291 

1979 self.expr() 

1980 self.state = 292 

1981 self.match(PigParser.FILTEROP) 

1982 self.state = 293 

1983 self.expr() 

1984 pass 

1985 

1986 elif la_ == 3: 

1987 self.enterOuterAlt(localctx, 3) 

1988 self.state = 295 

1989 self.func_clause() 

1990 pass 

1991 

1992 elif la_ == 4: 

1993 self.enterOuterAlt(localctx, 4) 

1994 self.state = 296 

1995 self.null_check_cond() 

1996 pass 

1997 

1998 elif la_ == 5: 

1999 self.enterOuterAlt(localctx, 5) 

2000 self.state = 297 

2001 self.not_cond() 

2002 pass 

2003 

2004 except RecognitionException as re: 

2005 localctx.exception = re 

2006 self._errHandler.reportError(self, re) 

2007 self._errHandler.recover(self, re) 

2008 finally: 

2009 self.exitRule() 

2010 return localctx 

2011 

2012 class Not_condContext(ParserRuleContext): 

2013 

2014 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

2015 super().__init__(parent, invokingState) 

2016 self.parser = parser 

2017 

2018 def NOT(self): 

2019 return self.getToken(PigParser.NOT, 0) 

2020 

2021 def unary_cond(self): 

2022 return self.getTypedRuleContext(PigParser.Unary_condContext, 0) 

2023 

2024 def getRuleIndex(self): 

2025 return PigParser.RULE_not_cond 

2026 

2027 def enterRule(self, listener: ParseTreeListener): 

2028 if hasattr(listener, "enterNot_cond"): 

2029 listener.enterNot_cond(self) 

2030 

2031 def exitRule(self, listener: ParseTreeListener): 

2032 if hasattr(listener, "exitNot_cond"): 

2033 listener.exitNot_cond(self) 

2034 

2035 def not_cond(self): 

2036 

2037 localctx = PigParser.Not_condContext(self, self._ctx, self.state) 

2038 self.enterRule(localctx, 48, self.RULE_not_cond) 

2039 try: 

2040 self.enterOuterAlt(localctx, 1) 

2041 self.state = 300 

2042 self.match(PigParser.NOT) 

2043 self.state = 301 

2044 self.unary_cond() 

2045 except RecognitionException as re: 

2046 localctx.exception = re 

2047 self._errHandler.reportError(self, re) 

2048 self._errHandler.recover(self, re) 

2049 finally: 

2050 self.exitRule() 

2051 return localctx 

2052 

2053 class Null_check_condContext(ParserRuleContext): 

2054 

2055 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

2056 super().__init__(parent, invokingState) 

2057 self.parser = parser 

2058 

2059 def expr(self): 

2060 return self.getTypedRuleContext(PigParser.ExprContext, 0) 

2061 

2062 def IS(self): 

2063 return self.getToken(PigParser.IS, 0) 

2064 

2065 def NULL(self): 

2066 return self.getToken(PigParser.NULL, 0) 

2067 

2068 def NOT(self): 

2069 return self.getToken(PigParser.NOT, 0) 

2070 

2071 def getRuleIndex(self): 

2072 return PigParser.RULE_null_check_cond 

2073 

2074 def enterRule(self, listener: ParseTreeListener): 

2075 if hasattr(listener, "enterNull_check_cond"): 

2076 listener.enterNull_check_cond(self) 

2077 

2078 def exitRule(self, listener: ParseTreeListener): 

2079 if hasattr(listener, "exitNull_check_cond"): 

2080 listener.exitNull_check_cond(self) 

2081 

2082 def null_check_cond(self): 

2083 

2084 localctx = PigParser.Null_check_condContext( 

2085 self, self._ctx, self.state) 

2086 self.enterRule(localctx, 50, self.RULE_null_check_cond) 

2087 self._la = 0 # Token type 

2088 try: 

2089 self.enterOuterAlt(localctx, 1) 

2090 self.state = 303 

2091 self.expr() 

2092 self.state = 304 

2093 self.match(PigParser.IS) 

2094 self.state = 306 

2095 self._errHandler.sync(self) 

2096 _la = self._input.LA(1) 

2097 if _la == PigParser.NOT: 

2098 self.state = 305 

2099 self.match(PigParser.NOT) 

2100 

2101 self.state = 308 

2102 self.match(PigParser.NULL) 

2103 except RecognitionException as re: 

2104 localctx.exception = re 

2105 self._errHandler.reportError(self, re) 

2106 self._errHandler.recover(self, re) 

2107 finally: 

2108 self.exitRule() 

2109 return localctx 

2110 

2111 class ExprContext(ParserRuleContext): 

2112 

2113 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

2114 super().__init__(parent, invokingState) 

2115 self.parser = parser 

2116 

2117 def add_expr(self): 

2118 return self.getTypedRuleContext(PigParser.Add_exprContext, 0) 

2119 

2120 def getRuleIndex(self): 

2121 return PigParser.RULE_expr 

2122 

2123 def enterRule(self, listener: ParseTreeListener): 

2124 if hasattr(listener, "enterExpr"): 

2125 listener.enterExpr(self) 

2126 

2127 def exitRule(self, listener: ParseTreeListener): 

2128 if hasattr(listener, "exitExpr"): 

2129 listener.exitExpr(self) 

2130 

2131 def expr(self): 

2132 

2133 localctx = PigParser.ExprContext(self, self._ctx, self.state) 

2134 self.enterRule(localctx, 52, self.RULE_expr) 

2135 try: 

2136 self.enterOuterAlt(localctx, 1) 

2137 self.state = 310 

2138 self.add_expr() 

2139 except RecognitionException as re: 

2140 localctx.exception = re 

2141 self._errHandler.reportError(self, re) 

2142 self._errHandler.recover(self, re) 

2143 finally: 

2144 self.exitRule() 

2145 return localctx 

2146 

2147 class Add_exprContext(ParserRuleContext): 

2148 

2149 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

2150 super().__init__(parent, invokingState) 

2151 self.parser = parser 

2152 

2153 def multi_expr(self, i: int = None): 

2154 if i is None: 

2155 return self.getTypedRuleContexts(PigParser.Multi_exprContext) 

2156 else: 

2157 return self.getTypedRuleContext(PigParser.Multi_exprContext, i) 

2158 

2159 def PLUS(self, i: int = None): 

2160 if i is None: 

2161 return self.getTokens(PigParser.PLUS) 

2162 else: 

2163 return self.getToken(PigParser.PLUS, i) 

2164 

2165 def MINUS(self, i: int = None): 

2166 if i is None: 

2167 return self.getTokens(PigParser.MINUS) 

2168 else: 

2169 return self.getToken(PigParser.MINUS, i) 

2170 

2171 def getRuleIndex(self): 

2172 return PigParser.RULE_add_expr 

2173 

2174 def enterRule(self, listener: ParseTreeListener): 

2175 if hasattr(listener, "enterAdd_expr"): 

2176 listener.enterAdd_expr(self) 

2177 

2178 def exitRule(self, listener: ParseTreeListener): 

2179 if hasattr(listener, "exitAdd_expr"): 

2180 listener.exitAdd_expr(self) 

2181 

2182 def add_expr(self): 

2183 

2184 localctx = PigParser.Add_exprContext(self, self._ctx, self.state) 

2185 self.enterRule(localctx, 54, self.RULE_add_expr) 

2186 self._la = 0 # Token type 

2187 try: 

2188 self.enterOuterAlt(localctx, 1) 

2189 self.state = 312 

2190 self.multi_expr() 

2191 self.state = 317 

2192 self._errHandler.sync(self) 

2193 _alt = self._interp.adaptivePredict(self._input, 30, self._ctx) 

2194 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: 

2195 if _alt == 1: 

2196 self.state = 313 

2197 _la = self._input.LA(1) 

2198 if not(_la == PigParser.PLUS or _la == PigParser.MINUS): 

2199 self._errHandler.recoverInline(self) 

2200 else: 

2201 self._errHandler.reportMatch(self) 

2202 self.consume() 

2203 self.state = 314 

2204 self.multi_expr() 

2205 self.state = 319 

2206 self._errHandler.sync(self) 

2207 _alt = self._interp.adaptivePredict(self._input, 30, self._ctx) 

2208 

2209 except RecognitionException as re: 

2210 localctx.exception = re 

2211 self._errHandler.reportError(self, re) 

2212 self._errHandler.recover(self, re) 

2213 finally: 

2214 self.exitRule() 

2215 return localctx 

2216 

2217 class Multi_exprContext(ParserRuleContext): 

2218 

2219 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

2220 super().__init__(parent, invokingState) 

2221 self.parser = parser 

2222 

2223 def cast_expr(self, i: int = None): 

2224 if i is None: 

2225 return self.getTypedRuleContexts(PigParser.Cast_exprContext) 

2226 else: 

2227 return self.getTypedRuleContext(PigParser.Cast_exprContext, i) 

2228 

2229 def START(self, i: int = None): 

2230 if i is None: 

2231 return self.getTokens(PigParser.START) 

2232 else: 

2233 return self.getToken(PigParser.START, i) 

2234 

2235 def DIV(self, i: int = None): 

2236 if i is None: 

2237 return self.getTokens(PigParser.DIV) 

2238 else: 

2239 return self.getToken(PigParser.DIV, i) 

2240 

2241 def PERCENT(self, i: int = None): 

2242 if i is None: 

2243 return self.getTokens(PigParser.PERCENT) 

2244 else: 

2245 return self.getToken(PigParser.PERCENT, i) 

2246 

2247 def getRuleIndex(self): 

2248 return PigParser.RULE_multi_expr 

2249 

2250 def enterRule(self, listener: ParseTreeListener): 

2251 if hasattr(listener, "enterMulti_expr"): 

2252 listener.enterMulti_expr(self) 

2253 

2254 def exitRule(self, listener: ParseTreeListener): 

2255 if hasattr(listener, "exitMulti_expr"): 

2256 listener.exitMulti_expr(self) 

2257 

2258 def multi_expr(self): 

2259 

2260 localctx = PigParser.Multi_exprContext(self, self._ctx, self.state) 

2261 self.enterRule(localctx, 56, self.RULE_multi_expr) 

2262 self._la = 0 # Token type 

2263 try: 

2264 self.enterOuterAlt(localctx, 1) 

2265 self.state = 320 

2266 self.cast_expr() 

2267 self.state = 325 

2268 self._errHandler.sync(self) 

2269 _alt = self._interp.adaptivePredict(self._input, 31, self._ctx) 

2270 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: 

2271 if _alt == 1: 

2272 self.state = 321 

2273 _la = self._input.LA(1) 

2274 if not(((((_la - 86)) & ~0x3f) == 0 and ((1 << (_la - 86)) & ((1 << (PigParser.DIV - 86)) | (1 << (PigParser.PERCENT - 86)) | (1 << (PigParser.START - 86)))) != 0)): 

2275 self._errHandler.recoverInline(self) 

2276 else: 

2277 self._errHandler.reportMatch(self) 

2278 self.consume() 

2279 self.state = 322 

2280 self.cast_expr() 

2281 self.state = 327 

2282 self._errHandler.sync(self) 

2283 _alt = self._interp.adaptivePredict(self._input, 31, self._ctx) 

2284 

2285 except RecognitionException as re: 

2286 localctx.exception = re 

2287 self._errHandler.reportError(self, re) 

2288 self._errHandler.recover(self, re) 

2289 finally: 

2290 self.exitRule() 

2291 return localctx 

2292 

2293 class Cast_exprContext(ParserRuleContext): 

2294 

2295 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

2296 super().__init__(parent, invokingState) 

2297 self.parser = parser 

2298 

2299 def unary_expr(self): 

2300 return self.getTypedRuleContext(PigParser.Unary_exprContext, 0) 

2301 

2302 def LEFT_PAREN(self): 

2303 return self.getToken(PigParser.LEFT_PAREN, 0) 

2304 

2305 def type_(self): 

2306 return self.getTypedRuleContext(PigParser.Type_Context, 0) 

2307 

2308 def RIGHT_PAREN(self): 

2309 return self.getToken(PigParser.RIGHT_PAREN, 0) 

2310 

2311 def NOT(self): 

2312 return self.getToken(PigParser.NOT, 0) 

2313 

2314 def CAST_EXPR(self): 

2315 return self.getToken(PigParser.CAST_EXPR, 0) 

2316 

2317 def getRuleIndex(self): 

2318 return PigParser.RULE_cast_expr 

2319 

2320 def enterRule(self, listener: ParseTreeListener): 

2321 if hasattr(listener, "enterCast_expr"): 

2322 listener.enterCast_expr(self) 

2323 

2324 def exitRule(self, listener: ParseTreeListener): 

2325 if hasattr(listener, "exitCast_expr"): 

2326 listener.exitCast_expr(self) 

2327 

2328 def cast_expr(self): 

2329 

2330 localctx = PigParser.Cast_exprContext(self, self._ctx, self.state) 

2331 self.enterRule(localctx, 58, self.RULE_cast_expr) 

2332 try: 

2333 self.state = 340 

2334 self._errHandler.sync(self) 

2335 la_ = self._interp.adaptivePredict(self._input, 32, self._ctx) 

2336 if la_ == 1: 

2337 self.enterOuterAlt(localctx, 1) 

2338 self.state = 328 

2339 self.match(PigParser.LEFT_PAREN) 

2340 self.state = 329 

2341 self.type_() 

2342 self.state = 330 

2343 self.match(PigParser.RIGHT_PAREN) 

2344 self.state = 332 

2345 self.unary_expr() 

2346 pass 

2347 

2348 elif la_ == 2: 

2349 self.enterOuterAlt(localctx, 2) 

2350 self.state = 334 

2351 self.match(PigParser.NOT) 

2352 

2353 self.state = 335 

2354 self.match(PigParser.CAST_EXPR) 

2355 self.state = 336 

2356 self.type_() 

2357 self.state = 337 

2358 self.unary_expr() 

2359 pass 

2360 

2361 elif la_ == 3: 

2362 self.enterOuterAlt(localctx, 3) 

2363 self.state = 339 

2364 self.unary_expr() 

2365 pass 

2366 

2367 except RecognitionException as re: 

2368 localctx.exception = re 

2369 self._errHandler.reportError(self, re) 

2370 self._errHandler.recover(self, re) 

2371 finally: 

2372 self.exitRule() 

2373 return localctx 

2374 

2375 class Unary_exprContext(ParserRuleContext): 

2376 

2377 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

2378 super().__init__(parent, invokingState) 

2379 self.parser = parser 

2380 

2381 def eval_expr(self): 

2382 return self.getTypedRuleContext(PigParser.Eval_exprContext, 0) 

2383 

2384 def LEFT_PAREN(self): 

2385 return self.getToken(PigParser.LEFT_PAREN, 0) 

2386 

2387 def infix_expr(self): 

2388 return self.getTypedRuleContext(PigParser.Infix_exprContext, 0) 

2389 

2390 def RIGHT_PAREN(self): 

2391 return self.getToken(PigParser.RIGHT_PAREN, 0) 

2392 

2393 def neg_expr(self): 

2394 return self.getTypedRuleContext(PigParser.Neg_exprContext, 0) 

2395 

2396 def getRuleIndex(self): 

2397 return PigParser.RULE_unary_expr 

2398 

2399 def enterRule(self, listener: ParseTreeListener): 

2400 if hasattr(listener, "enterUnary_expr"): 

2401 listener.enterUnary_expr(self) 

2402 

2403 def exitRule(self, listener: ParseTreeListener): 

2404 if hasattr(listener, "exitUnary_expr"): 

2405 listener.exitUnary_expr(self) 

2406 

2407 def unary_expr(self): 

2408 

2409 localctx = PigParser.Unary_exprContext(self, self._ctx, self.state) 

2410 self.enterRule(localctx, 60, self.RULE_unary_expr) 

2411 try: 

2412 self.state = 348 

2413 self._errHandler.sync(self) 

2414 la_ = self._interp.adaptivePredict(self._input, 33, self._ctx) 

2415 if la_ == 1: 

2416 self.enterOuterAlt(localctx, 1) 

2417 self.state = 342 

2418 self.eval_expr() 

2419 pass 

2420 

2421 elif la_ == 2: 

2422 self.enterOuterAlt(localctx, 2) 

2423 self.state = 343 

2424 self.match(PigParser.LEFT_PAREN) 

2425 self.state = 344 

2426 self.infix_expr() 

2427 self.state = 345 

2428 self.match(PigParser.RIGHT_PAREN) 

2429 pass 

2430 

2431 elif la_ == 3: 

2432 self.enterOuterAlt(localctx, 3) 

2433 self.state = 347 

2434 self.neg_expr() 

2435 pass 

2436 

2437 except RecognitionException as re: 

2438 localctx.exception = re 

2439 self._errHandler.reportError(self, re) 

2440 self._errHandler.recover(self, re) 

2441 finally: 

2442 self.exitRule() 

2443 return localctx 

2444 

2445 class Eval_exprContext(ParserRuleContext): 

2446 

2447 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

2448 super().__init__(parent, invokingState) 

2449 self.parser = parser 

2450 

2451 def const_expr(self): 

2452 return self.getTypedRuleContext(PigParser.Const_exprContext, 0) 

2453 

2454 def var_expr(self): 

2455 return self.getTypedRuleContext(PigParser.Var_exprContext, 0) 

2456 

2457 def getRuleIndex(self): 

2458 return PigParser.RULE_eval_expr 

2459 

2460 def enterRule(self, listener: ParseTreeListener): 

2461 if hasattr(listener, "enterEval_expr"): 

2462 listener.enterEval_expr(self) 

2463 

2464 def exitRule(self, listener: ParseTreeListener): 

2465 if hasattr(listener, "exitEval_expr"): 

2466 listener.exitEval_expr(self) 

2467 

2468 def eval_expr(self): 

2469 

2470 localctx = PigParser.Eval_exprContext(self, self._ctx, self.state) 

2471 self.enterRule(localctx, 62, self.RULE_eval_expr) 

2472 try: 

2473 self.state = 352 

2474 self._errHandler.sync(self) 

2475 la_ = self._interp.adaptivePredict(self._input, 34, self._ctx) 

2476 if la_ == 1: 

2477 self.enterOuterAlt(localctx, 1) 

2478 self.state = 350 

2479 self.const_expr() 

2480 pass 

2481 

2482 elif la_ == 2: 

2483 self.enterOuterAlt(localctx, 2) 

2484 self.state = 351 

2485 self.var_expr() 

2486 pass 

2487 

2488 except RecognitionException as re: 

2489 localctx.exception = re 

2490 self._errHandler.reportError(self, re) 

2491 self._errHandler.recover(self, re) 

2492 finally: 

2493 self.exitRule() 

2494 return localctx 

2495 

2496 class Var_exprContext(ParserRuleContext): 

2497 

2498 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

2499 super().__init__(parent, invokingState) 

2500 self.parser = parser 

2501 

2502 def projectable_expr(self): 

2503 return self.getTypedRuleContext(PigParser.Projectable_exprContext, 0) 

2504 

2505 def dot_proj(self, i: int = None): 

2506 if i is None: 

2507 return self.getTypedRuleContexts(PigParser.Dot_projContext) 

2508 else: 

2509 return self.getTypedRuleContext(PigParser.Dot_projContext, i) 

2510 

2511 def pound_proj(self, i: int = None): 

2512 if i is None: 

2513 return self.getTypedRuleContexts(PigParser.Pound_projContext) 

2514 else: 

2515 return self.getTypedRuleContext(PigParser.Pound_projContext, i) 

2516 

2517 def getRuleIndex(self): 

2518 return PigParser.RULE_var_expr 

2519 

2520 def enterRule(self, listener: ParseTreeListener): 

2521 if hasattr(listener, "enterVar_expr"): 

2522 listener.enterVar_expr(self) 

2523 

2524 def exitRule(self, listener: ParseTreeListener): 

2525 if hasattr(listener, "exitVar_expr"): 

2526 listener.exitVar_expr(self) 

2527 

2528 def var_expr(self): 

2529 

2530 localctx = PigParser.Var_exprContext(self, self._ctx, self.state) 

2531 self.enterRule(localctx, 64, self.RULE_var_expr) 

2532 try: 

2533 self.enterOuterAlt(localctx, 1) 

2534 self.state = 354 

2535 self.projectable_expr() 

2536 self.state = 359 

2537 self._errHandler.sync(self) 

2538 _alt = self._interp.adaptivePredict(self._input, 36, self._ctx) 

2539 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: 

2540 if _alt == 1: 

2541 self.state = 357 

2542 self._errHandler.sync(self) 

2543 token = self._input.LA(1) 

2544 if token in [PigParser.NOT, PigParser.PERIOD]: 

2545 self.state = 355 

2546 self.dot_proj() 

2547 pass 

2548 elif token in [PigParser.POUND]: 

2549 self.state = 356 

2550 self.pound_proj() 

2551 pass 

2552 else: 

2553 raise NoViableAltException(self) 

2554 

2555 self.state = 361 

2556 self._errHandler.sync(self) 

2557 _alt = self._interp.adaptivePredict(self._input, 36, self._ctx) 

2558 

2559 except RecognitionException as re: 

2560 localctx.exception = re 

2561 self._errHandler.reportError(self, re) 

2562 self._errHandler.recover(self, re) 

2563 finally: 

2564 self.exitRule() 

2565 return localctx 

2566 

2567 class Projectable_exprContext(ParserRuleContext): 

2568 

2569 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

2570 super().__init__(parent, invokingState) 

2571 self.parser = parser 

2572 

2573 def func_clause(self): 

2574 return self.getTypedRuleContext(PigParser.Func_clauseContext, 0) 

2575 

2576 def col_ref(self): 

2577 return self.getTypedRuleContext(PigParser.Col_refContext, 0) 

2578 

2579 def bin_expr(self): 

2580 return self.getTypedRuleContext(PigParser.Bin_exprContext, 0) 

2581 

2582 def getRuleIndex(self): 

2583 return PigParser.RULE_projectable_expr 

2584 

2585 def enterRule(self, listener: ParseTreeListener): 

2586 if hasattr(listener, "enterProjectable_expr"): 

2587 listener.enterProjectable_expr(self) 

2588 

2589 def exitRule(self, listener: ParseTreeListener): 

2590 if hasattr(listener, "exitProjectable_expr"): 

2591 listener.exitProjectable_expr(self) 

2592 

2593 def projectable_expr(self): 

2594 

2595 localctx = PigParser.Projectable_exprContext( 

2596 self, self._ctx, self.state) 

2597 self.enterRule(localctx, 66, self.RULE_projectable_expr) 

2598 try: 

2599 self.state = 365 

2600 self._errHandler.sync(self) 

2601 la_ = self._interp.adaptivePredict(self._input, 37, self._ctx) 

2602 if la_ == 1: 

2603 self.enterOuterAlt(localctx, 1) 

2604 self.state = 362 

2605 self.func_clause() 

2606 pass 

2607 

2608 elif la_ == 2: 

2609 self.enterOuterAlt(localctx, 2) 

2610 self.state = 363 

2611 self.col_ref() 

2612 pass 

2613 

2614 elif la_ == 3: 

2615 self.enterOuterAlt(localctx, 3) 

2616 self.state = 364 

2617 self.bin_expr() 

2618 pass 

2619 

2620 except RecognitionException as re: 

2621 localctx.exception = re 

2622 self._errHandler.reportError(self, re) 

2623 self._errHandler.recover(self, re) 

2624 finally: 

2625 self.exitRule() 

2626 return localctx 

2627 

2628 class Dot_projContext(ParserRuleContext): 

2629 

2630 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

2631 super().__init__(parent, invokingState) 

2632 self.parser = parser 

2633 

2634 def PERIOD(self): 

2635 return self.getToken(PigParser.PERIOD, 0) 

2636 

2637 def col_ref(self, i: int = None): 

2638 if i is None: 

2639 return self.getTypedRuleContexts(PigParser.Col_refContext) 

2640 else: 

2641 return self.getTypedRuleContext(PigParser.Col_refContext, i) 

2642 

2643 def LEFT_PAREN(self): 

2644 return self.getToken(PigParser.LEFT_PAREN, 0) 

2645 

2646 def RIGHT_PAREN(self): 

2647 return self.getToken(PigParser.RIGHT_PAREN, 0) 

2648 

2649 def COMMA(self, i: int = None): 

2650 if i is None: 

2651 return self.getTokens(PigParser.COMMA) 

2652 else: 

2653 return self.getToken(PigParser.COMMA, i) 

2654 

2655 def NOT(self): 

2656 return self.getToken(PigParser.NOT, 0) 

2657 

2658 def getRuleIndex(self): 

2659 return PigParser.RULE_dot_proj 

2660 

2661 def enterRule(self, listener: ParseTreeListener): 

2662 if hasattr(listener, "enterDot_proj"): 

2663 listener.enterDot_proj(self) 

2664 

2665 def exitRule(self, listener: ParseTreeListener): 

2666 if hasattr(listener, "exitDot_proj"): 

2667 listener.exitDot_proj(self) 

2668 

2669 def dot_proj(self): 

2670 

2671 localctx = PigParser.Dot_projContext(self, self._ctx, self.state) 

2672 self.enterRule(localctx, 68, self.RULE_dot_proj) 

2673 self._la = 0 # Token type 

2674 try: 

2675 self.state = 389 

2676 self._errHandler.sync(self) 

2677 token = self._input.LA(1) 

2678 if token in [PigParser.PERIOD]: 

2679 self.enterOuterAlt(localctx, 1) 

2680 self.state = 367 

2681 self.match(PigParser.PERIOD) 

2682 self.state = 380 

2683 self._errHandler.sync(self) 

2684 token = self._input.LA(1) 

2685 if token in [PigParser.GROUP, PigParser.IDENTIFIER, PigParser.DOLLAR]: 

2686 self.state = 368 

2687 self.col_ref() 

2688 pass 

2689 elif token in [PigParser.LEFT_PAREN]: 

2690 self.state = 369 

2691 self.match(PigParser.LEFT_PAREN) 

2692 self.state = 370 

2693 self.col_ref() 

2694 self.state = 375 

2695 self._errHandler.sync(self) 

2696 _la = self._input.LA(1) 

2697 while _la == PigParser.COMMA: 

2698 self.state = 371 

2699 self.match(PigParser.COMMA) 

2700 self.state = 372 

2701 self.col_ref() 

2702 self.state = 377 

2703 self._errHandler.sync(self) 

2704 _la = self._input.LA(1) 

2705 

2706 self.state = 378 

2707 self.match(PigParser.RIGHT_PAREN) 

2708 pass 

2709 else: 

2710 raise NoViableAltException(self) 

2711 

2712 pass 

2713 elif token in [PigParser.NOT]: 

2714 self.enterOuterAlt(localctx, 2) 

2715 self.state = 382 

2716 self.match(PigParser.NOT) 

2717 

2718 self.state = 383 

2719 self.match(PigParser.PERIOD) 

2720 self.state = 385 

2721 self._errHandler.sync(self) 

2722 _alt = 1 

2723 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: 

2724 if _alt == 1: 

2725 self.state = 384 

2726 self.col_ref() 

2727 

2728 else: 

2729 raise NoViableAltException(self) 

2730 self.state = 387 

2731 self._errHandler.sync(self) 

2732 _alt = self._interp.adaptivePredict( 

2733 self._input, 40, self._ctx) 

2734 

2735 pass 

2736 else: 

2737 raise NoViableAltException(self) 

2738 

2739 except RecognitionException as re: 

2740 localctx.exception = re 

2741 self._errHandler.reportError(self, re) 

2742 self._errHandler.recover(self, re) 

2743 finally: 

2744 self.exitRule() 

2745 return localctx 

2746 

2747 class Pound_projContext(ParserRuleContext): 

2748 

2749 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

2750 super().__init__(parent, invokingState) 

2751 self.parser = parser 

2752 

2753 def POUND(self): 

2754 return self.getToken(PigParser.POUND, 0) 

2755 

2756 def QUOTEDSTRING(self): 

2757 return self.getToken(PigParser.QUOTEDSTRING, 0) 

2758 

2759 def NULL(self): 

2760 return self.getToken(PigParser.NULL, 0) 

2761 

2762 def getRuleIndex(self): 

2763 return PigParser.RULE_pound_proj 

2764 

2765 def enterRule(self, listener: ParseTreeListener): 

2766 if hasattr(listener, "enterPound_proj"): 

2767 listener.enterPound_proj(self) 

2768 

2769 def exitRule(self, listener: ParseTreeListener): 

2770 if hasattr(listener, "exitPound_proj"): 

2771 listener.exitPound_proj(self) 

2772 

2773 def pound_proj(self): 

2774 

2775 localctx = PigParser.Pound_projContext(self, self._ctx, self.state) 

2776 self.enterRule(localctx, 70, self.RULE_pound_proj) 

2777 self._la = 0 # Token type 

2778 try: 

2779 self.enterOuterAlt(localctx, 1) 

2780 self.state = 391 

2781 self.match(PigParser.POUND) 

2782 self.state = 392 

2783 _la = self._input.LA(1) 

2784 if not(_la == PigParser.NULL or _la == PigParser.QUOTEDSTRING): 

2785 self._errHandler.recoverInline(self) 

2786 else: 

2787 self._errHandler.reportMatch(self) 

2788 self.consume() 

2789 except RecognitionException as re: 

2790 localctx.exception = re 

2791 self._errHandler.reportError(self, re) 

2792 self._errHandler.recover(self, re) 

2793 finally: 

2794 self.exitRule() 

2795 return localctx 

2796 

2797 class Bin_exprContext(ParserRuleContext): 

2798 

2799 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

2800 super().__init__(parent, invokingState) 

2801 self.parser = parser 

2802 

2803 def LEFT_PAREN(self): 

2804 return self.getToken(PigParser.LEFT_PAREN, 0) 

2805 

2806 def cond(self): 

2807 return self.getTypedRuleContext(PigParser.CondContext, 0) 

2808 

2809 def QMARK(self): 

2810 return self.getToken(PigParser.QMARK, 0) 

2811 

2812 def infix_expr(self, i: int = None): 

2813 if i is None: 

2814 return self.getTypedRuleContexts(PigParser.Infix_exprContext) 

2815 else: 

2816 return self.getTypedRuleContext(PigParser.Infix_exprContext, i) 

2817 

2818 def COLON(self): 

2819 return self.getToken(PigParser.COLON, 0) 

2820 

2821 def RIGHT_PAREN(self): 

2822 return self.getToken(PigParser.RIGHT_PAREN, 0) 

2823 

2824 def NOT(self): 

2825 return self.getToken(PigParser.NOT, 0) 

2826 

2827 def BIN_EXPR(self): 

2828 return self.getToken(PigParser.BIN_EXPR, 0) 

2829 

2830 def getRuleIndex(self): 

2831 return PigParser.RULE_bin_expr 

2832 

2833 def enterRule(self, listener: ParseTreeListener): 

2834 if hasattr(listener, "enterBin_expr"): 

2835 listener.enterBin_expr(self) 

2836 

2837 def exitRule(self, listener: ParseTreeListener): 

2838 if hasattr(listener, "exitBin_expr"): 

2839 listener.exitBin_expr(self) 

2840 

2841 def bin_expr(self): 

2842 

2843 localctx = PigParser.Bin_exprContext(self, self._ctx, self.state) 

2844 self.enterRule(localctx, 72, self.RULE_bin_expr) 

2845 try: 

2846 self.state = 408 

2847 self._errHandler.sync(self) 

2848 token = self._input.LA(1) 

2849 if token in [PigParser.LEFT_PAREN]: 

2850 self.enterOuterAlt(localctx, 1) 

2851 self.state = 394 

2852 self.match(PigParser.LEFT_PAREN) 

2853 self.state = 395 

2854 self.cond() 

2855 self.state = 396 

2856 self.match(PigParser.QMARK) 

2857 self.state = 397 

2858 self.infix_expr() 

2859 self.state = 398 

2860 self.match(PigParser.COLON) 

2861 self.state = 399 

2862 self.infix_expr() 

2863 self.state = 400 

2864 self.match(PigParser.RIGHT_PAREN) 

2865 pass 

2866 elif token in [PigParser.NOT]: 

2867 self.enterOuterAlt(localctx, 2) 

2868 self.state = 402 

2869 self.match(PigParser.NOT) 

2870 

2871 self.state = 403 

2872 self.match(PigParser.BIN_EXPR) 

2873 self.state = 404 

2874 self.cond() 

2875 self.state = 405 

2876 self.infix_expr() 

2877 self.state = 406 

2878 self.infix_expr() 

2879 pass 

2880 else: 

2881 raise NoViableAltException(self) 

2882 

2883 except RecognitionException as re: 

2884 localctx.exception = re 

2885 self._errHandler.reportError(self, re) 

2886 self._errHandler.recover(self, re) 

2887 finally: 

2888 self.exitRule() 

2889 return localctx 

2890 

2891 class Neg_exprContext(ParserRuleContext): 

2892 

2893 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

2894 super().__init__(parent, invokingState) 

2895 self.parser = parser 

2896 

2897 def MINUS(self): 

2898 return self.getToken(PigParser.MINUS, 0) 

2899 

2900 def cast_expr(self): 

2901 return self.getTypedRuleContext(PigParser.Cast_exprContext, 0) 

2902 

2903 def getRuleIndex(self): 

2904 return PigParser.RULE_neg_expr 

2905 

2906 def enterRule(self, listener: ParseTreeListener): 

2907 if hasattr(listener, "enterNeg_expr"): 

2908 listener.enterNeg_expr(self) 

2909 

2910 def exitRule(self, listener: ParseTreeListener): 

2911 if hasattr(listener, "exitNeg_expr"): 

2912 listener.exitNeg_expr(self) 

2913 

2914 def neg_expr(self): 

2915 

2916 localctx = PigParser.Neg_exprContext(self, self._ctx, self.state) 

2917 self.enterRule(localctx, 74, self.RULE_neg_expr) 

2918 try: 

2919 self.enterOuterAlt(localctx, 1) 

2920 self.state = 410 

2921 self.match(PigParser.MINUS) 

2922 self.state = 411 

2923 self.cast_expr() 

2924 except RecognitionException as re: 

2925 localctx.exception = re 

2926 self._errHandler.reportError(self, re) 

2927 self._errHandler.recover(self, re) 

2928 finally: 

2929 self.exitRule() 

2930 return localctx 

2931 

2932 class Distinct_clauseContext(ParserRuleContext): 

2933 

2934 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

2935 super().__init__(parent, invokingState) 

2936 self.parser = parser 

2937 

2938 def DISTINCT(self): 

2939 return self.getToken(PigParser.DISTINCT, 0) 

2940 

2941 def alias(self): 

2942 return self.getTypedRuleContext(PigParser.AliasContext, 0) 

2943 

2944 def getRuleIndex(self): 

2945 return PigParser.RULE_distinct_clause 

2946 

2947 def enterRule(self, listener: ParseTreeListener): 

2948 if hasattr(listener, "enterDistinct_clause"): 

2949 listener.enterDistinct_clause(self) 

2950 

2951 def exitRule(self, listener: ParseTreeListener): 

2952 if hasattr(listener, "exitDistinct_clause"): 

2953 listener.exitDistinct_clause(self) 

2954 

2955 def distinct_clause(self): 

2956 

2957 localctx = PigParser.Distinct_clauseContext( 

2958 self, self._ctx, self.state) 

2959 self.enterRule(localctx, 76, self.RULE_distinct_clause) 

2960 try: 

2961 self.enterOuterAlt(localctx, 1) 

2962 self.state = 413 

2963 self.match(PigParser.DISTINCT) 

2964 self.state = 414 

2965 self.alias() 

2966 except RecognitionException as re: 

2967 localctx.exception = re 

2968 self._errHandler.reportError(self, re) 

2969 self._errHandler.recover(self, re) 

2970 finally: 

2971 self.exitRule() 

2972 return localctx 

2973 

2974 class Col_refContext(ParserRuleContext): 

2975 

2976 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

2977 super().__init__(parent, invokingState) 

2978 self.parser = parser 

2979 

2980 def alias_col_ref(self): 

2981 return self.getTypedRuleContext(PigParser.Alias_col_refContext, 0) 

2982 

2983 def dollar_col_ref(self): 

2984 return self.getTypedRuleContext(PigParser.Dollar_col_refContext, 0) 

2985 

2986 def getRuleIndex(self): 

2987 return PigParser.RULE_col_ref 

2988 

2989 def enterRule(self, listener: ParseTreeListener): 

2990 if hasattr(listener, "enterCol_ref"): 

2991 listener.enterCol_ref(self) 

2992 

2993 def exitRule(self, listener: ParseTreeListener): 

2994 if hasattr(listener, "exitCol_ref"): 

2995 listener.exitCol_ref(self) 

2996 

2997 def col_ref(self): 

2998 

2999 localctx = PigParser.Col_refContext(self, self._ctx, self.state) 

3000 self.enterRule(localctx, 78, self.RULE_col_ref) 

3001 try: 

3002 self.state = 418 

3003 self._errHandler.sync(self) 

3004 token = self._input.LA(1) 

3005 if token in [PigParser.GROUP, PigParser.IDENTIFIER]: 

3006 self.enterOuterAlt(localctx, 1) 

3007 self.state = 416 

3008 self.alias_col_ref() 

3009 pass 

3010 elif token in [PigParser.DOLLAR]: 

3011 self.enterOuterAlt(localctx, 2) 

3012 self.state = 417 

3013 self.dollar_col_ref() 

3014 pass 

3015 else: 

3016 raise NoViableAltException(self) 

3017 

3018 except RecognitionException as re: 

3019 localctx.exception = re 

3020 self._errHandler.reportError(self, re) 

3021 self._errHandler.recover(self, re) 

3022 finally: 

3023 self.exitRule() 

3024 return localctx 

3025 

3026 class Alias_col_refContext(ParserRuleContext): 

3027 

3028 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

3029 super().__init__(parent, invokingState) 

3030 self.parser = parser 

3031 

3032 def GROUP(self): 

3033 return self.getToken(PigParser.GROUP, 0) 

3034 

3035 def IDENTIFIER(self): 

3036 return self.getToken(PigParser.IDENTIFIER, 0) 

3037 

3038 def getRuleIndex(self): 

3039 return PigParser.RULE_alias_col_ref 

3040 

3041 def enterRule(self, listener: ParseTreeListener): 

3042 if hasattr(listener, "enterAlias_col_ref"): 

3043 listener.enterAlias_col_ref(self) 

3044 

3045 def exitRule(self, listener: ParseTreeListener): 

3046 if hasattr(listener, "exitAlias_col_ref"): 

3047 listener.exitAlias_col_ref(self) 

3048 

3049 def alias_col_ref(self): 

3050 

3051 localctx = PigParser.Alias_col_refContext(self, self._ctx, self.state) 

3052 self.enterRule(localctx, 80, self.RULE_alias_col_ref) 

3053 self._la = 0 # Token type 

3054 try: 

3055 self.enterOuterAlt(localctx, 1) 

3056 self.state = 420 

3057 _la = self._input.LA(1) 

3058 if not(_la == PigParser.GROUP or _la == PigParser.IDENTIFIER): 

3059 self._errHandler.recoverInline(self) 

3060 else: 

3061 self._errHandler.reportMatch(self) 

3062 self.consume() 

3063 except RecognitionException as re: 

3064 localctx.exception = re 

3065 self._errHandler.reportError(self, re) 

3066 self._errHandler.recover(self, re) 

3067 finally: 

3068 self.exitRule() 

3069 return localctx 

3070 

3071 class Dollar_col_refContext(ParserRuleContext): 

3072 

3073 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

3074 super().__init__(parent, invokingState) 

3075 self.parser = parser 

3076 

3077 def DOLLAR(self): 

3078 return self.getToken(PigParser.DOLLAR, 0) 

3079 

3080 def INTEGER(self): 

3081 return self.getToken(PigParser.INTEGER, 0) 

3082 

3083 def getRuleIndex(self): 

3084 return PigParser.RULE_dollar_col_ref 

3085 

3086 def enterRule(self, listener: ParseTreeListener): 

3087 if hasattr(listener, "enterDollar_col_ref"): 

3088 listener.enterDollar_col_ref(self) 

3089 

3090 def exitRule(self, listener: ParseTreeListener): 

3091 if hasattr(listener, "exitDollar_col_ref"): 

3092 listener.exitDollar_col_ref(self) 

3093 

3094 def dollar_col_ref(self): 

3095 

3096 localctx = PigParser.Dollar_col_refContext(self, self._ctx, self.state) 

3097 self.enterRule(localctx, 82, self.RULE_dollar_col_ref) 

3098 try: 

3099 self.enterOuterAlt(localctx, 1) 

3100 self.state = 422 

3101 self.match(PigParser.DOLLAR) 

3102 self.state = 423 

3103 self.match(PigParser.INTEGER) 

3104 except RecognitionException as re: 

3105 localctx.exception = re 

3106 self._errHandler.reportError(self, re) 

3107 self._errHandler.recover(self, re) 

3108 finally: 

3109 self.exitRule() 

3110 return localctx 

3111 

3112 class Infix_exprContext(ParserRuleContext): 

3113 

3114 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

3115 super().__init__(parent, invokingState) 

3116 self.parser = parser 

3117 

3118 def add_expr(self): 

3119 return self.getTypedRuleContext(PigParser.Add_exprContext, 0) 

3120 

3121 def getRuleIndex(self): 

3122 return PigParser.RULE_infix_expr 

3123 

3124 def enterRule(self, listener: ParseTreeListener): 

3125 if hasattr(listener, "enterInfix_expr"): 

3126 listener.enterInfix_expr(self) 

3127 

3128 def exitRule(self, listener: ParseTreeListener): 

3129 if hasattr(listener, "exitInfix_expr"): 

3130 listener.exitInfix_expr(self) 

3131 

3132 def infix_expr(self): 

3133 

3134 localctx = PigParser.Infix_exprContext(self, self._ctx, self.state) 

3135 self.enterRule(localctx, 84, self.RULE_infix_expr) 

3136 try: 

3137 self.enterOuterAlt(localctx, 1) 

3138 self.state = 425 

3139 self.add_expr() 

3140 except RecognitionException as re: 

3141 localctx.exception = re 

3142 self._errHandler.reportError(self, re) 

3143 self._errHandler.recover(self, re) 

3144 finally: 

3145 self.exitRule() 

3146 return localctx 

3147 

3148 class Const_exprContext(ParserRuleContext): 

3149 

3150 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

3151 super().__init__(parent, invokingState) 

3152 self.parser = parser 

3153 

3154 def scalar(self): 

3155 return self.getTypedRuleContext(PigParser.ScalarContext, 0) 

3156 

3157 def map_(self): 

3158 return self.getTypedRuleContext(PigParser.Map_Context, 0) 

3159 

3160 def bag(self): 

3161 return self.getTypedRuleContext(PigParser.BagContext, 0) 

3162 

3163 def tuple_(self): 

3164 return self.getTypedRuleContext(PigParser.Tuple_Context, 0) 

3165 

3166 def getRuleIndex(self): 

3167 return PigParser.RULE_const_expr 

3168 

3169 def enterRule(self, listener: ParseTreeListener): 

3170 if hasattr(listener, "enterConst_expr"): 

3171 listener.enterConst_expr(self) 

3172 

3173 def exitRule(self, listener: ParseTreeListener): 

3174 if hasattr(listener, "exitConst_expr"): 

3175 listener.exitConst_expr(self) 

3176 

3177 def const_expr(self): 

3178 

3179 localctx = PigParser.Const_exprContext(self, self._ctx, self.state) 

3180 self.enterRule(localctx, 86, self.RULE_const_expr) 

3181 try: 

3182 self.state = 431 

3183 self._errHandler.sync(self) 

3184 la_ = self._interp.adaptivePredict(self._input, 44, self._ctx) 

3185 if la_ == 1: 

3186 self.enterOuterAlt(localctx, 1) 

3187 self.state = 427 

3188 self.scalar() 

3189 pass 

3190 

3191 elif la_ == 2: 

3192 self.enterOuterAlt(localctx, 2) 

3193 self.state = 428 

3194 self.map_() 

3195 pass 

3196 

3197 elif la_ == 3: 

3198 self.enterOuterAlt(localctx, 3) 

3199 self.state = 429 

3200 self.bag() 

3201 pass 

3202 

3203 elif la_ == 4: 

3204 self.enterOuterAlt(localctx, 4) 

3205 self.state = 430 

3206 self.tuple_() 

3207 pass 

3208 

3209 except RecognitionException as re: 

3210 localctx.exception = re 

3211 self._errHandler.reportError(self, re) 

3212 self._errHandler.recover(self, re) 

3213 finally: 

3214 self.exitRule() 

3215 return localctx 

3216 

3217 class ScalarContext(ParserRuleContext): 

3218 

3219 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

3220 super().__init__(parent, invokingState) 

3221 self.parser = parser 

3222 

3223 def INTEGER(self): 

3224 return self.getToken(PigParser.INTEGER, 0) 

3225 

3226 def LONGINEGER(self): 

3227 return self.getToken(PigParser.LONGINEGER, 0) 

3228 

3229 def FLOATNUMBER(self): 

3230 return self.getToken(PigParser.FLOATNUMBER, 0) 

3231 

3232 def DOUBLENUMBER(self): 

3233 return self.getToken(PigParser.DOUBLENUMBER, 0) 

3234 

3235 def QUOTEDSTRING(self): 

3236 return self.getToken(PigParser.QUOTEDSTRING, 0) 

3237 

3238 def NULL(self): 

3239 return self.getToken(PigParser.NULL, 0) 

3240 

3241 def getRuleIndex(self): 

3242 return PigParser.RULE_scalar 

3243 

3244 def enterRule(self, listener: ParseTreeListener): 

3245 if hasattr(listener, "enterScalar"): 

3246 listener.enterScalar(self) 

3247 

3248 def exitRule(self, listener: ParseTreeListener): 

3249 if hasattr(listener, "exitScalar"): 

3250 listener.exitScalar(self) 

3251 

3252 def scalar(self): 

3253 

3254 localctx = PigParser.ScalarContext(self, self._ctx, self.state) 

3255 self.enterRule(localctx, 88, self.RULE_scalar) 

3256 self._la = 0 # Token type 

3257 try: 

3258 self.enterOuterAlt(localctx, 1) 

3259 self.state = 433 

3260 _la = self._input.LA(1) 

3261 if not(((((_la - 45)) & ~0x3f) == 0 and ((1 << (_la - 45)) & ((1 << (PigParser.NULL - 45)) | (1 << (PigParser.INTEGER - 45)) | (1 << (PigParser.DOUBLENUMBER - 45)) | (1 << (PigParser.FLOATNUMBER - 45)) | (1 << (PigParser.QUOTEDSTRING - 45)) | (1 << (PigParser.LONGINEGER - 45)))) != 0)): 

3262 self._errHandler.recoverInline(self) 

3263 else: 

3264 self._errHandler.reportMatch(self) 

3265 self.consume() 

3266 except RecognitionException as re: 

3267 localctx.exception = re 

3268 self._errHandler.reportError(self, re) 

3269 self._errHandler.recover(self, re) 

3270 finally: 

3271 self.exitRule() 

3272 return localctx 

3273 

3274 class Map_Context(ParserRuleContext): 

3275 

3276 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

3277 super().__init__(parent, invokingState) 

3278 self.parser = parser 

3279 

3280 def LEFT_BRACKET(self): 

3281 return self.getToken(PigParser.LEFT_BRACKET, 0) 

3282 

3283 def RIGHT_BRACKET(self): 

3284 return self.getToken(PigParser.RIGHT_BRACKET, 0) 

3285 

3286 def keyvalue(self, i: int = None): 

3287 if i is None: 

3288 return self.getTypedRuleContexts(PigParser.KeyvalueContext) 

3289 else: 

3290 return self.getTypedRuleContext(PigParser.KeyvalueContext, i) 

3291 

3292 def COMMA(self, i: int = None): 

3293 if i is None: 

3294 return self.getTokens(PigParser.COMMA) 

3295 else: 

3296 return self.getToken(PigParser.COMMA, i) 

3297 

3298 def NOT(self): 

3299 return self.getToken(PigParser.NOT, 0) 

3300 

3301 def MAP_VAL(self): 

3302 return self.getToken(PigParser.MAP_VAL, 0) 

3303 

3304 def getRuleIndex(self): 

3305 return PigParser.RULE_map_ 

3306 

3307 def enterRule(self, listener: ParseTreeListener): 

3308 if hasattr(listener, "enterMap_"): 

3309 listener.enterMap_(self) 

3310 

3311 def exitRule(self, listener: ParseTreeListener): 

3312 if hasattr(listener, "exitMap_"): 

3313 listener.exitMap_(self) 

3314 

3315 def map_(self): 

3316 

3317 localctx = PigParser.Map_Context(self, self._ctx, self.state) 

3318 self.enterRule(localctx, 90, self.RULE_map_) 

3319 self._la = 0 # Token type 

3320 try: 

3321 self.state = 454 

3322 self._errHandler.sync(self) 

3323 token = self._input.LA(1) 

3324 if token in [PigParser.LEFT_BRACKET]: 

3325 self.enterOuterAlt(localctx, 1) 

3326 self.state = 435 

3327 self.match(PigParser.LEFT_BRACKET) 

3328 self.state = 444 

3329 self._errHandler.sync(self) 

3330 _la = self._input.LA(1) 

3331 if ((((_la - 29)) & ~0x3f) == 0 and ((1 << (_la - 29)) & ((1 << (PigParser.NOT - 29)) | (1 << (PigParser.NULL - 29)) | (1 << (PigParser.QUOTEDSTRING - 29)))) != 0): 

3332 self.state = 436 

3333 self.keyvalue() 

3334 self.state = 441 

3335 self._errHandler.sync(self) 

3336 _la = self._input.LA(1) 

3337 while _la == PigParser.COMMA: 

3338 self.state = 437 

3339 self.match(PigParser.COMMA) 

3340 self.state = 438 

3341 self.keyvalue() 

3342 self.state = 443 

3343 self._errHandler.sync(self) 

3344 _la = self._input.LA(1) 

3345 

3346 self.state = 446 

3347 self.match(PigParser.RIGHT_BRACKET) 

3348 pass 

3349 elif token in [PigParser.NOT]: 

3350 self.enterOuterAlt(localctx, 2) 

3351 self.state = 447 

3352 self.match(PigParser.NOT) 

3353 

3354 self.state = 448 

3355 self.match(PigParser.MAP_VAL) 

3356 self.state = 450 

3357 self._errHandler.sync(self) 

3358 _alt = 1 

3359 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: 

3360 if _alt == 1: 

3361 self.state = 449 

3362 self.keyvalue() 

3363 

3364 else: 

3365 raise NoViableAltException(self) 

3366 self.state = 452 

3367 self._errHandler.sync(self) 

3368 _alt = self._interp.adaptivePredict( 

3369 self._input, 47, self._ctx) 

3370 

3371 pass 

3372 else: 

3373 raise NoViableAltException(self) 

3374 

3375 except RecognitionException as re: 

3376 localctx.exception = re 

3377 self._errHandler.reportError(self, re) 

3378 self._errHandler.recover(self, re) 

3379 finally: 

3380 self.exitRule() 

3381 return localctx 

3382 

3383 class KeyvalueContext(ParserRuleContext): 

3384 

3385 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

3386 super().__init__(parent, invokingState) 

3387 self.parser = parser 

3388 

3389 def string_val(self): 

3390 return self.getTypedRuleContext(PigParser.String_valContext, 0) 

3391 

3392 def POUND(self): 

3393 return self.getToken(PigParser.POUND, 0) 

3394 

3395 def const_expr(self): 

3396 return self.getTypedRuleContext(PigParser.Const_exprContext, 0) 

3397 

3398 def NOT(self): 

3399 return self.getToken(PigParser.NOT, 0) 

3400 

3401 def KEY_VAL_PAIR(self): 

3402 return self.getToken(PigParser.KEY_VAL_PAIR, 0) 

3403 

3404 def getRuleIndex(self): 

3405 return PigParser.RULE_keyvalue 

3406 

3407 def enterRule(self, listener: ParseTreeListener): 

3408 if hasattr(listener, "enterKeyvalue"): 

3409 listener.enterKeyvalue(self) 

3410 

3411 def exitRule(self, listener: ParseTreeListener): 

3412 if hasattr(listener, "exitKeyvalue"): 

3413 listener.exitKeyvalue(self) 

3414 

3415 def keyvalue(self): 

3416 

3417 localctx = PigParser.KeyvalueContext(self, self._ctx, self.state) 

3418 self.enterRule(localctx, 92, self.RULE_keyvalue) 

3419 try: 

3420 self.state = 465 

3421 self._errHandler.sync(self) 

3422 token = self._input.LA(1) 

3423 if token in [PigParser.NULL, PigParser.QUOTEDSTRING]: 

3424 self.enterOuterAlt(localctx, 1) 

3425 self.state = 456 

3426 self.string_val() 

3427 self.state = 457 

3428 self.match(PigParser.POUND) 

3429 self.state = 458 

3430 self.const_expr() 

3431 pass 

3432 elif token in [PigParser.NOT]: 

3433 self.enterOuterAlt(localctx, 2) 

3434 self.state = 460 

3435 self.match(PigParser.NOT) 

3436 

3437 self.state = 461 

3438 self.match(PigParser.KEY_VAL_PAIR) 

3439 self.state = 462 

3440 self.string_val() 

3441 self.state = 463 

3442 self.const_expr() 

3443 pass 

3444 else: 

3445 raise NoViableAltException(self) 

3446 

3447 except RecognitionException as re: 

3448 localctx.exception = re 

3449 self._errHandler.reportError(self, re) 

3450 self._errHandler.recover(self, re) 

3451 finally: 

3452 self.exitRule() 

3453 return localctx 

3454 

3455 class String_valContext(ParserRuleContext): 

3456 

3457 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

3458 super().__init__(parent, invokingState) 

3459 self.parser = parser 

3460 

3461 def QUOTEDSTRING(self): 

3462 return self.getToken(PigParser.QUOTEDSTRING, 0) 

3463 

3464 def NULL(self): 

3465 return self.getToken(PigParser.NULL, 0) 

3466 

3467 def getRuleIndex(self): 

3468 return PigParser.RULE_string_val 

3469 

3470 def enterRule(self, listener: ParseTreeListener): 

3471 if hasattr(listener, "enterString_val"): 

3472 listener.enterString_val(self) 

3473 

3474 def exitRule(self, listener: ParseTreeListener): 

3475 if hasattr(listener, "exitString_val"): 

3476 listener.exitString_val(self) 

3477 

3478 def string_val(self): 

3479 

3480 localctx = PigParser.String_valContext(self, self._ctx, self.state) 

3481 self.enterRule(localctx, 94, self.RULE_string_val) 

3482 self._la = 0 # Token type 

3483 try: 

3484 self.enterOuterAlt(localctx, 1) 

3485 self.state = 467 

3486 _la = self._input.LA(1) 

3487 if not(_la == PigParser.NULL or _la == PigParser.QUOTEDSTRING): 

3488 self._errHandler.recoverInline(self) 

3489 else: 

3490 self._errHandler.reportMatch(self) 

3491 self.consume() 

3492 except RecognitionException as re: 

3493 localctx.exception = re 

3494 self._errHandler.reportError(self, re) 

3495 self._errHandler.recover(self, re) 

3496 finally: 

3497 self.exitRule() 

3498 return localctx 

3499 

3500 class BagContext(ParserRuleContext): 

3501 

3502 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

3503 super().__init__(parent, invokingState) 

3504 self.parser = parser 

3505 

3506 def LEFT_CURLY(self): 

3507 return self.getToken(PigParser.LEFT_CURLY, 0) 

3508 

3509 def RIGHT_CURLY(self): 

3510 return self.getToken(PigParser.RIGHT_CURLY, 0) 

3511 

3512 def tuple_(self, i: int = None): 

3513 if i is None: 

3514 return self.getTypedRuleContexts(PigParser.Tuple_Context) 

3515 else: 

3516 return self.getTypedRuleContext(PigParser.Tuple_Context, i) 

3517 

3518 def COMMA(self, i: int = None): 

3519 if i is None: 

3520 return self.getTokens(PigParser.COMMA) 

3521 else: 

3522 return self.getToken(PigParser.COMMA, i) 

3523 

3524 def NOT(self): 

3525 return self.getToken(PigParser.NOT, 0) 

3526 

3527 def BAG_VAL(self): 

3528 return self.getToken(PigParser.BAG_VAL, 0) 

3529 

3530 def getRuleIndex(self): 

3531 return PigParser.RULE_bag 

3532 

3533 def enterRule(self, listener: ParseTreeListener): 

3534 if hasattr(listener, "enterBag"): 

3535 listener.enterBag(self) 

3536 

3537 def exitRule(self, listener: ParseTreeListener): 

3538 if hasattr(listener, "exitBag"): 

3539 listener.exitBag(self) 

3540 

3541 def bag(self): 

3542 

3543 localctx = PigParser.BagContext(self, self._ctx, self.state) 

3544 self.enterRule(localctx, 96, self.RULE_bag) 

3545 self._la = 0 # Token type 

3546 try: 

3547 self.state = 488 

3548 self._errHandler.sync(self) 

3549 token = self._input.LA(1) 

3550 if token in [PigParser.LEFT_CURLY]: 

3551 self.enterOuterAlt(localctx, 1) 

3552 self.state = 469 

3553 self.match(PigParser.LEFT_CURLY) 

3554 self.state = 478 

3555 self._errHandler.sync(self) 

3556 _la = self._input.LA(1) 

3557 if _la == PigParser.NOT or _la == PigParser.LEFT_PAREN: 

3558 self.state = 470 

3559 self.tuple_() 

3560 self.state = 475 

3561 self._errHandler.sync(self) 

3562 _la = self._input.LA(1) 

3563 while _la == PigParser.COMMA: 

3564 self.state = 471 

3565 self.match(PigParser.COMMA) 

3566 self.state = 472 

3567 self.tuple_() 

3568 self.state = 477 

3569 self._errHandler.sync(self) 

3570 _la = self._input.LA(1) 

3571 

3572 self.state = 480 

3573 self.match(PigParser.RIGHT_CURLY) 

3574 pass 

3575 elif token in [PigParser.NOT]: 

3576 self.enterOuterAlt(localctx, 2) 

3577 self.state = 481 

3578 self.match(PigParser.NOT) 

3579 

3580 self.state = 482 

3581 self.match(PigParser.BAG_VAL) 

3582 self.state = 484 

3583 self._errHandler.sync(self) 

3584 _alt = 1 

3585 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: 

3586 if _alt == 1: 

3587 self.state = 483 

3588 self.tuple_() 

3589 

3590 else: 

3591 raise NoViableAltException(self) 

3592 self.state = 486 

3593 self._errHandler.sync(self) 

3594 _alt = self._interp.adaptivePredict( 

3595 self._input, 52, self._ctx) 

3596 

3597 pass 

3598 else: 

3599 raise NoViableAltException(self) 

3600 

3601 except RecognitionException as re: 

3602 localctx.exception = re 

3603 self._errHandler.reportError(self, re) 

3604 self._errHandler.recover(self, re) 

3605 finally: 

3606 self.exitRule() 

3607 return localctx 

3608 

3609 class Tuple_Context(ParserRuleContext): 

3610 

3611 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

3612 super().__init__(parent, invokingState) 

3613 self.parser = parser 

3614 

3615 def LEFT_PAREN(self): 

3616 return self.getToken(PigParser.LEFT_PAREN, 0) 

3617 

3618 def RIGHT_PAREN(self): 

3619 return self.getToken(PigParser.RIGHT_PAREN, 0) 

3620 

3621 def const_expr(self, i: int = None): 

3622 if i is None: 

3623 return self.getTypedRuleContexts(PigParser.Const_exprContext) 

3624 else: 

3625 return self.getTypedRuleContext(PigParser.Const_exprContext, i) 

3626 

3627 def COMMA(self, i: int = None): 

3628 if i is None: 

3629 return self.getTokens(PigParser.COMMA) 

3630 else: 

3631 return self.getToken(PigParser.COMMA, i) 

3632 

3633 def NOT(self): 

3634 return self.getToken(PigParser.NOT, 0) 

3635 

3636 def tuple_(self): 

3637 return self.getTypedRuleContext(PigParser.Tuple_Context, 0) 

3638 

3639 def getRuleIndex(self): 

3640 return PigParser.RULE_tuple_ 

3641 

3642 def enterRule(self, listener: ParseTreeListener): 

3643 if hasattr(listener, "enterTuple_"): 

3644 listener.enterTuple_(self) 

3645 

3646 def exitRule(self, listener: ParseTreeListener): 

3647 if hasattr(listener, "exitTuple_"): 

3648 listener.exitTuple_(self) 

3649 

3650 def tuple_(self): 

3651 

3652 localctx = PigParser.Tuple_Context(self, self._ctx, self.state) 

3653 self.enterRule(localctx, 98, self.RULE_tuple_) 

3654 self._la = 0 # Token type 

3655 try: 

3656 self.state = 509 

3657 self._errHandler.sync(self) 

3658 token = self._input.LA(1) 

3659 if token in [PigParser.LEFT_PAREN]: 

3660 self.enterOuterAlt(localctx, 1) 

3661 self.state = 490 

3662 self.match(PigParser.LEFT_PAREN) 

3663 self.state = 499 

3664 self._errHandler.sync(self) 

3665 _la = self._input.LA(1) 

3666 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << PigParser.NOT) | (1 << PigParser.NULL) | (1 << PigParser.INTEGER))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (PigParser.DOUBLENUMBER - 65)) | (1 << (PigParser.FLOATNUMBER - 65)) | (1 << (PigParser.QUOTEDSTRING - 65)) | (1 << (PigParser.LEFT_PAREN - 65)) | (1 << (PigParser.LEFT_BRACKET - 65)) | (1 << (PigParser.LONGINEGER - 65)) | (1 << (PigParser.LEFT_CURLY - 65)))) != 0): 

3667 self.state = 491 

3668 self.const_expr() 

3669 self.state = 496 

3670 self._errHandler.sync(self) 

3671 _la = self._input.LA(1) 

3672 while _la == PigParser.COMMA: 

3673 self.state = 492 

3674 self.match(PigParser.COMMA) 

3675 self.state = 493 

3676 self.const_expr() 

3677 self.state = 498 

3678 self._errHandler.sync(self) 

3679 _la = self._input.LA(1) 

3680 

3681 self.state = 501 

3682 self.match(PigParser.RIGHT_PAREN) 

3683 pass 

3684 elif token in [PigParser.NOT]: 

3685 self.enterOuterAlt(localctx, 2) 

3686 self.state = 502 

3687 self.match(PigParser.NOT) 

3688 

3689 self.state = 503 

3690 self.tuple_() 

3691 self.state = 505 

3692 self._errHandler.sync(self) 

3693 _alt = 1 

3694 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: 

3695 if _alt == 1: 

3696 self.state = 504 

3697 self.const_expr() 

3698 

3699 else: 

3700 raise NoViableAltException(self) 

3701 self.state = 507 

3702 self._errHandler.sync(self) 

3703 _alt = self._interp.adaptivePredict( 

3704 self._input, 56, self._ctx) 

3705 

3706 pass 

3707 else: 

3708 raise NoViableAltException(self) 

3709 

3710 except RecognitionException as re: 

3711 localctx.exception = re 

3712 self._errHandler.reportError(self, re) 

3713 self._errHandler.recover(self, re) 

3714 finally: 

3715 self.exitRule() 

3716 return localctx 

3717 

3718 def sempred(self, localctx: RuleContext, ruleIndex: int, predIndex: int): 

3719 if self._predicates == None: 

3720 self._predicates = dict() 

3721 self._predicates[1] = self.query_sempred 

3722 pred = self._predicates.get(ruleIndex, None) 

3723 if pred is None: 

3724 raise Exception("No predicate with index:" + str(ruleIndex)) 

3725 else: 

3726 return pred(localctx, predIndex) 

3727 

3728 def query_sempred(self, localctx: QueryContext, predIndex: int): 

3729 if predIndex == 0: 

3730 return self.precpred(self._ctx, 1)