"""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 optparse

import antlr3


class _Main(object):
    def __init__(self):
        self.stdin = sys.stdin
        self.stdout = sys.stdout
        self.stderr = sys.stderr

        
    def parseOptions(self, argv):
        optParser = optparse.OptionParser()
        optParser.add_option(
            "--encoding",
            action="store",
            type="string",
            dest="encoding"
            )
        optParser.add_option(
            "--input",
            action="store",
            type="string",
            dest="input"
            )
        optParser.add_option(
            "--interactive", "-i",
            action="store_true",
            dest="interactive"
            )
        optParser.add_option(
            "--no-output",
            action="store_true",
            dest="no_output"
            )
        optParser.add_option(
            "--profile",
            action="store_true",
            dest="profile"
            )
        optParser.add_option(
            "--hotshot",
            action="store_true",
            dest="hotshot"
            )

        self.setupOptions(optParser)
        
        return optParser.parse_args(argv[1:])


    def setupOptions(self, optParser):
        pass


    def execute(self, argv):
        options, args = self.parseOptions(argv)

        self.setUp(options)
        
        if options.interactive:
            while True:
                try:
                    input = raw_input(">>> ")
                except (EOFError, KeyboardInterrupt):
                    self.stdout.write("\nBye.\n")
                    break
            
                inStream = antlr3.ANTLRStringStream(input)
                self.parseStream(options, inStream)
            
        else:
            if options.input is not None:
                inStream = antlr3.ANTLRStringStream(options.input)

            elif len(args) == 1 and args[0] != '-':
                inStream = antlr3.ANTLRFileStream(
                    args[0], encoding=options.encoding
                    )

            else:
                inStream = antlr3.ANTLRInputStream(
                    self.stdin, encoding=options.encoding
                    )

            if options.profile:
                try:
                    import cProfile as profile
                except ImportError:
                    import profile

                profile.runctx(
                    'self.parseStream(options, inStream)',
                    globals(),
                    locals(),
                    'profile.dat'
                    )

                import pstats
                stats = pstats.Stats('profile.dat')
                stats.strip_dirs()
                stats.sort_stats('time')
                stats.print_stats(100)

            elif options.hotshot:
                import hotshot

                profiler = hotshot.Profile('hotshot.dat')
                profiler.runctx(
                    'self.parseStream(options, inStream)',
                    globals(),
                    locals()
                    )

            else:
                self.parseStream(options, inStream)


    def setUp(self, options):
        pass

    
    def parseStream(self, options, inStream):
        raise NotImplementedError


    def write(self, options, text):
        if not options.no_output:
            self.stdout.write(text)


    def writeln(self, options, text):
        self.write(options, text + '\n')


class LexerMain(_Main):
    def __init__(self, lexerClass):
        _Main.__init__(self)

        self.lexerClass = lexerClass
        
    
    def parseStream(self, options, inStream):
        lexer = self.lexerClass(inStream)
        for token in lexer:
            self.writeln(options, str(token))


class ParserMain(_Main):
    def __init__(self, lexerClassName, parserClass):
        _Main.__init__(self)

        self.lexerClassName = lexerClassName
        self.lexerClass = None
        self.parserClass = parserClass
        
    
    def setupOptions(self, optParser):
        optParser.add_option(
            "--lexer",
            action="store",
            type="string",
            dest="lexerClass",
            default=self.lexerClassName
            )
        optParser.add_option(
            "--rule",
            action="store",
            type="string",
            dest="parserRule"
            )


    def setUp(self, options):
        lexerMod = __import__(options.lexerClass)
        self.lexerClass = getattr(lexerMod, options.lexerClass)

        
    def parseStream(self, options, inStream):
        lexer = self.lexerClass(inStream)
        tokenStream = antlr3.CommonTokenStream(lexer)
        parser = self.parserClass(tokenStream)
        result = getattr(parser, options.parserRule)()
        if result is not None:
            if hasattr(result, 'tree'):
                if result.tree is not None:
                    self.writeln(options, result.tree.toStringTree())
            else:
                self.writeln(options, repr(result))


class WalkerMain(_Main):
    def __init__(self, walkerClass):
        _Main.__init__(self)

        self.lexerClass = None
        self.parserClass = None
        self.walkerClass = walkerClass
        
    
    def setupOptions(self, optParser):
        optParser.add_option(
            "--lexer",
            action="store",
            type="string",
            dest="lexerClass",
            default=None
            )
        optParser.add_option(
            "--parser",
            action="store",
            type="string",
            dest="parserClass",
            default=None
            )
        optParser.add_option(
            "--parser-rule",
            action="store",
            type="string",
            dest="parserRule",
            default=None
            )
        optParser.add_option(
            "--rule",
            action="store",
            type="string",
            dest="walkerRule"
            )


    def setUp(self, options):
        lexerMod = __import__(options.lexerClass)
        self.lexerClass = getattr(lexerMod, options.lexerClass)
        parserMod = __import__(options.parserClass)
        self.parserClass = getattr(parserMod, options.parserClass)

        
    def parseStream(self, options, inStream):
        lexer = self.lexerClass(inStream)
        tokenStream = antlr3.CommonTokenStream(lexer)
        parser = self.parserClass(tokenStream)
        result = getattr(parser, options.parserRule)()
        if result is not None:
            assert hasattr(result, 'tree'), "Parser did not return an AST"
            nodeStream = antlr3.tree.CommonTreeNodeStream(result.tree)
            nodeStream.setTokenStream(tokenStream)
            walker = self.walkerClass(nodeStream)
            result = getattr(walker, options.walkerRule)()
            if result is not None:
                if hasattr(result, 'tree'):
                    self.writeln(options, result.tree.toStringTree())
                else:
                    self.writeln(options, repr(result))