Hot-keys on this page
r m x p toggle line displays
j k next/prev highlighted chunk
0 (zero) top of page
1 (one) first highlighted chunk
1# Generated from \R.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
12def serializedATN():
13 with StringIO() as buf:
14 buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3H")
15 buf.write("\u02ec\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\3\2\3\2\3\2\3\2\7\2g\n\2\f\2")
23 buf.write("\16\2j\13\2\3\2\3\2\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3")
24 buf.write("\3\3\3\3\3\3\3\7\3z\n\3\f\3\16\3}\13\3\3\3\3\3\7\3\u0081")
25 buf.write("\n\3\f\3\16\3\u0084\13\3\3\3\3\3\7\3\u0088\n\3\f\3\16")
26 buf.write("\3\u008b\13\3\3\3\3\3\7\3\u008f\n\3\f\3\16\3\u0092\13")
27 buf.write("\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3")
28 buf.write("\7\3\u00a1\n\3\f\3\16\3\u00a4\13\3\3\3\3\3\7\3\u00a8\n")
29 buf.write("\3\f\3\16\3\u00ab\13\3\3\3\3\3\3\3\3\3\5\3\u00b1\n\3\3")
30 buf.write("\3\3\3\3\3\3\3\3\3\3\3\7\3\u00b9\n\3\f\3\16\3\u00bc\13")
31 buf.write("\3\3\3\3\3\7\3\u00c0\n\3\f\3\16\3\u00c3\13\3\3\3\3\3\3")
32 buf.write("\3\7\3\u00c8\n\3\f\3\16\3\u00cb\13\3\3\3\3\3\7\3\u00cf")
33 buf.write("\n\3\f\3\16\3\u00d2\13\3\3\3\3\3\3\3\3\3\7\3\u00d8\n\3")
34 buf.write("\f\3\16\3\u00db\13\3\3\3\3\3\7\3\u00df\n\3\f\3\16\3\u00e2")
35 buf.write("\13\3\3\3\3\3\3\3\3\3\7\3\u00e8\n\3\f\3\16\3\u00eb\13")
36 buf.write("\3\3\3\3\3\7\3\u00ef\n\3\f\3\16\3\u00f2\13\3\3\3\3\3\3")
37 buf.write("\3\7\3\u00f7\n\3\f\3\16\3\u00fa\13\3\3\3\3\3\7\3\u00fe")
38 buf.write("\n\3\f\3\16\3\u0101\13\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3")
39 buf.write("\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\7\3\u0113\n\3\f\3\16")
40 buf.write("\3\u0116\13\3\3\4\3\4\7\4\u011a\n\4\f\4\16\4\u011d\13")
41 buf.write("\4\3\4\3\4\7\4\u0121\n\4\f\4\16\4\u0124\13\4\3\4\3\4\7")
42 buf.write("\4\u0128\n\4\f\4\16\4\u012b\13\4\3\4\3\4\3\5\3\5\3\5\3")
43 buf.write("\6\3\6\3\6\7\6\u0135\n\6\f\6\16\6\u0138\13\6\3\6\5\6\u013b")
44 buf.write("\n\6\3\6\7\6\u013e\n\6\f\6\16\6\u0141\13\6\3\6\3\6\3\7")
45 buf.write("\3\7\3\7\7\7\u0148\n\7\f\7\16\7\u014b\13\7\3\7\5\7\u014e")
46 buf.write("\n\7\3\7\7\7\u0151\n\7\f\7\16\7\u0154\13\7\3\7\3\7\3\b")
47 buf.write("\3\b\3\b\3\b\3\b\3\t\3\t\5\t\u015f\n\t\3\t\3\t\3\n\3\n")
48 buf.write("\3\n\3\13\3\13\7\13\u0168\n\13\f\13\16\13\u016b\13\13")
49 buf.write("\3\f\3\f\5\f\u016f\n\f\3\r\3\r\5\r\u0173\n\r\3\r\3\r\7")
50 buf.write("\r\u0177\n\r\f\r\16\r\u017a\13\r\3\r\7\r\u017d\n\r\f\r")
51 buf.write("\16\r\u0180\13\r\3\16\3\16\3\16\3\16\3\16\3\16\5\16\u0188")
52 buf.write("\n\16\3\17\3\17\3\20\3\20\7\20\u018e\n\20\f\20\16\20\u0191")
53 buf.write("\13\20\3\20\3\20\7\20\u0195\n\20\f\20\16\20\u0198\13\20")
54 buf.write("\3\20\3\20\5\20\u019c\n\20\3\20\7\20\u019f\n\20\f\20\16")
55 buf.write("\20\u01a2\13\20\7\20\u01a4\n\20\f\20\16\20\u01a7\13\20")
56 buf.write("\3\21\3\21\5\21\u01ab\n\21\3\21\3\21\5\21\u01af\n\21\3")
57 buf.write("\21\3\21\5\21\u01b3\n\21\7\21\u01b5\n\21\f\21\16\21\u01b8")
58 buf.write("\13\21\3\22\3\22\5\22\u01bc\n\22\3\23\3\23\3\23\3\23\5")
59 buf.write("\23\u01c2\n\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23")
60 buf.write("\3\23\3\23\3\23\3\23\5\23\u01d0\n\23\3\24\3\24\5\24\u01d4")
61 buf.write("\n\24\3\25\3\25\5\25\u01d8\n\25\3\25\3\25\3\25\5\25\u01dd")
62 buf.write("\n\25\3\26\3\26\3\26\3\26\3\26\3\26\3\27\3\27\5\27\u01e7")
63 buf.write("\n\27\3\30\3\30\5\30\u01eb\n\30\3\30\3\30\3\30\3\31\3")
64 buf.write("\31\3\31\3\31\3\31\3\31\3\32\3\32\3\32\3\32\3\32\3\32")
65 buf.write("\3\32\3\32\3\32\3\32\5\32\u0200\n\32\3\33\3\33\3\34\3")
66 buf.write("\34\3\35\3\35\3\35\3\36\3\36\3\36\3\36\3\36\3\36\3\37")
67 buf.write("\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3 \3 \3 \3 \3 \7 ")
68 buf.write("\u021c\n \f \16 \u021f\13 \3 \3 \3 \3 \3 \3 \7 \u0227")
69 buf.write("\n \f \16 \u022a\13 \3 \3 \7 \u022e\n \f \16 \u0231\13")
70 buf.write(" \7 \u0233\n \f \16 \u0236\13 \3!\3!\3!\3!\3!\7!\u023d")
71 buf.write("\n!\f!\16!\u0240\13!\3!\3!\7!\u0244\n!\f!\16!\u0247\13")
72 buf.write("!\3!\3!\3!\3!\3!\7!\u024e\n!\f!\16!\u0251\13!\3!\3!\7")
73 buf.write("!\u0255\n!\f!\16!\u0258\13!\7!\u025a\n!\f!\16!\u025d\13")
74 buf.write("!\3!\3!\7!\u0261\n!\f!\16!\u0264\13!\3!\3!\3\"\3\"\3\"")
75 buf.write("\3#\3#\3#\3#\3#\3$\3$\3$\3$\3$\3$\3$\3$\3$\7$\u0279\n")
76 buf.write("$\f$\16$\u027c\13$\3$\3$\7$\u0280\n$\f$\16$\u0283\13$")
77 buf.write("\3$\3$\5$\u0287\n$\3%\7%\u028a\n%\f%\16%\u028d\13%\3%")
78 buf.write("\3%\7%\u0291\n%\f%\16%\u0294\13%\3%\3%\7%\u0298\n%\f%")
79 buf.write("\16%\u029b\13%\3%\3%\7%\u029f\n%\f%\16%\u02a2\13%\3&\3")
80 buf.write("&\3&\5&\u02a7\n&\3\'\5\'\u02aa\n\'\3\'\3\'\3\'\5\'\u02af")
81 buf.write("\n\'\3(\3(\3(\3(\3(\3(\7(\u02b7\n(\f(\16(\u02ba\13(\3")
82 buf.write("(\3(\3(\7(\u02bf\n(\f(\16(\u02c2\13(\3(\7(\u02c5\n(\f")
83 buf.write("(\16(\u02c8\13(\3(\3(\3(\3(\3(\3(\5(\u02d0\n(\3(\3(\3")
84 buf.write(")\3)\3)\3)\3)\3)\5)\u02da\n)\3*\3*\3+\3+\3,\3,\3-\3-\3")
85 buf.write(".\3.\3/\3/\3\60\3\60\3\61\3\61\3\61\2\3\4\62\2\4\6\b\n")
86 buf.write("\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<")
87 buf.write(">@BDFHJLNPRTVXZ\\^`\2\f\4\2\3\3GG\3\2\7\b\3\2\n\13\3\2")
88 buf.write("\f\r\3\2\36\37\4\2\26\26)-\4\2\31\31\60\61\3\2\62\63\5")
89 buf.write("\2\7\b\32\32\648\3\29>\2\u0337\2h\3\2\2\2\4\u00b0\3\2")
90 buf.write("\2\2\6\u0117\3\2\2\2\b\u012e\3\2\2\2\n\u0131\3\2\2\2\f")
91 buf.write("\u0144\3\2\2\2\16\u0157\3\2\2\2\20\u015c\3\2\2\2\22\u0162")
92 buf.write("\3\2\2\2\24\u0165\3\2\2\2\26\u016c\3\2\2\2\30\u0170\3")
93 buf.write("\2\2\2\32\u0187\3\2\2\2\34\u0189\3\2\2\2\36\u018b\3\2")
94 buf.write("\2\2 \u01a8\3\2\2\2\"\u01bb\3\2\2\2$\u01cf\3\2\2\2&\u01d3")
95 buf.write("\3\2\2\2(\u01d7\3\2\2\2*\u01de\3\2\2\2,\u01e6\3\2\2\2")
96 buf.write(".\u01ea\3\2\2\2\60\u01ef\3\2\2\2\62\u01ff\3\2\2\2\64\u0201")
97 buf.write("\3\2\2\2\66\u0203\3\2\2\28\u0205\3\2\2\2:\u0208\3\2\2")
98 buf.write("\2<\u020e\3\2\2\2>\u0216\3\2\2\2@\u0237\3\2\2\2B\u0267")
99 buf.write("\3\2\2\2D\u026a\3\2\2\2F\u026f\3\2\2\2H\u028b\3\2\2\2")
100 buf.write("J\u02a6\3\2\2\2L\u02a9\3\2\2\2N\u02b0\3\2\2\2P\u02d3\3")
101 buf.write("\2\2\2R\u02db\3\2\2\2T\u02dd\3\2\2\2V\u02df\3\2\2\2X\u02e1")
102 buf.write("\3\2\2\2Z\u02e3\3\2\2\2\\\u02e5\3\2\2\2^\u02e7\3\2\2\2")
103 buf.write("`\u02e9\3\2\2\2bc\5\4\3\2cd\t\2\2\2dg\3\2\2\2eg\7G\2\2")
104 buf.write("fb\3\2\2\2fe\3\2\2\2gj\3\2\2\2hf\3\2\2\2hi\3\2\2\2ik\3")
105 buf.write("\2\2\2jh\3\2\2\2kl\7\2\2\3l\3\3\2\2\2mn\b\3\1\2n\u00b1")
106 buf.write("\5&\24\2o\u00b1\5,\27\2pq\t\3\2\2q\u00b1\5\4\3\35rs\7")
107 buf.write("\t\2\2s\u00b1\5\4\3\27t\u00b1\5J&\2u\u00b1\5\6\4\2v\u00b1")
108 buf.write("\5\b\5\2w\u00b1\5F$\2xz\7G\2\2yx\3\2\2\2z}\3\2\2\2{y\3")
109 buf.write("\2\2\2{|\3\2\2\2|~\3\2\2\2}{\3\2\2\2~\u0082\7\16\2\2\177")
110 buf.write("\u0081\7G\2\2\u0080\177\3\2\2\2\u0081\u0084\3\2\2\2\u0082")
111 buf.write("\u0080\3\2\2\2\u0082\u0083\3\2\2\2\u0083\u0085\3\2\2\2")
112 buf.write("\u0084\u0082\3\2\2\2\u0085\u0089\5\24\13\2\u0086\u0088")
113 buf.write("\7G\2\2\u0087\u0086\3\2\2\2\u0088\u008b\3\2\2\2\u0089")
114 buf.write("\u0087\3\2\2\2\u0089\u008a\3\2\2\2\u008a\u008c\3\2\2\2")
115 buf.write("\u008b\u0089\3\2\2\2\u008c\u0090\7\17\2\2\u008d\u008f")
116 buf.write("\7G\2\2\u008e\u008d\3\2\2\2\u008f\u0092\3\2\2\2\u0090")
117 buf.write("\u008e\3\2\2\2\u0090\u0091\3\2\2\2\u0091\u00b1\3\2\2\2")
118 buf.write("\u0092\u0090\3\2\2\2\u0093\u00b1\5D#\2\u0094\u00b1\5@")
119 buf.write("!\2\u0095\u00b1\5> \2\u0096\u00b1\5<\37\2\u0097\u00b1")
120 buf.write("\5:\36\2\u0098\u00b1\58\35\2\u0099\u009a\7\20\2\2\u009a")
121 buf.write("\u00b1\5\4\3\t\u009b\u00b1\5\16\b\2\u009c\u00b1\5\66\34")
122 buf.write("\2\u009d\u00b1\7\21\2\2\u009e\u00a2\7\22\2\2\u009f\u00a1")
123 buf.write("\7G\2\2\u00a0\u009f\3\2\2\2\u00a1\u00a4\3\2\2\2\u00a2")
124 buf.write("\u00a0\3\2\2\2\u00a2\u00a3\3\2\2\2\u00a3\u00a5\3\2\2\2")
125 buf.write("\u00a4\u00a2\3\2\2\2\u00a5\u00a9\5\4\3\2\u00a6\u00a8\7")
126 buf.write("G\2\2\u00a7\u00a6\3\2\2\2\u00a8\u00ab\3\2\2\2\u00a9\u00a7")
127 buf.write("\3\2\2\2\u00a9\u00aa\3\2\2\2\u00aa\u00ac\3\2\2\2\u00ab")
128 buf.write("\u00a9\3\2\2\2\u00ac\u00ad\7\23\2\2\u00ad\u00b1\3\2\2")
129 buf.write("\2\u00ae\u00b1\5\62\32\2\u00af\u00b1\5V,\2\u00b0m\3\2")
130 buf.write("\2\2\u00b0o\3\2\2\2\u00b0p\3\2\2\2\u00b0r\3\2\2\2\u00b0")
131 buf.write("t\3\2\2\2\u00b0u\3\2\2\2\u00b0v\3\2\2\2\u00b0w\3\2\2\2")
132 buf.write("\u00b0{\3\2\2\2\u00b0\u0093\3\2\2\2\u00b0\u0094\3\2\2")
133 buf.write("\2\u00b0\u0095\3\2\2\2\u00b0\u0096\3\2\2\2\u00b0\u0097")
134 buf.write("\3\2\2\2\u00b0\u0098\3\2\2\2\u00b0\u0099\3\2\2\2\u00b0")
135 buf.write("\u009b\3\2\2\2\u00b0\u009c\3\2\2\2\u00b0\u009d\3\2\2\2")
136 buf.write("\u00b0\u009e\3\2\2\2\u00b0\u00ae\3\2\2\2\u00b0\u00af\3")
137 buf.write("\2\2\2\u00b1\u0114\3\2\2\2\u00b2\u00b3\f\36\2\2\u00b3")
138 buf.write("\u00b4\5\\/\2\u00b4\u00b5\5\4\3\37\u00b5\u0113\3\2\2\2")
139 buf.write("\u00b6\u00ba\f\32\2\2\u00b7\u00b9\7G\2\2\u00b8\u00b7\3")
140 buf.write("\2\2\2\u00b9\u00bc\3\2\2\2\u00ba\u00b8\3\2\2\2\u00ba\u00bb")
141 buf.write("\3\2\2\2\u00bb\u00bd\3\2\2\2\u00bc\u00ba\3\2\2\2\u00bd")
142 buf.write("\u00c1\7F\2\2\u00be\u00c0\7G\2\2\u00bf\u00be\3\2\2\2\u00c0")
143 buf.write("\u00c3\3\2\2\2\u00c1\u00bf\3\2\2\2\u00c1\u00c2\3\2\2\2")
144 buf.write("\u00c2\u00c4\3\2\2\2\u00c3\u00c1\3\2\2\2\u00c4\u0113\5")
145 buf.write("\4\3\32\u00c5\u00c9\f\31\2\2\u00c6\u00c8\7G\2\2\u00c7")
146 buf.write("\u00c6\3\2\2\2\u00c8\u00cb\3\2\2\2\u00c9\u00c7\3\2\2\2")
147 buf.write("\u00c9\u00ca\3\2\2\2\u00ca\u00cc\3\2\2\2\u00cb\u00c9\3")
148 buf.write("\2\2\2\u00cc\u00d0\5^\60\2\u00cd\u00cf\7G\2\2\u00ce\u00cd")
149 buf.write("\3\2\2\2\u00cf\u00d2\3\2\2\2\u00d0\u00ce\3\2\2\2\u00d0")
150 buf.write("\u00d1\3\2\2\2\u00d1\u00d3\3\2\2\2\u00d2\u00d0\3\2\2\2")
151 buf.write("\u00d3\u00d4\5\4\3\31\u00d4\u0113\3\2\2\2\u00d5\u00d9")
152 buf.write("\f\30\2\2\u00d6\u00d8\7G\2\2\u00d7\u00d6\3\2\2\2\u00d8")
153 buf.write("\u00db\3\2\2\2\u00d9\u00d7\3\2\2\2\u00d9\u00da\3\2\2\2")
154 buf.write("\u00da\u00dc\3\2\2\2\u00db\u00d9\3\2\2\2\u00dc\u00e0\5")
155 buf.write("`\61\2\u00dd\u00df\7G\2\2\u00de\u00dd\3\2\2\2\u00df\u00e2")
156 buf.write("\3\2\2\2\u00e0\u00de\3\2\2\2\u00e0\u00e1\3\2\2\2\u00e1")
157 buf.write("\u00e3\3\2\2\2\u00e2\u00e0\3\2\2\2\u00e3\u00e4\5\4\3\30")
158 buf.write("\u00e4\u0113\3\2\2\2\u00e5\u00e9\f\26\2\2\u00e6\u00e8")
159 buf.write("\7G\2\2\u00e7\u00e6\3\2\2\2\u00e8\u00eb\3\2\2\2\u00e9")
160 buf.write("\u00e7\3\2\2\2\u00e9\u00ea\3\2\2\2\u00ea\u00ec\3\2\2\2")
161 buf.write("\u00eb\u00e9\3\2\2\2\u00ec\u00f0\t\4\2\2\u00ed\u00ef\7")
162 buf.write("G\2\2\u00ee\u00ed\3\2\2\2\u00ef\u00f2\3\2\2\2\u00f0\u00ee")
163 buf.write("\3\2\2\2\u00f0\u00f1\3\2\2\2\u00f1\u00f3\3\2\2\2\u00f2")
164 buf.write("\u00f0\3\2\2\2\u00f3\u0113\5\4\3\27\u00f4\u00f8\f\25\2")
165 buf.write("\2\u00f5\u00f7\7G\2\2\u00f6\u00f5\3\2\2\2\u00f7\u00fa")
166 buf.write("\3\2\2\2\u00f8\u00f6\3\2\2\2\u00f8\u00f9\3\2\2\2\u00f9")
167 buf.write("\u00fb\3\2\2\2\u00fa\u00f8\3\2\2\2\u00fb\u00ff\t\5\2\2")
168 buf.write("\u00fc\u00fe\7G\2\2\u00fd\u00fc\3\2\2\2\u00fe\u0101\3")
169 buf.write("\2\2\2\u00ff\u00fd\3\2\2\2\u00ff\u0100\3\2\2\2\u0100\u0102")
170 buf.write("\3\2\2\2\u0101\u00ff\3\2\2\2\u0102\u0113\5\4\3\26\u0103")
171 buf.write("\u0104\f \2\2\u0104\u0105\7\4\2\2\u0105\u0106\5\36\20")
172 buf.write("\2\u0106\u0107\7\5\2\2\u0107\u0108\7\5\2\2\u0108\u0113")
173 buf.write("\3\2\2\2\u0109\u010a\f\37\2\2\u010a\u010b\7\6\2\2\u010b")
174 buf.write("\u010c\5\36\20\2\u010c\u010d\7\5\2\2\u010d\u0113\3\2\2")
175 buf.write("\2\u010e\u010f\f\34\2\2\u010f\u0113\5\20\t\2\u0110\u0111")
176 buf.write("\f\33\2\2\u0111\u0113\5\22\n\2\u0112\u00b2\3\2\2\2\u0112")
177 buf.write("\u00b6\3\2\2\2\u0112\u00c5\3\2\2\2\u0112\u00d5\3\2\2\2")
178 buf.write("\u0112\u00e5\3\2\2\2\u0112\u00f4\3\2\2\2\u0112\u0103\3")
179 buf.write("\2\2\2\u0112\u0109\3\2\2\2\u0112\u010e\3\2\2\2\u0112\u0110")
180 buf.write("\3\2\2\2\u0113\u0116\3\2\2\2\u0114\u0112\3\2\2\2\u0114")
181 buf.write("\u0115\3\2\2\2\u0115\5\3\2\2\2\u0116\u0114\3\2\2\2\u0117")
182 buf.write("\u011b\5\f\7\2\u0118\u011a\7G\2\2\u0119\u0118\3\2\2\2")
183 buf.write("\u011a\u011d\3\2\2\2\u011b\u0119\3\2\2\2\u011b\u011c\3")
184 buf.write("\2\2\2\u011c\u011e\3\2\2\2\u011d\u011b\3\2\2\2\u011e\u0122")
185 buf.write("\7\16\2\2\u011f\u0121\7G\2\2\u0120\u011f\3\2\2\2\u0121")
186 buf.write("\u0124\3\2\2\2\u0122\u0120\3\2\2\2\u0122\u0123\3\2\2\2")
187 buf.write("\u0123\u0125\3\2\2\2\u0124\u0122\3\2\2\2\u0125\u0129\5")
188 buf.write("\24\13\2\u0126\u0128\7G\2\2\u0127\u0126\3\2\2\2\u0128")
189 buf.write("\u012b\3\2\2\2\u0129\u0127\3\2\2\2\u0129\u012a\3\2\2\2")
190 buf.write("\u012a\u012c\3\2\2\2\u012b\u0129\3\2\2\2\u012c\u012d\7")
191 buf.write("\17\2\2\u012d\7\3\2\2\2\u012e\u012f\5\n\6\2\u012f\u0130")
192 buf.write("\5\4\3\2\u0130\t\3\2\2\2\u0131\u0132\5T+\2\u0132\u0136")
193 buf.write("\7\22\2\2\u0133\u0135\7G\2\2\u0134\u0133\3\2\2\2\u0135")
194 buf.write("\u0138\3\2\2\2\u0136\u0134\3\2\2\2\u0136\u0137\3\2\2\2")
195 buf.write("\u0137\u013a\3\2\2\2\u0138\u0136\3\2\2\2\u0139\u013b\5")
196 buf.write("\30\r\2\u013a\u0139\3\2\2\2\u013a\u013b\3\2\2\2\u013b")
197 buf.write("\u013f\3\2\2\2\u013c\u013e\7G\2\2\u013d\u013c\3\2\2\2")
198 buf.write("\u013e\u0141\3\2\2\2\u013f\u013d\3\2\2\2\u013f\u0140\3")
199 buf.write("\2\2\2\u0140\u0142\3\2\2\2\u0141\u013f\3\2\2\2\u0142\u0143")
200 buf.write("\7\23\2\2\u0143\13\3\2\2\2\u0144\u0145\5T+\2\u0145\u0149")
201 buf.write("\7\22\2\2\u0146\u0148\7G\2\2\u0147\u0146\3\2\2\2\u0148")
202 buf.write("\u014b\3\2\2\2\u0149\u0147\3\2\2\2\u0149\u014a\3\2\2\2")
203 buf.write("\u014a\u014d\3\2\2\2\u014b\u0149\3\2\2\2\u014c\u014e\5")
204 buf.write("\30\r\2\u014d\u014c\3\2\2\2\u014d\u014e\3\2\2\2\u014e")
205 buf.write("\u0152\3\2\2\2\u014f\u0151\7G\2\2\u0150\u014f\3\2\2\2")
206 buf.write("\u0151\u0154\3\2\2\2\u0152\u0150\3\2\2\2\u0152\u0153\3")
207 buf.write("\2\2\2\u0153\u0155\3\2\2\2\u0154\u0152\3\2\2\2\u0155\u0156")
208 buf.write("\7\23\2\2\u0156\r\3\2\2\2\u0157\u0158\7\24\2\2\u0158\u0159")
209 buf.write("\7\22\2\2\u0159\u015a\5V,\2\u015a\u015b\7\23\2\2\u015b")
210 buf.write("\17\3\2\2\2\u015c\u015e\5R*\2\u015d\u015f\7G\2\2\u015e")
211 buf.write("\u015d\3\2\2\2\u015e\u015f\3\2\2\2\u015f\u0160\3\2\2\2")
212 buf.write("\u0160\u0161\5\4\3\2\u0161\21\3\2\2\2\u0162\u0163\5Z.")
213 buf.write("\2\u0163\u0164\5\4\3\2\u0164\23\3\2\2\2\u0165\u0169\5")
214 buf.write("\4\3\2\u0166\u0168\5\26\f\2\u0167\u0166\3\2\2\2\u0168")
215 buf.write("\u016b\3\2\2\2\u0169\u0167\3\2\2\2\u0169\u016a\3\2\2\2")
216 buf.write("\u016a\25\3\2\2\2\u016b\u0169\3\2\2\2\u016c\u016e\t\2")
217 buf.write("\2\2\u016d\u016f\5\4\3\2\u016e\u016d\3\2\2\2\u016e\u016f")
218 buf.write("\3\2\2\2\u016f\27\3\2\2\2\u0170\u017e\5\32\16\2\u0171")
219 buf.write("\u0173\7G\2\2\u0172\u0171\3\2\2\2\u0172\u0173\3\2\2\2")
220 buf.write("\u0173\u0174\3\2\2\2\u0174\u0178\7\25\2\2\u0175\u0177")
221 buf.write("\7G\2\2\u0176\u0175\3\2\2\2\u0177\u017a\3\2\2\2\u0178")
222 buf.write("\u0176\3\2\2\2\u0178\u0179\3\2\2\2\u0179\u017b\3\2\2\2")
223 buf.write("\u017a\u0178\3\2\2\2\u017b\u017d\5\32\16\2\u017c\u0172")
224 buf.write("\3\2\2\2\u017d\u0180\3\2\2\2\u017e\u017c\3\2\2\2\u017e")
225 buf.write("\u017f\3\2\2\2\u017f\31\3\2\2\2\u0180\u017e\3\2\2\2\u0181")
226 buf.write("\u0188\5\34\17\2\u0182\u0183\5\34\17\2\u0183\u0184\7\26")
227 buf.write("\2\2\u0184\u0185\5\4\3\2\u0185\u0188\3\2\2\2\u0186\u0188")
228 buf.write("\7\27\2\2\u0187\u0181\3\2\2\2\u0187\u0182\3\2\2\2\u0187")
229 buf.write("\u0186\3\2\2\2\u0188\33\3\2\2\2\u0189\u018a\7E\2\2\u018a")
230 buf.write("\35\3\2\2\2\u018b\u01a5\5\"\22\2\u018c\u018e\7G\2\2\u018d")
231 buf.write("\u018c\3\2\2\2\u018e\u0191\3\2\2\2\u018f\u018d\3\2\2\2")
232 buf.write("\u018f\u0190\3\2\2\2\u0190\u0192\3\2\2\2\u0191\u018f\3")
233 buf.write("\2\2\2\u0192\u0196\7\25\2\2\u0193\u0195\7G\2\2\u0194\u0193")
234 buf.write("\3\2\2\2\u0195\u0198\3\2\2\2\u0196\u0194\3\2\2\2\u0196")
235 buf.write("\u0197\3\2\2\2\u0197\u019b\3\2\2\2\u0198\u0196\3\2\2\2")
236 buf.write("\u0199\u019c\5H%\2\u019a\u019c\5\"\22\2\u019b\u0199\3")
237 buf.write("\2\2\2\u019b\u019a\3\2\2\2\u019c\u01a0\3\2\2\2\u019d\u019f")
238 buf.write("\7G\2\2\u019e\u019d\3\2\2\2\u019f\u01a2\3\2\2\2\u01a0")
239 buf.write("\u019e\3\2\2\2\u01a0\u01a1\3\2\2\2\u01a1\u01a4\3\2\2\2")
240 buf.write("\u01a2\u01a0\3\2\2\2\u01a3\u018f\3\2\2\2\u01a4\u01a7\3")
241 buf.write("\2\2\2\u01a5\u01a3\3\2\2\2\u01a5\u01a6\3\2\2\2\u01a6\37")
242 buf.write("\3\2\2\2\u01a7\u01a5\3\2\2\2\u01a8\u01b6\5V,\2\u01a9\u01ab")
243 buf.write("\7G\2\2\u01aa\u01a9\3\2\2\2\u01aa\u01ab\3\2\2\2\u01ab")
244 buf.write("\u01ac\3\2\2\2\u01ac\u01ae\7\b\2\2\u01ad\u01af\7G\2\2")
245 buf.write("\u01ae\u01ad\3\2\2\2\u01ae\u01af\3\2\2\2\u01af\u01b0\3")
246 buf.write("\2\2\2\u01b0\u01b2\5V,\2\u01b1\u01b3\7G\2\2\u01b2\u01b1")
247 buf.write("\3\2\2\2\u01b2\u01b3\3\2\2\2\u01b3\u01b5\3\2\2\2\u01b4")
248 buf.write("\u01aa\3\2\2\2\u01b5\u01b8\3\2\2\2\u01b6\u01b4\3\2\2\2")
249 buf.write("\u01b6\u01b7\3\2\2\2\u01b7!\3\2\2\2\u01b8\u01b6\3\2\2")
250 buf.write("\2\u01b9\u01bc\5$\23\2\u01ba\u01bc\5\4\3\2\u01bb\u01b9")
251 buf.write("\3\2\2\2\u01bb\u01ba\3\2\2\2\u01bc#\3\2\2\2\u01bd\u01be")
252 buf.write("\5V,\2\u01be\u01c1\7\26\2\2\u01bf\u01c2\5H%\2\u01c0\u01c2")
253 buf.write("\5\4\3\2\u01c1\u01bf\3\2\2\2\u01c1\u01c0\3\2\2\2\u01c2")
254 buf.write("\u01d0\3\2\2\2\u01c3\u01c4\7D\2\2\u01c4\u01d0\7\26\2\2")
255 buf.write("\u01c5\u01c6\7D\2\2\u01c6\u01c7\7\26\2\2\u01c7\u01d0\5")
256 buf.write("\4\3\2\u01c8\u01c9\7\30\2\2\u01c9\u01d0\7\26\2\2\u01ca")
257 buf.write("\u01cb\7\30\2\2\u01cb\u01cc\7\26\2\2\u01cc\u01d0\5\4\3")
258 buf.write("\2\u01cd\u01d0\7\27\2\2\u01ce\u01d0\7\31\2\2\u01cf\u01bd")
259 buf.write("\3\2\2\2\u01cf\u01c3\3\2\2\2\u01cf\u01c5\3\2\2\2\u01cf")
260 buf.write("\u01c8\3\2\2\2\u01cf\u01ca\3\2\2\2\u01cf\u01cd\3\2\2\2")
261 buf.write("\u01cf\u01ce\3\2\2\2\u01d0%\3\2\2\2\u01d1\u01d4\5(\25")
262 buf.write("\2\u01d2\u01d4\5*\26\2\u01d3\u01d1\3\2\2\2\u01d3\u01d2")
263 buf.write("\3\2\2\2\u01d4\'\3\2\2\2\u01d5\u01d8\5V,\2\u01d6\u01d8")
264 buf.write("\7A\2\2\u01d7\u01d5\3\2\2\2\u01d7\u01d6\3\2\2\2\u01d8")
265 buf.write("\u01d9\3\2\2\2\u01d9\u01dc\7\31\2\2\u01da\u01dd\5V,\2")
266 buf.write("\u01db\u01dd\7A\2\2\u01dc\u01da\3\2\2\2\u01dc\u01db\3")
267 buf.write("\2\2\2\u01dd)\3\2\2\2\u01de\u01df\7\22\2\2\u01df\u01e0")
268 buf.write("\5\4\3\2\u01e0\u01e1\7\23\2\2\u01e1\u01e2\7\31\2\2\u01e2")
269 buf.write("\u01e3\5\4\3\2\u01e3+\3\2\2\2\u01e4\u01e7\5.\30\2\u01e5")
270 buf.write("\u01e7\5\60\31\2\u01e6\u01e4\3\2\2\2\u01e6\u01e5\3\2\2")
271 buf.write("\2\u01e7-\3\2\2\2\u01e8\u01eb\5V,\2\u01e9\u01eb\5\62\32")
272 buf.write("\2\u01ea\u01e8\3\2\2\2\u01ea\u01e9\3\2\2\2\u01eb\u01ec")
273 buf.write("\3\2\2\2\u01ec\u01ed\7\32\2\2\u01ed\u01ee\5\4\3\2\u01ee")
274 buf.write("/\3\2\2\2\u01ef\u01f0\7\22\2\2\u01f0\u01f1\5\4\3\2\u01f1")
275 buf.write("\u01f2\7\23\2\2\u01f2\u01f3\7\32\2\2\u01f3\u01f4\5\4\3")
276 buf.write("\2\u01f4\61\3\2\2\2\u01f5\u0200\7D\2\2\u01f6\u0200\7@")
277 buf.write("\2\2\u01f7\u0200\7A\2\2\u01f8\u0200\7B\2\2\u01f9\u0200")
278 buf.write("\7C\2\2\u01fa\u0200\7\30\2\2\u01fb\u0200\7\33\2\2\u01fc")
279 buf.write("\u0200\7\34\2\2\u01fd\u0200\7\35\2\2\u01fe\u0200\5\64")
280 buf.write("\33\2\u01ff\u01f5\3\2\2\2\u01ff\u01f6\3\2\2\2\u01ff\u01f7")
281 buf.write("\3\2\2\2\u01ff\u01f8\3\2\2\2\u01ff\u01f9\3\2\2\2\u01ff")
282 buf.write("\u01fa\3\2\2\2\u01ff\u01fb\3\2\2\2\u01ff\u01fc\3\2\2\2")
283 buf.write("\u01ff\u01fd\3\2\2\2\u01ff\u01fe\3\2\2\2\u0200\63\3\2")
284 buf.write("\2\2\u0201\u0202\t\6\2\2\u0202\65\3\2\2\2\u0203\u0204")
285 buf.write("\7 \2\2\u0204\67\3\2\2\2\u0205\u0206\7!\2\2\u0206\u0207")
286 buf.write("\5\4\3\2\u02079\3\2\2\2\u0208\u0209\7\"\2\2\u0209\u020a")
287 buf.write("\7\22\2\2\u020a\u020b\5\4\3\2\u020b\u020c\7\23\2\2\u020c")
288 buf.write("\u020d\5\4\3\2\u020d;\3\2\2\2\u020e\u020f\7#\2\2\u020f")
289 buf.write("\u0210\7\22\2\2\u0210\u0211\5V,\2\u0211\u0212\7$\2\2\u0212")
290 buf.write("\u0213\5\4\3\2\u0213\u0214\7\23\2\2\u0214\u0215\5\4\3")
291 buf.write("\2\u0215=\3\2\2\2\u0216\u0217\7%\2\2\u0217\u0218\7\22")
292 buf.write("\2\2\u0218\u0219\5\4\3\2\u0219\u021d\7\23\2\2\u021a\u021c")
293 buf.write("\7G\2\2\u021b\u021a\3\2\2\2\u021c\u021f\3\2\2\2\u021d")
294 buf.write("\u021b\3\2\2\2\u021d\u021e\3\2\2\2\u021e\u0220\3\2\2\2")
295 buf.write("\u021f\u021d\3\2\2\2\u0220\u0234\5\4\3\2\u0221\u0222\5")
296 buf.write("B\"\2\u0222\u0223\7\22\2\2\u0223\u0224\5\4\3\2\u0224\u0228")
297 buf.write("\7\23\2\2\u0225\u0227\7G\2\2\u0226\u0225\3\2\2\2\u0227")
298 buf.write("\u022a\3\2\2\2\u0228\u0226\3\2\2\2\u0228\u0229\3\2\2\2")
299 buf.write("\u0229\u022b\3\2\2\2\u022a\u0228\3\2\2\2\u022b\u022f\5")
300 buf.write("\4\3\2\u022c\u022e\7G\2\2\u022d\u022c\3\2\2\2\u022e\u0231")
301 buf.write("\3\2\2\2\u022f\u022d\3\2\2\2\u022f\u0230\3\2\2\2\u0230")
302 buf.write("\u0233\3\2\2\2\u0231\u022f\3\2\2\2\u0232\u0221\3\2\2\2")
303 buf.write("\u0233\u0236\3\2\2\2\u0234\u0232\3\2\2\2\u0234\u0235\3")
304 buf.write("\2\2\2\u0235?\3\2\2\2\u0236\u0234\3\2\2\2\u0237\u0238")
305 buf.write("\7%\2\2\u0238\u0239\7\22\2\2\u0239\u023a\5\4\3\2\u023a")
306 buf.write("\u023e\7\23\2\2\u023b\u023d\7G\2\2\u023c\u023b\3\2\2\2")
307 buf.write("\u023d\u0240\3\2\2\2\u023e\u023c\3\2\2\2\u023e\u023f\3")
308 buf.write("\2\2\2\u023f\u0241\3\2\2\2\u0240\u023e\3\2\2\2\u0241\u0245")
309 buf.write("\5\4\3\2\u0242\u0244\7G\2\2\u0243\u0242\3\2\2\2\u0244")
310 buf.write("\u0247\3\2\2\2\u0245\u0243\3\2\2\2\u0245\u0246\3\2\2\2")
311 buf.write("\u0246\u025b\3\2\2\2\u0247\u0245\3\2\2\2\u0248\u0249\5")
312 buf.write("B\"\2\u0249\u024a\7\22\2\2\u024a\u024b\5\4\3\2\u024b\u024f")
313 buf.write("\7\23\2\2\u024c\u024e\7G\2\2\u024d\u024c\3\2\2\2\u024e")
314 buf.write("\u0251\3\2\2\2\u024f\u024d\3\2\2\2\u024f\u0250\3\2\2\2")
315 buf.write("\u0250\u0252\3\2\2\2\u0251\u024f\3\2\2\2\u0252\u0256\5")
316 buf.write("\4\3\2\u0253\u0255\7G\2\2\u0254\u0253\3\2\2\2\u0255\u0258")
317 buf.write("\3\2\2\2\u0256\u0254\3\2\2\2\u0256\u0257\3\2\2\2\u0257")
318 buf.write("\u025a\3\2\2\2\u0258\u0256\3\2\2\2\u0259\u0248\3\2\2\2")
319 buf.write("\u025a\u025d\3\2\2\2\u025b\u0259\3\2\2\2\u025b\u025c\3")
320 buf.write("\2\2\2\u025c\u025e\3\2\2\2\u025d\u025b\3\2\2\2\u025e\u0262")
321 buf.write("\7&\2\2\u025f\u0261\7G\2\2\u0260\u025f\3\2\2\2\u0261\u0264")
322 buf.write("\3\2\2\2\u0262\u0260\3\2\2\2\u0262\u0263\3\2\2\2\u0263")
323 buf.write("\u0265\3\2\2\2\u0264\u0262\3\2\2\2\u0265\u0266\5\4\3\2")
324 buf.write("\u0266A\3\2\2\2\u0267\u0268\7&\2\2\u0268\u0269\7%\2\2")
325 buf.write("\u0269C\3\2\2\2\u026a\u026b\7\'\2\2\u026b\u026c\7\22\2")
326 buf.write("\2\u026c\u026d\5\4\3\2\u026d\u026e\7\23\2\2\u026eE\3\2")
327 buf.write("\2\2\u026f\u0286\5V,\2\u0270\u0271\7\22\2\2\u0271\u0287")
328 buf.write("\7\23\2\2\u0272\u0273\7\22\2\2\u0273\u0274\5H%\2\u0274")
329 buf.write("\u0275\7\23\2\2\u0275\u0287\3\2\2\2\u0276\u027a\7\22\2")
330 buf.write("\2\u0277\u0279\7G\2\2\u0278\u0277\3\2\2\2\u0279\u027c")
331 buf.write("\3\2\2\2\u027a\u0278\3\2\2\2\u027a\u027b\3\2\2\2\u027b")
332 buf.write("\u027d\3\2\2\2\u027c\u027a\3\2\2\2\u027d\u0281\5\36\20")
333 buf.write("\2\u027e\u0280\7G\2\2\u027f\u027e\3\2\2\2\u0280\u0283")
334 buf.write("\3\2\2\2\u0281\u027f\3\2\2\2\u0281\u0282\3\2\2\2\u0282")
335 buf.write("\u0284\3\2\2\2\u0283\u0281\3\2\2\2\u0284\u0285\7\23\2")
336 buf.write("\2\u0285\u0287\3\2\2\2\u0286\u0270\3\2\2\2\u0286\u0272")
337 buf.write("\3\2\2\2\u0286\u0276\3\2\2\2\u0287G\3\2\2\2\u0288\u028a")
338 buf.write("\7G\2\2\u0289\u0288\3\2\2\2\u028a\u028d\3\2\2\2\u028b")
339 buf.write("\u0289\3\2\2\2\u028b\u028c\3\2\2\2\u028c\u028e\3\2\2\2")
340 buf.write("\u028d\u028b\3\2\2\2\u028e\u0292\7\16\2\2\u028f\u0291")
341 buf.write("\7G\2\2\u0290\u028f\3\2\2\2\u0291\u0294\3\2\2\2\u0292")
342 buf.write("\u0290\3\2\2\2\u0292\u0293\3\2\2\2\u0293\u0295\3\2\2\2")
343 buf.write("\u0294\u0292\3\2\2\2\u0295\u0299\5\24\13\2\u0296\u0298")
344 buf.write("\7G\2\2\u0297\u0296\3\2\2\2\u0298\u029b\3\2\2\2\u0299")
345 buf.write("\u0297\3\2\2\2\u0299\u029a\3\2\2\2\u029a\u029c\3\2\2\2")
346 buf.write("\u029b\u0299\3\2\2\2\u029c\u02a0\7\17\2\2\u029d\u029f")
347 buf.write("\7G\2\2\u029e\u029d\3\2\2\2\u029f\u02a2\3\2\2\2\u02a0")
348 buf.write("\u029e\3\2\2\2\u02a0\u02a1\3\2\2\2\u02a1I\3\2\2\2\u02a2")
349 buf.write("\u02a0\3\2\2\2\u02a3\u02a7\5N(\2\u02a4\u02a7\5L\'\2\u02a5")
350 buf.write("\u02a7\5P)\2\u02a6\u02a3\3\2\2\2\u02a6\u02a4\3\2\2\2\u02a6")
351 buf.write("\u02a5\3\2\2\2\u02a7K\3\2\2\2\u02a8\u02aa\5V,\2\u02a9")
352 buf.write("\u02a8\3\2\2\2\u02a9\u02aa\3\2\2\2\u02aa\u02ab\3\2\2\2")
353 buf.write("\u02ab\u02ae\5X-\2\u02ac\u02af\5 \21\2\u02ad\u02af\7\24")
354 buf.write("\2\2\u02ae\u02ac\3\2\2\2\u02ae\u02ad\3\2\2\2\u02afM\3")
355 buf.write("\2\2\2\u02b0\u02b1\7(\2\2\u02b1\u02b2\7\22\2\2\u02b2\u02b3")
356 buf.write("\5V,\2\u02b3\u02cf\7\25\2\2\u02b4\u02b8\7\16\2\2\u02b5")
357 buf.write("\u02b7\7G\2\2\u02b6\u02b5\3\2\2\2\u02b7\u02ba\3\2\2\2")
358 buf.write("\u02b8\u02b6\3\2\2\2\u02b8\u02b9\3\2\2\2\u02b9\u02bb\3")
359 buf.write("\2\2\2\u02ba\u02b8\3\2\2\2\u02bb\u02c0\5\4\3\2\u02bc\u02bd")
360 buf.write("\7\3\2\2\u02bd\u02bf\5\4\3\2\u02be\u02bc\3\2\2\2\u02bf")
361 buf.write("\u02c2\3\2\2\2\u02c0\u02be\3\2\2\2\u02c0\u02c1\3\2\2\2")
362 buf.write("\u02c1\u02c6\3\2\2\2\u02c2\u02c0\3\2\2\2\u02c3\u02c5\7")
363 buf.write("G\2\2\u02c4\u02c3\3\2\2\2\u02c5\u02c8\3\2\2\2\u02c6\u02c4")
364 buf.write("\3\2\2\2\u02c6\u02c7\3\2\2\2\u02c7\u02c9\3\2\2\2\u02c8")
365 buf.write("\u02c6\3\2\2\2\u02c9\u02ca\7\17\2\2\u02ca\u02d0\3\2\2")
366 buf.write("\2\u02cb\u02cc\5V,\2\u02cc\u02cd\5R*\2\u02cd\u02ce\5\4")
367 buf.write("\3\2\u02ce\u02d0\3\2\2\2\u02cf\u02b4\3\2\2\2\u02cf\u02cb")
368 buf.write("\3\2\2\2\u02d0\u02d1\3\2\2\2\u02d1\u02d2\7\23\2\2\u02d2")
369 buf.write("O\3\2\2\2\u02d3\u02d4\7\22\2\2\u02d4\u02d5\5\4\3\2\u02d5")
370 buf.write("\u02d6\7\23\2\2\u02d6\u02d9\5X-\2\u02d7\u02da\5 \21\2")
371 buf.write("\u02d8\u02da\7\24\2\2\u02d9\u02d7\3\2\2\2\u02d9\u02d8")
372 buf.write("\3\2\2\2\u02daQ\3\2\2\2\u02db\u02dc\t\7\2\2\u02dcS\3\2")
373 buf.write("\2\2\u02dd\u02de\7.\2\2\u02deU\3\2\2\2\u02df\u02e0\7E")
374 buf.write("\2\2\u02e0W\3\2\2\2\u02e1\u02e2\7/\2\2\u02e2Y\3\2\2\2")
375 buf.write("\u02e3\u02e4\t\b\2\2\u02e4[\3\2\2\2\u02e5\u02e6\t\t\2")
376 buf.write("\2\u02e6]\3\2\2\2\u02e7\u02e8\t\n\2\2\u02e8_\3\2\2\2\u02e9")
377 buf.write("\u02ea\t\13\2\2\u02eaa\3\2\2\2Rfh{\u0082\u0089\u0090\u00a2")
378 buf.write("\u00a9\u00b0\u00ba\u00c1\u00c9\u00d0\u00d9\u00e0\u00e9")
379 buf.write("\u00f0\u00f8\u00ff\u0112\u0114\u011b\u0122\u0129\u0136")
380 buf.write("\u013a\u013f\u0149\u014d\u0152\u015e\u0169\u016e\u0172")
381 buf.write("\u0178\u017e\u0187\u018f\u0196\u019b\u01a0\u01a5\u01aa")
382 buf.write("\u01ae\u01b2\u01b6\u01bb\u01c1\u01cf\u01d3\u01d7\u01dc")
383 buf.write("\u01e6\u01ea\u01ff\u021d\u0228\u022f\u0234\u023e\u0245")
384 buf.write("\u024f\u0256\u025b\u0262\u027a\u0281\u0286\u028b\u0292")
385 buf.write("\u0299\u02a0\u02a6\u02a9\u02ae\u02b8\u02c0\u02c6\u02cf")
386 buf.write("\u02d9")
387 return buf.getvalue()
390class RParser (Parser):
392 grammarFileName = "R.g4"
394 atn = ATNDeserializer().deserialize(serializedATN())
396 decisionsToDFA = [DFA(ds, i) for i, ds in enumerate(atn.decisionToState)]
398 sharedContextCache = PredictionContextCache()
400 literalNames = ["<INVALID>", "';'", "'[['", "']'", "'['", "'-'", "'+'",
401 "'!'", "'&'", "'&&'", "'|'", "'||'", "'{'", "'}'",
402 "'?'", "'break'", "'('", "')'", "'.'", "','", "'='",
403 "'...'", "'NULL'", "':'", "'%in%'", "'NA'", "'Inf'",
404 "'NaN'", "'TRUE'", "'FALSE'", "'next'", "'repeat'",
405 "'while'", "'for'", "'in'", "'if'", "'else'", "'return'",
406 "'within'", "'<-'", "'<<-'", "'->'", "'->>'", "':='",
407 "'function'", "'~'", "'::'", "':::'", "'$'", "'@'",
408 "'*'", "'/'", "'%'", "'^'", "'%%'", "'>'", "'>='",
409 "'<'", "'<='", "'=='", "'!='"]
411 symbolicNames = ["<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
412 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
413 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
414 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
415 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
416 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
417 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
418 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
419 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
420 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
421 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
422 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
423 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
424 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
425 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
426 "<INVALID>", "PARENTHESIS", "HEX", "INT", "FLOAT",
427 "COMPLEX", "STRING", "ID", "USER_OP", "NL", "WS"]
429 RULE_parse = 0
430 RULE_expr = 1
431 RULE_functiondefbody = 2
432 RULE_functiondeflambda = 3
433 RULE_functiondefargslambda = 4
434 RULE_functiondefargs = 5
435 RULE_implicit_column_name = 6
436 RULE_affectation = 7
437 RULE_rangeopexpr = 8
438 RULE_exprlist = 9
439 RULE_rightexpr = 10
440 RULE_formlist = 11
441 RULE_form = 12
442 RULE_argumentname = 13
443 RULE_sublist = 14
444 RULE_sublistadd = 15
445 RULE_sub = 16
446 RULE_subnobracket = 17
447 RULE_ranges = 18
448 RULE_range_simple = 19
449 RULE_range_complexe = 20
450 RULE_intersections = 21
451 RULE_intersection_simple = 22
452 RULE_intersection_complexe = 23
453 RULE_constant = 24
454 RULE_boolean = 25
455 RULE_nextexpr = 26
456 RULE_repeatexpr = 27
457 RULE_whileexpr = 28
458 RULE_forexpr = 29
459 RULE_ifexpr = 30
460 RULE_ifelseexpr = 31
461 RULE_elseif = 32
462 RULE_returnexpr = 33
463 RULE_functioncall = 34
464 RULE_inlinefunction = 35
465 RULE_formula_simple = 36
466 RULE_formula_simple_A = 37
467 RULE_formula_simple_B = 38
468 RULE_formula_simple_C = 39
469 RULE_affectop = 40
470 RULE_functiondef = 41
471 RULE_identifier = 42
472 RULE_formop = 43
473 RULE_rangeop = 44
474 RULE_dotop = 45
475 RULE_operator = 46
476 RULE_comparison = 47
478 ruleNames = ["parse", "expr", "functiondefbody", "functiondeflambda",
479 "functiondefargslambda", "functiondefargs", "implicit_column_name",
480 "affectation", "rangeopexpr", "exprlist", "rightexpr",
481 "formlist", "form", "argumentname", "sublist", "sublistadd",
482 "sub", "subnobracket", "ranges", "range_simple", "range_complexe",
483 "intersections", "intersection_simple", "intersection_complexe",
484 "constant", "boolean", "nextexpr", "repeatexpr", "whileexpr",
485 "forexpr", "ifexpr", "ifelseexpr", "elseif", "returnexpr",
486 "functioncall", "inlinefunction", "formula_simple", "formula_simple_A",
487 "formula_simple_B", "formula_simple_C", "affectop", "functiondef",
488 "identifier", "formop", "rangeop", "dotop", "operator",
489 "comparison"]
491 EOF = Token.EOF
492 T__0 = 1
493 T__1 = 2
494 T__2 = 3
495 T__3 = 4
496 T__4 = 5
497 T__5 = 6
498 T__6 = 7
499 T__7 = 8
500 T__8 = 9
501 T__9 = 10
502 T__10 = 11
503 T__11 = 12
504 T__12 = 13
505 T__13 = 14
506 T__14 = 15
507 T__15 = 16
508 T__16 = 17
509 T__17 = 18
510 T__18 = 19
511 T__19 = 20
512 T__20 = 21
513 T__21 = 22
514 T__22 = 23
515 T__23 = 24
516 T__24 = 25
517 T__25 = 26
518 T__26 = 27
519 T__27 = 28
520 T__28 = 29
521 T__29 = 30
522 T__30 = 31
523 T__31 = 32
524 T__32 = 33
525 T__33 = 34
526 T__34 = 35
527 T__35 = 36
528 T__36 = 37
529 T__37 = 38
530 T__38 = 39
531 T__39 = 40
532 T__40 = 41
533 T__41 = 42
534 T__42 = 43
535 T__43 = 44
536 T__44 = 45
537 T__45 = 46
538 T__46 = 47
539 T__47 = 48
540 T__48 = 49
541 T__49 = 50
542 T__50 = 51
543 T__51 = 52
544 T__52 = 53
545 T__53 = 54
546 T__54 = 55
547 T__55 = 56
548 T__56 = 57
549 T__57 = 58
550 T__58 = 59
551 T__59 = 60
552 PARENTHESIS = 61
553 HEX = 62
554 INT = 63
555 FLOAT = 64
556 COMPLEX = 65
557 STRING = 66
558 ID = 67
559 USER_OP = 68
560 NL = 69
561 WS = 70
563 def __init__(self, input: TokenStream, output: TextIO = sys.stdout):
564 super().__init__(input, output)
565 self.checkVersion("4.9")
566 self._interp = ParserATNSimulator(
567 self, self.atn, self.decisionsToDFA, self.sharedContextCache)
568 self._predicates = None
570 class ParseContext(ParserRuleContext):
572 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
573 super().__init__(parent, invokingState)
574 self.parser = parser
576 def EOF(self):
577 return self.getToken(RParser.EOF, 0)
579 def expr(self, i: int = None):
580 if i is None:
581 return self.getTypedRuleContexts(RParser.ExprContext)
582 else:
583 return self.getTypedRuleContext(RParser.ExprContext, i)
585 def NL(self, i: int = None):
586 if i is None:
587 return self.getTokens(RParser.NL)
588 else:
589 return self.getToken(RParser.NL, i)
591 def getRuleIndex(self):
592 return RParser.RULE_parse
594 def enterRule(self, listener: ParseTreeListener):
595 if hasattr(listener, "enterParse"):
596 listener.enterParse(self)
598 def exitRule(self, listener: ParseTreeListener):
599 if hasattr(listener, "exitParse"):
600 listener.exitParse(self)
602 def parse(self):
604 localctx = RParser.ParseContext(self, self._ctx, self.state)
605 self.enterRule(localctx, 0, self.RULE_parse)
606 self._la = 0 # Token type
607 try:
608 self.enterOuterAlt(localctx, 1)
609 self.state = 102
610 self._errHandler.sync(self)
611 _la = self._input.LA(1)
612 while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RParser.T__4) | (1 << RParser.T__5) | (1 << RParser.T__6) | (1 << RParser.T__11) | (1 << RParser.T__13) | (1 << RParser.T__14) | (1 << RParser.T__15) | (1 << RParser.T__17) | (1 << RParser.T__21) | (1 << RParser.T__24) | (1 << RParser.T__25) | (1 << RParser.T__26) | (1 << RParser.T__27) | (1 << RParser.T__28) | (1 << RParser.T__29) | (1 << RParser.T__30) | (1 << RParser.T__31) | (1 << RParser.T__32) | (1 << RParser.T__34) | (1 << RParser.T__36) | (1 << RParser.T__37) | (1 << RParser.T__43) | (1 << RParser.T__44) | (1 << RParser.HEX) | (1 << RParser.INT))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (RParser.FLOAT - 64)) | (1 << (RParser.COMPLEX - 64)) | (1 << (RParser.STRING - 64)) | (1 << (RParser.ID - 64)) | (1 << (RParser.NL - 64)))) != 0):
613 self.state = 100
614 self._errHandler.sync(self)
615 la_ = self._interp.adaptivePredict(self._input, 0, self._ctx)
616 if la_ == 1:
617 self.state = 96
618 self.expr(0)
619 self.state = 97
620 _la = self._input.LA(1)
621 if not(_la == RParser.T__0 or _la == RParser.NL):
622 self._errHandler.recoverInline(self)
623 else:
624 self._errHandler.reportMatch(self)
625 self.consume()
626 pass
628 elif la_ == 2:
629 self.state = 99
630 self.match(RParser.NL)
631 pass
633 self.state = 104
634 self._errHandler.sync(self)
635 _la = self._input.LA(1)
637 self.state = 105
638 self.match(RParser.EOF)
639 except RecognitionException as re:
640 localctx.exception = re
641 self._errHandler.reportError(self, re)
642 self._errHandler.recover(self, re)
643 finally:
644 self.exitRule()
645 return localctx
647 class ExprContext(ParserRuleContext):
649 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
650 super().__init__(parent, invokingState)
651 self.parser = parser
653 def ranges(self):
654 return self.getTypedRuleContext(RParser.RangesContext, 0)
656 def intersections(self):
657 return self.getTypedRuleContext(RParser.IntersectionsContext, 0)
659 def expr(self, i: int = None):
660 if i is None:
661 return self.getTypedRuleContexts(RParser.ExprContext)
662 else:
663 return self.getTypedRuleContext(RParser.ExprContext, i)
665 def formula_simple(self):
666 return self.getTypedRuleContext(RParser.Formula_simpleContext, 0)
668 def functiondefbody(self):
669 return self.getTypedRuleContext(RParser.FunctiondefbodyContext, 0)
671 def functiondeflambda(self):
672 return self.getTypedRuleContext(RParser.FunctiondeflambdaContext, 0)
674 def functioncall(self):
675 return self.getTypedRuleContext(RParser.FunctioncallContext, 0)
677 def exprlist(self):
678 return self.getTypedRuleContext(RParser.ExprlistContext, 0)
680 def NL(self, i: int = None):
681 if i is None:
682 return self.getTokens(RParser.NL)
683 else:
684 return self.getToken(RParser.NL, i)
686 def returnexpr(self):
687 return self.getTypedRuleContext(RParser.ReturnexprContext, 0)
689 def ifelseexpr(self):
690 return self.getTypedRuleContext(RParser.IfelseexprContext, 0)
692 def ifexpr(self):
693 return self.getTypedRuleContext(RParser.IfexprContext, 0)
695 def forexpr(self):
696 return self.getTypedRuleContext(RParser.ForexprContext, 0)
698 def whileexpr(self):
699 return self.getTypedRuleContext(RParser.WhileexprContext, 0)
701 def repeatexpr(self):
702 return self.getTypedRuleContext(RParser.RepeatexprContext, 0)
704 def implicit_column_name(self):
705 return self.getTypedRuleContext(RParser.Implicit_column_nameContext, 0)
707 def nextexpr(self):
708 return self.getTypedRuleContext(RParser.NextexprContext, 0)
710 def constant(self):
711 return self.getTypedRuleContext(RParser.ConstantContext, 0)
713 def identifier(self):
714 return self.getTypedRuleContext(RParser.IdentifierContext, 0)
716 def dotop(self):
717 return self.getTypedRuleContext(RParser.DotopContext, 0)
719 def USER_OP(self):
720 return self.getToken(RParser.USER_OP, 0)
722 def operator(self):
723 return self.getTypedRuleContext(RParser.OperatorContext, 0)
725 def comparison(self):
726 return self.getTypedRuleContext(RParser.ComparisonContext, 0)
728 def sublist(self):
729 return self.getTypedRuleContext(RParser.SublistContext, 0)
731 def affectation(self):
732 return self.getTypedRuleContext(RParser.AffectationContext, 0)
734 def rangeopexpr(self):
735 return self.getTypedRuleContext(RParser.RangeopexprContext, 0)
737 def getRuleIndex(self):
738 return RParser.RULE_expr
740 def enterRule(self, listener: ParseTreeListener):
741 if hasattr(listener, "enterExpr"):
742 listener.enterExpr(self)
744 def exitRule(self, listener: ParseTreeListener):
745 if hasattr(listener, "exitExpr"):
746 listener.exitExpr(self)
748 def expr(self, _p: int = 0):
749 _parentctx = self._ctx
750 _parentState = self.state
751 localctx = RParser.ExprContext(self, self._ctx, _parentState)
752 _prevctx = localctx
753 _startState = 2
754 self.enterRecursionRule(localctx, 2, self.RULE_expr, _p)
755 self._la = 0 # Token type
756 try:
757 self.enterOuterAlt(localctx, 1)
758 self.state = 174
759 self._errHandler.sync(self)
760 la_ = self._interp.adaptivePredict(self._input, 8, self._ctx)
761 if la_ == 1:
762 self.state = 108
763 self.ranges()
764 pass
766 elif la_ == 2:
767 self.state = 109
768 self.intersections()
769 pass
771 elif la_ == 3:
772 self.state = 110
773 _la = self._input.LA(1)
774 if not(_la == RParser.T__4 or _la == RParser.T__5):
775 self._errHandler.recoverInline(self)
776 else:
777 self._errHandler.reportMatch(self)
778 self.consume()
779 self.state = 111
780 self.expr(27)
781 pass
783 elif la_ == 4:
784 self.state = 112
785 self.match(RParser.T__6)
786 self.state = 113
787 self.expr(21)
788 pass
790 elif la_ == 5:
791 self.state = 114
792 self.formula_simple()
793 pass
795 elif la_ == 6:
796 self.state = 115
797 self.functiondefbody()
798 pass
800 elif la_ == 7:
801 self.state = 116
802 self.functiondeflambda()
803 pass
805 elif la_ == 8:
806 self.state = 117
807 self.functioncall()
808 pass
810 elif la_ == 9:
811 self.state = 121
812 self._errHandler.sync(self)
813 _la = self._input.LA(1)
814 while _la == RParser.NL:
815 self.state = 118
816 self.match(RParser.NL)
817 self.state = 123
818 self._errHandler.sync(self)
819 _la = self._input.LA(1)
821 self.state = 124
822 self.match(RParser.T__11)
823 self.state = 128
824 self._errHandler.sync(self)
825 _alt = self._interp.adaptivePredict(self._input, 3, self._ctx)
826 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
827 if _alt == 1:
828 self.state = 125
829 self.match(RParser.NL)
830 self.state = 130
831 self._errHandler.sync(self)
832 _alt = self._interp.adaptivePredict(
833 self._input, 3, self._ctx)
835 self.state = 131
836 self.exprlist()
837 self.state = 135
838 self._errHandler.sync(self)
839 _la = self._input.LA(1)
840 while _la == RParser.NL:
841 self.state = 132
842 self.match(RParser.NL)
843 self.state = 137
844 self._errHandler.sync(self)
845 _la = self._input.LA(1)
847 self.state = 138
848 self.match(RParser.T__12)
849 self.state = 142
850 self._errHandler.sync(self)
851 _alt = self._interp.adaptivePredict(self._input, 5, self._ctx)
852 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
853 if _alt == 1:
854 self.state = 139
855 self.match(RParser.NL)
856 self.state = 144
857 self._errHandler.sync(self)
858 _alt = self._interp.adaptivePredict(
859 self._input, 5, self._ctx)
861 pass
863 elif la_ == 10:
864 self.state = 145
865 self.returnexpr()
866 pass
868 elif la_ == 11:
869 self.state = 146
870 self.ifelseexpr()
871 pass
873 elif la_ == 12:
874 self.state = 147
875 self.ifexpr()
876 pass
878 elif la_ == 13:
879 self.state = 148
880 self.forexpr()
881 pass
883 elif la_ == 14:
884 self.state = 149
885 self.whileexpr()
886 pass
888 elif la_ == 15:
889 self.state = 150
890 self.repeatexpr()
891 pass
893 elif la_ == 16:
894 self.state = 151
895 self.match(RParser.T__13)
896 self.state = 152
897 self.expr(7)
898 pass
900 elif la_ == 17:
901 self.state = 153
902 self.implicit_column_name()
903 pass
905 elif la_ == 18:
906 self.state = 154
907 self.nextexpr()
908 pass
910 elif la_ == 19:
911 self.state = 155
912 self.match(RParser.T__14)
913 pass
915 elif la_ == 20:
916 self.state = 156
917 self.match(RParser.T__15)
918 self.state = 160
919 self._errHandler.sync(self)
920 _alt = self._interp.adaptivePredict(self._input, 6, self._ctx)
921 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
922 if _alt == 1:
923 self.state = 157
924 self.match(RParser.NL)
925 self.state = 162
926 self._errHandler.sync(self)
927 _alt = self._interp.adaptivePredict(
928 self._input, 6, self._ctx)
930 self.state = 163
931 self.expr(0)
932 self.state = 167
933 self._errHandler.sync(self)
934 _la = self._input.LA(1)
935 while _la == RParser.NL:
936 self.state = 164
937 self.match(RParser.NL)
938 self.state = 169
939 self._errHandler.sync(self)
940 _la = self._input.LA(1)
942 self.state = 170
943 self.match(RParser.T__16)
944 pass
946 elif la_ == 21:
947 self.state = 172
948 self.constant()
949 pass
951 elif la_ == 22:
952 self.state = 173
953 self.identifier()
954 pass
956 self._ctx.stop = self._input.LT(-1)
957 self.state = 274
958 self._errHandler.sync(self)
959 _alt = self._interp.adaptivePredict(self._input, 20, self._ctx)
960 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
961 if _alt == 1:
962 if self._parseListeners is not None:
963 self.triggerExitRuleEvent()
964 _prevctx = localctx
965 self.state = 272
966 self._errHandler.sync(self)
967 la_ = self._interp.adaptivePredict(
968 self._input, 19, self._ctx)
969 if la_ == 1:
970 localctx = RParser.ExprContext(
971 self, _parentctx, _parentState)
972 self.pushNewRecursionContext(
973 localctx, _startState, self.RULE_expr)
974 self.state = 176
975 if not self.precpred(self._ctx, 28):
976 from antlr4.error.Errors import FailedPredicateException
977 raise FailedPredicateException(
978 self, "self.precpred(self._ctx, 28)")
979 self.state = 177
980 self.dotop()
981 self.state = 178
982 self.expr(29)
983 pass
985 elif la_ == 2:
986 localctx = RParser.ExprContext(
987 self, _parentctx, _parentState)
988 self.pushNewRecursionContext(
989 localctx, _startState, self.RULE_expr)
990 self.state = 180
991 if not self.precpred(self._ctx, 24):
992 from antlr4.error.Errors import FailedPredicateException
993 raise FailedPredicateException(
994 self, "self.precpred(self._ctx, 24)")
995 self.state = 184
996 self._errHandler.sync(self)
997 _la = self._input.LA(1)
998 while _la == RParser.NL:
999 self.state = 181
1000 self.match(RParser.NL)
1001 self.state = 186
1002 self._errHandler.sync(self)
1003 _la = self._input.LA(1)
1005 self.state = 187
1006 self.match(RParser.USER_OP)
1007 self.state = 191
1008 self._errHandler.sync(self)
1009 _alt = self._interp.adaptivePredict(
1010 self._input, 10, self._ctx)
1011 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
1012 if _alt == 1:
1013 self.state = 188
1014 self.match(RParser.NL)
1015 self.state = 193
1016 self._errHandler.sync(self)
1017 _alt = self._interp.adaptivePredict(
1018 self._input, 10, self._ctx)
1020 self.state = 194
1021 self.expr(24)
1022 pass
1024 elif la_ == 3:
1025 localctx = RParser.ExprContext(
1026 self, _parentctx, _parentState)
1027 self.pushNewRecursionContext(
1028 localctx, _startState, self.RULE_expr)
1029 self.state = 195
1030 if not self.precpred(self._ctx, 23):
1031 from antlr4.error.Errors import FailedPredicateException
1032 raise FailedPredicateException(
1033 self, "self.precpred(self._ctx, 23)")
1034 self.state = 199
1035 self._errHandler.sync(self)
1036 _la = self._input.LA(1)
1037 while _la == RParser.NL:
1038 self.state = 196
1039 self.match(RParser.NL)
1040 self.state = 201
1041 self._errHandler.sync(self)
1042 _la = self._input.LA(1)
1044 self.state = 202
1045 self.operator()
1046 self.state = 206
1047 self._errHandler.sync(self)
1048 _alt = self._interp.adaptivePredict(
1049 self._input, 12, self._ctx)
1050 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
1051 if _alt == 1:
1052 self.state = 203
1053 self.match(RParser.NL)
1054 self.state = 208
1055 self._errHandler.sync(self)
1056 _alt = self._interp.adaptivePredict(
1057 self._input, 12, self._ctx)
1059 self.state = 209
1060 self.expr(23)
1061 pass
1063 elif la_ == 4:
1064 localctx = RParser.ExprContext(
1065 self, _parentctx, _parentState)
1066 self.pushNewRecursionContext(
1067 localctx, _startState, self.RULE_expr)
1068 self.state = 211
1069 if not self.precpred(self._ctx, 22):
1070 from antlr4.error.Errors import FailedPredicateException
1071 raise FailedPredicateException(
1072 self, "self.precpred(self._ctx, 22)")
1073 self.state = 215
1074 self._errHandler.sync(self)
1075 _la = self._input.LA(1)
1076 while _la == RParser.NL:
1077 self.state = 212
1078 self.match(RParser.NL)
1079 self.state = 217
1080 self._errHandler.sync(self)
1081 _la = self._input.LA(1)
1083 self.state = 218
1084 self.comparison()
1085 self.state = 222
1086 self._errHandler.sync(self)
1087 _alt = self._interp.adaptivePredict(
1088 self._input, 14, self._ctx)
1089 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
1090 if _alt == 1:
1091 self.state = 219
1092 self.match(RParser.NL)
1093 self.state = 224
1094 self._errHandler.sync(self)
1095 _alt = self._interp.adaptivePredict(
1096 self._input, 14, self._ctx)
1098 self.state = 225
1099 self.expr(22)
1100 pass
1102 elif la_ == 5:
1103 localctx = RParser.ExprContext(
1104 self, _parentctx, _parentState)
1105 self.pushNewRecursionContext(
1106 localctx, _startState, self.RULE_expr)
1107 self.state = 227
1108 if not self.precpred(self._ctx, 20):
1109 from antlr4.error.Errors import FailedPredicateException
1110 raise FailedPredicateException(
1111 self, "self.precpred(self._ctx, 20)")
1112 self.state = 231
1113 self._errHandler.sync(self)
1114 _la = self._input.LA(1)
1115 while _la == RParser.NL:
1116 self.state = 228
1117 self.match(RParser.NL)
1118 self.state = 233
1119 self._errHandler.sync(self)
1120 _la = self._input.LA(1)
1122 self.state = 234
1123 _la = self._input.LA(1)
1124 if not(_la == RParser.T__7 or _la == RParser.T__8):
1125 self._errHandler.recoverInline(self)
1126 else:
1127 self._errHandler.reportMatch(self)
1128 self.consume()
1129 self.state = 238
1130 self._errHandler.sync(self)
1131 _alt = self._interp.adaptivePredict(
1132 self._input, 16, self._ctx)
1133 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
1134 if _alt == 1:
1135 self.state = 235
1136 self.match(RParser.NL)
1137 self.state = 240
1138 self._errHandler.sync(self)
1139 _alt = self._interp.adaptivePredict(
1140 self._input, 16, self._ctx)
1142 self.state = 241
1143 self.expr(21)
1144 pass
1146 elif la_ == 6:
1147 localctx = RParser.ExprContext(
1148 self, _parentctx, _parentState)
1149 self.pushNewRecursionContext(
1150 localctx, _startState, self.RULE_expr)
1151 self.state = 242
1152 if not self.precpred(self._ctx, 19):
1153 from antlr4.error.Errors import FailedPredicateException
1154 raise FailedPredicateException(
1155 self, "self.precpred(self._ctx, 19)")
1156 self.state = 246
1157 self._errHandler.sync(self)
1158 _la = self._input.LA(1)
1159 while _la == RParser.NL:
1160 self.state = 243
1161 self.match(RParser.NL)
1162 self.state = 248
1163 self._errHandler.sync(self)
1164 _la = self._input.LA(1)
1166 self.state = 249
1167 _la = self._input.LA(1)
1168 if not(_la == RParser.T__9 or _la == RParser.T__10):
1169 self._errHandler.recoverInline(self)
1170 else:
1171 self._errHandler.reportMatch(self)
1172 self.consume()
1173 self.state = 253
1174 self._errHandler.sync(self)
1175 _alt = self._interp.adaptivePredict(
1176 self._input, 18, self._ctx)
1177 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
1178 if _alt == 1:
1179 self.state = 250
1180 self.match(RParser.NL)
1181 self.state = 255
1182 self._errHandler.sync(self)
1183 _alt = self._interp.adaptivePredict(
1184 self._input, 18, self._ctx)
1186 self.state = 256
1187 self.expr(20)
1188 pass
1190 elif la_ == 7:
1191 localctx = RParser.ExprContext(
1192 self, _parentctx, _parentState)
1193 self.pushNewRecursionContext(
1194 localctx, _startState, self.RULE_expr)
1195 self.state = 257
1196 if not self.precpred(self._ctx, 30):
1197 from antlr4.error.Errors import FailedPredicateException
1198 raise FailedPredicateException(
1199 self, "self.precpred(self._ctx, 30)")
1200 self.state = 258
1201 self.match(RParser.T__1)
1202 self.state = 259
1203 self.sublist()
1204 self.state = 260
1205 self.match(RParser.T__2)
1206 self.state = 261
1207 self.match(RParser.T__2)
1208 pass
1210 elif la_ == 8:
1211 localctx = RParser.ExprContext(
1212 self, _parentctx, _parentState)
1213 self.pushNewRecursionContext(
1214 localctx, _startState, self.RULE_expr)
1215 self.state = 263
1216 if not self.precpred(self._ctx, 29):
1217 from antlr4.error.Errors import FailedPredicateException
1218 raise FailedPredicateException(
1219 self, "self.precpred(self._ctx, 29)")
1220 self.state = 264
1221 self.match(RParser.T__3)
1222 self.state = 265
1223 self.sublist()
1224 self.state = 266
1225 self.match(RParser.T__2)
1226 pass
1228 elif la_ == 9:
1229 localctx = RParser.ExprContext(
1230 self, _parentctx, _parentState)
1231 self.pushNewRecursionContext(
1232 localctx, _startState, self.RULE_expr)
1233 self.state = 268
1234 if not self.precpred(self._ctx, 26):
1235 from antlr4.error.Errors import FailedPredicateException
1236 raise FailedPredicateException(
1237 self, "self.precpred(self._ctx, 26)")
1238 self.state = 269
1239 self.affectation()
1240 pass
1242 elif la_ == 10:
1243 localctx = RParser.ExprContext(
1244 self, _parentctx, _parentState)
1245 self.pushNewRecursionContext(
1246 localctx, _startState, self.RULE_expr)
1247 self.state = 270
1248 if not self.precpred(self._ctx, 25):
1249 from antlr4.error.Errors import FailedPredicateException
1250 raise FailedPredicateException(
1251 self, "self.precpred(self._ctx, 25)")
1252 self.state = 271
1253 self.rangeopexpr()
1254 pass
1256 self.state = 276
1257 self._errHandler.sync(self)
1258 _alt = self._interp.adaptivePredict(self._input, 20, self._ctx)
1260 except RecognitionException as re:
1261 localctx.exception = re
1262 self._errHandler.reportError(self, re)
1263 self._errHandler.recover(self, re)
1264 finally:
1265 self.unrollRecursionContexts(_parentctx)
1266 return localctx
1268 class FunctiondefbodyContext(ParserRuleContext):
1270 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1271 super().__init__(parent, invokingState)
1272 self.parser = parser
1274 def functiondefargs(self):
1275 return self.getTypedRuleContext(RParser.FunctiondefargsContext, 0)
1277 def exprlist(self):
1278 return self.getTypedRuleContext(RParser.ExprlistContext, 0)
1280 def NL(self, i: int = None):
1281 if i is None:
1282 return self.getTokens(RParser.NL)
1283 else:
1284 return self.getToken(RParser.NL, i)
1286 def getRuleIndex(self):
1287 return RParser.RULE_functiondefbody
1289 def enterRule(self, listener: ParseTreeListener):
1290 if hasattr(listener, "enterFunctiondefbody"):
1291 listener.enterFunctiondefbody(self)
1293 def exitRule(self, listener: ParseTreeListener):
1294 if hasattr(listener, "exitFunctiondefbody"):
1295 listener.exitFunctiondefbody(self)
1297 def functiondefbody(self):
1299 localctx = RParser.FunctiondefbodyContext(self, self._ctx, self.state)
1300 self.enterRule(localctx, 4, self.RULE_functiondefbody)
1301 self._la = 0 # Token type
1302 try:
1303 self.enterOuterAlt(localctx, 1)
1304 self.state = 277
1305 self.functiondefargs()
1306 self.state = 281
1307 self._errHandler.sync(self)
1308 _la = self._input.LA(1)
1309 while _la == RParser.NL:
1310 self.state = 278
1311 self.match(RParser.NL)
1312 self.state = 283
1313 self._errHandler.sync(self)
1314 _la = self._input.LA(1)
1316 self.state = 284
1317 self.match(RParser.T__11)
1318 self.state = 288
1319 self._errHandler.sync(self)
1320 _alt = self._interp.adaptivePredict(self._input, 22, self._ctx)
1321 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
1322 if _alt == 1:
1323 self.state = 285
1324 self.match(RParser.NL)
1325 self.state = 290
1326 self._errHandler.sync(self)
1327 _alt = self._interp.adaptivePredict(self._input, 22, self._ctx)
1329 self.state = 291
1330 self.exprlist()
1331 self.state = 295
1332 self._errHandler.sync(self)
1333 _la = self._input.LA(1)
1334 while _la == RParser.NL:
1335 self.state = 292
1336 self.match(RParser.NL)
1337 self.state = 297
1338 self._errHandler.sync(self)
1339 _la = self._input.LA(1)
1341 self.state = 298
1342 self.match(RParser.T__12)
1343 except RecognitionException as re:
1344 localctx.exception = re
1345 self._errHandler.reportError(self, re)
1346 self._errHandler.recover(self, re)
1347 finally:
1348 self.exitRule()
1349 return localctx
1351 class FunctiondeflambdaContext(ParserRuleContext):
1353 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1354 super().__init__(parent, invokingState)
1355 self.parser = parser
1357 def functiondefargslambda(self):
1358 return self.getTypedRuleContext(RParser.FunctiondefargslambdaContext, 0)
1360 def expr(self):
1361 return self.getTypedRuleContext(RParser.ExprContext, 0)
1363 def getRuleIndex(self):
1364 return RParser.RULE_functiondeflambda
1366 def enterRule(self, listener: ParseTreeListener):
1367 if hasattr(listener, "enterFunctiondeflambda"):
1368 listener.enterFunctiondeflambda(self)
1370 def exitRule(self, listener: ParseTreeListener):
1371 if hasattr(listener, "exitFunctiondeflambda"):
1372 listener.exitFunctiondeflambda(self)
1374 def functiondeflambda(self):
1376 localctx = RParser.FunctiondeflambdaContext(
1377 self, self._ctx, self.state)
1378 self.enterRule(localctx, 6, self.RULE_functiondeflambda)
1379 try:
1380 self.enterOuterAlt(localctx, 1)
1381 self.state = 300
1382 self.functiondefargslambda()
1383 self.state = 301
1384 self.expr(0)
1385 except RecognitionException as re:
1386 localctx.exception = re
1387 self._errHandler.reportError(self, re)
1388 self._errHandler.recover(self, re)
1389 finally:
1390 self.exitRule()
1391 return localctx
1393 class FunctiondefargslambdaContext(ParserRuleContext):
1395 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1396 super().__init__(parent, invokingState)
1397 self.parser = parser
1399 def functiondef(self):
1400 return self.getTypedRuleContext(RParser.FunctiondefContext, 0)
1402 def NL(self, i: int = None):
1403 if i is None:
1404 return self.getTokens(RParser.NL)
1405 else:
1406 return self.getToken(RParser.NL, i)
1408 def formlist(self):
1409 return self.getTypedRuleContext(RParser.FormlistContext, 0)
1411 def getRuleIndex(self):
1412 return RParser.RULE_functiondefargslambda
1414 def enterRule(self, listener: ParseTreeListener):
1415 if hasattr(listener, "enterFunctiondefargslambda"):
1416 listener.enterFunctiondefargslambda(self)
1418 def exitRule(self, listener: ParseTreeListener):
1419 if hasattr(listener, "exitFunctiondefargslambda"):
1420 listener.exitFunctiondefargslambda(self)
1422 def functiondefargslambda(self):
1424 localctx = RParser.FunctiondefargslambdaContext(
1425 self, self._ctx, self.state)
1426 self.enterRule(localctx, 8, self.RULE_functiondefargslambda)
1427 self._la = 0 # Token type
1428 try:
1429 self.enterOuterAlt(localctx, 1)
1430 self.state = 303
1431 self.functiondef()
1432 self.state = 304
1433 self.match(RParser.T__15)
1434 self.state = 308
1435 self._errHandler.sync(self)
1436 _alt = self._interp.adaptivePredict(self._input, 24, self._ctx)
1437 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
1438 if _alt == 1:
1439 self.state = 305
1440 self.match(RParser.NL)
1441 self.state = 310
1442 self._errHandler.sync(self)
1443 _alt = self._interp.adaptivePredict(self._input, 24, self._ctx)
1445 self.state = 312
1446 self._errHandler.sync(self)
1447 _la = self._input.LA(1)
1448 if _la == RParser.T__20 or _la == RParser.ID:
1449 self.state = 311
1450 self.formlist()
1452 self.state = 317
1453 self._errHandler.sync(self)
1454 _la = self._input.LA(1)
1455 while _la == RParser.NL:
1456 self.state = 314
1457 self.match(RParser.NL)
1458 self.state = 319
1459 self._errHandler.sync(self)
1460 _la = self._input.LA(1)
1462 self.state = 320
1463 self.match(RParser.T__16)
1464 except RecognitionException as re:
1465 localctx.exception = re
1466 self._errHandler.reportError(self, re)
1467 self._errHandler.recover(self, re)
1468 finally:
1469 self.exitRule()
1470 return localctx
1472 class FunctiondefargsContext(ParserRuleContext):
1474 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1475 super().__init__(parent, invokingState)
1476 self.parser = parser
1478 def functiondef(self):
1479 return self.getTypedRuleContext(RParser.FunctiondefContext, 0)
1481 def NL(self, i: int = None):
1482 if i is None:
1483 return self.getTokens(RParser.NL)
1484 else:
1485 return self.getToken(RParser.NL, i)
1487 def formlist(self):
1488 return self.getTypedRuleContext(RParser.FormlistContext, 0)
1490 def getRuleIndex(self):
1491 return RParser.RULE_functiondefargs
1493 def enterRule(self, listener: ParseTreeListener):
1494 if hasattr(listener, "enterFunctiondefargs"):
1495 listener.enterFunctiondefargs(self)
1497 def exitRule(self, listener: ParseTreeListener):
1498 if hasattr(listener, "exitFunctiondefargs"):
1499 listener.exitFunctiondefargs(self)
1501 def functiondefargs(self):
1503 localctx = RParser.FunctiondefargsContext(self, self._ctx, self.state)
1504 self.enterRule(localctx, 10, self.RULE_functiondefargs)
1505 self._la = 0 # Token type
1506 try:
1507 self.enterOuterAlt(localctx, 1)
1508 self.state = 322
1509 self.functiondef()
1510 self.state = 323
1511 self.match(RParser.T__15)
1512 self.state = 327
1513 self._errHandler.sync(self)
1514 _alt = self._interp.adaptivePredict(self._input, 27, self._ctx)
1515 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
1516 if _alt == 1:
1517 self.state = 324
1518 self.match(RParser.NL)
1519 self.state = 329
1520 self._errHandler.sync(self)
1521 _alt = self._interp.adaptivePredict(self._input, 27, self._ctx)
1523 self.state = 331
1524 self._errHandler.sync(self)
1525 _la = self._input.LA(1)
1526 if _la == RParser.T__20 or _la == RParser.ID:
1527 self.state = 330
1528 self.formlist()
1530 self.state = 336
1531 self._errHandler.sync(self)
1532 _la = self._input.LA(1)
1533 while _la == RParser.NL:
1534 self.state = 333
1535 self.match(RParser.NL)
1536 self.state = 338
1537 self._errHandler.sync(self)
1538 _la = self._input.LA(1)
1540 self.state = 339
1541 self.match(RParser.T__16)
1542 except RecognitionException as re:
1543 localctx.exception = re
1544 self._errHandler.reportError(self, re)
1545 self._errHandler.recover(self, re)
1546 finally:
1547 self.exitRule()
1548 return localctx
1550 class Implicit_column_nameContext(ParserRuleContext):
1552 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1553 super().__init__(parent, invokingState)
1554 self.parser = parser
1556 def identifier(self):
1557 return self.getTypedRuleContext(RParser.IdentifierContext, 0)
1559 def getRuleIndex(self):
1560 return RParser.RULE_implicit_column_name
1562 def enterRule(self, listener: ParseTreeListener):
1563 if hasattr(listener, "enterImplicit_column_name"):
1564 listener.enterImplicit_column_name(self)
1566 def exitRule(self, listener: ParseTreeListener):
1567 if hasattr(listener, "exitImplicit_column_name"):
1568 listener.exitImplicit_column_name(self)
1570 def implicit_column_name(self):
1572 localctx = RParser.Implicit_column_nameContext(
1573 self, self._ctx, self.state)
1574 self.enterRule(localctx, 12, self.RULE_implicit_column_name)
1575 try:
1576 self.enterOuterAlt(localctx, 1)
1577 self.state = 341
1578 self.match(RParser.T__17)
1579 self.state = 342
1580 self.match(RParser.T__15)
1581 self.state = 343
1582 self.identifier()
1583 self.state = 344
1584 self.match(RParser.T__16)
1585 except RecognitionException as re:
1586 localctx.exception = re
1587 self._errHandler.reportError(self, re)
1588 self._errHandler.recover(self, re)
1589 finally:
1590 self.exitRule()
1591 return localctx
1593 class AffectationContext(ParserRuleContext):
1595 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1596 super().__init__(parent, invokingState)
1597 self.parser = parser
1599 def affectop(self):
1600 return self.getTypedRuleContext(RParser.AffectopContext, 0)
1602 def expr(self):
1603 return self.getTypedRuleContext(RParser.ExprContext, 0)
1605 def NL(self):
1606 return self.getToken(RParser.NL, 0)
1608 def getRuleIndex(self):
1609 return RParser.RULE_affectation
1611 def enterRule(self, listener: ParseTreeListener):
1612 if hasattr(listener, "enterAffectation"):
1613 listener.enterAffectation(self)
1615 def exitRule(self, listener: ParseTreeListener):
1616 if hasattr(listener, "exitAffectation"):
1617 listener.exitAffectation(self)
1619 def affectation(self):
1621 localctx = RParser.AffectationContext(self, self._ctx, self.state)
1622 self.enterRule(localctx, 14, self.RULE_affectation)
1623 try:
1624 self.enterOuterAlt(localctx, 1)
1625 self.state = 346
1626 self.affectop()
1627 self.state = 348
1628 self._errHandler.sync(self)
1629 la_ = self._interp.adaptivePredict(self._input, 30, self._ctx)
1630 if la_ == 1:
1631 self.state = 347
1632 self.match(RParser.NL)
1634 self.state = 350
1635 self.expr(0)
1636 except RecognitionException as re:
1637 localctx.exception = re
1638 self._errHandler.reportError(self, re)
1639 self._errHandler.recover(self, re)
1640 finally:
1641 self.exitRule()
1642 return localctx
1644 class RangeopexprContext(ParserRuleContext):
1646 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1647 super().__init__(parent, invokingState)
1648 self.parser = parser
1650 def rangeop(self):
1651 return self.getTypedRuleContext(RParser.RangeopContext, 0)
1653 def expr(self):
1654 return self.getTypedRuleContext(RParser.ExprContext, 0)
1656 def getRuleIndex(self):
1657 return RParser.RULE_rangeopexpr
1659 def enterRule(self, listener: ParseTreeListener):
1660 if hasattr(listener, "enterRangeopexpr"):
1661 listener.enterRangeopexpr(self)
1663 def exitRule(self, listener: ParseTreeListener):
1664 if hasattr(listener, "exitRangeopexpr"):
1665 listener.exitRangeopexpr(self)
1667 def rangeopexpr(self):
1669 localctx = RParser.RangeopexprContext(self, self._ctx, self.state)
1670 self.enterRule(localctx, 16, self.RULE_rangeopexpr)
1671 try:
1672 self.enterOuterAlt(localctx, 1)
1673 self.state = 352
1674 self.rangeop()
1675 self.state = 353
1676 self.expr(0)
1677 except RecognitionException as re:
1678 localctx.exception = re
1679 self._errHandler.reportError(self, re)
1680 self._errHandler.recover(self, re)
1681 finally:
1682 self.exitRule()
1683 return localctx
1685 class ExprlistContext(ParserRuleContext):
1687 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1688 super().__init__(parent, invokingState)
1689 self.parser = parser
1691 def expr(self):
1692 return self.getTypedRuleContext(RParser.ExprContext, 0)
1694 def rightexpr(self, i: int = None):
1695 if i is None:
1696 return self.getTypedRuleContexts(RParser.RightexprContext)
1697 else:
1698 return self.getTypedRuleContext(RParser.RightexprContext, i)
1700 def getRuleIndex(self):
1701 return RParser.RULE_exprlist
1703 def enterRule(self, listener: ParseTreeListener):
1704 if hasattr(listener, "enterExprlist"):
1705 listener.enterExprlist(self)
1707 def exitRule(self, listener: ParseTreeListener):
1708 if hasattr(listener, "exitExprlist"):
1709 listener.exitExprlist(self)
1711 def exprlist(self):
1713 localctx = RParser.ExprlistContext(self, self._ctx, self.state)
1714 self.enterRule(localctx, 18, self.RULE_exprlist)
1715 try:
1716 self.enterOuterAlt(localctx, 1)
1717 self.state = 355
1718 self.expr(0)
1719 self.state = 359
1720 self._errHandler.sync(self)
1721 _alt = self._interp.adaptivePredict(self._input, 31, self._ctx)
1722 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
1723 if _alt == 1:
1724 self.state = 356
1725 self.rightexpr()
1726 self.state = 361
1727 self._errHandler.sync(self)
1728 _alt = self._interp.adaptivePredict(self._input, 31, self._ctx)
1730 except RecognitionException as re:
1731 localctx.exception = re
1732 self._errHandler.reportError(self, re)
1733 self._errHandler.recover(self, re)
1734 finally:
1735 self.exitRule()
1736 return localctx
1738 class RightexprContext(ParserRuleContext):
1740 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1741 super().__init__(parent, invokingState)
1742 self.parser = parser
1744 def NL(self):
1745 return self.getToken(RParser.NL, 0)
1747 def expr(self):
1748 return self.getTypedRuleContext(RParser.ExprContext, 0)
1750 def getRuleIndex(self):
1751 return RParser.RULE_rightexpr
1753 def enterRule(self, listener: ParseTreeListener):
1754 if hasattr(listener, "enterRightexpr"):
1755 listener.enterRightexpr(self)
1757 def exitRule(self, listener: ParseTreeListener):
1758 if hasattr(listener, "exitRightexpr"):
1759 listener.exitRightexpr(self)
1761 def rightexpr(self):
1763 localctx = RParser.RightexprContext(self, self._ctx, self.state)
1764 self.enterRule(localctx, 20, self.RULE_rightexpr)
1765 self._la = 0 # Token type
1766 try:
1767 self.enterOuterAlt(localctx, 1)
1768 self.state = 362
1769 _la = self._input.LA(1)
1770 if not(_la == RParser.T__0 or _la == RParser.NL):
1771 self._errHandler.recoverInline(self)
1772 else:
1773 self._errHandler.reportMatch(self)
1774 self.consume()
1775 self.state = 364
1776 self._errHandler.sync(self)
1777 la_ = self._interp.adaptivePredict(self._input, 32, self._ctx)
1778 if la_ == 1:
1779 self.state = 363
1780 self.expr(0)
1782 except RecognitionException as re:
1783 localctx.exception = re
1784 self._errHandler.reportError(self, re)
1785 self._errHandler.recover(self, re)
1786 finally:
1787 self.exitRule()
1788 return localctx
1790 class FormlistContext(ParserRuleContext):
1792 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1793 super().__init__(parent, invokingState)
1794 self.parser = parser
1796 def form(self, i: int = None):
1797 if i is None:
1798 return self.getTypedRuleContexts(RParser.FormContext)
1799 else:
1800 return self.getTypedRuleContext(RParser.FormContext, i)
1802 def NL(self, i: int = None):
1803 if i is None:
1804 return self.getTokens(RParser.NL)
1805 else:
1806 return self.getToken(RParser.NL, i)
1808 def getRuleIndex(self):
1809 return RParser.RULE_formlist
1811 def enterRule(self, listener: ParseTreeListener):
1812 if hasattr(listener, "enterFormlist"):
1813 listener.enterFormlist(self)
1815 def exitRule(self, listener: ParseTreeListener):
1816 if hasattr(listener, "exitFormlist"):
1817 listener.exitFormlist(self)
1819 def formlist(self):
1821 localctx = RParser.FormlistContext(self, self._ctx, self.state)
1822 self.enterRule(localctx, 22, self.RULE_formlist)
1823 self._la = 0 # Token type
1824 try:
1825 self.enterOuterAlt(localctx, 1)
1826 self.state = 366
1827 self.form()
1828 self.state = 380
1829 self._errHandler.sync(self)
1830 _alt = self._interp.adaptivePredict(self._input, 35, self._ctx)
1831 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
1832 if _alt == 1:
1833 self.state = 368
1834 self._errHandler.sync(self)
1835 _la = self._input.LA(1)
1836 if _la == RParser.NL:
1837 self.state = 367
1838 self.match(RParser.NL)
1840 self.state = 370
1841 self.match(RParser.T__18)
1842 self.state = 374
1843 self._errHandler.sync(self)
1844 _la = self._input.LA(1)
1845 while _la == RParser.NL:
1846 self.state = 371
1847 self.match(RParser.NL)
1848 self.state = 376
1849 self._errHandler.sync(self)
1850 _la = self._input.LA(1)
1852 self.state = 377
1853 self.form()
1854 self.state = 382
1855 self._errHandler.sync(self)
1856 _alt = self._interp.adaptivePredict(self._input, 35, self._ctx)
1858 except RecognitionException as re:
1859 localctx.exception = re
1860 self._errHandler.reportError(self, re)
1861 self._errHandler.recover(self, re)
1862 finally:
1863 self.exitRule()
1864 return localctx
1866 class FormContext(ParserRuleContext):
1868 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1869 super().__init__(parent, invokingState)
1870 self.parser = parser
1872 def argumentname(self):
1873 return self.getTypedRuleContext(RParser.ArgumentnameContext, 0)
1875 def expr(self):
1876 return self.getTypedRuleContext(RParser.ExprContext, 0)
1878 def getRuleIndex(self):
1879 return RParser.RULE_form
1881 def enterRule(self, listener: ParseTreeListener):
1882 if hasattr(listener, "enterForm"):
1883 listener.enterForm(self)
1885 def exitRule(self, listener: ParseTreeListener):
1886 if hasattr(listener, "exitForm"):
1887 listener.exitForm(self)
1889 def form(self):
1891 localctx = RParser.FormContext(self, self._ctx, self.state)
1892 self.enterRule(localctx, 24, self.RULE_form)
1893 try:
1894 self.state = 389
1895 self._errHandler.sync(self)
1896 la_ = self._interp.adaptivePredict(self._input, 36, self._ctx)
1897 if la_ == 1:
1898 self.enterOuterAlt(localctx, 1)
1899 self.state = 383
1900 self.argumentname()
1901 pass
1903 elif la_ == 2:
1904 self.enterOuterAlt(localctx, 2)
1905 self.state = 384
1906 self.argumentname()
1907 self.state = 385
1908 self.match(RParser.T__19)
1909 self.state = 386
1910 self.expr(0)
1911 pass
1913 elif la_ == 3:
1914 self.enterOuterAlt(localctx, 3)
1915 self.state = 388
1916 self.match(RParser.T__20)
1917 pass
1919 except RecognitionException as re:
1920 localctx.exception = re
1921 self._errHandler.reportError(self, re)
1922 self._errHandler.recover(self, re)
1923 finally:
1924 self.exitRule()
1925 return localctx
1927 class ArgumentnameContext(ParserRuleContext):
1929 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1930 super().__init__(parent, invokingState)
1931 self.parser = parser
1933 def ID(self):
1934 return self.getToken(RParser.ID, 0)
1936 def getRuleIndex(self):
1937 return RParser.RULE_argumentname
1939 def enterRule(self, listener: ParseTreeListener):
1940 if hasattr(listener, "enterArgumentname"):
1941 listener.enterArgumentname(self)
1943 def exitRule(self, listener: ParseTreeListener):
1944 if hasattr(listener, "exitArgumentname"):
1945 listener.exitArgumentname(self)
1947 def argumentname(self):
1949 localctx = RParser.ArgumentnameContext(self, self._ctx, self.state)
1950 self.enterRule(localctx, 26, self.RULE_argumentname)
1951 try:
1952 self.enterOuterAlt(localctx, 1)
1953 self.state = 391
1954 self.match(RParser.ID)
1955 except RecognitionException as re:
1956 localctx.exception = re
1957 self._errHandler.reportError(self, re)
1958 self._errHandler.recover(self, re)
1959 finally:
1960 self.exitRule()
1961 return localctx
1963 class SublistContext(ParserRuleContext):
1965 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1966 super().__init__(parent, invokingState)
1967 self.parser = parser
1969 def sub(self, i: int = None):
1970 if i is None:
1971 return self.getTypedRuleContexts(RParser.SubContext)
1972 else:
1973 return self.getTypedRuleContext(RParser.SubContext, i)
1975 def inlinefunction(self, i: int = None):
1976 if i is None:
1977 return self.getTypedRuleContexts(RParser.InlinefunctionContext)
1978 else:
1979 return self.getTypedRuleContext(RParser.InlinefunctionContext, i)
1981 def NL(self, i: int = None):
1982 if i is None:
1983 return self.getTokens(RParser.NL)
1984 else:
1985 return self.getToken(RParser.NL, i)
1987 def getRuleIndex(self):
1988 return RParser.RULE_sublist
1990 def enterRule(self, listener: ParseTreeListener):
1991 if hasattr(listener, "enterSublist"):
1992 listener.enterSublist(self)
1994 def exitRule(self, listener: ParseTreeListener):
1995 if hasattr(listener, "exitSublist"):
1996 listener.exitSublist(self)
1998 def sublist(self):
2000 localctx = RParser.SublistContext(self, self._ctx, self.state)
2001 self.enterRule(localctx, 28, self.RULE_sublist)
2002 self._la = 0 # Token type
2003 try:
2004 self.enterOuterAlt(localctx, 1)
2005 self.state = 393
2006 self.sub()
2007 self.state = 419
2008 self._errHandler.sync(self)
2009 _alt = self._interp.adaptivePredict(self._input, 41, self._ctx)
2010 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
2011 if _alt == 1:
2012 self.state = 397
2013 self._errHandler.sync(self)
2014 _la = self._input.LA(1)
2015 while _la == RParser.NL:
2016 self.state = 394
2017 self.match(RParser.NL)
2018 self.state = 399
2019 self._errHandler.sync(self)
2020 _la = self._input.LA(1)
2022 self.state = 400
2023 self.match(RParser.T__18)
2024 self.state = 404
2025 self._errHandler.sync(self)
2026 _alt = self._interp.adaptivePredict(
2027 self._input, 38, self._ctx)
2028 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
2029 if _alt == 1:
2030 self.state = 401
2031 self.match(RParser.NL)
2032 self.state = 406
2033 self._errHandler.sync(self)
2034 _alt = self._interp.adaptivePredict(
2035 self._input, 38, self._ctx)
2037 self.state = 409
2038 self._errHandler.sync(self)
2039 la_ = self._interp.adaptivePredict(
2040 self._input, 39, self._ctx)
2041 if la_ == 1:
2042 self.state = 407
2043 self.inlinefunction()
2044 pass
2046 elif la_ == 2:
2047 self.state = 408
2048 self.sub()
2049 pass
2051 self.state = 414
2052 self._errHandler.sync(self)
2053 _alt = self._interp.adaptivePredict(
2054 self._input, 40, self._ctx)
2055 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
2056 if _alt == 1:
2057 self.state = 411
2058 self.match(RParser.NL)
2059 self.state = 416
2060 self._errHandler.sync(self)
2061 _alt = self._interp.adaptivePredict(
2062 self._input, 40, self._ctx)
2064 self.state = 421
2065 self._errHandler.sync(self)
2066 _alt = self._interp.adaptivePredict(self._input, 41, self._ctx)
2068 except RecognitionException as re:
2069 localctx.exception = re
2070 self._errHandler.reportError(self, re)
2071 self._errHandler.recover(self, re)
2072 finally:
2073 self.exitRule()
2074 return localctx
2076 class SublistaddContext(ParserRuleContext):
2078 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
2079 super().__init__(parent, invokingState)
2080 self.parser = parser
2082 def identifier(self, i: int = None):
2083 if i is None:
2084 return self.getTypedRuleContexts(RParser.IdentifierContext)
2085 else:
2086 return self.getTypedRuleContext(RParser.IdentifierContext, i)
2088 def NL(self, i: int = None):
2089 if i is None:
2090 return self.getTokens(RParser.NL)
2091 else:
2092 return self.getToken(RParser.NL, i)
2094 def getRuleIndex(self):
2095 return RParser.RULE_sublistadd
2097 def enterRule(self, listener: ParseTreeListener):
2098 if hasattr(listener, "enterSublistadd"):
2099 listener.enterSublistadd(self)
2101 def exitRule(self, listener: ParseTreeListener):
2102 if hasattr(listener, "exitSublistadd"):
2103 listener.exitSublistadd(self)
2105 def sublistadd(self):
2107 localctx = RParser.SublistaddContext(self, self._ctx, self.state)
2108 self.enterRule(localctx, 30, self.RULE_sublistadd)
2109 self._la = 0 # Token type
2110 try:
2111 self.enterOuterAlt(localctx, 1)
2112 self.state = 422
2113 self.identifier()
2114 self.state = 436
2115 self._errHandler.sync(self)
2116 _alt = self._interp.adaptivePredict(self._input, 45, self._ctx)
2117 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
2118 if _alt == 1:
2119 self.state = 424
2120 self._errHandler.sync(self)
2121 _la = self._input.LA(1)
2122 if _la == RParser.NL:
2123 self.state = 423
2124 self.match(RParser.NL)
2126 self.state = 426
2127 self.match(RParser.T__5)
2128 self.state = 428
2129 self._errHandler.sync(self)
2130 _la = self._input.LA(1)
2131 if _la == RParser.NL:
2132 self.state = 427
2133 self.match(RParser.NL)
2135 self.state = 430
2136 self.identifier()
2137 self.state = 432
2138 self._errHandler.sync(self)
2139 la_ = self._interp.adaptivePredict(
2140 self._input, 44, self._ctx)
2141 if la_ == 1:
2142 self.state = 431
2143 self.match(RParser.NL)
2145 self.state = 438
2146 self._errHandler.sync(self)
2147 _alt = self._interp.adaptivePredict(self._input, 45, self._ctx)
2149 except RecognitionException as re:
2150 localctx.exception = re
2151 self._errHandler.reportError(self, re)
2152 self._errHandler.recover(self, re)
2153 finally:
2154 self.exitRule()
2155 return localctx
2157 class SubContext(ParserRuleContext):
2159 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
2160 super().__init__(parent, invokingState)
2161 self.parser = parser
2163 def subnobracket(self):
2164 return self.getTypedRuleContext(RParser.SubnobracketContext, 0)
2166 def expr(self):
2167 return self.getTypedRuleContext(RParser.ExprContext, 0)
2169 def getRuleIndex(self):
2170 return RParser.RULE_sub
2172 def enterRule(self, listener: ParseTreeListener):
2173 if hasattr(listener, "enterSub"):
2174 listener.enterSub(self)
2176 def exitRule(self, listener: ParseTreeListener):
2177 if hasattr(listener, "exitSub"):
2178 listener.exitSub(self)
2180 def sub(self):
2182 localctx = RParser.SubContext(self, self._ctx, self.state)
2183 self.enterRule(localctx, 32, self.RULE_sub)
2184 try:
2185 self.state = 441
2186 self._errHandler.sync(self)
2187 la_ = self._interp.adaptivePredict(self._input, 46, self._ctx)
2188 if la_ == 1:
2189 self.enterOuterAlt(localctx, 1)
2190 self.state = 439
2191 self.subnobracket()
2192 pass
2194 elif la_ == 2:
2195 self.enterOuterAlt(localctx, 2)
2196 self.state = 440
2197 self.expr(0)
2198 pass
2200 except RecognitionException as re:
2201 localctx.exception = re
2202 self._errHandler.reportError(self, re)
2203 self._errHandler.recover(self, re)
2204 finally:
2205 self.exitRule()
2206 return localctx
2208 class SubnobracketContext(ParserRuleContext):
2210 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
2211 super().__init__(parent, invokingState)
2212 self.parser = parser
2214 def identifier(self):
2215 return self.getTypedRuleContext(RParser.IdentifierContext, 0)
2217 def inlinefunction(self):
2218 return self.getTypedRuleContext(RParser.InlinefunctionContext, 0)
2220 def expr(self):
2221 return self.getTypedRuleContext(RParser.ExprContext, 0)
2223 def STRING(self):
2224 return self.getToken(RParser.STRING, 0)
2226 def getRuleIndex(self):
2227 return RParser.RULE_subnobracket
2229 def enterRule(self, listener: ParseTreeListener):
2230 if hasattr(listener, "enterSubnobracket"):
2231 listener.enterSubnobracket(self)
2233 def exitRule(self, listener: ParseTreeListener):
2234 if hasattr(listener, "exitSubnobracket"):
2235 listener.exitSubnobracket(self)
2237 def subnobracket(self):
2239 localctx = RParser.SubnobracketContext(self, self._ctx, self.state)
2240 self.enterRule(localctx, 34, self.RULE_subnobracket)
2241 try:
2242 self.state = 461
2243 self._errHandler.sync(self)
2244 la_ = self._interp.adaptivePredict(self._input, 48, self._ctx)
2245 if la_ == 1:
2246 self.enterOuterAlt(localctx, 1)
2247 self.state = 443
2248 self.identifier()
2249 self.state = 444
2250 self.match(RParser.T__19)
2251 self.state = 447
2252 self._errHandler.sync(self)
2253 la_ = self._interp.adaptivePredict(self._input, 47, self._ctx)
2254 if la_ == 1:
2255 self.state = 445
2256 self.inlinefunction()
2257 pass
2259 elif la_ == 2:
2260 self.state = 446
2261 self.expr(0)
2262 pass
2264 pass
2266 elif la_ == 2:
2267 self.enterOuterAlt(localctx, 2)
2268 self.state = 449
2269 self.match(RParser.STRING)
2270 self.state = 450
2271 self.match(RParser.T__19)
2272 pass
2274 elif la_ == 3:
2275 self.enterOuterAlt(localctx, 3)
2276 self.state = 451
2277 self.match(RParser.STRING)
2278 self.state = 452
2279 self.match(RParser.T__19)
2280 self.state = 453
2281 self.expr(0)
2282 pass
2284 elif la_ == 4:
2285 self.enterOuterAlt(localctx, 4)
2286 self.state = 454
2287 self.match(RParser.T__21)
2288 self.state = 455
2289 self.match(RParser.T__19)
2290 pass
2292 elif la_ == 5:
2293 self.enterOuterAlt(localctx, 5)
2294 self.state = 456
2295 self.match(RParser.T__21)
2296 self.state = 457
2297 self.match(RParser.T__19)
2298 self.state = 458
2299 self.expr(0)
2300 pass
2302 elif la_ == 6:
2303 self.enterOuterAlt(localctx, 6)
2304 self.state = 459
2305 self.match(RParser.T__20)
2306 pass
2308 elif la_ == 7:
2309 self.enterOuterAlt(localctx, 7)
2310 self.state = 460
2311 self.match(RParser.T__22)
2312 pass
2314 except RecognitionException as re:
2315 localctx.exception = re
2316 self._errHandler.reportError(self, re)
2317 self._errHandler.recover(self, re)
2318 finally:
2319 self.exitRule()
2320 return localctx
2322 class RangesContext(ParserRuleContext):
2324 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
2325 super().__init__(parent, invokingState)
2326 self.parser = parser
2328 def range_simple(self):
2329 return self.getTypedRuleContext(RParser.Range_simpleContext, 0)
2331 def range_complexe(self):
2332 return self.getTypedRuleContext(RParser.Range_complexeContext, 0)
2334 def getRuleIndex(self):
2335 return RParser.RULE_ranges
2337 def enterRule(self, listener: ParseTreeListener):
2338 if hasattr(listener, "enterRanges"):
2339 listener.enterRanges(self)
2341 def exitRule(self, listener: ParseTreeListener):
2342 if hasattr(listener, "exitRanges"):
2343 listener.exitRanges(self)
2345 def ranges(self):
2347 localctx = RParser.RangesContext(self, self._ctx, self.state)
2348 self.enterRule(localctx, 36, self.RULE_ranges)
2349 try:
2350 self.state = 465
2351 self._errHandler.sync(self)
2352 token = self._input.LA(1)
2353 if token in [RParser.INT, RParser.ID]:
2354 self.enterOuterAlt(localctx, 1)
2355 self.state = 463
2356 self.range_simple()
2357 pass
2358 elif token in [RParser.T__15]:
2359 self.enterOuterAlt(localctx, 2)
2360 self.state = 464
2361 self.range_complexe()
2362 pass
2363 else:
2364 raise NoViableAltException(self)
2366 except RecognitionException as re:
2367 localctx.exception = re
2368 self._errHandler.reportError(self, re)
2369 self._errHandler.recover(self, re)
2370 finally:
2371 self.exitRule()
2372 return localctx
2374 class Range_simpleContext(ParserRuleContext):
2376 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
2377 super().__init__(parent, invokingState)
2378 self.parser = parser
2380 def identifier(self, i: int = None):
2381 if i is None:
2382 return self.getTypedRuleContexts(RParser.IdentifierContext)
2383 else:
2384 return self.getTypedRuleContext(RParser.IdentifierContext, i)
2386 def INT(self, i: int = None):
2387 if i is None:
2388 return self.getTokens(RParser.INT)
2389 else:
2390 return self.getToken(RParser.INT, i)
2392 def getRuleIndex(self):
2393 return RParser.RULE_range_simple
2395 def enterRule(self, listener: ParseTreeListener):
2396 if hasattr(listener, "enterRange_simple"):
2397 listener.enterRange_simple(self)
2399 def exitRule(self, listener: ParseTreeListener):
2400 if hasattr(listener, "exitRange_simple"):
2401 listener.exitRange_simple(self)
2403 def range_simple(self):
2405 localctx = RParser.Range_simpleContext(self, self._ctx, self.state)
2406 self.enterRule(localctx, 38, self.RULE_range_simple)
2407 try:
2408 self.enterOuterAlt(localctx, 1)
2409 self.state = 469
2410 self._errHandler.sync(self)
2411 token = self._input.LA(1)
2412 if token in [RParser.ID]:
2413 self.state = 467
2414 self.identifier()
2415 pass
2416 elif token in [RParser.INT]:
2417 self.state = 468
2418 self.match(RParser.INT)
2419 pass
2420 else:
2421 raise NoViableAltException(self)
2423 self.state = 471
2424 self.match(RParser.T__22)
2425 self.state = 474
2426 self._errHandler.sync(self)
2427 token = self._input.LA(1)
2428 if token in [RParser.ID]:
2429 self.state = 472
2430 self.identifier()
2431 pass
2432 elif token in [RParser.INT]:
2433 self.state = 473
2434 self.match(RParser.INT)
2435 pass
2436 else:
2437 raise NoViableAltException(self)
2439 except RecognitionException as re:
2440 localctx.exception = re
2441 self._errHandler.reportError(self, re)
2442 self._errHandler.recover(self, re)
2443 finally:
2444 self.exitRule()
2445 return localctx
2447 class Range_complexeContext(ParserRuleContext):
2449 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
2450 super().__init__(parent, invokingState)
2451 self.parser = parser
2453 def expr(self, i: int = None):
2454 if i is None:
2455 return self.getTypedRuleContexts(RParser.ExprContext)
2456 else:
2457 return self.getTypedRuleContext(RParser.ExprContext, i)
2459 def getRuleIndex(self):
2460 return RParser.RULE_range_complexe
2462 def enterRule(self, listener: ParseTreeListener):
2463 if hasattr(listener, "enterRange_complexe"):
2464 listener.enterRange_complexe(self)
2466 def exitRule(self, listener: ParseTreeListener):
2467 if hasattr(listener, "exitRange_complexe"):
2468 listener.exitRange_complexe(self)
2470 def range_complexe(self):
2472 localctx = RParser.Range_complexeContext(self, self._ctx, self.state)
2473 self.enterRule(localctx, 40, self.RULE_range_complexe)
2474 try:
2475 self.enterOuterAlt(localctx, 1)
2476 self.state = 476
2477 self.match(RParser.T__15)
2478 self.state = 477
2479 self.expr(0)
2480 self.state = 478
2481 self.match(RParser.T__16)
2482 self.state = 479
2483 self.match(RParser.T__22)
2484 self.state = 480
2485 self.expr(0)
2486 except RecognitionException as re:
2487 localctx.exception = re
2488 self._errHandler.reportError(self, re)
2489 self._errHandler.recover(self, re)
2490 finally:
2491 self.exitRule()
2492 return localctx
2494 class IntersectionsContext(ParserRuleContext):
2496 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
2497 super().__init__(parent, invokingState)
2498 self.parser = parser
2500 def intersection_simple(self):
2501 return self.getTypedRuleContext(RParser.Intersection_simpleContext, 0)
2503 def intersection_complexe(self):
2504 return self.getTypedRuleContext(RParser.Intersection_complexeContext, 0)
2506 def getRuleIndex(self):
2507 return RParser.RULE_intersections
2509 def enterRule(self, listener: ParseTreeListener):
2510 if hasattr(listener, "enterIntersections"):
2511 listener.enterIntersections(self)
2513 def exitRule(self, listener: ParseTreeListener):
2514 if hasattr(listener, "exitIntersections"):
2515 listener.exitIntersections(self)
2517 def intersections(self):
2519 localctx = RParser.IntersectionsContext(self, self._ctx, self.state)
2520 self.enterRule(localctx, 42, self.RULE_intersections)
2521 try:
2522 self.state = 484
2523 self._errHandler.sync(self)
2524 token = self._input.LA(1)
2525 if token in [RParser.T__21, RParser.T__24, RParser.T__25, RParser.T__26, RParser.T__27, RParser.T__28, RParser.HEX, RParser.INT, RParser.FLOAT, RParser.COMPLEX, RParser.STRING, RParser.ID]:
2526 self.enterOuterAlt(localctx, 1)
2527 self.state = 482
2528 self.intersection_simple()
2529 pass
2530 elif token in [RParser.T__15]:
2531 self.enterOuterAlt(localctx, 2)
2532 self.state = 483
2533 self.intersection_complexe()
2534 pass
2535 else:
2536 raise NoViableAltException(self)
2538 except RecognitionException as re:
2539 localctx.exception = re
2540 self._errHandler.reportError(self, re)
2541 self._errHandler.recover(self, re)
2542 finally:
2543 self.exitRule()
2544 return localctx
2546 class Intersection_simpleContext(ParserRuleContext):
2548 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
2549 super().__init__(parent, invokingState)
2550 self.parser = parser
2552 def expr(self):
2553 return self.getTypedRuleContext(RParser.ExprContext, 0)
2555 def identifier(self):
2556 return self.getTypedRuleContext(RParser.IdentifierContext, 0)
2558 def constant(self):
2559 return self.getTypedRuleContext(RParser.ConstantContext, 0)
2561 def getRuleIndex(self):
2562 return RParser.RULE_intersection_simple
2564 def enterRule(self, listener: ParseTreeListener):
2565 if hasattr(listener, "enterIntersection_simple"):
2566 listener.enterIntersection_simple(self)
2568 def exitRule(self, listener: ParseTreeListener):
2569 if hasattr(listener, "exitIntersection_simple"):
2570 listener.exitIntersection_simple(self)
2572 def intersection_simple(self):
2574 localctx = RParser.Intersection_simpleContext(
2575 self, self._ctx, self.state)
2576 self.enterRule(localctx, 44, self.RULE_intersection_simple)
2577 try:
2578 self.enterOuterAlt(localctx, 1)
2579 self.state = 488
2580 self._errHandler.sync(self)
2581 token = self._input.LA(1)
2582 if token in [RParser.ID]:
2583 self.state = 486
2584 self.identifier()
2585 pass
2586 elif token in [RParser.T__21, RParser.T__24, RParser.T__25, RParser.T__26, RParser.T__27, RParser.T__28, RParser.HEX, RParser.INT, RParser.FLOAT, RParser.COMPLEX, RParser.STRING]:
2587 self.state = 487
2588 self.constant()
2589 pass
2590 else:
2591 raise NoViableAltException(self)
2593 self.state = 490
2594 self.match(RParser.T__23)
2595 self.state = 491
2596 self.expr(0)
2597 except RecognitionException as re:
2598 localctx.exception = re
2599 self._errHandler.reportError(self, re)
2600 self._errHandler.recover(self, re)
2601 finally:
2602 self.exitRule()
2603 return localctx
2605 class Intersection_complexeContext(ParserRuleContext):
2607 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
2608 super().__init__(parent, invokingState)
2609 self.parser = parser
2611 def expr(self, i: int = None):
2612 if i is None:
2613 return self.getTypedRuleContexts(RParser.ExprContext)
2614 else:
2615 return self.getTypedRuleContext(RParser.ExprContext, i)
2617 def getRuleIndex(self):
2618 return RParser.RULE_intersection_complexe
2620 def enterRule(self, listener: ParseTreeListener):
2621 if hasattr(listener, "enterIntersection_complexe"):
2622 listener.enterIntersection_complexe(self)
2624 def exitRule(self, listener: ParseTreeListener):
2625 if hasattr(listener, "exitIntersection_complexe"):
2626 listener.exitIntersection_complexe(self)
2628 def intersection_complexe(self):
2630 localctx = RParser.Intersection_complexeContext(
2631 self, self._ctx, self.state)
2632 self.enterRule(localctx, 46, self.RULE_intersection_complexe)
2633 try:
2634 self.enterOuterAlt(localctx, 1)
2635 self.state = 493
2636 self.match(RParser.T__15)
2637 self.state = 494
2638 self.expr(0)
2639 self.state = 495
2640 self.match(RParser.T__16)
2641 self.state = 496
2642 self.match(RParser.T__23)
2643 self.state = 497
2644 self.expr(0)
2645 except RecognitionException as re:
2646 localctx.exception = re
2647 self._errHandler.reportError(self, re)
2648 self._errHandler.recover(self, re)
2649 finally:
2650 self.exitRule()
2651 return localctx
2653 class ConstantContext(ParserRuleContext):
2655 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
2656 super().__init__(parent, invokingState)
2657 self.parser = parser
2659 def STRING(self):
2660 return self.getToken(RParser.STRING, 0)
2662 def HEX(self):
2663 return self.getToken(RParser.HEX, 0)
2665 def INT(self):
2666 return self.getToken(RParser.INT, 0)
2668 def FLOAT(self):
2669 return self.getToken(RParser.FLOAT, 0)
2671 def COMPLEX(self):
2672 return self.getToken(RParser.COMPLEX, 0)
2674 def boolean(self):
2675 return self.getTypedRuleContext(RParser.BooleanContext, 0)
2677 def getRuleIndex(self):
2678 return RParser.RULE_constant
2680 def enterRule(self, listener: ParseTreeListener):
2681 if hasattr(listener, "enterConstant"):
2682 listener.enterConstant(self)
2684 def exitRule(self, listener: ParseTreeListener):
2685 if hasattr(listener, "exitConstant"):
2686 listener.exitConstant(self)
2688 def constant(self):
2690 localctx = RParser.ConstantContext(self, self._ctx, self.state)
2691 self.enterRule(localctx, 48, self.RULE_constant)
2692 try:
2693 self.state = 509
2694 self._errHandler.sync(self)
2695 token = self._input.LA(1)
2696 if token in [RParser.STRING]:
2697 self.enterOuterAlt(localctx, 1)
2698 self.state = 499
2699 self.match(RParser.STRING)
2700 pass
2701 elif token in [RParser.HEX]:
2702 self.enterOuterAlt(localctx, 2)
2703 self.state = 500
2704 self.match(RParser.HEX)
2705 pass
2706 elif token in [RParser.INT]:
2707 self.enterOuterAlt(localctx, 3)
2708 self.state = 501
2709 self.match(RParser.INT)
2710 pass
2711 elif token in [RParser.FLOAT]:
2712 self.enterOuterAlt(localctx, 4)
2713 self.state = 502
2714 self.match(RParser.FLOAT)
2715 pass
2716 elif token in [RParser.COMPLEX]:
2717 self.enterOuterAlt(localctx, 5)
2718 self.state = 503
2719 self.match(RParser.COMPLEX)
2720 pass
2721 elif token in [RParser.T__21]:
2722 self.enterOuterAlt(localctx, 6)
2723 self.state = 504
2724 self.match(RParser.T__21)
2725 pass
2726 elif token in [RParser.T__24]:
2727 self.enterOuterAlt(localctx, 7)
2728 self.state = 505
2729 self.match(RParser.T__24)
2730 pass
2731 elif token in [RParser.T__25]:
2732 self.enterOuterAlt(localctx, 8)
2733 self.state = 506
2734 self.match(RParser.T__25)
2735 pass
2736 elif token in [RParser.T__26]:
2737 self.enterOuterAlt(localctx, 9)
2738 self.state = 507
2739 self.match(RParser.T__26)
2740 pass
2741 elif token in [RParser.T__27, RParser.T__28]:
2742 self.enterOuterAlt(localctx, 10)
2743 self.state = 508
2744 self.boolean()
2745 pass
2746 else:
2747 raise NoViableAltException(self)
2749 except RecognitionException as re:
2750 localctx.exception = re
2751 self._errHandler.reportError(self, re)
2752 self._errHandler.recover(self, re)
2753 finally:
2754 self.exitRule()
2755 return localctx
2757 class BooleanContext(ParserRuleContext):
2759 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
2760 super().__init__(parent, invokingState)
2761 self.parser = parser
2763 def getRuleIndex(self):
2764 return RParser.RULE_boolean
2766 def enterRule(self, listener: ParseTreeListener):
2767 if hasattr(listener, "enterBoolean"):
2768 listener.enterBoolean(self)
2770 def exitRule(self, listener: ParseTreeListener):
2771 if hasattr(listener, "exitBoolean"):
2772 listener.exitBoolean(self)
2774 def boolean(self):
2776 localctx = RParser.BooleanContext(self, self._ctx, self.state)
2777 self.enterRule(localctx, 50, self.RULE_boolean)
2778 self._la = 0 # Token type
2779 try:
2780 self.enterOuterAlt(localctx, 1)
2781 self.state = 511
2782 _la = self._input.LA(1)
2783 if not(_la == RParser.T__27 or _la == RParser.T__28):
2784 self._errHandler.recoverInline(self)
2785 else:
2786 self._errHandler.reportMatch(self)
2787 self.consume()
2788 except RecognitionException as re:
2789 localctx.exception = re
2790 self._errHandler.reportError(self, re)
2791 self._errHandler.recover(self, re)
2792 finally:
2793 self.exitRule()
2794 return localctx
2796 class NextexprContext(ParserRuleContext):
2798 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
2799 super().__init__(parent, invokingState)
2800 self.parser = parser
2802 def getRuleIndex(self):
2803 return RParser.RULE_nextexpr
2805 def enterRule(self, listener: ParseTreeListener):
2806 if hasattr(listener, "enterNextexpr"):
2807 listener.enterNextexpr(self)
2809 def exitRule(self, listener: ParseTreeListener):
2810 if hasattr(listener, "exitNextexpr"):
2811 listener.exitNextexpr(self)
2813 def nextexpr(self):
2815 localctx = RParser.NextexprContext(self, self._ctx, self.state)
2816 self.enterRule(localctx, 52, self.RULE_nextexpr)
2817 try:
2818 self.enterOuterAlt(localctx, 1)
2819 self.state = 513
2820 self.match(RParser.T__29)
2821 except RecognitionException as re:
2822 localctx.exception = re
2823 self._errHandler.reportError(self, re)
2824 self._errHandler.recover(self, re)
2825 finally:
2826 self.exitRule()
2827 return localctx
2829 class RepeatexprContext(ParserRuleContext):
2831 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
2832 super().__init__(parent, invokingState)
2833 self.parser = parser
2835 def expr(self):
2836 return self.getTypedRuleContext(RParser.ExprContext, 0)
2838 def getRuleIndex(self):
2839 return RParser.RULE_repeatexpr
2841 def enterRule(self, listener: ParseTreeListener):
2842 if hasattr(listener, "enterRepeatexpr"):
2843 listener.enterRepeatexpr(self)
2845 def exitRule(self, listener: ParseTreeListener):
2846 if hasattr(listener, "exitRepeatexpr"):
2847 listener.exitRepeatexpr(self)
2849 def repeatexpr(self):
2851 localctx = RParser.RepeatexprContext(self, self._ctx, self.state)
2852 self.enterRule(localctx, 54, self.RULE_repeatexpr)
2853 try:
2854 self.enterOuterAlt(localctx, 1)
2855 self.state = 515
2856 self.match(RParser.T__30)
2857 self.state = 516
2858 self.expr(0)
2859 except RecognitionException as re:
2860 localctx.exception = re
2861 self._errHandler.reportError(self, re)
2862 self._errHandler.recover(self, re)
2863 finally:
2864 self.exitRule()
2865 return localctx
2867 class WhileexprContext(ParserRuleContext):
2869 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
2870 super().__init__(parent, invokingState)
2871 self.parser = parser
2873 def expr(self, i: int = None):
2874 if i is None:
2875 return self.getTypedRuleContexts(RParser.ExprContext)
2876 else:
2877 return self.getTypedRuleContext(RParser.ExprContext, i)
2879 def getRuleIndex(self):
2880 return RParser.RULE_whileexpr
2882 def enterRule(self, listener: ParseTreeListener):
2883 if hasattr(listener, "enterWhileexpr"):
2884 listener.enterWhileexpr(self)
2886 def exitRule(self, listener: ParseTreeListener):
2887 if hasattr(listener, "exitWhileexpr"):
2888 listener.exitWhileexpr(self)
2890 def whileexpr(self):
2892 localctx = RParser.WhileexprContext(self, self._ctx, self.state)
2893 self.enterRule(localctx, 56, self.RULE_whileexpr)
2894 try:
2895 self.enterOuterAlt(localctx, 1)
2896 self.state = 518
2897 self.match(RParser.T__31)
2898 self.state = 519
2899 self.match(RParser.T__15)
2900 self.state = 520
2901 self.expr(0)
2902 self.state = 521
2903 self.match(RParser.T__16)
2904 self.state = 522
2905 self.expr(0)
2906 except RecognitionException as re:
2907 localctx.exception = re
2908 self._errHandler.reportError(self, re)
2909 self._errHandler.recover(self, re)
2910 finally:
2911 self.exitRule()
2912 return localctx
2914 class ForexprContext(ParserRuleContext):
2916 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
2917 super().__init__(parent, invokingState)
2918 self.parser = parser
2920 def identifier(self):
2921 return self.getTypedRuleContext(RParser.IdentifierContext, 0)
2923 def expr(self, i: int = None):
2924 if i is None:
2925 return self.getTypedRuleContexts(RParser.ExprContext)
2926 else:
2927 return self.getTypedRuleContext(RParser.ExprContext, i)
2929 def getRuleIndex(self):
2930 return RParser.RULE_forexpr
2932 def enterRule(self, listener: ParseTreeListener):
2933 if hasattr(listener, "enterForexpr"):
2934 listener.enterForexpr(self)
2936 def exitRule(self, listener: ParseTreeListener):
2937 if hasattr(listener, "exitForexpr"):
2938 listener.exitForexpr(self)
2940 def forexpr(self):
2942 localctx = RParser.ForexprContext(self, self._ctx, self.state)
2943 self.enterRule(localctx, 58, self.RULE_forexpr)
2944 try:
2945 self.enterOuterAlt(localctx, 1)
2946 self.state = 524
2947 self.match(RParser.T__32)
2948 self.state = 525
2949 self.match(RParser.T__15)
2950 self.state = 526
2951 self.identifier()
2952 self.state = 527
2953 self.match(RParser.T__33)
2954 self.state = 528
2955 self.expr(0)
2956 self.state = 529
2957 self.match(RParser.T__16)
2958 self.state = 530
2959 self.expr(0)
2960 except RecognitionException as re:
2961 localctx.exception = re
2962 self._errHandler.reportError(self, re)
2963 self._errHandler.recover(self, re)
2964 finally:
2965 self.exitRule()
2966 return localctx
2968 class IfexprContext(ParserRuleContext):
2970 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
2971 super().__init__(parent, invokingState)
2972 self.parser = parser
2974 def expr(self, i: int = None):
2975 if i is None:
2976 return self.getTypedRuleContexts(RParser.ExprContext)
2977 else:
2978 return self.getTypedRuleContext(RParser.ExprContext, i)
2980 def NL(self, i: int = None):
2981 if i is None:
2982 return self.getTokens(RParser.NL)
2983 else:
2984 return self.getToken(RParser.NL, i)
2986 def elseif(self, i: int = None):
2987 if i is None:
2988 return self.getTypedRuleContexts(RParser.ElseifContext)
2989 else:
2990 return self.getTypedRuleContext(RParser.ElseifContext, i)
2992 def getRuleIndex(self):
2993 return RParser.RULE_ifexpr
2995 def enterRule(self, listener: ParseTreeListener):
2996 if hasattr(listener, "enterIfexpr"):
2997 listener.enterIfexpr(self)
2999 def exitRule(self, listener: ParseTreeListener):
3000 if hasattr(listener, "exitIfexpr"):
3001 listener.exitIfexpr(self)
3003 def ifexpr(self):
3005 localctx = RParser.IfexprContext(self, self._ctx, self.state)
3006 self.enterRule(localctx, 60, self.RULE_ifexpr)
3007 try:
3008 self.enterOuterAlt(localctx, 1)
3009 self.state = 532
3010 self.match(RParser.T__34)
3011 self.state = 533
3012 self.match(RParser.T__15)
3013 self.state = 534
3014 self.expr(0)
3015 self.state = 535
3016 self.match(RParser.T__16)
3017 self.state = 539
3018 self._errHandler.sync(self)
3019 _alt = self._interp.adaptivePredict(self._input, 55, self._ctx)
3020 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
3021 if _alt == 1:
3022 self.state = 536
3023 self.match(RParser.NL)
3024 self.state = 541
3025 self._errHandler.sync(self)
3026 _alt = self._interp.adaptivePredict(self._input, 55, self._ctx)
3028 self.state = 542
3029 self.expr(0)
3030 self.state = 562
3031 self._errHandler.sync(self)
3032 _alt = self._interp.adaptivePredict(self._input, 58, self._ctx)
3033 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
3034 if _alt == 1:
3035 self.state = 543
3036 self.elseif()
3037 self.state = 544
3038 self.match(RParser.T__15)
3039 self.state = 545
3040 self.expr(0)
3041 self.state = 546
3042 self.match(RParser.T__16)
3043 self.state = 550
3044 self._errHandler.sync(self)
3045 _alt = self._interp.adaptivePredict(
3046 self._input, 56, self._ctx)
3047 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
3048 if _alt == 1:
3049 self.state = 547
3050 self.match(RParser.NL)
3051 self.state = 552
3052 self._errHandler.sync(self)
3053 _alt = self._interp.adaptivePredict(
3054 self._input, 56, self._ctx)
3056 self.state = 553
3057 self.expr(0)
3058 self.state = 557
3059 self._errHandler.sync(self)
3060 _alt = self._interp.adaptivePredict(
3061 self._input, 57, self._ctx)
3062 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
3063 if _alt == 1:
3064 self.state = 554
3065 self.match(RParser.NL)
3066 self.state = 559
3067 self._errHandler.sync(self)
3068 _alt = self._interp.adaptivePredict(
3069 self._input, 57, self._ctx)
3071 self.state = 564
3072 self._errHandler.sync(self)
3073 _alt = self._interp.adaptivePredict(self._input, 58, self._ctx)
3075 except RecognitionException as re:
3076 localctx.exception = re
3077 self._errHandler.reportError(self, re)
3078 self._errHandler.recover(self, re)
3079 finally:
3080 self.exitRule()
3081 return localctx
3083 class IfelseexprContext(ParserRuleContext):
3085 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
3086 super().__init__(parent, invokingState)
3087 self.parser = parser
3089 def expr(self, i: int = None):
3090 if i is None:
3091 return self.getTypedRuleContexts(RParser.ExprContext)
3092 else:
3093 return self.getTypedRuleContext(RParser.ExprContext, i)
3095 def NL(self, i: int = None):
3096 if i is None:
3097 return self.getTokens(RParser.NL)
3098 else:
3099 return self.getToken(RParser.NL, i)
3101 def elseif(self, i: int = None):
3102 if i is None:
3103 return self.getTypedRuleContexts(RParser.ElseifContext)
3104 else:
3105 return self.getTypedRuleContext(RParser.ElseifContext, i)
3107 def getRuleIndex(self):
3108 return RParser.RULE_ifelseexpr
3110 def enterRule(self, listener: ParseTreeListener):
3111 if hasattr(listener, "enterIfelseexpr"):
3112 listener.enterIfelseexpr(self)
3114 def exitRule(self, listener: ParseTreeListener):
3115 if hasattr(listener, "exitIfelseexpr"):
3116 listener.exitIfelseexpr(self)
3118 def ifelseexpr(self):
3120 localctx = RParser.IfelseexprContext(self, self._ctx, self.state)
3121 self.enterRule(localctx, 62, self.RULE_ifelseexpr)
3122 self._la = 0 # Token type
3123 try:
3124 self.enterOuterAlt(localctx, 1)
3125 self.state = 565
3126 self.match(RParser.T__34)
3127 self.state = 566
3128 self.match(RParser.T__15)
3129 self.state = 567
3130 self.expr(0)
3131 self.state = 568
3132 self.match(RParser.T__16)
3133 self.state = 572
3134 self._errHandler.sync(self)
3135 _alt = self._interp.adaptivePredict(self._input, 59, self._ctx)
3136 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
3137 if _alt == 1:
3138 self.state = 569
3139 self.match(RParser.NL)
3140 self.state = 574
3141 self._errHandler.sync(self)
3142 _alt = self._interp.adaptivePredict(self._input, 59, self._ctx)
3144 self.state = 575
3145 self.expr(0)
3146 self.state = 579
3147 self._errHandler.sync(self)
3148 _la = self._input.LA(1)
3149 while _la == RParser.NL:
3150 self.state = 576
3151 self.match(RParser.NL)
3152 self.state = 581
3153 self._errHandler.sync(self)
3154 _la = self._input.LA(1)
3156 self.state = 601
3157 self._errHandler.sync(self)
3158 _alt = self._interp.adaptivePredict(self._input, 63, self._ctx)
3159 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
3160 if _alt == 1:
3161 self.state = 582
3162 self.elseif()
3163 self.state = 583
3164 self.match(RParser.T__15)
3165 self.state = 584
3166 self.expr(0)
3167 self.state = 585
3168 self.match(RParser.T__16)
3169 self.state = 589
3170 self._errHandler.sync(self)
3171 _alt = self._interp.adaptivePredict(
3172 self._input, 61, self._ctx)
3173 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
3174 if _alt == 1:
3175 self.state = 586
3176 self.match(RParser.NL)
3177 self.state = 591
3178 self._errHandler.sync(self)
3179 _alt = self._interp.adaptivePredict(
3180 self._input, 61, self._ctx)
3182 self.state = 592
3183 self.expr(0)
3184 self.state = 596
3185 self._errHandler.sync(self)
3186 _la = self._input.LA(1)
3187 while _la == RParser.NL:
3188 self.state = 593
3189 self.match(RParser.NL)
3190 self.state = 598
3191 self._errHandler.sync(self)
3192 _la = self._input.LA(1)
3194 self.state = 603
3195 self._errHandler.sync(self)
3196 _alt = self._interp.adaptivePredict(self._input, 63, self._ctx)
3198 self.state = 604
3199 self.match(RParser.T__35)
3200 self.state = 608
3201 self._errHandler.sync(self)
3202 _alt = self._interp.adaptivePredict(self._input, 64, self._ctx)
3203 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
3204 if _alt == 1:
3205 self.state = 605
3206 self.match(RParser.NL)
3207 self.state = 610
3208 self._errHandler.sync(self)
3209 _alt = self._interp.adaptivePredict(self._input, 64, self._ctx)
3211 self.state = 611
3212 self.expr(0)
3213 except RecognitionException as re:
3214 localctx.exception = re
3215 self._errHandler.reportError(self, re)
3216 self._errHandler.recover(self, re)
3217 finally:
3218 self.exitRule()
3219 return localctx
3221 class ElseifContext(ParserRuleContext):
3223 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
3224 super().__init__(parent, invokingState)
3225 self.parser = parser
3227 def getRuleIndex(self):
3228 return RParser.RULE_elseif
3230 def enterRule(self, listener: ParseTreeListener):
3231 if hasattr(listener, "enterElseif"):
3232 listener.enterElseif(self)
3234 def exitRule(self, listener: ParseTreeListener):
3235 if hasattr(listener, "exitElseif"):
3236 listener.exitElseif(self)
3238 def elseif(self):
3240 localctx = RParser.ElseifContext(self, self._ctx, self.state)
3241 self.enterRule(localctx, 64, self.RULE_elseif)
3242 try:
3243 self.enterOuterAlt(localctx, 1)
3244 self.state = 613
3245 self.match(RParser.T__35)
3246 self.state = 614
3247 self.match(RParser.T__34)
3248 except RecognitionException as re:
3249 localctx.exception = re
3250 self._errHandler.reportError(self, re)
3251 self._errHandler.recover(self, re)
3252 finally:
3253 self.exitRule()
3254 return localctx
3256 class ReturnexprContext(ParserRuleContext):
3258 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
3259 super().__init__(parent, invokingState)
3260 self.parser = parser
3262 def expr(self):
3263 return self.getTypedRuleContext(RParser.ExprContext, 0)
3265 def getRuleIndex(self):
3266 return RParser.RULE_returnexpr
3268 def enterRule(self, listener: ParseTreeListener):
3269 if hasattr(listener, "enterReturnexpr"):
3270 listener.enterReturnexpr(self)
3272 def exitRule(self, listener: ParseTreeListener):
3273 if hasattr(listener, "exitReturnexpr"):
3274 listener.exitReturnexpr(self)
3276 def returnexpr(self):
3278 localctx = RParser.ReturnexprContext(self, self._ctx, self.state)
3279 self.enterRule(localctx, 66, self.RULE_returnexpr)
3280 try:
3281 self.enterOuterAlt(localctx, 1)
3282 self.state = 616
3283 self.match(RParser.T__36)
3284 self.state = 617
3285 self.match(RParser.T__15)
3286 self.state = 618
3287 self.expr(0)
3288 self.state = 619
3289 self.match(RParser.T__16)
3290 except RecognitionException as re:
3291 localctx.exception = re
3292 self._errHandler.reportError(self, re)
3293 self._errHandler.recover(self, re)
3294 finally:
3295 self.exitRule()
3296 return localctx
3298 class FunctioncallContext(ParserRuleContext):
3300 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
3301 super().__init__(parent, invokingState)
3302 self.parser = parser
3304 def identifier(self):
3305 return self.getTypedRuleContext(RParser.IdentifierContext, 0)
3307 def inlinefunction(self):
3308 return self.getTypedRuleContext(RParser.InlinefunctionContext, 0)
3310 def sublist(self):
3311 return self.getTypedRuleContext(RParser.SublistContext, 0)
3313 def NL(self, i: int = None):
3314 if i is None:
3315 return self.getTokens(RParser.NL)
3316 else:
3317 return self.getToken(RParser.NL, i)
3319 def getRuleIndex(self):
3320 return RParser.RULE_functioncall
3322 def enterRule(self, listener: ParseTreeListener):
3323 if hasattr(listener, "enterFunctioncall"):
3324 listener.enterFunctioncall(self)
3326 def exitRule(self, listener: ParseTreeListener):
3327 if hasattr(listener, "exitFunctioncall"):
3328 listener.exitFunctioncall(self)
3330 def functioncall(self):
3332 localctx = RParser.FunctioncallContext(self, self._ctx, self.state)
3333 self.enterRule(localctx, 68, self.RULE_functioncall)
3334 self._la = 0 # Token type
3335 try:
3336 self.enterOuterAlt(localctx, 1)
3337 self.state = 621
3338 self.identifier()
3339 self.state = 644
3340 self._errHandler.sync(self)
3341 la_ = self._interp.adaptivePredict(self._input, 67, self._ctx)
3342 if la_ == 1:
3343 self.state = 622
3344 self.match(RParser.T__15)
3345 self.state = 623
3346 self.match(RParser.T__16)
3347 pass
3349 elif la_ == 2:
3350 self.state = 624
3351 self.match(RParser.T__15)
3352 self.state = 625
3353 self.inlinefunction()
3354 self.state = 626
3355 self.match(RParser.T__16)
3356 pass
3358 elif la_ == 3:
3359 self.state = 628
3360 self.match(RParser.T__15)
3361 self.state = 632
3362 self._errHandler.sync(self)
3363 _alt = self._interp.adaptivePredict(self._input, 65, self._ctx)
3364 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
3365 if _alt == 1:
3366 self.state = 629
3367 self.match(RParser.NL)
3368 self.state = 634
3369 self._errHandler.sync(self)
3370 _alt = self._interp.adaptivePredict(
3371 self._input, 65, self._ctx)
3373 self.state = 635
3374 self.sublist()
3375 self.state = 639
3376 self._errHandler.sync(self)
3377 _la = self._input.LA(1)
3378 while _la == RParser.NL:
3379 self.state = 636
3380 self.match(RParser.NL)
3381 self.state = 641
3382 self._errHandler.sync(self)
3383 _la = self._input.LA(1)
3385 self.state = 642
3386 self.match(RParser.T__16)
3387 pass
3389 except RecognitionException as re:
3390 localctx.exception = re
3391 self._errHandler.reportError(self, re)
3392 self._errHandler.recover(self, re)
3393 finally:
3394 self.exitRule()
3395 return localctx
3397 class InlinefunctionContext(ParserRuleContext):
3399 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
3400 super().__init__(parent, invokingState)
3401 self.parser = parser
3403 def exprlist(self):
3404 return self.getTypedRuleContext(RParser.ExprlistContext, 0)
3406 def NL(self, i: int = None):
3407 if i is None:
3408 return self.getTokens(RParser.NL)
3409 else:
3410 return self.getToken(RParser.NL, i)
3412 def getRuleIndex(self):
3413 return RParser.RULE_inlinefunction
3415 def enterRule(self, listener: ParseTreeListener):
3416 if hasattr(listener, "enterInlinefunction"):
3417 listener.enterInlinefunction(self)
3419 def exitRule(self, listener: ParseTreeListener):
3420 if hasattr(listener, "exitInlinefunction"):
3421 listener.exitInlinefunction(self)
3423 def inlinefunction(self):
3425 localctx = RParser.InlinefunctionContext(self, self._ctx, self.state)
3426 self.enterRule(localctx, 70, self.RULE_inlinefunction)
3427 self._la = 0 # Token type
3428 try:
3429 self.enterOuterAlt(localctx, 1)
3430 self.state = 649
3431 self._errHandler.sync(self)
3432 _la = self._input.LA(1)
3433 while _la == RParser.NL:
3434 self.state = 646
3435 self.match(RParser.NL)
3436 self.state = 651
3437 self._errHandler.sync(self)
3438 _la = self._input.LA(1)
3440 self.state = 652
3441 self.match(RParser.T__11)
3442 self.state = 656
3443 self._errHandler.sync(self)
3444 _alt = self._interp.adaptivePredict(self._input, 69, self._ctx)
3445 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
3446 if _alt == 1:
3447 self.state = 653
3448 self.match(RParser.NL)
3449 self.state = 658
3450 self._errHandler.sync(self)
3451 _alt = self._interp.adaptivePredict(self._input, 69, self._ctx)
3453 self.state = 659
3454 self.exprlist()
3455 self.state = 663
3456 self._errHandler.sync(self)
3457 _la = self._input.LA(1)
3458 while _la == RParser.NL:
3459 self.state = 660
3460 self.match(RParser.NL)
3461 self.state = 665
3462 self._errHandler.sync(self)
3463 _la = self._input.LA(1)
3465 self.state = 666
3466 self.match(RParser.T__12)
3467 self.state = 670
3468 self._errHandler.sync(self)
3469 _alt = self._interp.adaptivePredict(self._input, 71, self._ctx)
3470 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
3471 if _alt == 1:
3472 self.state = 667
3473 self.match(RParser.NL)
3474 self.state = 672
3475 self._errHandler.sync(self)
3476 _alt = self._interp.adaptivePredict(self._input, 71, self._ctx)
3478 except RecognitionException as re:
3479 localctx.exception = re
3480 self._errHandler.reportError(self, re)
3481 self._errHandler.recover(self, re)
3482 finally:
3483 self.exitRule()
3484 return localctx
3486 class Formula_simpleContext(ParserRuleContext):
3488 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
3489 super().__init__(parent, invokingState)
3490 self.parser = parser
3492 def formula_simple_B(self):
3493 return self.getTypedRuleContext(RParser.Formula_simple_BContext, 0)
3495 def formula_simple_A(self):
3496 return self.getTypedRuleContext(RParser.Formula_simple_AContext, 0)
3498 def formula_simple_C(self):
3499 return self.getTypedRuleContext(RParser.Formula_simple_CContext, 0)
3501 def getRuleIndex(self):
3502 return RParser.RULE_formula_simple
3504 def enterRule(self, listener: ParseTreeListener):
3505 if hasattr(listener, "enterFormula_simple"):
3506 listener.enterFormula_simple(self)
3508 def exitRule(self, listener: ParseTreeListener):
3509 if hasattr(listener, "exitFormula_simple"):
3510 listener.exitFormula_simple(self)
3512 def formula_simple(self):
3514 localctx = RParser.Formula_simpleContext(self, self._ctx, self.state)
3515 self.enterRule(localctx, 72, self.RULE_formula_simple)
3516 try:
3517 self.state = 676
3518 self._errHandler.sync(self)
3519 token = self._input.LA(1)
3520 if token in [RParser.T__37]:
3521 self.enterOuterAlt(localctx, 1)
3522 self.state = 673
3523 self.formula_simple_B()
3524 pass
3525 elif token in [RParser.T__44, RParser.ID]:
3526 self.enterOuterAlt(localctx, 2)
3527 self.state = 674
3528 self.formula_simple_A()
3529 pass
3530 elif token in [RParser.T__15]:
3531 self.enterOuterAlt(localctx, 3)
3532 self.state = 675
3533 self.formula_simple_C()
3534 pass
3535 else:
3536 raise NoViableAltException(self)
3538 except RecognitionException as re:
3539 localctx.exception = re
3540 self._errHandler.reportError(self, re)
3541 self._errHandler.recover(self, re)
3542 finally:
3543 self.exitRule()
3544 return localctx
3546 class Formula_simple_AContext(ParserRuleContext):
3548 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
3549 super().__init__(parent, invokingState)
3550 self.parser = parser
3552 def formop(self):
3553 return self.getTypedRuleContext(RParser.FormopContext, 0)
3555 def sublistadd(self):
3556 return self.getTypedRuleContext(RParser.SublistaddContext, 0)
3558 def identifier(self):
3559 return self.getTypedRuleContext(RParser.IdentifierContext, 0)
3561 def getRuleIndex(self):
3562 return RParser.RULE_formula_simple_A
3564 def enterRule(self, listener: ParseTreeListener):
3565 if hasattr(listener, "enterFormula_simple_A"):
3566 listener.enterFormula_simple_A(self)
3568 def exitRule(self, listener: ParseTreeListener):
3569 if hasattr(listener, "exitFormula_simple_A"):
3570 listener.exitFormula_simple_A(self)
3572 def formula_simple_A(self):
3574 localctx = RParser.Formula_simple_AContext(self, self._ctx, self.state)
3575 self.enterRule(localctx, 74, self.RULE_formula_simple_A)
3576 self._la = 0 # Token type
3577 try:
3578 self.enterOuterAlt(localctx, 1)
3579 self.state = 679
3580 self._errHandler.sync(self)
3581 _la = self._input.LA(1)
3582 if _la == RParser.ID:
3583 self.state = 678
3584 self.identifier()
3586 self.state = 681
3587 self.formop()
3588 self.state = 684
3589 self._errHandler.sync(self)
3590 token = self._input.LA(1)
3591 if token in [RParser.ID]:
3592 self.state = 682
3593 self.sublistadd()
3594 pass
3595 elif token in [RParser.T__17]:
3596 self.state = 683
3597 self.match(RParser.T__17)
3598 pass
3599 else:
3600 raise NoViableAltException(self)
3602 except RecognitionException as re:
3603 localctx.exception = re
3604 self._errHandler.reportError(self, re)
3605 self._errHandler.recover(self, re)
3606 finally:
3607 self.exitRule()
3608 return localctx
3610 class Formula_simple_BContext(ParserRuleContext):
3612 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
3613 super().__init__(parent, invokingState)
3614 self.parser = parser
3616 def identifier(self, i: int = None):
3617 if i is None:
3618 return self.getTypedRuleContexts(RParser.IdentifierContext)
3619 else:
3620 return self.getTypedRuleContext(RParser.IdentifierContext, i)
3622 def expr(self, i: int = None):
3623 if i is None:
3624 return self.getTypedRuleContexts(RParser.ExprContext)
3625 else:
3626 return self.getTypedRuleContext(RParser.ExprContext, i)
3628 def affectop(self):
3629 return self.getTypedRuleContext(RParser.AffectopContext, 0)
3631 def NL(self, i: int = None):
3632 if i is None:
3633 return self.getTokens(RParser.NL)
3634 else:
3635 return self.getToken(RParser.NL, i)
3637 def getRuleIndex(self):
3638 return RParser.RULE_formula_simple_B
3640 def enterRule(self, listener: ParseTreeListener):
3641 if hasattr(listener, "enterFormula_simple_B"):
3642 listener.enterFormula_simple_B(self)
3644 def exitRule(self, listener: ParseTreeListener):
3645 if hasattr(listener, "exitFormula_simple_B"):
3646 listener.exitFormula_simple_B(self)
3648 def formula_simple_B(self):
3650 localctx = RParser.Formula_simple_BContext(self, self._ctx, self.state)
3651 self.enterRule(localctx, 76, self.RULE_formula_simple_B)
3652 self._la = 0 # Token type
3653 try:
3654 self.enterOuterAlt(localctx, 1)
3655 self.state = 686
3656 self.match(RParser.T__37)
3657 self.state = 687
3658 self.match(RParser.T__15)
3659 self.state = 688
3660 self.identifier()
3661 self.state = 689
3662 self.match(RParser.T__18)
3663 self.state = 717
3664 self._errHandler.sync(self)
3665 token = self._input.LA(1)
3666 if token in [RParser.T__11]:
3667 self.state = 690
3668 self.match(RParser.T__11)
3669 self.state = 694
3670 self._errHandler.sync(self)
3671 _alt = self._interp.adaptivePredict(self._input, 75, self._ctx)
3672 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
3673 if _alt == 1:
3674 self.state = 691
3675 self.match(RParser.NL)
3676 self.state = 696
3677 self._errHandler.sync(self)
3678 _alt = self._interp.adaptivePredict(
3679 self._input, 75, self._ctx)
3681 self.state = 697
3682 self.expr(0)
3683 self.state = 702
3684 self._errHandler.sync(self)
3685 _la = self._input.LA(1)
3686 while _la == RParser.T__0:
3687 self.state = 698
3688 self.match(RParser.T__0)
3689 self.state = 699
3690 self.expr(0)
3691 self.state = 704
3692 self._errHandler.sync(self)
3693 _la = self._input.LA(1)
3695 self.state = 708
3696 self._errHandler.sync(self)
3697 _la = self._input.LA(1)
3698 while _la == RParser.NL:
3699 self.state = 705
3700 self.match(RParser.NL)
3701 self.state = 710
3702 self._errHandler.sync(self)
3703 _la = self._input.LA(1)
3705 self.state = 711
3706 self.match(RParser.T__12)
3707 pass
3708 elif token in [RParser.ID]:
3709 self.state = 713
3710 self.identifier()
3711 self.state = 714
3712 self.affectop()
3713 self.state = 715
3714 self.expr(0)
3715 pass
3716 else:
3717 raise NoViableAltException(self)
3719 self.state = 719
3720 self.match(RParser.T__16)
3721 except RecognitionException as re:
3722 localctx.exception = re
3723 self._errHandler.reportError(self, re)
3724 self._errHandler.recover(self, re)
3725 finally:
3726 self.exitRule()
3727 return localctx
3729 class Formula_simple_CContext(ParserRuleContext):
3731 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
3732 super().__init__(parent, invokingState)
3733 self.parser = parser
3735 def expr(self):
3736 return self.getTypedRuleContext(RParser.ExprContext, 0)
3738 def formop(self):
3739 return self.getTypedRuleContext(RParser.FormopContext, 0)
3741 def sublistadd(self):
3742 return self.getTypedRuleContext(RParser.SublistaddContext, 0)
3744 def getRuleIndex(self):
3745 return RParser.RULE_formula_simple_C
3747 def enterRule(self, listener: ParseTreeListener):
3748 if hasattr(listener, "enterFormula_simple_C"):
3749 listener.enterFormula_simple_C(self)
3751 def exitRule(self, listener: ParseTreeListener):
3752 if hasattr(listener, "exitFormula_simple_C"):
3753 listener.exitFormula_simple_C(self)
3755 def formula_simple_C(self):
3757 localctx = RParser.Formula_simple_CContext(self, self._ctx, self.state)
3758 self.enterRule(localctx, 78, self.RULE_formula_simple_C)
3759 try:
3760 self.enterOuterAlt(localctx, 1)
3761 self.state = 721
3762 self.match(RParser.T__15)
3763 self.state = 722
3764 self.expr(0)
3765 self.state = 723
3766 self.match(RParser.T__16)
3767 self.state = 724
3768 self.formop()
3769 self.state = 727
3770 self._errHandler.sync(self)
3771 token = self._input.LA(1)
3772 if token in [RParser.ID]:
3773 self.state = 725
3774 self.sublistadd()
3775 pass
3776 elif token in [RParser.T__17]:
3777 self.state = 726
3778 self.match(RParser.T__17)
3779 pass
3780 else:
3781 raise NoViableAltException(self)
3783 except RecognitionException as re:
3784 localctx.exception = re
3785 self._errHandler.reportError(self, re)
3786 self._errHandler.recover(self, re)
3787 finally:
3788 self.exitRule()
3789 return localctx
3791 class AffectopContext(ParserRuleContext):
3793 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
3794 super().__init__(parent, invokingState)
3795 self.parser = parser
3797 def getRuleIndex(self):
3798 return RParser.RULE_affectop
3800 def enterRule(self, listener: ParseTreeListener):
3801 if hasattr(listener, "enterAffectop"):
3802 listener.enterAffectop(self)
3804 def exitRule(self, listener: ParseTreeListener):
3805 if hasattr(listener, "exitAffectop"):
3806 listener.exitAffectop(self)
3808 def affectop(self):
3810 localctx = RParser.AffectopContext(self, self._ctx, self.state)
3811 self.enterRule(localctx, 80, self.RULE_affectop)
3812 self._la = 0 # Token type
3813 try:
3814 self.enterOuterAlt(localctx, 1)
3815 self.state = 729
3816 _la = self._input.LA(1)
3817 if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RParser.T__19) | (1 << RParser.T__38) | (1 << RParser.T__39) | (1 << RParser.T__40) | (1 << RParser.T__41) | (1 << RParser.T__42))) != 0)):
3818 self._errHandler.recoverInline(self)
3819 else:
3820 self._errHandler.reportMatch(self)
3821 self.consume()
3822 except RecognitionException as re:
3823 localctx.exception = re
3824 self._errHandler.reportError(self, re)
3825 self._errHandler.recover(self, re)
3826 finally:
3827 self.exitRule()
3828 return localctx
3830 class FunctiondefContext(ParserRuleContext):
3832 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
3833 super().__init__(parent, invokingState)
3834 self.parser = parser
3836 def getRuleIndex(self):
3837 return RParser.RULE_functiondef
3839 def enterRule(self, listener: ParseTreeListener):
3840 if hasattr(listener, "enterFunctiondef"):
3841 listener.enterFunctiondef(self)
3843 def exitRule(self, listener: ParseTreeListener):
3844 if hasattr(listener, "exitFunctiondef"):
3845 listener.exitFunctiondef(self)
3847 def functiondef(self):
3849 localctx = RParser.FunctiondefContext(self, self._ctx, self.state)
3850 self.enterRule(localctx, 82, self.RULE_functiondef)
3851 try:
3852 self.enterOuterAlt(localctx, 1)
3853 self.state = 731
3854 self.match(RParser.T__43)
3855 except RecognitionException as re:
3856 localctx.exception = re
3857 self._errHandler.reportError(self, re)
3858 self._errHandler.recover(self, re)
3859 finally:
3860 self.exitRule()
3861 return localctx
3863 class IdentifierContext(ParserRuleContext):
3865 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
3866 super().__init__(parent, invokingState)
3867 self.parser = parser
3869 def ID(self):
3870 return self.getToken(RParser.ID, 0)
3872 def getRuleIndex(self):
3873 return RParser.RULE_identifier
3875 def enterRule(self, listener: ParseTreeListener):
3876 if hasattr(listener, "enterIdentifier"):
3877 listener.enterIdentifier(self)
3879 def exitRule(self, listener: ParseTreeListener):
3880 if hasattr(listener, "exitIdentifier"):
3881 listener.exitIdentifier(self)
3883 def identifier(self):
3885 localctx = RParser.IdentifierContext(self, self._ctx, self.state)
3886 self.enterRule(localctx, 84, self.RULE_identifier)
3887 try:
3888 self.enterOuterAlt(localctx, 1)
3889 self.state = 733
3890 self.match(RParser.ID)
3891 except RecognitionException as re:
3892 localctx.exception = re
3893 self._errHandler.reportError(self, re)
3894 self._errHandler.recover(self, re)
3895 finally:
3896 self.exitRule()
3897 return localctx
3899 class FormopContext(ParserRuleContext):
3901 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
3902 super().__init__(parent, invokingState)
3903 self.parser = parser
3905 def getRuleIndex(self):
3906 return RParser.RULE_formop
3908 def enterRule(self, listener: ParseTreeListener):
3909 if hasattr(listener, "enterFormop"):
3910 listener.enterFormop(self)
3912 def exitRule(self, listener: ParseTreeListener):
3913 if hasattr(listener, "exitFormop"):
3914 listener.exitFormop(self)
3916 def formop(self):
3918 localctx = RParser.FormopContext(self, self._ctx, self.state)
3919 self.enterRule(localctx, 86, self.RULE_formop)
3920 try:
3921 self.enterOuterAlt(localctx, 1)
3922 self.state = 735
3923 self.match(RParser.T__44)
3924 except RecognitionException as re:
3925 localctx.exception = re
3926 self._errHandler.reportError(self, re)
3927 self._errHandler.recover(self, re)
3928 finally:
3929 self.exitRule()
3930 return localctx
3932 class RangeopContext(ParserRuleContext):
3934 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
3935 super().__init__(parent, invokingState)
3936 self.parser = parser
3938 def getRuleIndex(self):
3939 return RParser.RULE_rangeop
3941 def enterRule(self, listener: ParseTreeListener):
3942 if hasattr(listener, "enterRangeop"):
3943 listener.enterRangeop(self)
3945 def exitRule(self, listener: ParseTreeListener):
3946 if hasattr(listener, "exitRangeop"):
3947 listener.exitRangeop(self)
3949 def rangeop(self):
3951 localctx = RParser.RangeopContext(self, self._ctx, self.state)
3952 self.enterRule(localctx, 88, self.RULE_rangeop)
3953 self._la = 0 # Token type
3954 try:
3955 self.enterOuterAlt(localctx, 1)
3956 self.state = 737
3957 _la = self._input.LA(1)
3958 if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RParser.T__22) | (1 << RParser.T__45) | (1 << RParser.T__46))) != 0)):
3959 self._errHandler.recoverInline(self)
3960 else:
3961 self._errHandler.reportMatch(self)
3962 self.consume()
3963 except RecognitionException as re:
3964 localctx.exception = re
3965 self._errHandler.reportError(self, re)
3966 self._errHandler.recover(self, re)
3967 finally:
3968 self.exitRule()
3969 return localctx
3971 class DotopContext(ParserRuleContext):
3973 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
3974 super().__init__(parent, invokingState)
3975 self.parser = parser
3977 def getRuleIndex(self):
3978 return RParser.RULE_dotop
3980 def enterRule(self, listener: ParseTreeListener):
3981 if hasattr(listener, "enterDotop"):
3982 listener.enterDotop(self)
3984 def exitRule(self, listener: ParseTreeListener):
3985 if hasattr(listener, "exitDotop"):
3986 listener.exitDotop(self)
3988 def dotop(self):
3990 localctx = RParser.DotopContext(self, self._ctx, self.state)
3991 self.enterRule(localctx, 90, self.RULE_dotop)
3992 self._la = 0 # Token type
3993 try:
3994 self.enterOuterAlt(localctx, 1)
3995 self.state = 739
3996 _la = self._input.LA(1)
3997 if not(_la == RParser.T__47 or _la == RParser.T__48):
3998 self._errHandler.recoverInline(self)
3999 else:
4000 self._errHandler.reportMatch(self)
4001 self.consume()
4002 except RecognitionException as re:
4003 localctx.exception = re
4004 self._errHandler.reportError(self, re)
4005 self._errHandler.recover(self, re)
4006 finally:
4007 self.exitRule()
4008 return localctx
4010 class OperatorContext(ParserRuleContext):
4012 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
4013 super().__init__(parent, invokingState)
4014 self.parser = parser
4016 def getRuleIndex(self):
4017 return RParser.RULE_operator
4019 def enterRule(self, listener: ParseTreeListener):
4020 if hasattr(listener, "enterOperator"):
4021 listener.enterOperator(self)
4023 def exitRule(self, listener: ParseTreeListener):
4024 if hasattr(listener, "exitOperator"):
4025 listener.exitOperator(self)
4027 def operator(self):
4029 localctx = RParser.OperatorContext(self, self._ctx, self.state)
4030 self.enterRule(localctx, 92, self.RULE_operator)
4031 self._la = 0 # Token type
4032 try:
4033 self.enterOuterAlt(localctx, 1)
4034 self.state = 741
4035 _la = self._input.LA(1)
4036 if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RParser.T__4) | (1 << RParser.T__5) | (1 << RParser.T__23) | (1 << RParser.T__49) | (1 << RParser.T__50) | (1 << RParser.T__51) | (1 << RParser.T__52) | (1 << RParser.T__53))) != 0)):
4037 self._errHandler.recoverInline(self)
4038 else:
4039 self._errHandler.reportMatch(self)
4040 self.consume()
4041 except RecognitionException as re:
4042 localctx.exception = re
4043 self._errHandler.reportError(self, re)
4044 self._errHandler.recover(self, re)
4045 finally:
4046 self.exitRule()
4047 return localctx
4049 class ComparisonContext(ParserRuleContext):
4051 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
4052 super().__init__(parent, invokingState)
4053 self.parser = parser
4055 def getRuleIndex(self):
4056 return RParser.RULE_comparison
4058 def enterRule(self, listener: ParseTreeListener):
4059 if hasattr(listener, "enterComparison"):
4060 listener.enterComparison(self)
4062 def exitRule(self, listener: ParseTreeListener):
4063 if hasattr(listener, "exitComparison"):
4064 listener.exitComparison(self)
4066 def comparison(self):
4068 localctx = RParser.ComparisonContext(self, self._ctx, self.state)
4069 self.enterRule(localctx, 94, self.RULE_comparison)
4070 self._la = 0 # Token type
4071 try:
4072 self.enterOuterAlt(localctx, 1)
4073 self.state = 743
4074 _la = self._input.LA(1)
4075 if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RParser.T__54) | (1 << RParser.T__55) | (1 << RParser.T__56) | (1 << RParser.T__57) | (1 << RParser.T__58) | (1 << RParser.T__59))) != 0)):
4076 self._errHandler.recoverInline(self)
4077 else:
4078 self._errHandler.reportMatch(self)
4079 self.consume()
4080 except RecognitionException as re:
4081 localctx.exception = re
4082 self._errHandler.reportError(self, re)
4083 self._errHandler.recover(self, re)
4084 finally:
4085 self.exitRule()
4086 return localctx
4088 def sempred(self, localctx: RuleContext, ruleIndex: int, predIndex: int):
4089 if self._predicates == None:
4090 self._predicates = dict()
4091 self._predicates[1] = self.expr_sempred
4092 pred = self._predicates.get(ruleIndex, None)
4093 if pred is None:
4094 raise Exception("No predicate with index:" + str(ruleIndex))
4095 else:
4096 return pred(localctx, predIndex)
4098 def expr_sempred(self, localctx: ExprContext, predIndex: int):
4099 if predIndex == 0:
4100 return self.precpred(self._ctx, 28)
4102 if predIndex == 1:
4103 return self.precpred(self._ctx, 24)
4105 if predIndex == 2:
4106 return self.precpred(self._ctx, 23)
4108 if predIndex == 3:
4109 return self.precpred(self._ctx, 22)
4111 if predIndex == 4:
4112 return self.precpred(self._ctx, 20)
4114 if predIndex == 5:
4115 return self.precpred(self._ctx, 19)
4117 if predIndex == 6:
4118 return self.precpred(self._ctx, 30)
4120 if predIndex == 7:
4121 return self.precpred(self._ctx, 29)
4123 if predIndex == 8:
4124 return self.precpred(self._ctx, 26)
4126 if predIndex == 9:
4127 return self.precpred(self._ctx, 25)