def my_test(cmd, outputfile, testname, timeout=300):
outputfile.write('\t%s:' % (testname))
print(cmd)
try:
result, rtime = run_command(cmd, timeout)
except TimeoutError:
outputfile.write('timeout after %i \n' % (timeout))
else:
print(result)
benchmarkFile = open(testname)
bm = stripComments(benchmarkFile)
bmExpr = sexp.sexp.parseString(
bm, parseAll=True).asList()[0] # Parse string to python list
checker = translator.ReadQuery(bmExpr)
try:
checkresult = checker.check(str(result, encoding='utf-8'))
except Exception as e:
# outputfile.write('Wrong Answer: Invalid check result %s(%f)\n' %(result,rtime))
outputfile.write('Invalid format(%f)\n' % (rtime))
else:
if (checkresult == None):
outputfile.write('Passed(%f)\n' % (rtime))
else:
# outputfile.write('Wrong Answer: get %s(%f)\n' %(result,rtime))
outputfile.write('Wrong Answer(%f)\n' % (rtime))
def __init__(self, filename, instrument=True):
'''
:param filename:
There should be only one instance active
'''
benchmarkFile = open(filename)
bm = self._stripComments(benchmarkFile)
self.ori = TaskData()
self.ins = None
self.ori.bmExpr = sexp.sexp.parseString(bm, parseAll=True).asList()[0]
self.ori.bmLogic = None
self.ori.bmSyn = None
self.ori.bmDeclvar = []
self.ori.bmConstraint = []
self.ori.bmDefineFun = []
for expr in self.ori.bmExpr:
if len(expr) == 0:
continue
elif expr[0] == 'set-logic':
self.ori.bmLogic = expr
elif expr[0] == 'synth-fun':
self.ori.bmSyn = expr
elif expr[0] == 'declare-var':
self.ori.bmDeclvar.append(expr)
elif expr[0] == 'constraint':
self.ori.bmConstraint.append(expr)
elif expr[0] == 'define-fun':
self.ori.bmDefineFun.append(expr)
# TODO: defining a function
assert len(self.ori.bmDefineFun) == 0
self._initialize_production()
Expr.productions = self.productions
self.ori.z3checker = translator.ReadQuery(self.ori.bmExpr)
self.ori.inputlist, self.ori.inputtylist, self.ori.inputmap = _get_inputlists(
self.ori.bmDeclvar)
self.ori.constraintlist = _get_constraintlist(self.ori.bmConstraint,
self.functionProto)
self.ori.constraint = _constraintlist2conjunction(
self.ori.constraintlist)
self.ori.vartab = _getvartab(self.ori.inputlist, self.ori.inputtylist)
self.ori.semchecker = SemChecker(self.functionProto,
self.ori.constraint,
self.ori.inputlist,
self.ori.inputtylist)
if instrument:
self.ins = TaskData()
self.ins.bmDefineFun = self.ori.bmDefineFun
self.ins.bmLogic = self.ori.bmLogic
self.ins.bmSyn = self.ori.bmSyn
self._initialize_instrument()
def getPossibleValue(Operators, Expr, Terminals):
SynFunExpr, VarTable, FunDefMap, Constraints = translator.ReadQuery(Expr)
returnType = SynFunExpr[3]
functionCallDic = {}
ReplacedConsInfo = []
for i in range(len(Constraints)):
ReplacedConsInfo.append(
replaceFunctionCall(Constraints[i], functionCallDic, SynFunExpr[1],
SynFunExpr[3], VarTable))
ReplacedConsSet = getConsSet(ReplacedConsInfo)
# pprint.pprint(ReplacedConsSet)
resultSet = []
argVarTable = {}
for arg in SynFunExpr[2]:
declareVar(arg[1], arg[0], argVarTable)
Samples = []
sampleNum = 30
for _ in range(sampleNum):
sample = {}
for arg in SynFunExpr[2]:
value = False
if arg[1] == 'Bool':
value = random.randint(0, 1) == 0
else:
value = random.randint(0, 100)
sample[arg[0]] = value
Samples.append(sample)
Value = ValueSet(argVarTable, Samples, Operators)
if returnType == 'Bool':
resultSet = ['true', 'false']
else:
depth = 0
argVarTable["__result"] = Int("__result")
for terminal in Terminals['Int']:
Value.addNewValue(terminal, depth)
#print(Value)
while True:
resultSet += Value.get(depth)
#print(resultSet)
if isValueSetFull(resultSet, functionCallDic, SynFunExpr[2],
VarTable, ReplacedConsSet):
break
depth += 1
resultSet = simplifyResultSet(resultSet, [], functionCallDic,
SynFunExpr[2], VarTable, ReplacedConsSet)
return resultSet, Value
def _initialize_instrument(self):
cnf = buildCNF(self.ori.constraint, self.ori.vartab,
self.functionProto)
cnfsuffix = _instrument_add_suffix(cnf, self.ori.inputmap)
cnfconstrains = getCNFclause(cnfsuffix)
if not all(map(_check_single_call, cnfconstrains)):
self.ins = self.ori
return
constraintlist, eqmaplist = zip(*list(
map(lambda x: _instrument_constraint(x, self.functionProto),
cnfconstrains)))
self.ins.constraintlist = _merge_eqclass(constraintlist, eqmaplist)
self.ins.constraint = _assembly_clauses_with('and',
self.ins.constraintlist)
self.ins.inputlist, self.ins.inputtylist, self.ins.inputmap = \
_get_instrumented_varlist(self.ins.constraint, self.functionProto)
self.ins.bmDeclvar = []
for m in self.ins.inputmap:
self.ins.bmDeclvar.append(['declare-var', m, self.ins.inputmap[m]])
self.ins.bmConstraint = []
for c in self.ins.constraintlist:
self.ins.bmConstraint.append(['constraint', exprToList(c)])
self.ins.bmExpr = \
[self.ins.bmLogic] + \
self.ins.bmDeclvar + \
self.ins.bmDefineFun + \
[self.ins.bmSyn] + \
self.ins.bmConstraint + \
[self.ins.bmEnd]
self.ins.z3checker = translator.ReadQuery(self.ins.bmExpr)
self.ins.vartab = _getvartab(self.ins.inputlist, self.ins.inputtylist)
self.ins.semchecker = SemChecker(self.functionProto,
self.ins.constraint,
self.ins.inputlist,
self.ins.inputtylist)
i = 1
def stripComments(bmFile):
noComments = '('
for line in bmFile:
line = line.split(';', 1)[0]
noComments += line
return noComments + ')'
if __name__ == '__main__':
benchmarkFile = open(sys.argv[1])
bm = stripComments(benchmarkFile)
# Parse string to python list
bmExpr = sexp.sexp.parseString(bm, parseAll=True).asList()[0]
# pprint.pprint(bmExpr)
checker = translator.ReadQuery(bmExpr)
SynFunExpr = []
StartSym = 'My-Start-Symbol' #virtual starting symbol
for expr in bmExpr:
if len(expr)==0:
continue
elif expr[0]=='synth-fun':
SynFunExpr=expr
print("Function to Synthesize: ", SynFunExpr)
FuncDefine = ['define-fun']+SynFunExpr[1:4] #copy function signature
FuncDefineStr = translator.toString(FuncDefine,ForceBracket = True)
# use Force Bracket = True on function definition. MAGIC CODE. DO NOT MODIFY THE ARGUMENT ForceBracket = True.
#print(FuncDefine)
BfsQueue = [[StartSym]] #Top-down
Productions = {StartSym:[]}
Type = {StartSym:SynFunExpr[3]} # set starting symbol's return type
def getTermCondition(Expr, TermInfo, currentTerm, RemainTerms, ConsTable,
VarTable):
SynFunExpr, VarTable, FunDefMap, Constraints = translator.ReadQuery(Expr)
inputVarTable = VarTable.copy()
functionCallDic = {}
ReplacedConsInfo = []
for i in range(len(Constraints)):
ReplacedConsInfo.append(
replaceFunctionCall(Constraints[i], functionCallDic, SynFunExpr[1],
SynFunExpr[3], VarTable))
ReplacedConsSet = getConsSet(ReplacedConsInfo)
assert len(ReplacedConsSet) == 1 and len(ReplacedConsSet[0][0]) == 1
ReplacedCons = ReplacedConsSet[0][1]
# print(functionCallDic)
functionCallVar = None
functionArgs = None
for functionCallId in functionCallDic:
functionCallVar, functionArgs = functionCallDic[functionCallId]
# print(functionCallVar, functionArgs)
exampleGenerator = Solver()
checkSolver = Solver()
for condition, term in TermInfo:
spec = "(assert (not %s))" % (translator.toString(
replaceArgs(condition, SynFunExpr[2], functionArgs)))
spec = parse_smt2_string(spec, decls=VarTable)
exampleGenerator.add(spec)
checkSolver.add(spec)
for term in RemainTerms:
spec = "(assert (not (= %s %s)))" % (
str(functionCallVar),
translator.toString(replaceArgs(term, SynFunExpr[2],
functionArgs)))
# print(spec)
exampleGenerator.add(parse_smt2_string(spec, decls=VarTable))
spec = "(assert (= %s %s))" % (str(functionCallVar),
translator.toString(
replaceArgs(currentTerm, SynFunExpr[2],
functionArgs)))
spec = parse_smt2_string(spec, decls=VarTable)
exampleGenerator.add(spec)
checkSolver.add(spec)
spec = "\n".join(
list(
map(lambda x: "(assert %s)" % (translator.toString(x[1:])),
ReplacedCons)))
spec = parse_smt2_string(spec, decls=VarTable)
exampleGenerator.add(spec)
checkSolver.add(Not(And(spec)))
# print(checkSolver)
depth = 0
result = []
qualityConsNum = 3
inputVars = []
for var in inputVarTable:
inputVars.append(inputVarTable[var])
Examples = []
currentCondition = []
while True:
exampleGenerator.push()
if len(currentCondition) > 0:
spec = "(assert (not %s))" % (translator.toString(
replaceArgs(currentCondition, SynFunExpr[2], functionArgs)))
exampleGenerator.add(parse_smt2_string(spec, decls=VarTable))
exampleResult = exampleGenerator.check()
if exampleResult == unsat:
break
exampleGenerator.push()
for __ in range(1, qualityConsNum):
lVar = inputVars[random.randint(0, len(inputVars) - 1)]
rVar = inputVars[random.randint(0, len(inputVars) - 1)]
exampleGenerator.push()
exampleGenerator.add(lVar > rVar + 5)
if exampleGenerator.check() == sat:
exampleGenerator.pop()
exampleGenerator.add(lVar > rVar + 5)
else:
exampleGenerator.pop()
exampleGenerator.check()
example = exampleGenerator.model()
exampleGenerator.pop()
exampleGenerator.pop()
Examples.append(example)
BestCons = None
isChange = False
while len(Examples) > 0:
suitableCons = ConsTable.filter(depth, Examples)
if checkValid(checkSolver, suitableCons, VarTable, SynFunExpr[2],
functionArgs):
BestCons = suitableCons
break
Examples = Examples[1:]
isChange = True
if isChange and len(currentCondition) > 0:
if len(result) == 0:
result = currentCondition
else:
result = ["or", result, currentCondition]
spec = "(assert (not %s))" % (translator.toString(
replaceArgs(currentCondition, SynFunExpr[2], functionArgs)))
exampleGenerator.add(parse_smt2_string(spec, decls=VarTable))
currentCondition = []
# input()
# print(Examples)
if BestCons is None:
depth += 1
continue
reducedCondition = reduceCons(checkSolver, BestCons, [], VarTable,
SynFunExpr[2], functionArgs, True)
currentCondition = reformatListCons(reducedCondition)
if len(currentCondition) == 0:
return []
if len(result) == 0:
result = currentCondition
else:
result = ["or", result, currentCondition]
return result
NTType = NonTerm[1]
assert NTType in ['Int', 'Bool']
if NTType == Type[StartSym]:
Productions[StartSym].append(NTName)
Type[NTName] = NTType
# Productions[NTName] = NonTerm[2]
Productions[NTName] = []
for NT in NonTerm[2]:
if type(NT) == tuple:
Productions[NTName].append(
str(NT[1])
) # deal with ('Int',0). You can also utilize type information, but you will suffer from these tuples.
else:
Productions[NTName].append(NT)
SynFunExpr, VarTable, _, Constraints, checker = translator.ReadQuery(
bmExpr, True)
previousSynFunExpr, _, _, previousConstraints = translator.ReadQuery(
task.ori.bmExpr)
for NonTerm in SynFunExpr[4]:
for NT in NonTerm[2]:
current = NT
if type(NT) == tuple:
current = str(NT[1])
if type(current) == str:
if current not in Type and current not in Terminals[
NonTerm[1]]:
Terminals[NonTerm[1]].append(current)
Operators = []
for operatorType in defaultOperators:
def trySolve(Terminals, Operators, ReturnType, bmExpr):
# print(Operators)
InputVar = []
OutputVar = []
OperatorTypeVar = []
TypeNumber = {'Bool': 0, 'Int': 0}
MidNumber = max(len(Terminals['Bool']), len(Terminals['Int']))
StartNumber = MidNumber
SynFunExpr, VarTable, FunDefMap, Constraints = translator.ReadQuery(bmExpr)
inputVars = list(VarTable.keys())
inputVarTable = VarTable.copy()
qualityCons = []
for i in range(len(inputVars)):
x = VarTable[inputVars[i]]
qualityCons.append(x > 4)
for j in range(len(inputVars)):
if i != j:
y = VarTable[inputVars[j]]
qualityCons.append(x > y + 4)
random.shuffle(qualityCons)
for operator in Operators:
outputType = operator[1]
OutputVar.append(
declareVar('Int', getId(outputType, TypeNumber[outputType]),
VarTable))
TypeNumber[outputType] += 1
MidNumber += 1
currentInputVar = []
for arg in operator[2:]:
if type(arg) == list:
inputType = arg[0]
currentInputVar.append(
declareVar('Int', getId(inputType, TypeNumber[inputType]),
VarTable))
TypeNumber[inputType] += 1
InputVar.append(currentInputVar)
resultVar = declareVar('Int', getId(ReturnType, TypeNumber[ReturnType]),
VarTable)
TypeNumber[ReturnType] += 1
s1 = Solver()
s2 = Solver()
s3 = Solver()
functionCallDic = {}
ReplacedCons = []
for i in range(len(Constraints)):
ReplacedCons.append(
replaceFunctionCall(Constraints[i], functionCallDic, SynFunExpr[1],
SynFunExpr[3], VarTable))
spec = "\n".join(
list(
map(lambda x: "(assert %s)" % translator.toString(x[1:]),
ReplacedCons)))
spec = parse_smt2_string(spec, decls=VarTable)
s1.add(spec)
inputQualityCons = []
for constraint in qualityCons:
inputQualityCons.append(constraint)
s1.push()
s1.add(And(inputQualityCons))
currentRes = s1.check()
s1.pop()
if currentRes == unsat:
inputQualityCons = inputQualityCons[:-1]
s1.push()
s1.add(inputQualityCons)
s1.check()
currentModel = s1.model()
s1.pop()
Models = []
s1 = Solver()
ArgumentDict = {}
# print(Terminals)
argId = -1
for arg in SynFunExpr[2]:
argId += 1
ArgumentDict[arg[0]] = argId
SimplifyOption = False
for operator in Operators:
if '+' or '-' in operator[0] and "0" in Terminals['Int']:
SimplifyOption = True
if '*' or '/' or 'div' in operator[0] and "1" in Terminals['Int']:
SimplifyOption = True
for i in range(len(Operators)):
OperatorTypeVar.append(
declareVar('Int', getId("operatorType", i), VarTable))
outputVar = OutputVar[i]
operator = Operators[i]
operatorTypeVar = OperatorTypeVar[i]
s3.add(outputVar >= StartNumber)
s3.add(outputVar < MidNumber)
s3.add(operatorTypeVar >= 0)
s3.add(operatorTypeVar < len(operator[0]))
for inputVar in InputVar[i]:
s3.add(outputVar > inputVar)
if 'Bool' in str(inputVar):
currentInputType = 'Bool'
else:
currentInputType = 'Int'
if SimplifyOption and currentInputType == 'Int' and operator[
1] == 'Bool':
# print(operator)
currentCons = []
terminalId = -1
for terminal in Terminals['Int']:
terminalId += 1
try:
int(terminal)
except:
# print(terminal)
currentCons += [inputVar == terminalId]
else:
currentCons = [
And(inputVar >= 0,
inputVar < len(Terminals[currentInputType]))
]
for j in range(len(Operators)):
if Operators[j][1] == currentInputType:
currentCons.append(inputVar == OutputVar[j])
s3.add(Or(currentCons))
currentCons = []
for i in range(len(Operators)):
if Operators[i][1] == ReturnType:
currentCons.append(resultVar == OutputVar[i])
# print "fin ", currentCons
s3.add(Or(currentCons))
for i in range(len(Operators)):
for j in range(i + 1, len(Operators)):
s3.add(OutputVar[i] != OutputVar[j])
# print(Operators)
# print(Terminals)
# print(MidNumber)
# print len(Terminals['Int']), len(Terminals['Bool'])
# print(inputQualityCons)
# print(Models)
# print(Terminals)
while True:
s3.push()
callId = -1
for currentModel in Models:
newVarTable = VarTable.copy()
currentOuterCons = ReplacedCons.copy()
for functionCallName in functionCallDic:
returnValueVar, CurrentArguments = functionCallDic[
functionCallName]
InputValueVar = []
OutputValueVar = []
callId += 1
ValueTypeNumber = {
'Bool': len(Terminals['Bool']),
'Int': len(Terminals['Int'])
}
for i in range(len(Operators)):
operator = Operators[i]
outputType = operator[1]
outputValueVar = declareVar(
outputType,
getId(outputType + str(callId) + "-",
ValueTypeNumber[outputType]), newVarTable)
OutputValueVar.append(outputValueVar)
ValueTypeNumber[outputType] += 1
currentInputValue = []
operatorTypeVar = OperatorTypeVar[i]
InputValueVarTable = []
for arg in operator[2:]:
if type(arg) == list:
inputType = arg[0]
inputValueVar = declareVar(
inputType,
getId(inputType + str(callId) + "-",
ValueTypeNumber[inputType]), newVarTable)
InputValueVarTable.append(inputValueVar)
ValueTypeNumber[inputType] += 1
currentInputValue.append(inputValueVar)
# print(currentInputValue)
InputValueVar.append(currentInputValue)
for typeId in range(len(operator[0])):
currentCons = [operator[0][typeId]]
inputValueVarId = -1
for arg in operator[2:]:
if type(arg) == list:
inputValueVarId += 1
currentCons.append(
str(InputValueVarTable[inputValueVarId]))
else:
currentCons.append(arg)
currentCons = ["=", str(outputValueVar), currentCons]
currentCons = [
"=>", ["=", str(typeId),
str(operatorTypeVar)], currentCons
]
spec = '(assert %s)' % (
translator.toString(currentCons))
spec = parse_smt2_string(spec, decls=dict(newVarTable))
# print(spec[0])
s3.add(spec[0])
# print "CurrentArg: ", CurrentArguments
# print ArgumentDict
# print(InputValueVar)
for i in range(len(Operators)):
for j in range(len(InputVar[i])):
inputVar = InputVar[i][j]
inputValue = InputValueVar[i][j]
for k in range(len(Operators)):
if i == k: continue
outputVar = OutputVar[k]
outputValue = OutputValueVar[k]
outputType = Operators[k][1]
if outputType in str(inputVar):
s3.add(
Implies(outputVar == inputVar,
outputValue == inputValue))
if "Bool" in str(inputVar):
currentType = "Bool"
else:
currentType = "Int"
for k in range(len(Terminals[currentType])):
terminal = Terminals[currentType][k]
if terminal in ArgumentDict:
argId = ArgumentDict[terminal]
currentCons = [
"=>", ["=", str(inputVar),
str(k)],
[
"=", CurrentArguments[argId],
str(inputValue)
]
]
else:
currentCons = [
"=>", ["=", str(inputVar),
str(k)],
["=", terminal,
str(inputValue)]
]
currentCons = '(assert %s)' % (
translator.toString(currentCons))
currentCons = parse_smt2_string(
currentCons, decls=dict(newVarTable))
currentCons = currentModel.eval(currentCons[0])
s3.add(currentCons)
newReturnValueVar = declareVar(ReturnType,
getId("returnValueVar", callId),
newVarTable)
currentOuterCons = replaceCons(currentOuterCons,
str(returnValueVar),
str(newReturnValueVar))
for k in range(len(Operators)):
outputVar = OutputVar[k]
outputValue = OutputValueVar[k]
outputType = Operators[k][1]
if outputType == ReturnType:
s3.add(
Implies(resultVar == outputVar,
newReturnValueVar == outputValue))
spec = "\n".join(
list(
map(lambda x: "(assert %s)" % translator.toString(x[1:]),
currentOuterCons)))
spec = parse_smt2_string(spec, decls=newVarTable)
#print(spec)
spec = list(map(lambda x: currentModel.eval(x), spec))
#print(spec)
s3.add(spec)
#print "start"
#print(s3)
resS3 = s3.check()
# print(s3.unsat_core())
# print(resS3)
# print "end"
# print(resS3)
if resS3 == unsat:
return None
currentCodeModel = s3.model()
s3.pop()
OutputTable = {}
for i in range(len(Operators)):
outputId = currentCodeModel[OutputVar[i]].as_long()
OutputTable[outputId] = i
'''print("Now")
for i in range(len(Operators)):
print("")
print(Operators[i])
print(currentCodeModel[OutputVar[i]])
print(map(lambda x: currentCodeModel[x], InputVar[i]))'''
resultId = currentCodeModel[resultVar].as_long()
# print(currentCodeModel)
if resultId < len(Terminals[ReturnType]):
resultCode = Terminals[ReturnType][resultId]
else:
resultCode = getCode(OutputTable[resultId], currentCodeModel,
Operators, InputVar, OutputTable, Terminals,
OperatorTypeVar)
#print translator.toString(resultCode)
s2.push()
FuncDefineStr = '(define-fun'
for i in range(1, 4):
currentStr = translator.toString(SynFunExpr[i])
if i == 2 and len(SynFunExpr[i]) == 1:
currentStr = "(%s)" % (currentStr)
FuncDefineStr += " " + currentStr
FuncDefineStr += ")"
#print FuncDefineStr
fullResultCode = FuncDefineStr[:-1] + ' ' + translator.toString(
resultCode) + FuncDefineStr[-1]
spec_smt2 = [fullResultCode]
for constraint in Constraints:
spec_smt2.append('(assert %s)' %
(translator.toString(constraint[1:])))
spec_smt2 = '\n'.join(spec_smt2)
spec = parse_smt2_string(spec_smt2, decls=dict(VarTable))
# print "End"
s2.add(Not(And(spec)))
while True:
s2.push()
s2.add(And(inputQualityCons))
resS2 = s2.check()
if resS2 == unsat:
if len(inputQualityCons) == 0:
return fullResultCode
else:
s2.pop()
inputQualityCons = inputQualityCons[:-1]
continue
newInput = s2.model()
s2.pop()
break
s2.pop()
s1.push()
for var in inputVarTable:
newInputValue = newInput[inputVarTable[var]]
if newInputValue is not None:
s1.add(inputVarTable[var] == newInputValue)
s1.check()
newFullInput = s1.model()
s1.pop()
#print(newFullInput)
#print(fullResultCode)
#input()
Models.append(newFullInput)
return None
NTType = NonTerm[1]
assert NTType in ['Int', 'Bool']
if NTType == Type[StartSym]:
Productions[StartSym].append(NTName)
Type[NTName] = NTType
#Productions[NTName] = NonTerm[2]
Productions[NTName] = []
for NT in NonTerm[2]:
if type(NT) == tuple:
Productions[NTName].append(
str(NT[1])
) # deal with ('Int',0). You can also utilize type information, but you will suffer from these tuples.
else:
Productions[NTName].append(NT)
_, _, _, Constraints = translator.ReadQuery(bmExpr)
operatorTable = {}
for NonTerm in SynFunExpr[4]:
for NT in NonTerm[2]:
current = NT
if type(NT) == tuple:
current = str(NT[1])
if type(current) == str:
if current not in Type and current not in Terminals[
NonTerm[1]]:
Terminals[NonTerm[1]].append(current)
else:
operatorArgs = []
for i in NT[1:]:
if i in Type:
def trySolve(Terminals, Operators, ReturnType, bmExpr):
# print(Operators)
InputVar = []
OutputVar = []
TypeNumber = {'Bool': 0, 'Int': 0}
MidNumber = max(len(Terminals['Bool']), len(Terminals['Int']))
StartNumber = MidNumber
SynFunExpr, VarTable, FunDefMap, Constraints = translator.ReadQuery(bmExpr)
for operator in Operators:
outputType = operator[1]
OutputVar.append(declareVar('Int', getId(outputType, TypeNumber[outputType]), VarTable))
TypeNumber[outputType] += 1
MidNumber += 1
currentInputVar = []
for arg in operator[2:]:
if type(arg) == list:
inputType = arg[0]
currentInputVar.append(declareVar('Int', getId(inputType, TypeNumber[inputType]), VarTable))
TypeNumber[inputType] += 1
InputVar.append(currentInputVar)
resultVar = declareVar('Int', getId(ReturnType, TypeNumber[ReturnType]), VarTable)
TypeNumber[ReturnType] += 1
s1 = Solver()
s2 = Solver()
s3 = Solver()
functionCallDic = {}
ReplacedCons = []
for i in range(len(Constraints)):
ReplacedCons.append(replaceFunctionCall(Constraints[i], functionCallDic, SynFunExpr[1], SynFunExpr[3], VarTable))
spec = "\n".join(list(map(lambda x: "(assert %s)"%translator.toString(x[1:]), ReplacedCons)))
spec = parse_smt2_string(spec, decls=VarTable)
# print(spec)
s1.add(spec)
s1.check()
currentModel = s1.model()
Models = [currentModel]
s1VarTable = VarTable.copy()
ArgumentDict = {}
# print(Terminals)
argId = -1
for arg in SynFunExpr[2]:
argId += 1
ArgumentDict[arg[0]] = argId
for i in range(len(Operators)):
outputVar = OutputVar[i]
operator = Operators[i]
s3.add(outputVar >= StartNumber)
s3.add(outputVar < MidNumber)
for inputVar in InputVar[i]:
s3.add(outputVar > inputVar)
if 'Bool' in str(inputVar):
currentInputType = 'Bool'
else:
currentInputType = 'Int'
currentCons = [And(inputVar >= 0, inputVar < len(Terminals[currentInputType]))]
for j in range(len(Operators)):
if Operators[j][1] == currentInputType:
currentCons.append(inputVar == OutputVar[j])
s3.add(Or(currentCons))
currentCons = []
for i in range(len(Operators)):
if Operators[i][1] == ReturnType:
currentCons.append(resultVar == OutputVar[i])
# print "fin ", currentCons
s3.add(Or(currentCons))
for i in range(len(Operators)):
for j in range(i+1, len(Operators)):
s3.add(OutputVar[i] != OutputVar[j])
# print(Operators)
# print(Terminals)
# print(MidNumber)
# print len(Terminals['Int']), len(Terminals['Bool'])
while True:
s3.push()
callId = -1
for currentModel in Models:
for functionCallName in functionCallDic:
newVarTable = VarTable.copy()
returnValueVar, CurrentArguments = functionCallDic[functionCallName]
InputValueVar = []
OutputValueVar = []
callId += 1
ValueTypeNumber = {'Bool': len(Terminals['Bool']), 'Int': len(Terminals['Int'])}
for operator in Operators:
outputType = operator[1]
outputValueVar = declareVar(outputType,
getId(outputType + str(callId) + "-", ValueTypeNumber[outputType]),
newVarTable)
OutputValueVar.append(outputValueVar)
ValueTypeNumber[outputType] += 1
currentInputValue = []
currentCons = [operator[0]]
for arg in operator[2:]:
if type(arg) == list:
inputType = arg[0]
inputValueVar = declareVar(inputType,
getId(inputType + str(callId) + "-", ValueTypeNumber[inputType]),
newVarTable)
ValueTypeNumber[inputType] += 1
currentInputValue.append(inputValueVar)
currentCons.append(str(inputValueVar))
else:
currentCons.append(arg)
InputValueVar.append(currentInputValue)
currentCons = ["=", str(outputValueVar), currentCons]
spec = '(assert %s)' % (translator.toString(currentCons))
spec = parse_smt2_string(spec, decls=dict(newVarTable))
# print(spec[0])
s3.add(spec[0])
# print "CurrentArg: ", CurrentArguments
# print ArgumentDict
for i in range(len(Operators)):
for j in range(len(InputVar[i])):
inputVar = InputVar[i][j]
inputValue = InputValueVar[i][j]
for k in range(len(Operators)):
if i == k: continue
outputVar = OutputVar[k]
outputValue = OutputValueVar[k]
outputType = Operators[k][1]
if outputType in str(inputVar):
s3.add(Implies(outputVar == inputVar, outputValue == inputValue))
if "Bool" in str(inputVar):
currentType = "Bool"
else:
currentType = "Int"
for k in range(len(Terminals[currentType])):
terminal = Terminals[currentType][k]
if terminal in ArgumentDict:
argId = ArgumentDict[terminal]
currentCons = ["=>", ["=", str(inputVar), str(k)],
["=", CurrentArguments[argId], str(inputValue)]]
else:
currentCons = ["=>", ["=", str(inputVar), str(k)], ["=", terminal, str(inputValue)]]
currentCons = '(assert %s)' % (translator.toString(currentCons))
currentCons = parse_smt2_string(currentCons, decls=dict(newVarTable))
currentCons = currentModel.eval(currentCons[0])
s3.add(currentCons)
for k in range(len(Operators)):
outputVar = OutputVar[k]
outputValue = OutputValueVar[k]
outputType = Operators[k][1]
if outputType == ReturnType:
# print Implies(resultVar == outputVar, currentModel.eval(returnValueVar) == outputValue)
s3.add(Implies(resultVar == outputVar, currentModel.eval(returnValueVar) == outputValue))
#print "start"
resS3 = s3.check()
# print "end"
# print resS3
if resS3 == unsat:
return None
currentCodeModel = s3.model()
s3.pop()
OutputTable = {}
for i in range(len(Operators)):
outputId = currentCodeModel[OutputVar[i]].as_long()
OutputTable[outputId] = i
'''print("Now")
for i in range(len(Operators)):
print("")
print(Operators[i])
print(currentCodeModel[OutputVar[i]])
print(map(lambda x: currentCodeModel[x], InputVar[i]))'''
resultId = currentCodeModel[resultVar].as_long()
# print(currentCodeModel)
if resultId < len(Terminals[ReturnType]):
resultCode = Terminals[ReturnType][resultId]
else:
resultCode = getCode(OutputTable[resultId], currentCodeModel, Operators, InputVar, OutputTable, Terminals)
#print translator.toString(resultCode)
s2.push()
FuncDefineStr = '(define-fun'
for i in range(1, 4):
currentStr = translator.toString(SynFunExpr[i])
if i == 2 and len(SynFunExpr[i]) == 1:
currentStr = "(%s)"%(currentStr)
FuncDefineStr += " " + currentStr
FuncDefineStr += ")"
#print FuncDefineStr
fullResultCode = FuncDefineStr[:-1] + ' ' + translator.toString(resultCode) + FuncDefineStr[-1]
spec_smt2=[fullResultCode]
for constraint in Constraints:
spec_smt2.append('(assert %s)'%(translator.toString(constraint[1:])))
spec_smt2='\n'.join(spec_smt2)
# print(spec_smt2)
# print spec_smt2
# print VarTable
spec = parse_smt2_string(spec_smt2, decls=dict(VarTable))
# print "End"
s2.add(Not(And(spec)))
resS2 = s2.check()
if resS2 == unsat:
return fullResultCode
newInput = s2.model()
s2.pop()
s1.push()
for var in s1VarTable:
newInputValue = newInput[s1VarTable[var]]
if newInputValue is not None:
s1.add(s1VarTable[var] == newInputValue)
s1.check()
newFullInput = s1.model()
s1.pop()
# print(newFullInput)
# print(fullResultCode)
# raw_input()
Models.append(newFullInput)
return None
noComments += line
return noComments + ')'
if __name__ == '__main__':
TE_set = set()
begin_t = time.time()
file_name = 'open_tests/' + default_file
if (len(sys.argv) > 1):
file_name = sys.argv[1]
benchmarkFile = open(file_name)
bm = stripComments(benchmarkFile)
bmExpr = sexp.sexp.parseString(
bm, parseAll=True).asList()[0] # Parse string to python list
# pprint.pprint(bmExpr)
checker, is_ite_prior, is_cmp_prior, preCons = translator.ReadQuery(bmExpr)
# print (checker.check('(define-fun f ((x Int)) Int (mod (* x 3) 10) )'))
# raw_input()
SynFunExpr = []
StartSym = 'My-Start-Symbol' # virtual starting symbol
for expr in bmExpr:
if len(expr) == 0:
continue
elif expr[0] == 'synth-fun':
SynFunExpr = expr
FuncDefine = ['define-fun'] + SynFunExpr[1:4] # copy function signature
FuncDefineStr = translator.toString(FuncDefine, ForceBracket=True)
# print(FuncDefine)
BfsQueue = [[StartSym]] # Top-down
Productions = {StartSym: []}
Type = {StartSym: SynFunExpr[3]} # set starting symbol's return type