summaryrefslogtreecommitdiffstats
path: root/google_appengine/google/appengine/cron/GrocParser.py
diff options
context:
space:
mode:
Diffstat (limited to 'google_appengine/google/appengine/cron/GrocParser.py')
-rwxr-xr-xgoogle_appengine/google/appengine/cron/GrocParser.py1008
1 files changed, 1008 insertions, 0 deletions
diff --git a/google_appengine/google/appengine/cron/GrocParser.py b/google_appengine/google/appengine/cron/GrocParser.py
new file mode 100755
index 0000000..b86cb4e
--- /dev/null
+++ b/google_appengine/google/appengine/cron/GrocParser.py
@@ -0,0 +1,1008 @@
+#!/usr/bin/env python
+#
+# Copyright 2007 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+import sys
+from antlr3 import *
+from antlr3.compat import set, frozenset
+
+
+
+
+
+allOrdinals = set([1, 2, 3, 4, 5])
+numOrdinals = len(allOrdinals)
+
+
+
+
+HIDDEN = BaseRecognizer.HIDDEN
+
+THIRD=12
+SEPTEMBER=35
+FOURTH=13
+SECOND=11
+WEDNESDAY=21
+NOVEMBER=37
+SATURDAY=24
+JULY=33
+APRIL=30
+DIGITS=8
+OCTOBER=36
+MAY=31
+EVERY=6
+FEBRUARY=28
+MONDAY=19
+SUNDAY=25
+JUNE=32
+DAY=18
+MARCH=29
+OF=4
+EOF=-1
+JANUARY=27
+MONTH=26
+FRIDAY=23
+FIFTH=14
+MINUTES=17
+TIME=5
+WS=40
+QUARTER=39
+THURSDAY=22
+COMMA=9
+DECEMBER=38
+AUGUST=34
+DIGIT=7
+TUESDAY=20
+HOURS=16
+FIRST=10
+FOURTH_OR_FIFTH=15
+
+tokenNames = [
+ "<invalid>", "<EOR>", "<DOWN>", "<UP>",
+ "OF", "TIME", "EVERY", "DIGIT", "DIGITS", "COMMA", "FIRST", "SECOND",
+ "THIRD", "FOURTH", "FIFTH", "FOURTH_OR_FIFTH", "HOURS", "MINUTES", "DAY",
+ "MONDAY", "TUESDAY", "WEDNESDAY", "THURSDAY", "FRIDAY", "SATURDAY",
+ "SUNDAY", "MONTH", "JANUARY", "FEBRUARY", "MARCH", "APRIL", "MAY", "JUNE",
+ "JULY", "AUGUST", "SEPTEMBER", "OCTOBER", "NOVEMBER", "DECEMBER", "QUARTER",
+ "WS"
+]
+
+
+
+
+class GrocParser(Parser):
+ grammarFileName = "Groc.g"
+ antlr_version = version_str_to_tuple("3.1.1")
+ antlr_version_str = "3.1.1"
+ tokenNames = tokenNames
+
+ def __init__(self, input, state=None):
+ if state is None:
+ state = RecognizerSharedState()
+
+ Parser.__init__(self, input, state)
+
+
+ self.dfa3 = self.DFA3(
+ self, 3,
+ eot = self.DFA3_eot,
+ eof = self.DFA3_eof,
+ min = self.DFA3_min,
+ max = self.DFA3_max,
+ accept = self.DFA3_accept,
+ special = self.DFA3_special,
+ transition = self.DFA3_transition
+ )
+
+
+
+
+ self.ordinal_set = set()
+ self.weekday_set = set()
+ self.month_set = set()
+ self.time_string = '';
+ self.interval_mins = 0;
+ self.period_string = '';
+
+
+
+
+
+
+
+
+
+
+ valuesDict = {
+ SUNDAY: 0,
+ FIRST: 1,
+ MONDAY: 1,
+ JANUARY: 1,
+ TUESDAY: 2,
+ SECOND: 2,
+ FEBRUARY: 2,
+ WEDNESDAY: 3,
+ THIRD: 3,
+ MARCH: 3,
+ THURSDAY: 4,
+ FOURTH: 4,
+ APRIL: 4,
+ FRIDAY: 5,
+ FIFTH: 5,
+ MAY: 5,
+ SATURDAY: 6,
+ JUNE: 6,
+ JULY: 7,
+ AUGUST: 8,
+ SEPTEMBER: 9,
+ OCTOBER: 10,
+ NOVEMBER: 11,
+ DECEMBER: 12,
+ }
+
+ def ValueOf(self, token_type):
+ return self.valuesDict.get(token_type, -1)
+
+
+
+
+ def timespec(self, ):
+
+ try:
+ try:
+ pass
+ alt1 = 2
+ LA1_0 = self.input.LA(1)
+
+ if (LA1_0 == EVERY) :
+ LA1_1 = self.input.LA(2)
+
+ if ((DIGIT <= LA1_1 <= DIGITS)) :
+ alt1 = 2
+ elif ((DAY <= LA1_1 <= SUNDAY)) :
+ alt1 = 1
+ else:
+ nvae = NoViableAltException("", 1, 1, self.input)
+
+ raise nvae
+
+ elif ((FIRST <= LA1_0 <= FOURTH_OR_FIFTH)) :
+ alt1 = 1
+ else:
+ nvae = NoViableAltException("", 1, 0, self.input)
+
+ raise nvae
+
+ if alt1 == 1:
+ pass
+ self._state.following.append(self.FOLLOW_specifictime_in_timespec44)
+ self.specifictime()
+
+ self._state.following.pop()
+
+
+ elif alt1 == 2:
+ pass
+ self._state.following.append(self.FOLLOW_interval_in_timespec48)
+ self.interval()
+
+ self._state.following.pop()
+
+
+
+
+
+
+
+ except RecognitionException, re:
+ self.reportError(re)
+ self.recover(self.input, re)
+ finally:
+
+ pass
+
+ return
+
+
+
+ def specifictime(self, ):
+
+ TIME1 = None
+
+ try:
+ try:
+ pass
+ pass
+ alt3 = 2
+ alt3 = self.dfa3.predict(self.input)
+ if alt3 == 1:
+ pass
+ pass
+ pass
+ self._state.following.append(self.FOLLOW_ordinals_in_specifictime69)
+ self.ordinals()
+
+ self._state.following.pop()
+ self._state.following.append(self.FOLLOW_weekdays_in_specifictime71)
+ self.weekdays()
+
+ self._state.following.pop()
+
+
+
+ self.match(self.input, OF, self.FOLLOW_OF_in_specifictime74)
+ alt2 = 2
+ LA2_0 = self.input.LA(1)
+
+ if ((MONTH <= LA2_0 <= DECEMBER)) :
+ alt2 = 1
+ elif ((FIRST <= LA2_0 <= THIRD) or LA2_0 == QUARTER) :
+ alt2 = 2
+ else:
+ nvae = NoViableAltException("", 2, 0, self.input)
+
+ raise nvae
+
+ if alt2 == 1:
+ pass
+ self._state.following.append(self.FOLLOW_monthspec_in_specifictime77)
+ self.monthspec()
+
+ self._state.following.pop()
+
+
+ elif alt2 == 2:
+ pass
+ self._state.following.append(self.FOLLOW_quarterspec_in_specifictime79)
+ self.quarterspec()
+
+ self._state.following.pop()
+
+
+
+
+
+
+
+
+ elif alt3 == 2:
+ pass
+ pass
+ self._state.following.append(self.FOLLOW_ordinals_in_specifictime96)
+ self.ordinals()
+
+ self._state.following.pop()
+ self._state.following.append(self.FOLLOW_weekdays_in_specifictime98)
+ self.weekdays()
+
+ self._state.following.pop()
+ self.month_set = set(range(1,13))
+
+
+
+
+
+
+ TIME1=self.match(self.input, TIME, self.FOLLOW_TIME_in_specifictime112)
+ self.time_string = TIME1.text
+
+
+
+
+
+
+
+ except RecognitionException, re:
+ self.reportError(re)
+ self.recover(self.input, re)
+ finally:
+
+ pass
+
+ return
+
+
+
+ def interval(self, ):
+
+ intervalnum = None
+ period2 = None
+
+
+ try:
+ try:
+ pass
+ pass
+ self.match(self.input, EVERY, self.FOLLOW_EVERY_in_interval131)
+ intervalnum = self.input.LT(1)
+ if (DIGIT <= self.input.LA(1) <= DIGITS):
+ self.input.consume()
+ self._state.errorRecovery = False
+
+ else:
+ mse = MismatchedSetException(None, self.input)
+ raise mse
+
+
+
+ self.interval_mins = int(intervalnum.text)
+
+ self._state.following.append(self.FOLLOW_period_in_interval157)
+ period2 = self.period()
+
+ self._state.following.pop()
+
+ if ((period2 is not None) and [self.input.toString(period2.start,period2.stop)] or [None])[0] == "hours":
+ self.period_string = "hours"
+ else:
+ self.period_string = "minutes"
+
+
+
+
+
+
+
+
+ except RecognitionException, re:
+ self.reportError(re)
+ self.recover(self.input, re)
+ finally:
+
+ pass
+
+ return
+
+
+
+ def ordinals(self, ):
+
+ try:
+ try:
+ pass
+ alt5 = 2
+ LA5_0 = self.input.LA(1)
+
+ if (LA5_0 == EVERY) :
+ alt5 = 1
+ elif ((FIRST <= LA5_0 <= FOURTH_OR_FIFTH)) :
+ alt5 = 2
+ else:
+ nvae = NoViableAltException("", 5, 0, self.input)
+
+ raise nvae
+
+ if alt5 == 1:
+ pass
+ self.match(self.input, EVERY, self.FOLLOW_EVERY_in_ordinals176)
+ self.ordinal_set = self.ordinal_set.union(allOrdinals)
+
+
+ elif alt5 == 2:
+ pass
+ pass
+ self._state.following.append(self.FOLLOW_ordinal_in_ordinals192)
+ self.ordinal()
+
+ self._state.following.pop()
+ while True:
+ alt4 = 2
+ LA4_0 = self.input.LA(1)
+
+ if (LA4_0 == COMMA) :
+ alt4 = 1
+
+
+ if alt4 == 1:
+ pass
+ self.match(self.input, COMMA, self.FOLLOW_COMMA_in_ordinals195)
+ self._state.following.append(self.FOLLOW_ordinal_in_ordinals197)
+ self.ordinal()
+
+ self._state.following.pop()
+
+
+ else:
+ break
+
+
+
+
+
+
+
+
+
+
+
+
+ except RecognitionException, re:
+ self.reportError(re)
+ self.recover(self.input, re)
+ finally:
+
+ pass
+
+ return
+
+
+
+ def ordinal(self, ):
+
+ ord = None
+
+ try:
+ try:
+ pass
+ ord = self.input.LT(1)
+ if (FIRST <= self.input.LA(1) <= FOURTH_OR_FIFTH):
+ self.input.consume()
+ self._state.errorRecovery = False
+
+ else:
+ mse = MismatchedSetException(None, self.input)
+ raise mse
+
+
+
+ self.ordinal_set.add(self.ValueOf(ord.type));
+
+
+
+
+
+ except RecognitionException, re:
+ self.reportError(re)
+ self.recover(self.input, re)
+ finally:
+
+ pass
+
+ return
+
+
+ class period_return(ParserRuleReturnScope):
+ def __init__(self):
+ ParserRuleReturnScope.__init__(self)
+
+
+
+
+
+ def period(self, ):
+
+ retval = self.period_return()
+ retval.start = self.input.LT(1)
+
+ try:
+ try:
+ pass
+ if (HOURS <= self.input.LA(1) <= MINUTES):
+ self.input.consume()
+ self._state.errorRecovery = False
+
+ else:
+ mse = MismatchedSetException(None, self.input)
+ raise mse
+
+
+
+
+
+ retval.stop = self.input.LT(-1)
+
+
+ except RecognitionException, re:
+ self.reportError(re)
+ self.recover(self.input, re)
+ finally:
+
+ pass
+
+ return retval
+
+
+
+ def weekdays(self, ):
+
+ try:
+ try:
+ pass
+ alt7 = 2
+ LA7_0 = self.input.LA(1)
+
+ if (LA7_0 == DAY) :
+ alt7 = 1
+ elif ((MONDAY <= LA7_0 <= SUNDAY)) :
+ alt7 = 2
+ else:
+ nvae = NoViableAltException("", 7, 0, self.input)
+
+ raise nvae
+
+ if alt7 == 1:
+ pass
+ self.match(self.input, DAY, self.FOLLOW_DAY_in_weekdays280)
+
+ self.weekday_set = set([self.ValueOf(SUNDAY), self.ValueOf(MONDAY),
+ self.ValueOf(TUESDAY), self.ValueOf(WEDNESDAY),
+ self.ValueOf(THURSDAY), self.ValueOf(FRIDAY),
+ self.ValueOf(SATURDAY), self.ValueOf(SUNDAY)])
+
+
+
+ elif alt7 == 2:
+ pass
+ pass
+ self._state.following.append(self.FOLLOW_weekday_in_weekdays288)
+ self.weekday()
+
+ self._state.following.pop()
+ while True:
+ alt6 = 2
+ LA6_0 = self.input.LA(1)
+
+ if (LA6_0 == COMMA) :
+ alt6 = 1
+
+
+ if alt6 == 1:
+ pass
+ self.match(self.input, COMMA, self.FOLLOW_COMMA_in_weekdays291)
+ self._state.following.append(self.FOLLOW_weekday_in_weekdays293)
+ self.weekday()
+
+ self._state.following.pop()
+
+
+ else:
+ break
+
+
+
+
+
+
+
+
+
+
+
+
+ except RecognitionException, re:
+ self.reportError(re)
+ self.recover(self.input, re)
+ finally:
+
+ pass
+
+ return
+
+
+
+ def weekday(self, ):
+
+ dayname = None
+
+ try:
+ try:
+ pass
+ dayname = self.input.LT(1)
+ if (MONDAY <= self.input.LA(1) <= SUNDAY):
+ self.input.consume()
+ self._state.errorRecovery = False
+
+ else:
+ mse = MismatchedSetException(None, self.input)
+ raise mse
+
+
+
+ self.weekday_set.add(self.ValueOf(dayname.type))
+
+
+
+
+
+ except RecognitionException, re:
+ self.reportError(re)
+ self.recover(self.input, re)
+ finally:
+
+ pass
+
+ return
+
+
+
+ def monthspec(self, ):
+
+ try:
+ try:
+ pass
+ alt8 = 2
+ LA8_0 = self.input.LA(1)
+
+ if (LA8_0 == MONTH) :
+ alt8 = 1
+ elif ((JANUARY <= LA8_0 <= DECEMBER)) :
+ alt8 = 2
+ else:
+ nvae = NoViableAltException("", 8, 0, self.input)
+
+ raise nvae
+
+ if alt8 == 1:
+ pass
+ self.match(self.input, MONTH, self.FOLLOW_MONTH_in_monthspec373)
+
+ self.month_set = self.month_set.union(set([
+ self.ValueOf(JANUARY), self.ValueOf(FEBRUARY), self.ValueOf(MARCH),
+ self.ValueOf(APRIL), self.ValueOf(MAY), self.ValueOf(JUNE),
+ self.ValueOf(JULY), self.ValueOf(AUGUST), self.ValueOf(SEPTEMBER),
+ self.ValueOf(OCTOBER), self.ValueOf(NOVEMBER),
+ self.ValueOf(DECEMBER)]))
+
+
+
+ elif alt8 == 2:
+ pass
+ self._state.following.append(self.FOLLOW_months_in_monthspec383)
+ self.months()
+
+ self._state.following.pop()
+
+
+
+
+
+
+
+ except RecognitionException, re:
+ self.reportError(re)
+ self.recover(self.input, re)
+ finally:
+
+ pass
+
+ return
+
+
+
+ def months(self, ):
+
+ try:
+ try:
+ pass
+ pass
+ self._state.following.append(self.FOLLOW_month_in_months400)
+ self.month()
+
+ self._state.following.pop()
+ while True:
+ alt9 = 2
+ LA9_0 = self.input.LA(1)
+
+ if (LA9_0 == COMMA) :
+ alt9 = 1
+
+
+ if alt9 == 1:
+ pass
+ self.match(self.input, COMMA, self.FOLLOW_COMMA_in_months403)
+ self._state.following.append(self.FOLLOW_month_in_months405)
+ self.month()
+
+ self._state.following.pop()
+
+
+ else:
+ break
+
+
+
+
+
+
+
+
+
+ except RecognitionException, re:
+ self.reportError(re)
+ self.recover(self.input, re)
+ finally:
+
+ pass
+
+ return
+
+
+
+ def month(self, ):
+
+ monthname = None
+
+ try:
+ try:
+ pass
+ monthname = self.input.LT(1)
+ if (JANUARY <= self.input.LA(1) <= DECEMBER):
+ self.input.consume()
+ self._state.errorRecovery = False
+
+ else:
+ mse = MismatchedSetException(None, self.input)
+ raise mse
+
+
+ self.month_set.add(self.ValueOf(monthname.type));
+
+
+
+
+ except RecognitionException, re:
+ self.reportError(re)
+ self.recover(self.input, re)
+ finally:
+
+ pass
+
+ return
+
+
+
+ def quarterspec(self, ):
+
+ try:
+ try:
+ pass
+ alt10 = 2
+ LA10_0 = self.input.LA(1)
+
+ if (LA10_0 == QUARTER) :
+ alt10 = 1
+ elif ((FIRST <= LA10_0 <= THIRD)) :
+ alt10 = 2
+ else:
+ nvae = NoViableAltException("", 10, 0, self.input)
+
+ raise nvae
+
+ if alt10 == 1:
+ pass
+ self.match(self.input, QUARTER, self.FOLLOW_QUARTER_in_quarterspec497)
+
+ self.month_set = self.month_set.union(set([
+ self.ValueOf(JANUARY), self.ValueOf(APRIL), self.ValueOf(JULY),
+ self.ValueOf(OCTOBER)]))
+
+
+ elif alt10 == 2:
+ pass
+ pass
+ self._state.following.append(self.FOLLOW_quarter_ordinals_in_quarterspec509)
+ self.quarter_ordinals()
+
+ self._state.following.pop()
+ self.match(self.input, MONTH, self.FOLLOW_MONTH_in_quarterspec511)
+ self.match(self.input, OF, self.FOLLOW_OF_in_quarterspec513)
+ self.match(self.input, QUARTER, self.FOLLOW_QUARTER_in_quarterspec515)
+
+
+
+
+
+
+
+
+
+
+ except RecognitionException, re:
+ self.reportError(re)
+ self.recover(self.input, re)
+ finally:
+
+ pass
+
+ return
+
+
+
+ def quarter_ordinals(self, ):
+
+ try:
+ try:
+ pass
+ pass
+ self._state.following.append(self.FOLLOW_month_of_quarter_ordinal_in_quarter_ordinals534)
+ self.month_of_quarter_ordinal()
+
+ self._state.following.pop()
+ while True:
+ alt11 = 2
+ LA11_0 = self.input.LA(1)
+
+ if (LA11_0 == COMMA) :
+ alt11 = 1
+
+
+ if alt11 == 1:
+ pass
+ self.match(self.input, COMMA, self.FOLLOW_COMMA_in_quarter_ordinals537)
+ self._state.following.append(self.FOLLOW_month_of_quarter_ordinal_in_quarter_ordinals539)
+ self.month_of_quarter_ordinal()
+
+ self._state.following.pop()
+
+
+ else:
+ break
+
+
+
+
+
+
+
+
+
+ except RecognitionException, re:
+ self.reportError(re)
+ self.recover(self.input, re)
+ finally:
+
+ pass
+
+ return
+
+
+
+ def month_of_quarter_ordinal(self, ):
+
+ offset = None
+
+ try:
+ try:
+ pass
+ offset = self.input.LT(1)
+ if (FIRST <= self.input.LA(1) <= THIRD):
+ self.input.consume()
+ self._state.errorRecovery = False
+
+ else:
+ mse = MismatchedSetException(None, self.input)
+ raise mse
+
+
+
+ jOffset = self.ValueOf(offset.type) - 1
+ self.month_set = self.month_set.union(set([
+ jOffset + self.ValueOf(JANUARY), jOffset + self.ValueOf(APRIL),
+ jOffset + self.ValueOf(JULY), jOffset + self.ValueOf(OCTOBER)]))
+
+
+
+
+ except RecognitionException, re:
+ self.reportError(re)
+ self.recover(self.input, re)
+ finally:
+
+ pass
+
+ return
+
+
+
+
+
+
+ DFA3_eot = DFA.unpack(
+ u"\13\uffff"
+ )
+
+ DFA3_eof = DFA.unpack(
+ u"\13\uffff"
+ )
+
+ DFA3_min = DFA.unpack(
+ u"\1\6\1\22\1\11\2\4\1\12\2\uffff\1\23\1\11\1\4"
+ )
+
+ DFA3_max = DFA.unpack(
+ u"\1\17\2\31\1\5\1\11\1\17\2\uffff\2\31\1\11"
+ )
+
+ DFA3_accept = DFA.unpack(
+ u"\6\uffff\1\1\1\2\3\uffff"
+ )
+
+ DFA3_special = DFA.unpack(
+ u"\13\uffff"
+ )
+
+
+ DFA3_transition = [
+ DFA.unpack(u"\1\1\3\uffff\6\2"),
+ DFA.unpack(u"\1\3\7\4"),
+ DFA.unpack(u"\1\5\10\uffff\1\3\7\4"),
+ DFA.unpack(u"\1\6\1\7"),
+ DFA.unpack(u"\1\6\1\7\3\uffff\1\10"),
+ DFA.unpack(u"\6\11"),
+ DFA.unpack(u""),
+ DFA.unpack(u""),
+ DFA.unpack(u"\7\12"),
+ DFA.unpack(u"\1\5\10\uffff\1\3\7\4"),
+ DFA.unpack(u"\1\6\1\7\3\uffff\1\10")
+ ]
+
+
+ DFA3 = DFA
+
+
+ FOLLOW_specifictime_in_timespec44 = frozenset([1])
+ FOLLOW_interval_in_timespec48 = frozenset([1])
+ FOLLOW_ordinals_in_specifictime69 = frozenset([18, 19, 20, 21, 22, 23, 24, 25])
+ FOLLOW_weekdays_in_specifictime71 = frozenset([4])
+ FOLLOW_OF_in_specifictime74 = frozenset([10, 11, 12, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39])
+ FOLLOW_monthspec_in_specifictime77 = frozenset([5])
+ FOLLOW_quarterspec_in_specifictime79 = frozenset([5])
+ FOLLOW_ordinals_in_specifictime96 = frozenset([18, 19, 20, 21, 22, 23, 24, 25])
+ FOLLOW_weekdays_in_specifictime98 = frozenset([5])
+ FOLLOW_TIME_in_specifictime112 = frozenset([1])
+ FOLLOW_EVERY_in_interval131 = frozenset([7, 8])
+ FOLLOW_set_in_interval141 = frozenset([16, 17])
+ FOLLOW_period_in_interval157 = frozenset([1])
+ FOLLOW_EVERY_in_ordinals176 = frozenset([1])
+ FOLLOW_ordinal_in_ordinals192 = frozenset([1, 9])
+ FOLLOW_COMMA_in_ordinals195 = frozenset([10, 11, 12, 13, 14, 15])
+ FOLLOW_ordinal_in_ordinals197 = frozenset([1, 9])
+ FOLLOW_set_in_ordinal218 = frozenset([1])
+ FOLLOW_set_in_period257 = frozenset([1])
+ FOLLOW_DAY_in_weekdays280 = frozenset([1])
+ FOLLOW_weekday_in_weekdays288 = frozenset([1, 9])
+ FOLLOW_COMMA_in_weekdays291 = frozenset([18, 19, 20, 21, 22, 23, 24, 25])
+ FOLLOW_weekday_in_weekdays293 = frozenset([1, 9])
+ FOLLOW_set_in_weekday314 = frozenset([1])
+ FOLLOW_MONTH_in_monthspec373 = frozenset([1])
+ FOLLOW_months_in_monthspec383 = frozenset([1])
+ FOLLOW_month_in_months400 = frozenset([1, 9])
+ FOLLOW_COMMA_in_months403 = frozenset([26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38])
+ FOLLOW_month_in_months405 = frozenset([1, 9])
+ FOLLOW_set_in_month424 = frozenset([1])
+ FOLLOW_QUARTER_in_quarterspec497 = frozenset([1])
+ FOLLOW_quarter_ordinals_in_quarterspec509 = frozenset([26])
+ FOLLOW_MONTH_in_quarterspec511 = frozenset([4])
+ FOLLOW_OF_in_quarterspec513 = frozenset([39])
+ FOLLOW_QUARTER_in_quarterspec515 = frozenset([1])
+ FOLLOW_month_of_quarter_ordinal_in_quarter_ordinals534 = frozenset([1, 9])
+ FOLLOW_COMMA_in_quarter_ordinals537 = frozenset([10, 11, 12, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39])
+ FOLLOW_month_of_quarter_ordinal_in_quarter_ordinals539 = frozenset([1, 9])
+ FOLLOW_set_in_month_of_quarter_ordinal558 = frozenset([1])
+
+
+
+def main(argv, stdin=sys.stdin, stdout=sys.stdout, stderr=sys.stderr):
+ from antlr3.main import ParserMain
+ main = ParserMain("GrocLexer", GrocParser)
+ main.stdin = stdin
+ main.stdout = stdout
+ main.stderr = stderr
+ main.execute(argv)
+
+
+if __name__ == '__main__':
+ main(sys.argv)
Copyright © 1996 – 2023 Jason A. Donenfeld. All Rights Reverse Engineered.