| """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" |
| ) |
| optParser.add_option( |
| "--port", |
| type="int", |
| dest="port", |
| default=None |
| ) |
| optParser.add_option( |
| "--debug-socket", |
| action='store_true', |
| dest="debug_socket", |
| default=None |
| ) |
| |
| 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): |
| kwargs = {} |
| if options.port is not None: |
| kwargs['port'] = options.port |
| if options.debug_socket is not None: |
| kwargs['debug_socket'] = sys.stderr |
| |
| lexer = self.lexerClass(inStream) |
| tokenStream = antlr3.CommonTokenStream(lexer) |
| parser = self.parserClass(tokenStream, **kwargs) |
| result = getattr(parser, options.parserRule)() |
| if result is not None: |
| if hasattr(result, 'tree') and 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)) |
