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()
