import ivy_graph_ui import ivy_alpha from ivy_art import AnalysisGraph, AnalysisSubgraph from ivy_graph_ui import GraphWidget import ivy_ui_util as uu import ivy_utils as iu # Following is a hint to center window. Needs more research. # from tkinter import * # app = Tk() # app.eval('tk::PlaceWindow %s center' % app.winfo_pathname(app.winfo_id()) ) modes = ["abstract","concrete","bounded","induction"] default_mode = iu.Parameter("mode","abstract",lambda s: s in modes) class AnalysisGraphUI(object): # This defines the menus items we provide. The actual menus might be # tool buttons or other such things. def menus(self): return [("menu","File", [("button","Save",self.save), ("button","Save abstraction",self.save_abstraction), ("separator",), ("button","Remove tab",lambda self=self: self.ui_parent.remove(self)), ("button","Exit", lambda self=self: self.ui_parent.exit()),]), ("menu","Mode", [("radiobuttons","mode",default_mode.get(),
theory.append(inst) # iu.dbg('inst') matched.add(term) return lu.Clauses(theory) def background_theory(symbols=None): return module.background_theory(symbols) def find_action(name): return module.actions.get(name, None) param_logic = iu.Parameter("complete", ','.join(il.default_logics), check=lambda ls: all(s in il.logics for s in ls.split(','))) def logics(): return param_logic.get().split(',') def drop_label(labeled_fmla): return labeled_fmla.formula if hasattr(labeled_fmla, 'formula') else labeled_fmla class ModuleTheoryContext(object): def __init__(self, instantiator): self.instantiator = instantiator
variables_distinct_ast, is_individual_ast, variables_distinct_list_ast, sym_placeholders, sym_inst, apps_ast,\ eq_atom, eq_lit, eqs_ast, TseitinContext, formula_to_clauses_tseitin,\ used_symbols_asts, symbols_asts, has_enumerated_sort, false_clauses, true_clauses, or_clauses, dual_formula, Clauses, and_clauses, substitute_constants_ast, rename_ast, bool_const, used_variables_ast, unfold_definitions_clauses, skolemize_formula from ivy_transrel import state_to_action,new, compose_updates, condition_update_on_fmla, hide, join_action,\ subst_action, null_update, exist_quant, hide_state, hide_state_map, constrain_state, bind_olds_action, old from ivy_utils import unzip_append, IvyError, IvyUndefined, distinct_obj_renaming, dbg import ivy_ast from ivy_ast import AST, compose_atoms, MixinAfterDef import ivy_module import ivy_utils as iu def p_c_a(s): a = s.split(':') return (a[0]+'.ivy',int(a[1])) checked_assert = iu.Parameter("assert","",check=lambda s: len(s.split(':'))==2, process=p_c_a) class Schema(AST): def __init__(self,defn,fresh): self.defn,self.fresh = defn,fresh self.args = [defn,fresh] self.instances = [] def __str__(self): res = repr(self.defn) if self.fresh: res += ' fresh ' + ','.join(repr(x) for x in self.fresh) return res def defines(self): return self.defn.defines() def get_instance(self,params,to_clauses=True): defn = self.defn
def native(self, native_def): self.mod.natives.append(compile_native_def(native_def)) def ivy_new(filename=None): # d = Interp() if filename: f = open(filename, 'r') if not f: raise IvyError(None, "not found: %s" % filename) ivy_load_file(f) ag = AnalysisGraph() return ag isolate = iu.Parameter("isolate") # collect actions in case of forward reference def collect_actions(decls): res = {} for d in decls: if d.name() == 'action': for a in d.args: res[a.defines()] = a.formal_returns return res def infer_parameters(decls): mixees = defaultdict(list) actdecls = dict()
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(): if itp.false_properties(): if diagnose.get():
import ivy_graph_ui import ivy_alpha from ivy_art import AnalysisGraph, AnalysisSubgraph from ivy_graph_ui import GraphWidget import ivy_ui_util as uu import ivy_utils as iu # Following is a hint to center window. Needs more research. # from tkinter import * # app = Tk() # app.eval('tk::PlaceWindow %s center' % app.winfo_pathname(app.winfo_id()) ) modes = ["abstract","concrete","bounded","induction"] default_mode = iu.Parameter("mode","abstract",lambda s: s in modes) class AnalysisGraphUI(object): # This defines the menus items we provide. The actual menus might be # tool buttons or other such things. def menus(self): return [("menu","File", [("button","Save",self.save), ("button","Save abstraction",self.save_abstraction), ("separator",), ("button","Remove tab",lambda self=self: self.ui_parent.remove(self)), ("button","Exit", lambda self=self: self.ui_parent.exit()),]), ("menu","Mode", [("radiobuttons","mode",default_mode.get(),
key=key) after = sorted( [m for m in mixins if isinstance(m, ivy_ast.MixinAfterDef)], key=key) # order = SortOrder(arcs) # before = sorted([m for m in mixins if isinstance(m,ivy_ast.MixinBeforeDef)],order) # after = sorted([m for m in mixins if isinstance(m,ivy_ast.MixinAfterDef)],order) before.reverse() # add the before mixins in reverse order mixins = implements + before + after # print 'mixin order for action {}:' # for m in mixins: # print m.args[0] mod.mixins[action] = mixins ext_action = iu.Parameter("ext", None) def hide_action_params(action): params = action.formal_params + action.formal_returns res = ia.LocalAction(*(params + [action])) return res def get_cone(mod, action_name, cone): if action_name not in cone: cone.add(action_name) for a in mod.actions[action_name].iter_calls(): get_cone(mod, a, cone)
# referenced ones, but we need to know abstract domain for # this for df in self.concepts: theory.append(df.to_constraint()) # TODO: make this a def? return lu.Clauses(theory) def add_to_hierarchy(self,name): if iu.ivy_compose_character in name: pref,suff = string.rsplit(name,iu.ivy_compose_character,1) self.add_to_hierarchy(pref) self.hierarchy[pref].add(suff) module = None def background_theory(symbols = None): return module.background_theory(symbols) def find_action(name): return module.actions.get(name,None) param_logic = iu.Parameter("complete","epr",check=lambda s: (s in il.logics)) def logic(): return param_logic.get()