pop(insert(l,x,idx),idx) = x
pop_last(l) = pop(l,len(idx)-1)
append(l,x) = insert(l,x,len(idx)-1)
"""
import random
import os.path
from collections import Counter
import vu_common as CM
import config as CC
from term import IncompatTyp, Term, Fun
from eqfun import EqFun
from alg_lang import Python, Java
logger = CM.VLog(os.path.basename(__file__))
logger.level = CC.logger_level
CM.VLog.PRINT_TIME = False
class Infer(object):
clses = {Python.__name__.lower(): Python, Java.__name__.lower(): Java}
def __init__(self, terms):
assert all(isinstance(t, Term) for t in terms)
self.terms = terms
@classmethod
def prune(cls, axioms, pure_imply=True):
"""
Return strongest axioms not implied by others
import abc
from collections import OrderedDict, MutableSet, MutableMapping
import collections
import itertools
import os.path
import sage.all
import vu_common as CM
from sageutil import is_sage_expr
import settings
logger = CM.VLog('alg')
logger.level = settings.logger_level
import miscs
from cpa import RT #Reachability Tool
from solver import EqtSolver, RangeSolver, OctSolver, IeqSolver
### Classes ###
class MySet(MutableSet):
__metaclass__ = abc.ABCMeta
def __init__(self):
self.__set__ = set()
def __len__(self):
return len(self.__set__)
def __iter__(self):
return iter(self.__set__)
import os.path
import itertools
from collections import OrderedDict
import collections
import os
import subprocess as sp
import shutil
from math import factorial
import sage.all
import random
import operator
import vu_common as CM
import sageutil
logger = CM.VLog('dig2')
logger.level = 0
class Miscs(object):
@staticmethod
def elimDenom(p):
"""
Eliminate (Integer) denominators in expression operands.
Will not eliminate if denominators is a var (e.g., (3*x)/(y+2)).
Examples:
sage: var('x y z')
(x, y, z)
import os
from collections import OrderedDict
import sage.all
from klee import KLEE
import vu_common as CM
import settings
logger = CM.VLog('src')
logger.level = settings.logger_level
stripTo = lambda s, to_s: s[s.find(to_s) + 1:].strip() #e.g., ...:x -> x
class Src(object):
def __init__(self, filename):
assert os.path.isfile(filename), filename
self.filename = filename
def parse(self):
return self._parse(self.filename)
def instrPrintfs(self, invdecls):
assert isinstance(invdecls, dict) and invdecls, invdecls
return self.instr(self.filename, ".printf.c", invdecls, self.mkPrintfs)
def instrAsserts(self, invs, inps, inpsd, invdecls, startFun="mainQ"):
assert isinstance(invs, dict), invs
assert (inpsd is None
or (isinstance(inpsd, OrderedDict) and inpsd)), inpsd
assert isinstance(invdecls, OrderedDict) and invdecls, invdecls
assert inps is None or (isinstance(inps, set) and inps), inps
import random
import itertools
import sage.all
from sage.all import cached_function
import vu_common as CM
import sageutil
import settings
logger = CM.VLog('miscs')
logger.level = settings.logger_level
logger.printtime = settings.logger_printtime
class Miscs(object):
@cached_function
def ratOfStr(s):
"""
Convert the input 's' to a rational number if possible.
Otherwise returns None
Examples:
sage: assert ratOfStr('.3333333') == 3333333/10000000
sage: assert ratOfStr('3/7') == 3/7
sage: assert ratOfStr('1.') == 1
sage: assert ratOfStr('1.2') == 6/5
sage: assert ratOfStr('.333') == 333/1000
sage: assert ratOfStr('-.333') == -333/1000
sage: assert ratOfStr('-12.13') == -1213/100
"""
Given as input a Klee src file, returns a set of inputs [[v1,...], [v3,..]]
that hit the desired locations
"""
import os
import subprocess as sp
import shutil
import vu_common as CM
import settings
logger = CM.VLog('klee')
logger.level = settings.logger_level
logger.printtime = settings.logger_printtime
# if settings.logger_level > 0:
# logger.level = settings.logger_level - 1
# else:
# logger.level = settings.logger_level
class KLEE(object):
cexStr = "counterexample"
haltStr = "halting execution, dumping remaining states"
failedStr = "failed."
def __init__(self, filename, tmpdir):
assert os.path.isfile(filename)
assert os.path.isdir(tmpdir)
aparser.add_argument("--maxterm", "-maxterm",
type=int,
default=None,
help="autodegree")
aparser.add_argument("--noeqts", "-noeqts",
action="store_true")
aparser.add_argument("--noieqs", "-noieqs",
action="store_true")
from time import time
args = aparser.parse_args()
import settings
settings.logger_level = args.logger_level
settings.logger_printTime = args.printTime
logger = CM.VLog("dig2")
logger.level = settings.logger_level
logger.PRINT_TIME = settings.logger_printTime
if __debug__: logger.warn("DEBUG MODE ON. Can be slow !")
seed = round(time(), 2) if args.seed is None else float(args.seed)
import alg
st = time()
dig2 = alg.DIG2(args.inp)
invs = dig2.start(seed=seed, maxdeg=args.maxdeg, maxterm=args.maxterm,
doEqts=not args.noeqts, doIeqs=not args.noieqs)
logger.info("time {}s".format(time() - st))
"""
Given as input a Klee src file, returns a set of inputs [[v1,...], [v3,..]]
that hit the desired locations
"""
import os
import subprocess as sp
import shutil
import vu_common as CM
import settings
logger = CM.VLog('cpa')
logger.level = settings.logger_level
class RT(object):
assume_f = "__VERIFIER_assume"
error_f = "ERROR: __VERIFIER_error();"
cexStr = "counterexample"
def __init__(self, filename, maxtime, tmpdir):
assert os.path.isfile(filename)
assert os.path.isdir(tmpdir)
self.filename = CM.getpath(filename)
import tempfile
self.tmpdir = tmpdir
self.maxtime = maxtime
logger.detail("running CPA on {}, tmpdir {}".format(
self.filename, self.tmpdir))
import sage.all
from sage.all import cached_function
import vu_common as CM
from sageutil import is_sage_expr, get_vars
from miscs import Miscs
import settings
logger = CM.VLog('ds')
logger.level = settings.logger_level
logger.printtime = settings.logger_printtime
"""
Data structures
"""
class Inp(tuple):
pass
class Inps(set):
def __init__(self, myset=set()):
super(Inps, self).__init__(myset)
def __contains__(self, inp):
assert isinstance(inp, Inp), inp
return super(Inps, self).__contains__(inp)
def add(self, inp):
assert isinstance(inp, Inp), inp
return super(Inps, self).add(inp)
import os.path
from collections import OrderedDict
import time
import vu_common as CM
from miscs import Miscs
from klee import KLEE
import settings
logger = CM.VLog('prover')
logger.level = settings.logger_level
logger.printtime = settings.logger_printtime
from ds import Inp, Inps, DTraces, Inv, DInvs, Invs
from src import Src
def merge(ds):
newD = {}
for d in ds:
for loc in d:
assert d[loc]
if loc not in newD: newD[loc] = {}
for inv in d[loc]:
assert d[loc][inv]
if inv not in newD[loc]: newD[loc][inv] = set()
for e in d[loc][inv]:
newD[loc][inv].add(e)
return newD
class Prover(object):
import abc
from collections import OrderedDict, MutableSet, MutableMapping
import collections
import itertools
import random
import os.path
import sage.all
import vu_common as CM
import sageutil
import settings
logger = CM.VLog('solver')
logger.level = settings.logger_level
import miscs
#Exceptions
class NotEnoughTraces(Exception):
pass
class SameInsts(Exception):
pass
isIterator = lambda it: isinstance(it, collections.Iterator)
def getTermsFixedCoefs(ss, subsetSiz):
"""
"""
Given as input a Klee src file, returns a set of inputs [[v1,...], [v3,..]]
that hit the desired locations
"""
import os
import subprocess as sp
import shutil
import vu_common as CM
import settings
logger = CM.VLog('cp')
logger.level = settings.logger_level
class CPA(object):
cexStr = "counterexample"
haltStr = "halting execution, dumping remaining states"
failedStr = "failed."
def __init__(self, filename, tmpdir):
assert os.path.isfile(filename)
assert os.path.isdir(tmpdir)
self.filename = CM.getpath(filename)
import tempfile
self.tmpdir = tmpdir
logger.detail("running KLEE on {}, tmpdir {}".format(
self.filename, self.tmpdir))
