text: """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))
  
  