import unittest
import textwrap
import antlr3
import antlr3.tree
import antlr3.debug
import testbase
import sys
import threading
import socket
import errno
import time
class Debugger(threading.Thread):
def __init__(self, port):
super(Debugger, self).__init__()
self.events = []
self.success = False
self.port = port
def run(self):
# create listening socket
s = None
tstart = time.time()
while time.time() - tstart < 10:
try:
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect(('127.0.0.1', self.port))
break
except socket.error, exc:
if exc.args[0] != errno.ECONNREFUSED:
raise
time.sleep(0.1)
if s is None:
self.events.append(['nosocket'])
return
s.setblocking(1)
s.settimeout(10.0)
output = s.makefile('w', 0)
input = s.makefile('r', 0)
try:
# handshake
l = input.readline().strip()
assert l == 'ANTLR 2'
l = input.readline().strip()
assert l.startswith('grammar "')
output.write('ACK\n')
output.flush()
while True:
event = input.readline().strip()
self.events.append(event.split('\t'))
output.write('ACK\n')
output.flush()
if event == 'terminate':
self.success = True
break
except socket.timeout:
self.events.append(['timeout'])
except socket.error, exc:
self.events.append(['socketerror', exc.args])
s.close()
class T(testbase.ANTLRTest):
def execParser(self, grammar, grammarEntry, input, listener,
parser_args={}):
if listener is None:
port = 49100
debugger = Debugger(port)
debugger.start()
# TODO(pink): install alarm, so it doesn't hang forever in case of a bug
else:
port = None
try:
lexerCls, parserCls = self.compileInlineGrammar(
grammar, options='-debug')
cStream = antlr3.StringStream(input)
lexer = lexerCls(cStream)
tStream = antlr3.CommonTokenStream(lexer)
parser = parserCls(tStream, dbg=listener, port=port, **parser_args)
getattr(parser, grammarEntry)()
finally:
if listener is None:
debugger.join()
return debugger
def testBasicParser(self):
grammar = textwrap.dedent(
r'''
grammar T;
options {
language=Python;
}
a : ID EOF;
ID : 'a'..'z'+ ;
WS : (' '|'\n') {$channel=HIDDEN;} ;
''')
listener = antlr3.debug.RecordDebugEventListener()
self.execParser(
grammar, 'a',
input="a",
listener=listener)
# We only check that some LT events are present. How many is subject
# to change (at the time of writing there are two, which is one too
# many).
lt_events = [event for event in listener.events
if event.startswith("LT ")]
self.assertNotEqual(lt_events, [])
# For the rest, filter out LT events to get a reliable test.
expected = ["enterRule a",
"location 6:1",
"location 6:5",
"location 6:8",
"location 6:11",
"exitRule a"]
found = [event for event in listener.events
if not event.startswith("LT ")]
self.assertListEqual(found, expected)
def testSocketProxy(self):
grammar = textwrap.dedent(
r'''
grammar T;
options {
language=Python;
}
a : ID EOF;
ID : 'a'..'z'+ ;
WS : (' '|'\n') {$channel=HIDDEN;} ;
''')
debugger = self.execParser(
grammar, 'a',
input="a",
listener=None)
self.assertTrue(debugger.success)
expected = [['enterRule', 'T.g', 'a'],
['location', '6', '1'],
['enterAlt', '1'],
['location', '6', '5'],
['LT', '1', '0', '4', '0', '1', '0', '"a'],
['LT', '1', '0', '4', '0', '1', '0', '"a'],
['consumeToken', '0', '4', '0', '1', '0', '"a'],
['location', '6', '8'],
['LT', '1', '-1', '-1', '0', '1', '1', '"<EOF>'],
['LT', '1', '-1', '-1', '0', '1', '1', '"<EOF>'],
['consumeToken', '-1', '-1', '0', '1', '1', '"<EOF>'],
['location', '6', '11'],
['exitRule', 'T.g', 'a'],
['terminate']]
self.assertListEqual(debugger.events, expected)
def testRecognitionException(self):
grammar = textwrap.dedent(
r'''
grammar T;
options {
language=Python;
}
a : ID EOF;
ID : 'a'..'z'+ ;
WS : (' '|'\n') {$channel=HIDDEN;} ;
''')
debugger = self.execParser(
grammar, 'a',
input="a b",
listener=None)
self.assertTrue(debugger.success)
expected = [['enterRule', 'T.g', 'a'],
['location', '6', '1'],
['enterAlt', '1'],
['location', '6', '5'],
['LT', '1', '0', '4', '0', '1', '0', '"a'],
['LT', '1', '0', '4', '0', '1', '0', '"a'],
['consumeToken', '0', '4', '0', '1', '0', '"a'],
['consumeHiddenToken', '1', '5', '99', '1', '1', '"'],
['location', '6', '8'],
['LT', '1', '2', '4', '0', '1', '2', '"b'],
['LT', '1', '2', '4', '0', '1', '2', '"b'],
['LT', '2', '-1', '-1', '0', '1', '3', '"<EOF>'],
['LT', '1', '2', '4', '0', '1', '2', '"b'],
['LT', '1', '2', '4', '0', '1', '2', '"b'],
['beginResync'],
['consumeToken', '2', '4', '0', '1', '2', '"b'],
['endResync'],
['exception', 'UnwantedTokenException', '2', '1', '2'],
['LT', '1', '-1', '-1', '0', '1', '3', '"<EOF>'],
['consumeToken', '-1', '-1', '0', '1', '3', '"<EOF>'],
['location', '6', '11'],
['exitRule', 'T.g', 'a'],
['terminate']]
self.assertListEqual(debugger.events, expected)
def testSemPred(self):
grammar = textwrap.dedent(
r'''
grammar T;
options {
language=Python;
}
a : {True}? ID EOF;
ID : 'a'..'z'+ ;
WS : (' '|'\n') {$channel=HIDDEN;} ;
''')
debugger = self.execParser(
grammar, 'a',
input="a",
listener=None)
self.assertTrue(debugger.success)
expected = [['enterRule', 'T.g', 'a'],
['location', '6', '1'],
['enterAlt', '1'],
['location', '6', '5'],
['semanticPredicate', '1', 'True'],
['location', '6', '13'],
['LT', '1', '0', '4', '0', '1', '0', '"a'],
['LT', '1', '0', '4', '0', '1', '0', '"a'],
['consumeToken', '0', '4', '0', '1', '0', '"a'],
['location', '6', '16'],
['LT', '1', '-1', '-1', '0', '1', '1', '"<EOF>'],
['LT', '1', '-1', '-1', '0', '1', '1', '"<EOF>'],
['consumeToken', '-1', '-1', '0', '1', '1', '"<EOF>'],
['location', '6', '19'],
['exitRule', 'T.g', 'a'],
['terminate']]
self.assertListEqual(debugger.events, expected)
def testPositiveClosureBlock(self):
grammar = textwrap.dedent(
r'''
grammar T;
options {
language=Python;
}
a : ID ( ID | INT )+ EOF;
ID : 'a'..'z'+ ;
INT : '0'..'9'+ ;
WS : (' '|'\n') {$channel=HIDDEN;} ;
''')
debugger = self.execParser(
grammar, 'a',
input="a 1 b c 3",
listener=None)
self.assertTrue(debugger.success)
expected = [['enterRule', 'T.g', 'a'],
['location', '6', '1'],
['enterAlt', '1'],
['location', '6', '5'],
['LT', '1', '0', '4', '0', '1', '0', '"a'],
['LT', '1', '0', '4', '0', '1', '0', '"a'],
['consumeToken', '0', '4', '0', '1', '0', '"a'],
['consumeHiddenToken', '1', '6', '99', '1', '1', '"'],
['location', '6', '8'],
['enterSubRule', '1'],
['enterDecision', '1', '0'],
['LT', '1', '2', '5', '0', '1', '2', '"1'],
['exitDecision', '1'],
['enterAlt', '1'],
['location', '6', '8'],
['LT', '1', '2', '5', '0', '1', '2', '"1'],
['consumeToken', '2', '5', '0', '1', '2', '"1'],
['consumeHiddenToken', '3', '6', '99', '1', '3', '"'],
['enterDecision', '1', '0'],
['LT', '1', '4', '4', '0', '1', '4', '"b'],
['exitDecision', '1'],
['enterAlt', '1'],
['location', '6', '8'],
['LT', '1', '4', '4', '0', '1', '4', '"b'],
['consumeToken', '4', '4', '0', '1', '4', '"b'],
['consumeHiddenToken', '5', '6', '99', '1', '5', '"'],
['enterDecision', '1', '0'],
['LT', '1', '6', '4', '0', '1', '6', '"c'],
['exitDecision', '1'],
['enterAlt', '1'],
['location', '6', '8'],
['LT', '1', '6', '4', '0', '1', '6', '"c'],
['consumeToken', '6', '4', '0', '1', '6', '"c'],
['consumeHiddenToken', '7', '6', '99', '1', '7', '"'],
['enterDecision', '1', '0'],
['LT', '1', '8', '5', '0', '1', '8', '"3'],
['exitDecision', '1'],
['enterAlt', '1'],
['location', '6', '8'],
['LT', '1', '8', '5', '0', '1', '8', '"3'],
['consumeToken', '8', '5', '0', '1', '8', '"3'],
['enterDecision', '1', '0'],
['LT', '1', '-1', '-1', '0', '1', '9', '"<EOF>'],
['exitDecision', '1'],
['exitSubRule', '1'],
['location', '6', '22'],
['LT', '1', '-1', '-1', '0', '1', '9', '"<EOF>'],
['LT', '1', '-1', '-1', '0', '1', '9', '"<EOF>'],
['consumeToken', '-1', '-1', '0', '1', '9', '"<EOF>'],
['location', '6', '25'],
['exitRule', 'T.g', 'a'],
['terminate']]
self.assertListEqual(debugger.events, expected)
def testClosureBlock(self):
grammar = textwrap.dedent(
r'''
grammar T;
options {
language=Python;
}
a : ID ( ID | INT )* EOF;
ID : 'a'..'z'+ ;
INT : '0'..'9'+ ;
WS : (' '|'\n') {$channel=HIDDEN;} ;
''')
debugger = self.execParser(
grammar, 'a',
input="a 1 b c 3",
listener=None)
self.assertTrue(debugger.success)
expected = [['enterRule', 'T.g', 'a'],
['location', '6', '1'],
['enterAlt', '1'],
['location', '6', '5'],
['LT', '1', '0', '4', '0', '1', '0', '"a'],
['LT', '1', '0', '4', '0', '1', '0', '"a'],
['consumeToken', '0', '4', '0', '1', '0', '"a'],
['consumeHiddenToken', '1', '6', '99', '1', '1', '"'],
['location', '6', '8'],
['enterSubRule', '1'],
['enterDecision', '1', '0'],
['LT', '1', '2', '5', '0', '1', '2', '"1'],
['exitDecision', '1'],
['enterAlt', '1'],
['location', '6', '8'],
['LT', '1', '2', '5', '0', '1', '2', '"1'],
['consumeToken', '2', '5', '0', '1', '2', '"1'],
['consumeHiddenToken', '3', '6', '99', '1', '3', '"'],
['enterDecision', '1', '0'],
['LT', '1', '4', '4', '0', '1', '4', '"b'],
['exitDecision', '1'],
['enterAlt', '1'],
['location', '6', '8'],
['LT', '1', '4', '4', '0', '1', '4', '"b'],
['consumeToken', '4', '4', '0', '1', '4', '"b'],
['consumeHiddenToken', '5', '6', '99', '1', '5', '"'],
['enterDecision', '1', '0'],
['LT', '1', '6', '4', '0', '1', '6', '"c'],
['exitDecision', '1'],
['enterAlt', '1'],
['location', '6', '8'],
['LT', '1', '6', '4', '0', '1', '6', '"c'],
['consumeToken', '6', '4', '0', '1', '6', '"c'],
['consumeHiddenToken', '7', '6', '99', '1', '7', '"'],
['enterDecision', '1', '0'],
['LT', '1', '8', '5', '0', '1', '8', '"3'],
['exitDecision', '1'],
['enterAlt', '1'],
['location', '6', '8'],
['LT', '1', '8', '5', '0', '1', '8', '"3'],
['consumeToken', '8', '5', '0', '1', '8', '"3'],
['enterDecision', '1', '0'],
['LT', '1', '-1', '-1', '0', '1', '9', '"<EOF>'],
['exitDecision', '1'],
['exitSubRule', '1'],
['location', '6', '22'],
['LT', '1', '-1', '-1', '0', '1', '9', '"<EOF>'],
['LT', '1', '-1', '-1', '0', '1', '9', '"<EOF>'],
['consumeToken', '-1', '-1', '0', '1', '9', '"<EOF>'],
['location', '6', '25'],
['exitRule', 'T.g', 'a'],
['terminate']]
self.assertListEqual(debugger.events, expected)
def testMismatchedSetException(self):
grammar = textwrap.dedent(
r'''
grammar T;
options {
language=Python;
}
a : ID ( ID | INT ) EOF;
ID : 'a'..'z'+ ;
INT : '0'..'9'+ ;
WS : (' '|'\n') {$channel=HIDDEN;} ;
''')
debugger = self.execParser(
grammar, 'a',
input="a",
listener=None)
self.assertTrue(debugger.success)
expected = [['enterRule', 'T.g', 'a'],
['location', '6', '1'],
['enterAlt', '1'],
['location', '6', '5'],
['LT', '1', '0', '4', '0', '1', '0', '"a'],
['LT', '1', '0', '4', '0', '1', '0', '"a'],
['consumeToken', '0', '4', '0', '1', '0', '"a'],
['location', '6', '8'],
['LT', '1', '-1', '-1', '0', '1', '1', '"<EOF>'],
['LT', '1', '-1', '-1', '0', '1', '1', '"<EOF>'],
['LT', '1', '-1', '-1', '0', '1', '1', '"<EOF>'],
['exception', 'MismatchedSetException', '1', '1', '1'],
['exception', 'MismatchedSetException', '1', '1', '1'],
['beginResync'],
['LT', '1', '-1', '-1', '0', '1', '1', '"<EOF>'],
['endResync'],
['location', '6', '24'],
['exitRule', 'T.g', 'a'],
['terminate']]
self.assertListEqual(debugger.events, expected)
def testBlock(self):
grammar = textwrap.dedent(
r'''
grammar T;
options {
language=Python;
}
a : ID ( b | c ) EOF;
b : ID;
c : INT;
ID : 'a'..'z'+ ;
INT : '0'..'9'+ ;
WS : (' '|'\n') {$channel=HIDDEN;} ;
''')
debugger = self.execParser(
grammar, 'a',
input="a 1",
listener=None)
self.assertTrue(debugger.success)
expected = [['enterRule', 'T.g', 'a'],
['location', '6', '1'],
['enterAlt', '1'],
['location', '6', '5'],
['LT', '1', '0', '4', '0', '1', '0', '"a'],
['LT', '1', '0', '4', '0', '1', '0', '"a'],
['consumeToken', '0', '4', '0', '1', '0', '"a'],
['consumeHiddenToken', '1', '6', '99', '1', '1', '"'],
['location', '6', '8'],
['enterSubRule', '1'],
['enterDecision', '1', '0'],
['LT', '1', '2', '5', '0', '1', '2', '"1'],
['exitDecision', '1'],
['enterAlt', '2'],
['location', '6', '14'],
['enterRule', 'T.g', 'c'],
['location', '8', '1'],
['enterAlt', '1'],
['location', '8', '5'],
['LT', '1', '2', '5', '0', '1', '2', '"1'],
['LT', '1', '2', '5', '0', '1', '2', '"1'],
['consumeToken', '2', '5', '0', '1', '2', '"1'],
['location', '8', '8'],
['exitRule', 'T.g', 'c'],
['exitSubRule', '1'],
['location', '6', '18'],
['LT', '1', '-1', '-1', '0', '1', '3', '"<EOF>'],
['LT', '1', '-1', '-1', '0', '1', '3', '"<EOF>'],
['consumeToken', '-1', '-1', '0', '1', '3', '"<EOF>'],
['location', '6', '21'],
['exitRule', 'T.g', 'a'],
['terminate']]
self.assertListEqual(debugger.events, expected)
def testNoViableAlt(self):
grammar = textwrap.dedent(
r'''
grammar T;
options {
language=Python;
}
a : ID ( b | c ) EOF;
b : ID;
c : INT;
ID : 'a'..'z'+ ;
INT : '0'..'9'+ ;
BANG : '!' ;
WS : (' '|'\n') {$channel=HIDDEN;} ;
''')
debugger = self.execParser(
grammar, 'a',
input="a !",
listener=None)
self.assertTrue(debugger.success)
expected = [['enterRule', 'T.g', 'a'],
['location', '6', '1'],
['enterAlt', '1'],
['location', '6', '5'],
['LT', '1', '0', '5', '0', '1', '0', '"a'],
['LT', '1', '0', '5', '0', '1', '0', '"a'],
['consumeToken', '0', '5', '0', '1', '0', '"a'],
['consumeHiddenToken', '1', '7', '99', '1', '1', '"'],
['location', '6', '8'],
['enterSubRule', '1'],
['enterDecision', '1', '0'],
['LT', '1', '2', '4', '0', '1', '2', '"!'],
['LT', '1', '2', '4', '0', '1', '2', '"!'],
['LT', '1', '2', '4', '0', '1', '2', '"!'],
['exception', 'NoViableAltException', '2', '1', '2'],
['exitDecision', '1'],
['exitSubRule', '1'],
['exception', 'NoViableAltException', '2', '1', '2'],
['beginResync'],
['LT', '1', '2', '4', '0', '1', '2', '"!'],
['consumeToken', '2', '4', '0', '1', '2', '"!'],
['LT', '1', '-1', '-1', '0', '1', '3', '"<EOF>'],
['endResync'],
['location', '6', '21'],
['exitRule', 'T.g', 'a'],
['terminate']]
self.assertListEqual(debugger.events, expected)
def testRuleBlock(self):
grammar = textwrap.dedent(
r'''
grammar T;
options {
language=Python;
}
a : b | c;
b : ID;
c : INT;
ID : 'a'..'z'+ ;
INT : '0'..'9'+ ;
WS : (' '|'\n') {$channel=HIDDEN;} ;
''')
debugger = self.execParser(
grammar, 'a',
input="1",
listener=None)
self.assertTrue(debugger.success)
expected = [['enterRule', 'T.g', 'a'],
['location', '6', '1'],
['enterDecision', '1', '0'],
['LT', '1', '0', '5', '0', '1', '0', '"1'],
['exitDecision', '1'],
['enterAlt', '2'],
['location', '6', '9'],
['enterRule', 'T.g', 'c'],
['location', '8', '1'],
['enterAlt', '1'],
['location', '8', '5'],
['LT', '1', '0', '5', '0', '1', '0', '"1'],
['LT', '1', '0', '5', '0', '1', '0', '"1'],
['consumeToken', '0', '5', '0', '1', '0', '"1'],
['location', '8', '8'],
['exitRule', 'T.g', 'c'],
['location', '6', '10'],
['exitRule', 'T.g', 'a'],
['terminate']]
self.assertListEqual(debugger.events, expected)
def testRuleBlockSingleAlt(self):
grammar = textwrap.dedent(
r'''
grammar T;
options {
language=Python;
}
a : b;
b : ID;
ID : 'a'..'z'+ ;
INT : '0'..'9'+ ;
WS : (' '|'\n') {$channel=HIDDEN;} ;
''')
debugger = self.execParser(
grammar, 'a',
input="a",
listener=None)
self.assertTrue(debugger.success)
expected = [['enterRule', 'T.g', 'a'],
['location', '6', '1'],
['enterAlt', '1'],
['location', '6', '5'],
['enterRule', 'T.g', 'b'],
['location', '7', '1'],
['enterAlt', '1'],
['location', '7', '5'],
['LT', '1', '0', '4', '0', '1', '0', '"a'],
['LT', '1', '0', '4', '0', '1', '0', '"a'],
['consumeToken', '0', '4', '0', '1', '0', '"a'],
['location', '7', '7'],
['exitRule', 'T.g', 'b'],
['location', '6', '6'],
['exitRule', 'T.g', 'a'],
['terminate']]
self.assertListEqual(debugger.events, expected)
def testBlockSingleAlt(self):
grammar = textwrap.dedent(
r'''
grammar T;
options {
language=Python;
}
a : ( b );
b : ID;
ID : 'a'..'z'+ ;
INT : '0'..'9'+ ;
WS : (' '|'\n') {$channel=HIDDEN;} ;
''')
debugger = self.execParser(
grammar, 'a',
input="a",
listener=None)
self.assertTrue(debugger.success)
expected = [['enterRule', 'T.g', 'a'],
['location', '6', '1'],
['enterAlt', '1'],
['location', '6', '5'],
['enterAlt', '1'],
['location', '6', '7'],
['enterRule', 'T.g', 'b'],
['location', '7', '1'],
['enterAlt', '1'],
['location', '7', '5'],
['LT', '1', '0', '4', '0', '1', '0', '"a'],
['LT', '1', '0', '4', '0', '1', '0', '"a'],
['consumeToken', '0', '4', '0', '1', '0', '"a'],
['location', '7', '7'],
['exitRule', 'T.g', 'b'],
['location', '6', '10'],
['exitRule', 'T.g', 'a'],
['terminate']]
self.assertListEqual(debugger.events, expected)
def testDFA(self):
grammar = textwrap.dedent(
r'''
grammar T;
options {
language=Python;
}
a : ( b | c ) EOF;
b : ID* INT;
c : ID+ BANG;
ID : 'a'..'z'+ ;
INT : '0'..'9'+ ;
BANG : '!';
WS : (' '|'\n') {$channel=HIDDEN;} ;
''')
debugger = self.execParser(
grammar, 'a',
input="a!",
listener=None)
self.assertTrue(debugger.success)
expected = [['enterRule', 'T.g', 'a'],
['location', '6', '1'],
['enterAlt', '1'],
['location', '6', '5'],
['enterSubRule', '1'],
['enterDecision', '1', '0'],
['mark', '0'],
['LT', '1', '0', '5', '0', '1', '0', '"a'],
['consumeToken', '0', '5', '0', '1', '0', '"a'],
['LT', '1', '1', '4', '0', '1', '1', '"!'],
['consumeToken', '1', '4', '0', '1', '1', '"!'],
['rewind', '0'],
['exitDecision', '1'],
['enterAlt', '2'],
['location', '6', '11'],
['enterRule', 'T.g', 'c'],
['location', '8', '1'],
['enterAlt', '1'],
['location', '8', '5'],
['enterSubRule', '3'],
['enterDecision', '3', '0'],
['LT', '1', '0', '5', '0', '1', '0', '"a'],
['exitDecision', '3'],
['enterAlt', '1'],
['location', '8', '5'],
['LT', '1', '0', '5', '0', '1', '0', '"a'],
['LT', '1', '0', '5', '0', '1', '0', '"a'],
['consumeToken', '0', '5', '0', '1', '0', '"a'],
['enterDecision', '3', '0'],
['LT', '1', '1', '4', '0', '1', '1', '"!'],
['exitDecision', '3'],
['exitSubRule', '3'],
['location', '8', '9'],
['LT', '1', '1', '4', '0', '1', '1', '"!'],
['LT', '1', '1', '4', '0', '1', '1', '"!'],
['consumeToken', '1', '4', '0', '1', '1', '"!'],
['location', '8', '13'],
['exitRule', 'T.g', 'c'],
['exitSubRule', '1'],
['location', '6', '15'],
['LT', '1', '-1', '-1', '0', '1', '2', '"<EOF>'],
['LT', '1', '-1', '-1', '0', '1', '2', '"<EOF>'],
['consumeToken', '-1', '-1', '0', '1', '2', '"<EOF>'],
['location', '6', '18'],
['exitRule', 'T.g', 'a'],
['terminate']]
self.assertListEqual(debugger.events, expected)
def testBasicAST(self):
grammar = textwrap.dedent(
r'''
grammar T;
options {
language=Python;
output=AST;
}
a : ( b | c ) EOF!;
b : ID* INT -> ^(INT ID*);
c : ID+ BANG -> ^(BANG ID+);
ID : 'a'..'z'+ ;
INT : '0'..'9'+ ;
BANG : '!';
WS : (' '|'\n') {$channel=HIDDEN;} ;
''')
listener = antlr3.debug.RecordDebugEventListener()
self.execParser(
grammar, 'a',
input="a!",
listener=listener)
# don't check output for now (too dynamic), I'm satisfied if it
# doesn't crash
if __name__ == '__main__':
unittest.main()