"""ANTLR3 runtime package"""

# begin[licence]

#

# [The "BSD licence"]

# Copyright (c) 2005-2008 Terence Parr

# All rights reserved.

#

# Redistribution and use in source and binary forms, with or without

# modification, are permitted provided that the following conditions

# are met:

# 1. Redistributions of source code must retain the above copyright

#    notice, this list of conditions and the following disclaimer.

# 2. Redistributions in binary form must reproduce the above copyright

#    notice, this list of conditions and the following disclaimer in the

#    documentation and/or other materials provided with the distribution.

# 3. The name of the author may not be used to endorse or promote products

#    derived from this software without specific prior written permission.

#

# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR

# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.

# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,

# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT

# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#

# end[licence]

import sys

import inspect

from antlr3 import runtime_version, runtime_version_str

from antlr3.constants import DEFAULT_CHANNEL, HIDDEN_CHANNEL, EOF, \

     EOR_TOKEN_TYPE, INVALID_TOKEN_TYPE

from antlr3.exceptions import RecognitionException, MismatchedTokenException, \

     MismatchedRangeException, MismatchedTreeNodeException, \

     NoViableAltException, EarlyExitException, MismatchedSetException, \

     MismatchedNotSetException, FailedPredicateException, \

     BacktrackingFailed, UnwantedTokenException, MissingTokenException

from antlr3.tokens import CommonToken, EOF_TOKEN, SKIP_TOKEN

from antlr3.compat import set, frozenset, reversed

class RecognizerSharedState(object):

    """

    The set of fields needed by an abstract recognizer to recognize input

    and recover from errors etc...  As a separate state object, it can be

    shared among multiple grammars; e.g., when one grammar imports another.

    These fields are publically visible but the actual state pointer per

    parser is protected.

    """

    def __init__(self):

        # Track the set of token types that can follow any rule invocation.

        # Stack grows upwards.

        self.following = []

        # This is true when we see an error and before having successfully

        # matched a token.  Prevents generation of more than one error message

        # per error.

        self.errorRecovery = False

        # The index into the input stream where the last error occurred.

        # This is used to prevent infinite loops where an error is found

        # but no token is consumed during recovery...another error is found,

        # ad naseum.  This is a failsafe mechanism to guarantee that at least

        # one token/tree node is consumed for two errors.

        self.lastErrorIndex = -1

        # If 0, no backtracking is going on.  Safe to exec actions etc...

        # If >0 then it's the level of backtracking.

        self.backtracking = 0

        # An array[size num rules] of Map<Integer,Integer> that tracks

        # the stop token index for each rule.  ruleMemo[ruleIndex] is

        # the memoization table for ruleIndex.  For key ruleStartIndex, you

        # get back the stop token for associated rule or MEMO_RULE_FAILED.

        #

        # This is only used if rule memoization is on (which it is by default).

        self.ruleMemo = None

        ## Did the recognizer encounter a syntax error?  Track how many.

        self.syntaxErrors = 0

        # LEXER FIELDS (must be in same state object to avoid casting

        # constantly in generated code and Lexer object) :(

	## The goal of all lexer rules/methods is to create a token object.

        # This is an instance variable as multiple rules may collaborate to

        # create a single token.  nextToken will return this object after

        # matching lexer rule(s).  If you subclass to allow multiple token

        # emissions, then set this to the last token to be matched or

        # something nonnull so that the auto token emit mechanism will not

        # emit another token.

        self.token = None

        ## What character index in the stream did the current token start at?

        # Needed, for example, to get the text for current token.  Set at

        # the start of nextToken.

        self.tokenStartCharIndex = -1

        ## The line on which the first character of the token resides

        self.tokenStartLine = None

        ## The character position of first character within the line

        self.tokenStartCharPositionInLine = None

        ## The channel number for the current token

        self.channel = None

        ## The token type for the current token

        self.type = None

        ## You can set the text for the current token to override what is in

        # the input char buffer.  Use setText() or can set this instance var.

        self.text = None

class BaseRecognizer(object):

    """

    @brief Common recognizer functionality.

    A generic recognizer that can handle recognizers generated from

    lexer, parser, and tree grammars.  This is all the parsing

    support code essentially; most of it is error recovery stuff and

    backtracking.

    """

    MEMO_RULE_FAILED = -2

    MEMO_RULE_UNKNOWN = -1

    # copies from Token object for convenience in actions

    DEFAULT_TOKEN_CHANNEL = DEFAULT_CHANNEL

    # for convenience in actions

    HIDDEN = HIDDEN_CHANNEL

    # overridden by generated subclasses

    tokenNames = None

    # The antlr_version attribute has been introduced in 3.1. If it is not

    # overwritten in the generated recognizer, we assume a default of 3.0.1.

    antlr_version = (3, 0, 1, 0)

    antlr_version_str = "3.0.1"

    def __init__(self, state=None):

        # Input stream of the recognizer. Must be initialized by a subclass.

        self.input = None

        ## State of a lexer, parser, or tree parser are collected into a state

        # object so the state can be shared.  This sharing is needed to

        # have one grammar import others and share same error variables

        # and other state variables.  It's a kind of explicit multiple

        # inheritance via delegation of methods and shared state.

        if state is None:

            state = RecognizerSharedState()

        self._state = state

        if self.antlr_version > runtime_version:

            raise RuntimeError(

                "ANTLR version mismatch: "

                "The recognizer has been generated by V%s, but this runtime "

                "is V%s. Please use the V%s runtime or higher."

                % (self.antlr_version_str,

                   runtime_version_str,

                   self.antlr_version_str))

        elif (self.antlr_version < (3, 1, 0, 0) and

              self.antlr_version != runtime_version):

            # FIXME: make the runtime compatible with 3.0.1 codegen

            # and remove this block.

            raise RuntimeError(

                "ANTLR version mismatch: "

                "The recognizer has been generated by V%s, but this runtime "

                "is V%s. Please use the V%s runtime."

                % (self.antlr_version_str,

                   runtime_version_str,

                   self.antlr_version_str))

    # this one only exists to shut up pylint :(

    def setInput(self, input):

        self.input = input

    def reset(self):

        """

        reset the parser's state; subclasses must rewinds the input stream

        """

        # wack everything related to error recovery

        if self._state is None:

            # no shared state work to do

            return

        self._state.following = []

        self._state.errorRecovery = False

        self._state.lastErrorIndex = -1

        self._state.syntaxErrors = 0

        # wack everything related to backtracking and memoization

        self._state.backtracking = 0

        if self._state.ruleMemo is not None:

            self._state.ruleMemo = {}

    def match(self, input, ttype, follow):

        """

        Match current input symbol against ttype.  Attempt

        single token insertion or deletion error recovery.  If

        that fails, throw MismatchedTokenException.

        To turn off single token insertion or deletion error

        recovery, override mismatchRecover() and have it call

        plain mismatch(), which does not recover.  Then any error

        in a rule will cause an exception and immediate exit from

        rule.  Rule would recover by resynchronizing to the set of

        symbols that can follow rule ref.

        """

        matchedSymbol = self.getCurrentInputSymbol(input)

        if self.input.LA(1) == ttype:

            self.input.consume()

            self._state.errorRecovery = False

            return matchedSymbol

        if self._state.backtracking > 0:

            # FIXME: need to return matchedSymbol here as well. damn!!

            raise BacktrackingFailed

        matchedSymbol = self.recoverFromMismatchedToken(input, ttype, follow)

        return matchedSymbol

    def matchAny(self, input):

        """Match the wildcard: in a symbol"""

        self._state.errorRecovery = False

        self.input.consume()

    def mismatchIsUnwantedToken(self, input, ttype):

        return input.LA(2) == ttype

    def mismatchIsMissingToken(self, input, follow):

        if follow is None:

            # we have no information about the follow; we can only consume

            # a single token and hope for the best

            return False

        # compute what can follow this grammar element reference

        if EOR_TOKEN_TYPE in follow:

            if len(self._state.following) > 0:

                # remove EOR if we're not the start symbol

                follow = follow - set([EOR_TOKEN_TYPE])

            viableTokensFollowingThisRule = self.computeContextSensitiveRuleFOLLOW()

            follow = follow | viableTokensFollowingThisRule

        # if current token is consistent with what could come after set

        # then we know we're missing a token; error recovery is free to

        # "insert" the missing token

        if input.LA(1) in follow or EOR_TOKEN_TYPE in follow:

            return True

        return False

    def mismatch(self, input, ttype, follow):

        """

        Factor out what to do upon token mismatch so tree parsers can behave

        differently.  Override and call mismatchRecover(input, ttype, follow)

        to get single token insertion and deletion. Use this to turn of

        single token insertion and deletion. Override mismatchRecover

        to call this instead.

        """

        if self.mismatchIsUnwantedToken(input, ttype):

            raise UnwantedTokenException(ttype, input)

        elif self.mismatchIsMissingToken(input, follow):

            raise MissingTokenException(ttype, input, None)

        raise MismatchedTokenException(ttype, input)

##     def mismatchRecover(self, input, ttype, follow):

##         if self.mismatchIsUnwantedToken(input, ttype):

##             mte = UnwantedTokenException(ttype, input)

##         elif self.mismatchIsMissingToken(input, follow):

##             mte = MissingTokenException(ttype, input)

##         else:

##             mte = MismatchedTokenException(ttype, input)

##         self.recoverFromMismatchedToken(input, mte, ttype, follow)

    def reportError(self, e):

        """Report a recognition problem.

        This method sets errorRecovery to indicate the parser is recovering

        not parsing.  Once in recovery mode, no errors are generated.

        To get out of recovery mode, the parser must successfully match

        a token (after a resync).  So it will go:

        1. error occurs

        2. enter recovery mode, report error

        3. consume until token found in resynch set

        4. try to resume parsing

        5. next match() will reset errorRecovery mode

        If you override, make sure to update syntaxErrors if you care about

        that.

        """

        # if we've already reported an error and have not matched a token

        # yet successfully, don't report any errors.

        if self._state.errorRecovery:

            return

        self._state.syntaxErrors += 1 # don't count spurious

        self._state.errorRecovery = True

        self.displayRecognitionError(self.tokenNames, e)

    def displayRecognitionError(self, tokenNames, e):

        hdr = self.getErrorHeader(e)

        msg = self.getErrorMessage(e, tokenNames)

        self.emitErrorMessage(hdr+" "+msg)

    def getErrorMessage(self, e, tokenNames):

        """

        What error message should be generated for the various

        exception types?

        Not very object-oriented code, but I like having all error message

        generation within one method rather than spread among all of the

        exception classes. This also makes it much easier for the exception

        handling because the exception classes do not have to have pointers back

        to this object to access utility routines and so on. Also, changing

        the message for an exception type would be difficult because you

        would have to subclassing exception, but then somehow get ANTLR

        to make those kinds of exception objects instead of the default.

        This looks weird, but trust me--it makes the most sense in terms

        of flexibility.

        For grammar debugging, you will want to override this to add

        more information such as the stack frame with

        getRuleInvocationStack(e, this.getClass().getName()) and,

        for no viable alts, the decision description and state etc...

        Override this to change the message generated for one or more

        exception types.

        """

        if isinstance(e, UnwantedTokenException):

            tokenName = "<unknown>"

            if e.expecting == EOF:

                tokenName = "EOF"

            else:

                tokenName = self.tokenNames[e.expecting]

            msg = "extraneous input %s expecting %s" % (

                self.getTokenErrorDisplay(e.getUnexpectedToken()),

                tokenName

                )

        elif isinstance(e, MissingTokenException):

            tokenName = "<unknown>"

            if e.expecting == EOF:

                tokenName = "EOF"

            else:

                tokenName = self.tokenNames[e.expecting]

            msg = "missing %s at %s" % (

                tokenName, self.getTokenErrorDisplay(e.token)

                )

        elif isinstance(e, MismatchedTokenException):

            tokenName = "<unknown>"

            if e.expecting == EOF:

                tokenName = "EOF"

            else:

                tokenName = self.tokenNames[e.expecting]

            msg = "mismatched input " \

                  + self.getTokenErrorDisplay(e.token) \

                  + " expecting " \

                  + tokenName

        elif isinstance(e, MismatchedTreeNodeException):

            tokenName = "<unknown>"

            if e.expecting == EOF:

                tokenName = "EOF"

            else:

                tokenName = self.tokenNames[e.expecting]

            msg = "mismatched tree node: %s expecting %s" \

                  % (e.node, tokenName)

        elif isinstance(e, NoViableAltException):

            msg = "no viable alternative at input " \

                  + self.getTokenErrorDisplay(e.token)

        elif isinstance(e, EarlyExitException):

            msg = "required (...)+ loop did not match anything at input " \

                  + self.getTokenErrorDisplay(e.token)

        elif isinstance(e, MismatchedSetException):

            msg = "mismatched input " \

                  + self.getTokenErrorDisplay(e.token) \

                  + " expecting set " \

                  + repr(e.expecting)

        elif isinstance(e, MismatchedNotSetException):

            msg = "mismatched input " \

                  + self.getTokenErrorDisplay(e.token) \

                  + " expecting set " \

                  + repr(e.expecting)

        elif isinstance(e, FailedPredicateException):

            msg = "rule " \

                  + e.ruleName \

                  + " failed predicate: {" \

                  + e.predicateText \

                  + "}?"

        else:

            msg = str(e)

        return msg

    def getNumberOfSyntaxErrors(self):

        """

        Get number of recognition errors (lexer, parser, tree parser).  Each

        recognizer tracks its own number.  So parser and lexer each have

        separate count.  Does not count the spurious errors found between

        an error and next valid token match

        See also reportError()

	"""

        return self._state.syntaxErrors

    def getErrorHeader(self, e):

        """

        What is the error header, normally line/character position information?

        """

        return "line %d:%d" % (e.line, e.charPositionInLine)

    def getTokenErrorDisplay(self, t):

        """

        How should a token be displayed in an error message? The default

        is to display just the text, but during development you might

        want to have a lot of information spit out.  Override in that case

        to use t.toString() (which, for CommonToken, dumps everything about

        the token). This is better than forcing you to override a method in

        your token objects because you don't have to go modify your lexer

        so that it creates a new Java type.

        """

        s = t.text

        if s is None:

            if t.type == EOF:

                s = "<EOF>"

            else:

                s = "<"+t.type+">"

        return repr(s)

    def emitErrorMessage(self, msg):

        """Override this method to change where error messages go"""

        sys.stderr.write(msg + '\n')

    def recover(self, input, re):

        """

        Recover from an error found on the input stream.  This is

        for NoViableAlt and mismatched symbol exceptions.  If you enable

        single token insertion and deletion, this will usually not

        handle mismatched symbol exceptions but there could be a mismatched

        token that the match() routine could not recover from.

        """

        # PROBLEM? what if input stream is not the same as last time

        # perhaps make lastErrorIndex a member of input

        if self._state.lastErrorIndex == input.index():

            # uh oh, another error at same token index; must be a case

            # where LT(1) is in the recovery token set so nothing is

            # consumed; consume a single token so at least to prevent

            # an infinite loop; this is a failsafe.

            input.consume()

        self._state.lastErrorIndex = input.index()

        followSet = self.computeErrorRecoverySet()

        self.beginResync()

        self.consumeUntil(input, followSet)

        self.endResync()

    def beginResync(self):

        """

        A hook to listen in on the token consumption during error recovery.

        The DebugParser subclasses this to fire events to the listenter.

        """

        pass

    def endResync(self):

        """

        A hook to listen in on the token consumption during error recovery.