def MemAcc(self, left, right):
primed = False
if TS.is_prime(left):
primed = True
left = TS.get_ref_var(left)
timed_symbol = lambda v: v if not primed else TS.get_prime(v)
memname = left.symbol_name()
allsymbols = list(get_env().formula_manager.get_all_symbols())
memsymbols = [(v.symbol_name(), timed_symbol(v)) for v in allsymbols \
if (not TS.is_prime(v)) and (not TS.is_timed(v)) and (v.symbol_name()[:len(memname)] == memname) \
and v.symbol_name() != memname]
memsymbols.sort()
memsize = len(memsymbols)
if memsize < 1:
Logger.error("Memory \"%s\" has size 1"%(memname))
if right.is_int_constant():
location = right.constant_value()
if location > memsize-1:
Logger.error("Out of bound access for memory \"%s\", size %d"%(memname, memsize))
return memsymbols[location][1]
else:
if not (right.is_symbol() and right.symbol_type().is_bv_type()):
Logger.error("Symbolic memory access requires Bitvector indexing")
width_idx = right.symbol_type().width
width_mem = min(memsize, width_idx)
return mem_access(right, [m[1] for m in memsymbols], width_idx)
def revise_abstract_clock(model, abstract_clock_list):
newmodel = {}
abs_clock = dict(abstract_clock_list)
length = 0
for var, value in model.items():
refvar = TS.get_ref_var(var)
time = TS.get_time(var)
if time > 0:
if refvar not in abs_clock:
newmodel[TS.get_timed(refvar, (time*2)-1)] = value
newmodel[TS.get_timed(refvar, (time*2))] = value
else:
newmodel[TS.get_timed(refvar, (time*2)-1)] = abs_clock[refvar][1]
if value == abs_clock[refvar][1]:
newmodel[TS.get_timed(refvar, (time*2))] = abs_clock[refvar][0]
else:
newmodel[TS.get_timed(refvar, (time*2))] = abs_clock[refvar][1]
if ((time*2)+1) > length:
length = ((time*2))
else:
if refvar not in abs_clock:
newmodel[TS.get_timed(refvar, 0)] = value
else:
newmodel[TS.get_timed(refvar, 0)] = abs_clock[refvar][0]
return (newmodel, length)
def extend_ts(ts, modifier):
affect_init = False
if ts.ftrans is None:
return (ts, [])
new_ftrans = {}
vars = []
for (assign, cond_assign_list) in ts.ftrans.items():
fv = get_free_variables(assign)
assert len(fv) == 1
var = fv.pop()
is_next = TS.has_next(var)
refvar = TS.get_ref_var(var)
nomvar = Symbol(NOMIN % refvar.symbol_name(), var.symbol_type())
fvar = Symbol(FAULT % refvar.symbol_name(), BOOL)
vars.append(nomvar)
vars.append(fvar)
repldic = dict([(refvar.symbol_name(), nomvar.symbol_name()), \
(TS.get_prime(refvar).symbol_name(), TS.get_prime(nomvar).symbol_name())])
# Remapping nominal behavior to new variable
new_ftrans[substitute(assign,
repldic)] = [(substitute(c[0], repldic),
substitute(c[1], repldic))
for c in cond_assign_list]
# Definition of the nominal behavior
new_ftrans[refvar] = [(Not(fvar), nomvar)]
# Application of the faulty behavior
new_ftrans[refvar].append(
(fvar, modifier.get_behavior(nomvar, refvar)))
ts.trans = And(ts.trans, Implies(fvar, TS.get_prime(fvar)))
if affect_init:
ts.init = substitute(ts.init, repldic)
else:
ts.init = And(ts.init, Not(fvar))
# add the vars to the transition system
for var in vars:
ts.add_var(var)
ts.ftrans = new_ftrans
return (ts, vars)
def walk_symbol(self, formula):
if TS.is_prime(formula):
self.write("next('%s')" % TS.get_ref_var(formula).symbol_name())
else:
self.write("'%s'" % formula.symbol_name())
def _free_variables(self, formula):
if formula not in self.fv_dict:
fv = get_free_variables(formula)
self.fv_dict[formula] = frozenset([TS.get_ref_var(v) for v in fv])
return self.fv_dict[formula]
