#!/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