thirdparty/google_appengine/google/appengine/cron/GrocParser.py
author Lennard de Rijk <ljvderijk@gmail.com>
Wed, 21 Jan 2009 14:57:12 +0000
changeset 868 8d3c1ee6eba7
parent 828 f5fd65cc3bf3
child 2309 be1b94099f2d
permissions -rw-r--r--
onCreate for a Club now marks any application for the same club as completed and invites the admins. This is useful for when the club has been created without using the application. Patch by: Lennard de Rijk

#!/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=34
FOURTH=13
SECOND=11
WEDNESDAY=20
NOVEMBER=36
SATURDAY=23
JULY=32
APRIL=29
DIGITS=8
OCTOBER=35
MAY=30
EVERY=6
FEBRUARY=27
MONDAY=18
SUNDAY=24
JUNE=31
MARCH=28
OF=4
EOF=-1
JANUARY=26
MONTH=25
FRIDAY=22
FIFTH=14
MINUTES=17
TIME=5
WS=39
QUARTER=38
THURSDAY=21
COMMA=9
DECEMBER=37
AUGUST=33
DIGIT=7
TUESDAY=19
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", "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.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 ((MONDAY <= 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
                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_specifictime75)
                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_specifictime78)
                    self.monthspec()

                    self._state.following.pop()


                elif alt2 == 2:
                    pass
                    self._state.following.append(self.FOLLOW_quarterspec_in_specifictime80)
                    self.quarterspec()

                    self._state.following.pop()






                TIME1=self.match(self.input, TIME, self.FOLLOW_TIME_in_specifictime93)
                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_interval112)
                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_interval138)
                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
                alt4 = 2
                LA4_0 = self.input.LA(1)

                if (LA4_0 == EVERY) :
                    alt4 = 1
                elif ((FIRST <= LA4_0 <= FOURTH_OR_FIFTH)) :
                    alt4 = 2
                else:
                    nvae = NoViableAltException("", 4, 0, self.input)

                    raise nvae

                if alt4 == 1:
                    pass
                    self.match(self.input, EVERY, self.FOLLOW_EVERY_in_ordinals157)
                    self.ordinal_set = self.ordinal_set.union(allOrdinals)


                elif alt4 == 2:
                    pass
                    pass
                    self._state.following.append(self.FOLLOW_ordinal_in_ordinals173)
                    self.ordinal()

                    self._state.following.pop()
                    while True:
                        alt3 = 2
                        LA3_0 = self.input.LA(1)

                        if (LA3_0 == COMMA) :
                            alt3 = 1


                        if alt3 == 1:
                            pass
                            self.match(self.input, COMMA, self.FOLLOW_COMMA_in_ordinals176)
                            self._state.following.append(self.FOLLOW_ordinal_in_ordinals178)
                            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
                pass
                self._state.following.append(self.FOLLOW_weekday_in_weekdays261)
                self.weekday()

                self._state.following.pop()
                while True:
                    alt5 = 2
                    LA5_0 = self.input.LA(1)

                    if (LA5_0 == COMMA) :
                        alt5 = 1


                    if alt5 == 1:
                        pass
                        self.match(self.input, COMMA, self.FOLLOW_COMMA_in_weekdays264)
                        self._state.following.append(self.FOLLOW_weekday_in_weekdays266)
                        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
                alt6 = 2
                LA6_0 = self.input.LA(1)

                if (LA6_0 == MONTH) :
                    alt6 = 1
                elif ((JANUARY <= LA6_0 <= DECEMBER)) :
                    alt6 = 2
                else:
                    nvae = NoViableAltException("", 6, 0, self.input)

                    raise nvae

                if alt6 == 1:
                    pass
                    self.match(self.input, MONTH, self.FOLLOW_MONTH_in_monthspec344)

                    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 alt6 == 2:
                    pass
                    self._state.following.append(self.FOLLOW_months_in_monthspec354)
                    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_months371)
                self.month()

                self._state.following.pop()
                while True:
                    alt7 = 2
                    LA7_0 = self.input.LA(1)

                    if (LA7_0 == COMMA) :
                        alt7 = 1


                    if alt7 == 1:
                        pass
                        self.match(self.input, COMMA, self.FOLLOW_COMMA_in_months374)
                        self._state.following.append(self.FOLLOW_month_in_months376)
                        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
                alt8 = 2
                LA8_0 = self.input.LA(1)

                if (LA8_0 == QUARTER) :
                    alt8 = 1
                elif ((FIRST <= LA8_0 <= THIRD)) :
                    alt8 = 2
                else:
                    nvae = NoViableAltException("", 8, 0, self.input)

                    raise nvae

                if alt8 == 1:
                    pass
                    self.match(self.input, QUARTER, self.FOLLOW_QUARTER_in_quarterspec468)

                    self.month_set = self.month_set.union(set([
                        self.ValueOf(JANUARY), self.ValueOf(APRIL), self.ValueOf(JULY),
                        self.ValueOf(OCTOBER)]))


                elif alt8 == 2:
                    pass
                    pass
                    self._state.following.append(self.FOLLOW_quarter_ordinals_in_quarterspec480)
                    self.quarter_ordinals()

                    self._state.following.pop()
                    self.match(self.input, MONTH, self.FOLLOW_MONTH_in_quarterspec482)
                    self.match(self.input, OF, self.FOLLOW_OF_in_quarterspec484)
                    self.match(self.input, QUARTER, self.FOLLOW_QUARTER_in_quarterspec486)










            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_ordinals505)
                self.month_of_quarter_ordinal()

                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_quarter_ordinals508)
                        self._state.following.append(self.FOLLOW_month_of_quarter_ordinal_in_quarter_ordinals510)
                        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







    FOLLOW_specifictime_in_timespec44 = frozenset([1])
    FOLLOW_interval_in_timespec48 = frozenset([1])
    FOLLOW_ordinals_in_specifictime69 = frozenset([18, 19, 20, 21, 22, 23, 24])
    FOLLOW_weekdays_in_specifictime71 = frozenset([4])
    FOLLOW_OF_in_specifictime75 = frozenset([10, 11, 12, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38])
    FOLLOW_monthspec_in_specifictime78 = frozenset([5])
    FOLLOW_quarterspec_in_specifictime80 = frozenset([5])
    FOLLOW_TIME_in_specifictime93 = frozenset([1])
    FOLLOW_EVERY_in_interval112 = frozenset([7, 8])
    FOLLOW_set_in_interval122 = frozenset([16, 17])
    FOLLOW_period_in_interval138 = frozenset([1])
    FOLLOW_EVERY_in_ordinals157 = frozenset([1])
    FOLLOW_ordinal_in_ordinals173 = frozenset([1, 9])
    FOLLOW_COMMA_in_ordinals176 = frozenset([10, 11, 12, 13, 14, 15])
    FOLLOW_ordinal_in_ordinals178 = frozenset([1, 9])
    FOLLOW_set_in_ordinal199 = frozenset([1])
    FOLLOW_set_in_period238 = frozenset([1])
    FOLLOW_weekday_in_weekdays261 = frozenset([1, 9])
    FOLLOW_COMMA_in_weekdays264 = frozenset([18, 19, 20, 21, 22, 23, 24])
    FOLLOW_weekday_in_weekdays266 = frozenset([1, 9])
    FOLLOW_set_in_weekday285 = frozenset([1])
    FOLLOW_MONTH_in_monthspec344 = frozenset([1])
    FOLLOW_months_in_monthspec354 = frozenset([1])
    FOLLOW_month_in_months371 = frozenset([1, 9])
    FOLLOW_COMMA_in_months374 = frozenset([25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37])
    FOLLOW_month_in_months376 = frozenset([1, 9])
    FOLLOW_set_in_month395 = frozenset([1])
    FOLLOW_QUARTER_in_quarterspec468 = frozenset([1])
    FOLLOW_quarter_ordinals_in_quarterspec480 = frozenset([25])
    FOLLOW_MONTH_in_quarterspec482 = frozenset([4])
    FOLLOW_OF_in_quarterspec484 = frozenset([38])
    FOLLOW_QUARTER_in_quarterspec486 = frozenset([1])
    FOLLOW_month_of_quarter_ordinal_in_quarter_ordinals505 = frozenset([1, 9])
    FOLLOW_COMMA_in_quarter_ordinals508 = frozenset([10, 11, 12, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38])
    FOLLOW_month_of_quarter_ordinal_in_quarter_ordinals510 = frozenset([1, 9])
    FOLLOW_set_in_month_of_quarter_ordinal529 = 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)