def __init__(self, spec, depth=None, loc=None):
self.z3_solver = Solver()
custom_list = spec.get_productions_with_lhs('SmallStr')
if len(custom_list) > 0:
# Switch to optimizer
self.z3_solver = Optimize()
self.variables = []
self.sk_vars = []
self.program2tree = {}
self.spec = spec
if depth <= 0:
raise ValueError(
'Depth cannot be non-positive: {}'.format(depth))
self.depth = depth
if loc <= 0:
raise ValueError(
'LOC cannot be non-positive: {}'.format(loc))
self.loc = loc
self.max_children = self.maxChildren()
self.builder = D.Builder(self.spec)
self.lines, self.nodes = self.buildKLines(self.max_children, self.loc, self.z3_solver)
self.model = None
self.createStmtConstraints()
self.createDefuseConstraints()
def buildProgram(self):
result = [0] * len(self.model)
for x in self.model:
c = x()
a = str(x)
if a[:1] == 'n':
result[int(a[1:]) - 1] = int(str(self.model[c]))
self.program2tree.clear()
code = []
for n in self.nodes:
prod = self.spec.get_production_or_raise(result[n.id - 1])
code.append(prod)
builder = D.Builder(self.spec)
builder_nodes = [None] * len(self.nodes)
for x in range(0, len(self.nodes)):
y = len(self.nodes) - x - 1
if str(code[self.nodes[y].id - 1]).find('Empty') == -1:
children = []
if self.nodes[y].children is not None:
for c in self.nodes[y].children:
if str(code[c.id - 1]).find('Empty') == -1:
assert builder_nodes[c.id - 1] is not None
children.append(builder_nodes[c.id - 1])
n = code[self.nodes[y].id - 1].id
builder_nodes[y] = builder.make_node(n, children)
self.program2tree[builder_nodes[y]] = self.nodes[y]
assert (builder_nodes[0] is not None)
return builder_nodes[0]
def __init__(self,
spec: S.TyrellSpec,
max_depth: int,
seed: Optional[int] = None):
self._rand = Random(seed)
self._builder = D.Builder(spec)
if max_depth <= 0:
raise ValueError(
'Max depth cannot be non-positive: {}'.format(max_depth))
self._max_depth = max_depth
def main():
logger.info('Parsing Spec...')
spec = S.parse(toy_spec_str)
logger.info('Parsing succeeded')
logger.info('Building sample program...')
prog = D.Builder(spec).from_sexp_string(toy_dsl_sexp)
logger.info('Build program = {}'.format(prog))
interpreter = ToyInterpreter()
logger.info('Executing program on inputs {}...'.format(input0))
out_value = execute(interpreter, prog, input0)
logger.info('Execution finished with output = {}'.format(out_value))
assert out_value == toy_dsl_func(input0)
logger.info('Executing program on inputs {}...'.format(input1))
out_value = execute(interpreter, prog, input1)
logger.info('Execution finished with output = {}'.format(out_value))
assert out_value == toy_dsl_func(input1)
def setUp(self):
self._builder = D.Builder(spec)
self._interp = BoolInterpreter()
self._domain = [False, True]