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