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 parse_formulae(self, strforms):
formulae = []
if strforms is None:
return formulae
for strform in strforms:
if ("#" not in strform) and (strform != ""):
formula = self.parse_formula(strform)
formula_fv = get_free_variables(formula)
nextvars = [v for v in formula_fv if TS.is_prime(v)] != []
prevvars = [v for v in formula_fv if TS.is_prev(v)] != []
formulae.append((strform, formula, (nextvars, prevvars)))
return formulae
def parse_formulae(self, str_or_fnodes):
formulae = []
if str_or_fnodes is None:
return formulae
for s in str_or_fnodes:
if isinstance(s, str):
if ('#' in s) or len(s) == 0:
continue
formula = self.parse_formula(s)
else:
formula = s
formula_fv = get_free_variables(formula)
nextvars = [v for v in formula_fv if TS.is_prime(v)] != []
prevvars = [v for v in formula_fv if TS.is_prev(v)] != []
formulae.append((str(s), formula, (nextvars, prevvars)))
return formulae
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 generate_STS(self, lines):
ts = TS("Additional system")
init = TRUE()
trans = TRUE()
invar = TRUE()
states = {}
assigns = set([])
varsmap = {}
def def_var(name, vtype):
if name in varsmap:
return varsmap[name]
var = Symbol(name, vtype)
ts.add_state_var(var)
return var
for line in lines:
if line.comment:
continue
if line.init:
if T_I not in states:
states[T_I] = TRUE()
if line.init.varname != "":
(value, typev) = self.__get_value(line.init.value)
ivar = def_var(line.init.varname, typev)
state = EqualsOrIff(ivar, value)
else:
state = TRUE() if line.init.value == T_TRUE else FALSE()
states[T_I] = And(states[T_I], state)
# Optimization for the initial state assignment
init = And(init, state)
state = TRUE()
if line.state:
sname = T_S + line.state.id
if (line.state.varname != ""):
(value, typev) = self.__get_value(line.state.value)
ivar = def_var(line.state.varname, typev)
state = EqualsOrIff(ivar, value)
assval = (sname, line.state.varname)
if assval not in assigns:
assigns.add(assval)
else:
Logger.error(
"Double assignment for variable \"%s\" at state \"%s\""
% (line.state.varname, sname))
else:
state = TRUE() if line.state.value == T_TRUE else FALSE()
if sname not in states:
states[sname] = TRUE()
states[sname] = And(states[sname], state)
stateid_width = math.ceil(math.log(len(states)) / math.log(2))
stateid_var = Symbol(self.new_state_id(), BVType(stateid_width))
init = And(init, EqualsOrIff(stateid_var, BV(0, stateid_width)))
invar = And(
invar,
Implies(EqualsOrIff(stateid_var, BV(0, stateid_width)),
states[T_I]))
states[T_I] = EqualsOrIff(stateid_var, BV(0, stateid_width))
count = 1
state_items = list(states.keys())
state_items.sort()
for state in state_items:
if state == T_I:
continue
invar = And(
invar,
Implies(EqualsOrIff(stateid_var, BV(count, stateid_width)),
states[state]))
states[state] = EqualsOrIff(stateid_var, BV(count, stateid_width))
count += 1
transdic = {}
for line in lines:
if line.comment:
continue
if line.trans:
if states[line.trans.start] not in transdic:
transdic[states[line.trans.start]] = []
transdic[states[line.trans.start]].append(
states[line.trans.end])
for transition in transdic:
(start, end) = (transition, transdic[transition])
trans = And(trans, Implies(start, TS.to_next(Or(end))))
vars_ = [v for v in get_free_variables(trans) if not TS.is_prime(v)]
vars_ += get_free_variables(init)
vars_ += get_free_variables(invar)
invar = And(invar, BVULE(stateid_var, BV(count - 1, stateid_width)))
ts.set_behavior(init, trans, invar)
ts.add_state_var(stateid_var)
hts = HTS("ETS")
hts.add_ts(ts)
invar_props = []
ltl_props = []
return (hts, invar_props, ltl_props)
