def __init__(self):
self.grammar = parglare.Grammar.from_file(
os.path.join(os.path.dirname(os.path.realpath(__file__)),
"chrono_tile_grammar.pg"))
self.parser = parglare.GLRParser(self.grammar,
actions=self.actions,
ws="\r")
lambda _, x: [ComplexTerm('field', [x[0], x[4]])],
lambda _, x: x[0] + [ComplexTerm('field', [x[3], x[7]])],
],
'record_value_fields': [
lambda _, x: [ComplexTerm('field', [x[0], x[4]])],
lambda _, x: x[0] + [ComplexTerm('field', [x[3], x[7]])],
],
'var_or_label': [
pass_single(0),
lambda _, x: Name(x[0][1:-1]),
]
}
pg_grammar, start = to_parglare_grammar(grammar['productions'],
grammar['terminals'], grammar['start'])
parser = parglare.GLRParser(pg_grammar, ws='', actions=actions)
current_block_lines = []
judgements = []
judgement = False
for i, line in enumerate(sys.stdin):
if line.startswith('!stop'):
break
if line.startswith(' '):
current_block_lines.append(line[4:])
if line.startswith(' ─'):
judgement = True
else:
if judgement:
print('parsing judgement at lines {} - {}'.format(
i - len(current_block_lines) + 1,
with timeit('making parser'):
_grammar, _start = to_parglare_grammar(
productions,
terminals,
original_start_symbol,
recognizers={
'simple-label': simple_label_recognizer,
'single-quote-regular-chunk':
single_quote_regular_chunk_recognizer,
},
)
assert _start == start_symbol
parser = parglare.GLRParser(
_grammar,
ws='',
table=parglare.tables.persist.table_from_serializable(
parse_table, _grammar),
actions=_actions,
)
class SyntaxError(Exception):
pass
def parse(string):
try:
trees = parser.parse(string)
except parglare.ParseError as e:
raise SyntaxError(e)
# GLR parser can return multiple trees when there is ambiguity
abnf_parser = parglare.GLRParser(
abnf_grammar,
ws='',
actions={
'dec?':
parglare.actions.optional,
'hex?':
parglare.actions.optional,
'hex':
lambda _, v: int(v, 16),
'dec':
lambda _, v: int(v, 10),
'hex_string':
concat_0_2_actions,
'dec_string':
concat_0_2_actions,
'string': [
lambda _, c: ''.join(map(chr, c[1])),
lambda _, c: ''.join(map(chr, c[1])),
take_raw(1),
lambda _, c: '',
],
'definition0': [
lambda _, c: Alternative((c[0], c[4])),
take_raw(0),
],
'definition1': [
lambda _, c: Sequence((c[0], c[2])),
take_raw(0),
],
'definition2': [
lambda _, c: ExactRepetition(c[0], c[1]),
lambda _, c: RangeRepetition(c[3], c[0], c[2]),
take_raw(0),
],
'definition3': [
take_raw(2),
take(Optional, [2]),
take(RangeTerminal, [1, 3]),
take(RangeTerminal, [1, 3]),
take(StringTerminal, [0]),
take(Name, [0]),
],
'rule':
lambda _, c: (c[0], c[4]),
'rules':
concat_0_2_actions,
'start':
lambda _, c: Grammar(dict(c[1])),
start_symbol:
take_raw(0),
},
)