238 lines
7.1 KiB
Python
238 lines
7.1 KiB
Python
"""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)
|
|
|
|
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))
|