import ivy_actions as act import ivy_utils as utl import ivy_logic_utils as lut import tk_ui as ui import ivy_logic as lg import ivy_utils as iu import ivy_module as im import ivy_alpha import ivy_art import ivy_interp import ivy_compiler import ivy_isolate import sys diagnose = iu.BooleanParameter("diagnose", False) def usage(): print "usage: \n {} file.ivy".format(sys.argv[0]) sys.exit(1) def check_module(): # If user specifies an isolate, check it. Else, if any isolates # are specificied in the file, check all, else check globally. isolate = ivy_compiler.isolate.get() with im.module.copy(): ivy_isolate.create_isolate(isolate) # ,ext='ext'
self.public_actions = set() self.initializers = [] # list of name,action pairs self.sig """ from collections import defaultdict from itertools import chain from ivy_printer import print_module from ivy_actions import (AssignAction, Sequence, ChoiceAction, AssumeAction, AssertAction, HavocAction, concat_actions) import logic as lg import ivy_logic_utils as ilu import ivy_utils as iu debug = iu.BooleanParameter("l2s_debug", False) def forall(vs, body): return lg.ForAll(vs, body) if len(vs) > 0 else body def l2s(mod, lf): # modify mod in place # module pass helper funciton def mod_pass(transform): mod.labeled_conjs = [transform(x) for x in mod.labeled_conjs] # TODO: what about axioms and properties? for a in mod.public_actions:
import ivy_art import ivy_interp import ivy_compiler import ivy_isolate import ivy_ast import ivy_theory as ith import ivy_transrel as itr import ivy_solver as islv import ivy_fragment as ifc import ivy_proof import ivy_trace import sys from collections import defaultdict diagnose = iu.BooleanParameter("diagnose", False) coverage = iu.BooleanParameter("coverage", True) checked_action = iu.Parameter("action", "") opt_trusted = iu.BooleanParameter("trusted", False) opt_mc = iu.BooleanParameter("mc", False) opt_trace = iu.BooleanParameter("trace", False) opt_separate = iu.BooleanParameter("separate", None) def display_cex(msg, ag): if diagnose.get(): import tk_ui as ui iu.set_parameters({'mode': 'induction'}) ui.ui_main_loop(ag) exit(1) raise iu.IvyError(None, msg)
import ivy_actions as act import ivy_utils as utl import ivy_logic_utils as lut import ivy_logic as lg import ivy_utils as iu import ivy_module as im import ivy_alpha import ivy_art import ivy_interp import ivy_compiler import ivy_isolate import ivy_ast import sys diagnose = iu.BooleanParameter("diagnose", False) coverage = iu.BooleanParameter("coverage", True) checked_action = iu.Parameter("action", "") opt_trusted = iu.BooleanParameter("trusted", False) def display_cex(msg, ag): if diagnose.get(): import tk_ui as ui iu.set_parameters({'mode': 'induction'}) ui.ui_main_loop(ag) exit(1) raise iu.IvyError(None, msg) def check_properties():
# information on why a property is false. class Counterexample(object): def __init__(self, clauses, state, conc, msg): self.clauses, self.state, self.msg, self.conc = clauses, state, msg, conc def __nonzero__(self): return False ######################################## # # option to abstract the initial state option_abs_init = iu.BooleanParameter("abs_init", False) ######################################## # # The class of ARG's class AnalysisGraph(object): def __init__(self, module=None, pvars=[], initializer=None): if module == None: module = im.module # use the current module if not specified self.domain = module self.states = [] self.transitions = [] # TODO: redundant, remove self.covering = [] self.pvars = pvars # TODO: remove this field
import ivy_dafny_compiler as dc import ivy_solver as slv import ivy_logic_utils as lu import string import ivy_ast import ivy_utils as iu import ivy_actions as ia import ivy_alpha import ivy_module as im import ivy_theory as ith import ivy_concept_space as ics from ivy_ast import ASTContext from collections import defaultdict import ivy_printer show_compiled = iu.BooleanParameter("show_compiled", False) cone_of_influence = iu.BooleanParameter("coi", True) filter_symbols = iu.BooleanParameter("filter_symbols", True) create_imports = iu.BooleanParameter("create_imports", False) enforce_axioms = iu.BooleanParameter("enforce_axioms", False) def lookup_action(ast, mod, name): if name not in mod.actions: raise iu.IvyError(ast, "action {} undefined".format(name)) return mod.actions[name] def add_mixins(mod, actname, action2,
import ivy_actions as act import ivy_utils as utl import ivy_logic_utils as lut import tk_ui as ui import ivy_logic as lg import ivy_utils as iu import ivy_module as im import ivy_alpha import ivy_art import ivy_interp import ivy_compiler import ivy_isolate import sys diagnose = iu.BooleanParameter("diagnose", False) coverage = iu.BooleanParameter("coverage", True) def display_cex(msg, ag): if diagnose.get(): ui.ui_main_loop(ag) exit(1) raise iu.IvyError(None, msg) def check_properties(): if itp.false_properties(): if diagnose.get(): print "Some properties failed." gui = ui.new_ui()
import ivy_logic import ivy_dafny_compiler as dc import ivy_solver as slv import ivy_logic_utils as lu import string import ivy_ast import ivy_utils as iu import ivy_actions as ia import ivy_alpha import ivy_module as im import ivy_theory as ith import ivy_concept_space as ics from ivy_ast import ASTContext from collections import defaultdict show_compiled = iu.BooleanParameter("show_compiled",False) def lookup_action(ast,mod,name): if name not in mod.actions: raise iu.IvyError(ast,"action {} undefined".format(name)) return mod.actions[name] def add_mixins(mod,actname,action2,assert_to_assume=lambda m:False,use_mixin=lambda:True,mod_mixin=lambda m:m): # TODO: mixins need to be in a fixed order assert hasattr(action2,'lineno'), action2 assert hasattr(action2,'formal_params'), action2 res = action2 for mixin in mod.mixins[actname]: mixin_name = mixin.args[0].relname action1 = lookup_action(mixin,mod,mixin_name) assert hasattr(action1,'lineno')
import ivy_utils as iu # <TODO> No such assumption as universe cannot be empty # <TODO> support for enumerated sort # <TODO> dictionary mapping Var to its assigned number # <TODO> action Clause for positive sample is different from Neg sample module = None featureset = [] numVarFS = { } # number of Variables(quant.) of each sort in feature set (invariant: equal to max number of quantified Var that could be present in CandInv) numVarInv = { } # number of variables of each sort in learned as well as previous invariant. Used for determining instance size candInv = true_clauses() coincide = false_clauses() silent = False # if True then silent the print statement in sat checker (ivy backend) enum = iu.BooleanParameter("enum", False) ''' :returns a tuple containing universe and pure state. pure state is again a tuple with 2nd element a clause repr that state ''' def sampleUtil(mod, preclause, fcs, actname): ''' a sample created by using z3 which satsfies preclauses and final condition(fcs) where transtion function is obtained from action corresponding to actname ''' action = mod.actions[actname] ag = ivy_art.AnalysisGraph() pre = itp.State() pre.clauses = preclause