Gecko [ v3.cesa.co.za ]

Name	Size	Permission	Date
LICENSE	1.39 KB	-rw-r--r--	1980-01-01 08:00
__init__.py	5.57 KB	-rw-r--r--	1980-01-01 08:00
compat.py	1.71 KB	-rw-r--r--	1980-01-01 08:00
constants.py	2.06 KB	-rw-r--r--	1980-01-01 08:00
dfa.py	6.69 KB	-rw-r--r--	1980-01-01 08:00
dottreegen.py	6.49 KB	-rw-r--r--	1980-01-01 08:00
exceptions.py	11.73 KB	-rw-r--r--	1980-01-01 08:00
extras.py	1.86 KB	-rw-r--r--	1980-01-01 08:00
main.py	7.1 KB	-rw-r--r--	1980-01-01 08:00
recognizers.py	47.92 KB	-rw-r--r--	1980-01-01 08:00
streams.py	39.14 KB	-rw-r--r--	1980-01-01 08:00
tokens.py	10.82 KB	-rw-r--r--	1980-01-01 08:00
tree.py	63.21 KB	-rw-r--r--	1980-01-01 08:00
treewizard.py	16.16 KB	-rw-r--r--	1980-01-01 08:00

Rename

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

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import optparse
import sys

import antlr3
from six.moves import input

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 = 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)

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))