def to_generator(self, generator_factory=None):
if generator_factory == None:
generator_factory = enumerators.RecursiveGeneratorFactory()
for nt in self.non_terminals:
if not generator_factory.has_placeholder(
_nt_to_generator_name(nt)):
generator_factory.make_placeholder(_nt_to_generator_name(nt))
place_holders = generator_factory.generator_map
ret = None
for nt in self.non_terminals:
generators = []
leaves = []
for rewrite in self.rules[nt]:
if type(rewrite) == ExpressionRewrite:
leaves.append(rewrite.expr)
elif type(rewrite) == NTRewrite:
generators.append(place_holders[_nt_to_generator_name(
rewrite.non_terminal)])
elif type(rewrite) == FunctionRewrite:
generators.append(rewrite.to_generator(place_holders))
else:
raise Exception('Unknown rewrite type: %s' %
str(type(rewrite)))
leaf_generator = enumerators.LeafGenerator(leaves)
nt_generator = generator_factory.make_generator(
_nt_to_generator_name(nt), enumerators.AlternativesGenerator,
([leaf_generator] + generators, ))
if nt == self.start:
ret = nt_generator
return ret
def to_generator(self, place_holders):
ph_vars, nts, expr_template = self.to_template_expr()
if len(ph_vars) == 0:
return enumerators.LeafGenerator([expr_template])
sub_gens = [place_holders[_nt_to_generator_name(nt)] for nt in nts]
# Try some pruning rules
if (len(self.children) == 2 and self.function_info.commutative
and self.children[0] == self.children[1]):
good_size_tuple = enumerators.commutative_good_size_tuple
else:
good_size_tuple = enumerators.default_good_size_tuple
return enumerators.ExpressionTemplateGenerator(
expr_template, ph_vars, sub_gens, good_size_tuple=good_size_tuple)