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

FOURTH=13

SECOND=11

DIGITS=8

EVERY=6

OF=4

EOF=-1

FIFTH=14

MINUTES=17

TIME=5

COMMA=9

DIGIT=7

HOURS=16

FIRST=10

FOURTH_OR_FIFTH=15

tokenNames = [

    "<invalid>", "<EOR>", "<DOWN>", "<UP>",

    "OF", "TIME", "EVERY", "DIGIT", "DIGITS", "COMMA", "FIRST", "SECOND",

    "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

                        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

                    self._state.following.pop()

                    self._state.following.pop()

                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

                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)

                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

                else:

                    raise nvae

                    pass

                    self.ordinal_set = self.ordinal_set.union(allOrdinals)

                    pass

                    pass

                    self.ordinal()

                    self._state.following.pop()

                    while True:

                            pass

                            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