def op_card(arg):
'''
:param arg:
:type left: :class:`~arg`
:param right:
:type right: :class:`~ExprArg`
:returns: :class:`~IntArg`
Returns the number of instances that are *on* in arg.
'''
assert isinstance(arg, ExprArg)
instances = []
matches = getSetInstancePairs(arg)
known_card = 0
if arg.getInts():
card_cons = compute_int_set(arg.getInts())
for i in card_cons:
if isinstance(i, SMTLib.SMT_BoolConst):
if i.value:
known_card = known_card + 1
else:
instances.append(
SMTLib.SMT_If(i, SMTLib.SMT_IntConst(1),
SMTLib.SMT_IntConst(0)))
for (instance, _) in matches.values():
(expr, polarity) = instance
if polarity == Common.DEFINITELY_ON:
known_card = known_card + 1
else:
instances.append(
SMTLib.SMT_If(expr, SMTLib.SMT_IntConst(1),
SMTLib.SMT_IntConst(0)))
instances.append(SMTLib.SMT_IntConst(known_card))
return IntArg(SMTLib.createSum(instances))
def op_replace(whole_string, from_string, to_string):
(_, whole_mask) = whole_string.getInstanceSort(0)
whole_i = whole_mask.get(0)
(_, from_mask) = from_string.getInstanceSort(0)
from_i = from_mask.get(0)
(_, to_mask) = to_string.getInstanceSort(0)
to_i = to_mask.get(0)
return IntArg(["Replace$" + whole_i + "$" + from_i + "$" + to_i])
def op_substring(whole_string, left_index, right_index):
(_, whole_mask) = whole_string.getInstanceSort(0)
whole_i = whole_mask.get(0)
left_stringID = Common.STRCONS_SUB + str(Common.getStringUID())
right_stringID = Common.STRCONS_SUB + str(Common.getStringUID())
Common.string_map[left_stringID] = left_index
Common.string_map[right_stringID] = right_index
return IntArg(
["Substring$" + whole_i + "$" + left_stringID + "$" + right_stringID])
def op_sum(arg):
'''
:param arg:
:type arg: :class:`~ExprArg`
:returns: :class:`~IntArg`
Computes the sum of all integer instances in arg. May not match the semantics of the Alloy backend.
'''
assert isinstance(arg, ExprArg)
sum_list = []
for (e, c) in arg.getInts():
sum_list.append(SMTLib.createIf(c, e, SMTLib.SMT_IntConst(0)))
return IntArg(SMTLib.createSum(sum_list))
def op_un_minus(arg):
'''
:param arg:
:type arg: :class:`~ExprArg`
:returns: :class:`~IntArg`
Negates arg.
'''
assert isinstance(arg, IntArg)
val = arg.getInts()
val = [SMTLib.createIf(c, e, SMTLib.SMT_IntConst(0)) for (e, c) in val]
val_sum = SMTLib.createSum(val)
return IntArg(SMTLib.createNeg(val_sum))
def op_mul(left, right):
'''
:param left:
:type left: :class:`~ExprArg`
:param right:
:type right: :class:`~ExprArg`
:returns: :class:`~IntArg`
Returns left * right.
'''
assert isinstance(left, ExprArg)
assert isinstance(right, ExprArg)
lval = left.getInts()
lval = [SMTLib.createIf(c, e, SMTLib.SMT_IntConst(0)) for (e, c) in lval]
lval = SMTLib.createSum(lval)
rval = right.getInts()
rval = [SMTLib.createIf(c, e, SMTLib.SMT_IntConst(0)) for (e, c) in rval]
rval = SMTLib.createSum(rval)
return IntArg(SMTLib.SMT_Times(lval, rval))
def op_div(left, right):
'''
:param left:
:type left: :class:`~ExprArg`
:param right:
:type right: :class:`~ExprArg`
:returns: :class:`~IntArg`
Returns left / right.
'''
assert isinstance(left, ExprArg)
assert isinstance(right, ExprArg)
lval = left.getInts()
lval = [SMTLib.createIf(c, e, SMTLib.SMT_IntConst(0)) for (e, c) in lval]
lval = SMTLib.createSum(lval)
rval = right.getInts()
rval = [SMTLib.createIf(c, e, SMTLib.SMT_IntConst(0)) for (e, c) in rval]
rval = SMTLib.createSum(rval)
return IntArg(
SMTLib.SMT_Divide(lval, rval) if (
(not isinstance(lval, SMTLib.SMT_IntConst)) or (
not isinstance(rval, SMTLib.SMT_IntConst))
) else SMTLib.SMT_IntDivide(lval, rval))
def integerliteralVisit(self, element):
if (self.inConstraint):
self.currentConstraint.addArg(
[IntArg(SMTLib.SMT_IntConst(element.value))])
def op_indexof(left, right):
(_, mask) = left.getInstanceSort(0)
left_i = mask.get(0)
(_, mask) = right.getInstanceSort(0)
right_i = mask.get(0)
return IntArg([SMTLib.SMT_Int("Indexof$" + left_i + "$" + right_i)])
def op_length(arg):
(_, mask) = arg.getInstanceSort(0)
arg_i = mask.get(0)
stringID = Common.STRCONS_SUB + str(Common.getStringUID())
Common.string_map[stringID] = arg_i
return IntArg([SMTLib.SMT_Int("Length$" + str(stringID))])
def op_concat(left, right):
(_, left_mask) = left.getInstanceSort(0)
left_i = left_mask.get(0)
(_, right_mask) = right.getInstanceSort(0)
right_i = right_mask.get(0)
return IntArg(["Concat$" + left_i + "$" + right_i])