def visit_oneormoreexpr(self, node):
self.visit(node.expr)
if isinstance(node.expr, (CharRangeExpr, AnyCharExpr)):
result_line = 'result = "".join(results_{})'.format(node.id)
else:
result_line = 'result = results_{}'.format(node.id)
code = """
# {0}
self.p_save()
results_{3} = []
while 42:
{1}
if result is not self.NoMatch:
results_{3}.append(result)
else:
break
if not results_{3}:
self.p_restore()
{4}
result = self.NoMatch
else:
self.p_discard()
{2}
""".format(
node.as_grammar(),
indent(node.expr._py_code, 1),
result_line,
node.id,
indent(self.report_error(node.id), 1)
)
node._py_code = code.strip()
def visit_oneormoreexpr(self, node):
self.visit(node.expr)
if isinstance(node.expr, (CharRangeExpr, AnyCharExpr)):
result_line = 'result = "".join(results_{})'.format(node.id)
else:
result_line = 'result = results_{}'.format(node.id)
code = """
# {0}
self.p_save()
results_{3} = []
while 42:
{1}
if result is not self.NoMatch:
results_{3}.append(result)
else:
break
if not results_{3}:
self.p_restore()
{4}
result = self.NoMatch
else:
self.p_discard()
{2}
""".format(node.as_grammar(), indent(node.expr._py_code, 1),
result_line, node.id, indent(self.report_error(node.id), 1))
node._py_code = code.strip()
def expressions():
exprs = []
for i, expr in enumerate(node.exprs):
self.visit(expr)
expr_code = """
{}
if result is self.NoMatch:
""".format(expr._py_code).strip()
exprs.append(indent(expr_code, i))
exprs.append(indent("pass", i + 1))
return "\n".join(exprs)
def expressions():
exprs = []
for i, expr in enumerate(node.exprs):
self.visit(expr)
expr_code = """
{}
if result is self.NoMatch:
""".format(expr._py_code).strip()
exprs.append(indent(expr_code, i))
exprs.append(indent("pass", i + 1))
return "\n".join(exprs)
def visit_choiceexpr(self, node):
if not node.exprs:
node._py_code = "result = self.NoMatch"
return
def expressions():
exprs = []
for i, expr in enumerate(node.exprs):
self.visit(expr)
expr_code = """
{}
if result is self.NoMatch:
""".format(expr._py_code).strip()
exprs.append(indent(expr_code, i))
exprs.append(indent("pass", i + 1))
return "\n".join(exprs)
code = """
# {1}
self.p_save()
{0}
if result is self.NoMatch:
self.p_restore()
{2}
else:
self.p_discard()
""".format(
expressions(),
node.as_grammar(),
indent(self.report_error(node.id), 1)
)
node._py_code = code.strip()
def visit_choiceexpr(self, node):
if not node.exprs:
node._py_code = "result = self.NoMatch"
return
def expressions():
exprs = []
for i, expr in enumerate(node.exprs):
self.visit(expr)
expr_code = """
{}
if result is self.NoMatch:
""".format(expr._py_code).strip()
exprs.append(indent(expr_code, i))
exprs.append(indent("pass", i + 1))
return "\n".join(exprs)
code = """
# {1}
self.p_save()
{0}
if result is self.NoMatch:
self.p_restore()
{2}
else:
self.p_discard()
""".format(expressions(), node.as_grammar(),
indent(self.report_error(node.id), 1))
node._py_code = code.strip()
def expressions():
exprs = []
for i, expr in enumerate(node.exprs):
self.visit(expr)
expr_code = """
{0}
if result is self.NoMatch:
results_{1} = self.NoMatch
self.p_restore()
{2}
else:
results_{1}.append(result)
""".format(expr._py_code, node.id,
indent(self.report_error(node.id).strip(), 1))
exprs.append(indent(expr_code, i))
return "\n".join(exprs)
def expressions():
exprs = []
for i, expr in enumerate(node.exprs):
self.visit(expr)
expr_code = """
{0}
if result is self.NoMatch:
results_{1} = self.NoMatch
self.p_restore()
{2}
else:
results_{1}.append(result)
""".format(expr._py_code, node.id,
indent(self.report_error(node.id).strip(), 1))
exprs.append(indent(expr_code, i))
return "\n".join(exprs)
def visit_lookahead(self, node):
self.visit(node.expr)
code = """
# {1}
self.p_save()
{0}
result = result if result is self.NoMatch else ""
self.p_restore()
if result is self.NoMatch:
{2}
""".format(node.expr._py_code, node.as_grammar(),
indent(self.report_error(node.id), 1))
node._py_code = code.strip()
def visit_literalexpr(self, node):
if node.lit == "":
node._py_code = "result = ''"
return
code = """
# {2}
result = self.p_startswith({0}, {1})
if not result:
{3}
result = self.NoMatch
""".format(repr(node.lit), repr(node.ignorecase), node.as_grammar(),
indent(self.report_error(node.id), 1))
node._py_code = code.strip()
def visit_anycharexpr(self, node):
code = """
# .
self.p_save()
n = self.p_next()
if n is not None:
self.p_discard()
result = n
else:
self.p_restore()
{}
result = self.NoMatch
""".format(indent(self.report_error(node.id), 1))
node._py_code = code.strip()
def visit_anycharexpr(self, node):
code = """
# .
self.p_save()
n = self.p_next()
if n is not None:
self.p_discard()
result = n
else:
self.p_restore()
{}
result = self.NoMatch
""".format(indent(self.report_error(node.id), 1))
node._py_code = code.strip()
def visit_rule(self, node):
self.visit(node.expr)
code = """ '''{3}'''
# -- self.p_debug("{0}({5})")
# -- self._debug_indent += 1
args = dict()
{1}
# -- self._debug_indent -= 1
if result is not self.NoMatch:
{2}
# -- self.p_debug("{0}({5}) -- MATCH " + repr(result) )
else:
{4}
# -- self.p_debug("{0}({5}) -- NO MATCH")
return result
""".format(
node.name,
indent(node.expr._py_code, 1),
self._action(node.action),
node.as_grammar().replace("'", "\\'"),
indent(self.report_error(node.id), 2),
node.id,
)
defline = "def {}(self):".format(node.name)
code = "\n".join([defline, code])
if self.debug:
code = code.replace("# -- ", "")
else:
lines = code.splitlines(True)
code = ""
for line in lines:
if line.strip().startswith("# --"):
continue
else:
code += line
node._py_code = code.strip()
return node
def visit_rule(self, node):
self.visit(node.expr)
code = """ '''{3}'''
# -- self.p_debug("{0}({5})")
# -- self._debug_indent += 1
args = dict()
{1}
# -- self._debug_indent -= 1
if result is not self.NoMatch:
{2}
# -- self.p_debug("{0}({5}) -- MATCH " + repr(result) )
else:
{4}
# -- self.p_debug("{0}({5}) -- NO MATCH")
return result
""".format(node.name,
indent(node.expr._py_code, 1),
self._action(node.action),
node.as_grammar().replace("'", "\\'"),
indent(self.report_error(node.id), 2),
node.id,
)
defline = "def {}(self):".format(node.name)
code = "\n".join([defline, code])
if self.debug:
code = code.replace("# -- ", "")
else:
lines = code.splitlines(True)
code = ""
for line in lines:
if line.strip().startswith("# --"):
continue
else:
code += line
node._py_code = code.strip()
return node
def visit_charrangeexpr(self, node):
code = """
# {0}
self.p_save()
n = self.p_next()
if n is not None and n in {1}:
self.p_discard()
result = n
else:
self.p_restore()
{2}
result = self.NoMatch
""".format(node.as_grammar(), repr(node.chars),
indent(self.report_error(node.id), 1))
node._py_code = code.strip()
def visit_not(self, node):
self.visit(node.expr)
code = """
# {1}
self.p_save()
{0}
result = "" if result is self.NoMatch else self.NoMatch
self.p_restore()
if result is self.NoMatch:
{2}
#else:
#print self._p_error_stack
#self._p_error_stack.pop()
""".format(node.expr._py_code, node.as_grammar(),
indent(self.report_error(node.id), 1))
node._py_code = code.strip()
def _py_code(self):
PyCodeGen(self.debug).visit(self.expr)
pk = hash(self.expr.as_grammar())
code = """
start_pos_{2}= self.pos
if ({0}, start_pos_{2}) in self._p_memoized:
result, self.pos = self._p_memoized[({0}, self.pos)]
else:
{1}
self._p_memoized[({0}, start_pos_{2})] = result, self.pos
""".format(
pk,
indent(self.expr._py_code, 1),
self.expr.id,
)
return code.strip()
def visit_lookahead(self, node):
self.visit(node.expr)
code = """
# {1}
self.p_save()
{0}
result = result if result is self.NoMatch else ""
self.p_restore()
if result is self.NoMatch:
{2}
""".format(
node.expr._py_code,
node.as_grammar(),
indent(self.report_error(node.id), 1)
)
node._py_code = code.strip()
def _py_code(self):
PyCodeGen(self.debug).visit(self.expr)
pk = hash(self.expr.as_grammar())
code = """
start_pos_{2}= self.pos
if ({0}, start_pos_{2}) in self._p_memoized:
result, self.pos = self._p_memoized[({0}, self.pos)]
else:
{1}
self._p_memoized[({0}, start_pos_{2})] = result, self.pos
""".format(
pk,
indent(self.expr._py_code, 1),
self.expr.id,
)
return code.strip()
def visit_regexexpr(self, node):
code = """
# {0}
regex = self._p_py_constants[{2}]["regex"]
m = regex.match(self.p_suffix())
if m:
result = self.p_suffix(m.end())
self.pos += m.end()
else:
{1}
result = self.NoMatch
""".format(
node.as_grammar(),
indent(self.report_error(node.id), 1),
node.id,
)
node._py_code = code.strip()
def visit_regexexpr(self, node):
code = """
# {0}
regex = self._p_py_constants[{2}]["regex"]
m = regex.match(self.p_suffix())
if m:
result = self.p_suffix(m.end())
self.pos += m.end()
else:
{1}
result = self.NoMatch
""".format(
node.as_grammar(),
indent(self.report_error(node.id), 1),
node.id,
)
node._py_code = code.strip()
def visit_literalexpr(self, node):
if node.lit == "":
node._py_code = "result = ''"
return
code = """
# {2}
result = self.p_startswith({0}, {1})
if not result:
{3}
result = self.NoMatch
""".format(
repr(node.lit),
repr(node.ignorecase),
node.as_grammar(),
indent(self.report_error(node.id), 1)
)
node._py_code = code.strip()
def visit_charrangeexpr(self, node):
code = """
# {0}
self.p_save()
n = self.p_next()
if n is not None and n in {1}:
self.p_discard()
result = n
else:
self.p_restore()
{2}
result = self.NoMatch
""".format(
node.as_grammar(),
repr(node.chars),
indent(self.report_error(node.id), 1)
)
node._py_code = code.strip()
def visit_not(self, node):
self.visit(node.expr)
code = """
# {1}
self.p_save()
{0}
result = "" if result is self.NoMatch else self.NoMatch
self.p_restore()
if result is self.NoMatch:
{2}
#else:
#print self._p_error_stack
#self._p_error_stack.pop()
""".format(
node.expr._py_code,
node.as_grammar(),
indent(self.report_error(node.id), 1)
)
node._py_code = code.strip()
def visit_zeroormoreexpr(self, node):
self.visit(node.expr)
if isinstance(node.expr, (CharRangeExpr, AnyCharExpr)):
result_line = 'result = "".join(results_{})'.format(node.id)
else:
result_line = 'result = results_{}'.format(node.id)
code = """
# {0}
results_{3} = []
while 42:
{1}
if result is not self.NoMatch:
results_{3}.append(result)
else:
break
# print self._p_error_stack
{2}
""".format(
node.as_grammar(),
indent(node.expr._py_code, 1),
result_line,
node.id,
)
node._py_code = code.strip()
def visit_zeroormoreexpr(self, node):
self.visit(node.expr)
if isinstance(node.expr, (CharRangeExpr, AnyCharExpr)):
result_line = 'result = "".join(results_{})'.format(node.id)
else:
result_line = 'result = results_{}'.format(node.id)
code = """
# {0}
results_{3} = []
while 42:
{1}
if result is not self.NoMatch:
results_{3}.append(result)
else:
break
# print self._p_error_stack
{2}
""".format(
node.as_grammar(),
indent(node.expr._py_code, 1),
result_line,
node.id,
)
node._py_code = code.strip()
def visit_rule(self, node):
self.output.write(indent(node._py_code, self.indent))
self.output.write("\n\n")
def visit_rule(self, node):
self.output.write(indent(node._py_code, self.indent))
self.output.write("\n\n")
