#!/usr/bin/env python

############################

###Started on 12/11/2015

###########################

import sympy

import z3

import numpy as np

import scipy.optimize as op

import argparse

import sys, os

import time

import collections

import subprocess

import multiprocessing as mp

import warnings

import struct

import cPickle as pickle

DEBUG=False

def noop_min(fun, x0, args, **options):

return op.OptimizeResult(x=x0, fun=fun(x0), success=True, nfev=1)

def _get_template():

return template

class Sort:

Int='int'

def verify_solution(ez, X_star,symbolTable,printModel=False):

return _is_true(z3.simplify(z3.substitute(ez, *model)))

def _getSort(expr_z3):

return Sort. UNKNOWN

def var_name(expr_z3):

return "_t_"+str(expr_z3.get_id())

def replace_all(text, dic):

for i, j in dic.iteritems():

text = text.replace(i, j)

return text

def rename_var(var):

reps = {':':'_', '@':'_', '|':'_',"#":'_',"!":"_"}

return replace_all(var,reps)

def _gen(expr_z3,symbolTable,cache,result):

raise NotImplementedError ("Not implemented case 002 for expr_z3 = %s, kind(%s)" %(expr_z3,expr_z3.decl().kind()))

def _is_fpNeg(a):

return a.decl().kind()==z3.Z3_OP_FPA_NEG

def _is_fpDiv(a):

return a.decl().kind()==z3.Z3_OP_FPA_DIV

def _is_fpMul(a):

return a.decl().kind()==z3.Z3_OP_FPA_MUL

def _is_RNE(a):

return a.decl().kind()==z3.Z3_OP_FPA_RM_NEAREST_TIES_TO_EVEN

def _is_fpAdd(a):

return a.decl().kind()==z3.Z3_OP_FPA_ADD

def _is_lt(a):

return a.decl().kind()==z3.Z3_OP_LT or a.decl().kind()==z3.Z3_OP_FPA_LT

def _is_le(a):

return a.decl().kind()==z3.Z3_OP_LE or a.decl().kind()==z3.Z3_OP_FPA_LE

def _is_ge(a):

return a.decl().kind()==z3.Z3_OP_GE or a.decl().kind()==z3.Z3_OP_FPA_GE

def _is_eq(a):

return a.decl().kind()==z3.Z3_OP_EQ or a.decl().kind()==z3.Z3_OP_FPA_EQ

def _is_distinct(a):

return a.decl().kind()==z3.Z3_OP_DISTINCT # no FPA_DISTINCT

def _is_gt(a):

return a.decl().kind()==z3.Z3_OP_GT or a.decl().kind()==z3.Z3_OP_FPA_GT

def _dist_le(lhs,rhs):

assert (isinstance(lhs, sympy.Expr) and isinstance(rhs,sympy.Expr))

return sympy.Piecewise( (lhs - rhs,lhs > rhs), (0,True))

def _dist_lt(lhs,rhs):

assert (isinstance(lhs, sympy.Expr) and isinstance(rhs,sympy.Expr))

return _dist_le(lhs+_theta(), rhs)

def _dist_ge(lhs,rhs):

assert (isinstance(lhs, sympy.Expr) and isinstance(rhs,sympy.Expr))

return _dist_le(rhs,lhs)

def _dist_gt(lhs,rhs):

assert (isinstance(lhs, sympy.Expr) and isinstance(rhs,sympy.Expr))

return _dist_lt(rhs,lhs)

def _is_true(a):

return a.decl().kind()==z3.Z3_OP_TRUE

def _is_false(a):

return a.decl().kind()==z3.Z3_OP_FALSE

def _dist_eq(lhs,rhs):

assert (isinstance(lhs, sympy.Expr) and isinstance(rhs,sympy.Expr))

return sympy.Abs(lhs-rhs)

def _dist_distinct(lhs,rhs):

assert (isinstance(lhs, sympy.Expr) and isinstance(rhs,sympy.Expr))

return sympy.Piecewise( (_theta(),sympy.Eq(lhs,rhs)), (0,True))

def _is_fpFP(a):

return a.decl().kind() == z3.Z3_OP_FPA_TO_FP

def _is_variable(a):

return z3.is_const(a) and a.decl().kind() == z3.Z3_OP_UNINTERPRETED

def _is_value(a):

return z3.is_const(a) and a.decl().kind() != z3.Z3_OP_UNINTERPRETED

def gen(expr_z3):

return symbolTable, _get_template() %{"x_vars":x_vars,"x_types":x_types,"x_refs":x_refs,"x_expr":x_expr,"x_dim":x_dim, "x_body":x_body}

def _print_xsatInfo():

print "*"*50

if __name__ == "__main__":

parser = argparse.ArgumentParser(prog='XSat')

parser.add_argument('smt2_file', help='specify the smt2 file to analyze.',type=argparse.FileType('r'))

parser.add_argument('-v', '--version', action='version', version='%(prog) version 12/18/2015')

parser.add_argument ('--niter', help='niter in basinhopping', action='store', type=int, required=False,default=100)

parser.add_argument ('--nStartOver', help='startOver times', action='store', type=int, required=False,default=2)

parser.add_argument('--method', help='Local minimization procedure', default='powell', choices=['powell', 'slsqp', 'cg', 'l-bfgs-b', 'cobyla','tnc', 'bfgs', 'nelder-mead','noop_min']

)

parser.add_argument ('--showTime', help='show the time-related info (default: false)', action='store_true', default=False)

parser.add_argument ('--showResult', help='show the basinhopping output (default:false)', action='store_true',default=False)

parser.add_argument ('--stepSize', help='parameter of basinhopping', type=float, default=10.0);

parser.add_argument ('--stepSize_round2', help='parameter of basinhopping', type=float, default=100.0);

parser.add_argument ('--verify', help='verify the model', action='store_true',default=False)

parser.add_argument ('--verify2', help='verify the model (method 2)', action='store_true',default=False)

parser.add_argument ('--showModel', help='show the model as a var->value mapping', action='store_true',default=False)

parser.add_argument ('--showSymbolTable', help='show the symbol table, var->type', action='store_true',default=False)

parser.add_argument ('--showConstraint', help='show the constraint, using the Z3 frontend', action='store_true',default=False)

parser.add_argument ('--showVariableNumber', help='show variable number, using the Z3 frontend', action='store_true',default=False)

parser.add_argument('--command_compilation', help='the command used to compile the generated foo.c to foo.so', default='gcc -O3 -fbracket-depth=2048 -fPIC -I /usr/local/Cellar/python/2.7.9/Frameworks/Python.framework/Versions/2.7/include/python2.7/ %(file)s.c -dynamiclib -o %(file)s.so -L /usr/local/Cellar/python/2.7.9/Frameworks/Python.framework/Versions/Current/lib/ -lpython2.7')

parser.add_argument ('--startPoint', help='start point in a single dimension', action='store',type=float,default=1.0);

parser.add_argument("--multi", help="multi-processing (default: false)",default=False,action='store_true')

parser.add_argument("--multiMessage", help="multi-processing message",default=False,action='store_true')

parser.add_argument("--round2", help="activate round2 when unsat (default: false)",default=False,action='store_true')

parser.add_argument("--niter_round2", help="niter for round2",action='store',type=int,required=False,default=100)

parser.add_argument("--suppressWarning", help="Suppress warnings",default=False,action='store_true')

if len(sys.argv[1:])==0:

_print_xsatInfo()

parser.print_help()

parser.exit()

args = parser.parse_args()

if args.suppressWarning:

warnings.filterwarnings("ignore")

try:

expr_z3=z3.simplify(z3.parse_smt2_string(args.smt2_file.read()))

except z3.Z3Exception:

sys.stderr.write("[Xsat] The Z3 fornt-end crashes.\n")

symbolTable, foo_dot_c=gen(expr_z3)

args.smt2_file.close()

#dump symbolTable for future verification step (in xsat.py)

pickle.dump(symbolTable, open("build/foo.symbolTable","wb"))

print foo_dot_c