def param_repr(p):
if isinstance(p, (int, float)):
return ustr(p)
elif isinstance(p, strtype) and p.isalnum():
return ustr(p)
else:
return urepr(p)
def render_fields(self, fields):
template = trim(self.option_template)
options = [template.format(option=indent(self.rend(o))) for o in self.node.options]
options = "\n".join(o for o in options)
firstset = " ".join(f[0] for f in sorted(self.node.firstset) if f)
if firstset:
error = "expecting one of: " + firstset
else:
error = "no available options"
fields.update(n=self.counter(), options=indent(options), error=urepr(error))
def parse(self, ctx):
with ctx._choice():
for o in self.options:
with ctx._option():
ctx.last_node = o.parse(ctx)
return ctx.last_node
lookahead = ' '.join(ustr(urepr(f[0])) for f in self.lookahead if f)
if lookahead:
ctx._error('expecting one of {%s}' % lookahead)
ctx._error('no available options')
def render_fields(self, fields):
self.reset_counter()
params = kwparams = ""
if self.node.params:
params = ", ".join(self.param_repr(self.rend(p)) for p in self.node.params)
if self.node.kwparams:
kwparams = ", ".join("%s=%s" % (k, self.param_repr(self.rend(v))) for k, v in self.kwparams.items())
if params and kwparams:
params = params + ", " + kwparams
elif kwparams:
params = kwparams
fields.update(params=params)
defines = compress_seq(self.defines())
sdefs = [d for d, l in defines if not l]
ldefs = [d for d, l in defines if l]
if not (sdefs or ldefs):
sdefines = ""
else:
sdefs = "[%s]" % ", ".join(urepr(d) for d in sdefs)
ldefs = "[%s]" % ", ".join(urepr(d) for d in ldefs)
if not ldefs:
sdefines = "\n\n self.ast._define(%s, %s)" % (sdefs, ldefs)
else:
sdefines = indent(
"\n\n"
+ trim(
"""\
self.ast._define(
%s,
%s
)"""
% (sdefs, ldefs)
)
)
fields.update(defines=sdefines)
def render_fields(self, fields):
abstract_template = trim(self.abstract_rule_template)
abstract_rules = [abstract_template.format(name=safe_name(rule.name)) for rule in self.node.rules]
abstract_rules = indent("\n".join(abstract_rules))
if self.node.whitespace is not None:
whitespace = urepr(self.node.whitespace)
elif self.node.directives.get("whitespace") is not None:
whitespace = "re.compile({0}, RE_FLAGS | re.DOTALL)".format(urepr(self.node.directives.get("whitespace")))
else:
whitespace = "None"
if self.node.nameguard is not None:
nameguard = urepr(self.node.nameguard)
elif self.node.directives.get("nameguard") is not None:
nameguard = self.node.directives.get("nameguard")
else:
nameguard = "None"
comments_re = urepr(self.node.directives.get("comments"))
eol_comments_re = urepr(self.node.directives.get("eol_comments"))
ignorecase = self.node.directives.get("ignorecase", "None")
left_recursion = self.node.directives.get("left_recursion", True)
rules = "\n".join([self.get_renderer(rule).render() for rule in self.node.rules])
version = str(tuple(int(n) for n in str(timestamp()).split(".")))
fields.update(
rules=indent(rules),
abstract_rules=abstract_rules,
version=version,
whitespace=whitespace,
nameguard=nameguard,
comments_re=comments_re,
eol_comments_re=eol_comments_re,
ignorecase=ignorecase,
left_recursion=left_recursion,
)
def __init__(self, ast=None, **kwargs):
super(Choice, self).__init__(ast=AST(options=ast))
assert isinstance(self.options, list), urepr(self.options)
def __str__(self):
return urepr(self.token)
def render_fields(self, fields):
raw_repr = "r" + urepr(self.node.pattern).replace("\\\\", "\\")
fields.update(pattern=raw_repr)
def render_fields(self, fields):
fields.update(token=urepr(self.node.token))
def param_repr(p):
if isinstance(p, (int, float)):
return ustr(p)
else:
return urepr(p)
