def __init__(self, e):
if not in_constraint_scope():
raise Exception(
"Attempting to use if_then constraint outside constraint scope"
)
to_expr(e)
self.stmt = ConstraintIfElseModel(pop_expr())
if in_srcinfo_mode():
self.stmt.srcinfo = SourceInfo.mk()
push_constraint_stmt(self.stmt)
def inside(self, rhs):
lhs_e = pop_expr()
if isinstance(rhs, rangelist):
return expr(ExprInModel(lhs_e, rhs.range_l))
elif isinstance(rhs, list_t):
return expr(ExprInModel(
lhs_e,
ExprRangelistModel(
[ExprFieldRefModel(rhs.get_model())])))
else:
raise Exception("Unsupported 'inside' argument of type " + str(type(rhs)))
def __init__(self, val, w):
rng_lhs_e = None
rng_rhs_e = None
if isinstance(val, (list, tuple)):
if len(val) != 2:
raise Exception("Weight range must have two elements")
to_expr(val[0])
rng_lhs_e = pop_expr()
to_expr(val[1])
rng_rhs_e = pop_expr()
elif isinstance(val, rng):
rng_lhs_e = val.low
rng_rhs_e = val.high
else:
to_expr(val)
rng_lhs_e = pop_expr()
to_expr(w)
w_e = pop_expr()
self.weight_e = DistWeightExprModel(rng_lhs_e, rng_rhs_e, w_e)
def __init__(self, *args):
if len(args) == 0:
raise Exception("Empty rangelist specified")
self.range_l = ExprRangelistModel()
for i in range(-1,-(len(args)+1), -1):
a = args[i]
if isinstance(a, tuple):
# This needs to be a two-element array
if len(a) != 2:
raise Exception("Range specified with " + str(len(a)) + " elements is invalid. Two elements required")
to_expr(a[0])
to_expr(a[1])
e1 = pop_expr()
e0 = pop_expr()
self.range_l.add_range(ExprRangeModel(e0, e1))
elif isinstance(a, rng):
to_expr(a.low)
to_expr(a.high)
e1 = pop_expr()
e0 = pop_expr()
self.range_l.add_range(ExprRangeModel(e0, e1))
elif isinstance(a, list):
for ai in a:
to_expr(ai)
eai = pop_expr()
self.range_l.add_range(eai)
else:
to_expr(a)
e = pop_expr()
self.range_l.add_range(e)
def __getitem__(self, k):
model = self._int_field_info.model
if get_expr_mode():
# TODO: must determine whether we're within a foreach or just on our own
if is_foreach_arr(self):
to_expr(k)
idx_e = pop_expr()
return expr(
ExprArraySubscriptModel(
ExprFieldRefModel(self.get_model()), idx_e))
else:
to_expr(k)
idx_e = pop_expr()
return expr(
ExprArraySubscriptModel(
ExprFieldRefModel(self.get_model()), idx_e))
else:
if self.is_scalar:
return int(model.field_l[k].get_val())
else:
return self.backing_arr[k]
def append(self, a):
if isinstance(a, tuple):
# This needs to be a two-element array
if len(a) != 2:
raise Exception("Range specified with " + str(len(a)) +
" elements is invalid. Two elements required")
to_expr(a[0])
e0 = pop_expr()
to_expr(a[1])
e1 = pop_expr()
self.range_l.add_range(ExprRangeModel(e0, e1))
elif isinstance(a, rng):
self.range_l.add_range(ExprRangeModel(a.low, a.high))
elif isinstance(a, list):
for ai in a:
to_expr(ai)
eai = pop_expr()
self.range_l.add_range(eai)
else:
to_expr(a)
e = pop_expr()
self.range_l.add_range(e)
def dist(lhs, weights):
"""Applies distribution weights to the specified field"""
to_expr(lhs)
lhs_e = pop_expr()
weight_l = []
for w in weights:
if not isinstance(w, weight):
raise Exception("Weight specifications must of type 'vsc.weight', not " +
str(w))
weight_l.append(w.weight_e)
push_constraint_stmt(ConstraintDistModel(lhs_e, weight_l))
def __getitem__(self, rng):
if is_expr_mode():
if isinstance(rng, slice):
# slice
to_expr(rng.start)
to_expr(rng.stop)
e0 = pop_expr()
e1 = pop_expr()
return expr(ExprPartselectModel(
ExprFieldRefModel(self._int_field_info.model), e0, e1))
else:
# single value
to_expr(rng)
e = pop_expr()
return expr(ExprPartselectModel(
ExprFieldRefModel(self._int_field_info.model), e))
else:
curr = int(self.get_model().get_val())
if isinstance(rng, slice):
msk = ((1 << (rng.start-rng.stop))-1) << rng.stop
curr = (curr & msk) >> rng.stop
else:
curr = (curr & (1 << rng)) >> rng
return curr
def __getitem__(self, k):
if is_expr_mode():
if isinstance(k, slice):
# Part-select on a field expression
print("k=" + str(k) + " start=" + str(k.start) + " stop=" +
str(k.stop))
to_expr(k.start)
upper = pop_expr()
to_expr(k.stop)
lower = pop_expr()
base_e = pop_expr()
return expr(ExprPartselectModel(base_e, upper, lower))
else:
# single value
to_expr(k)
idx_e = pop_expr()
base_e = pop_expr()
return expr_subscript(ExprArraySubscriptModel(base_e, idx_e))
else:
raise Exception(
"Calling __getitem__ on an expr on non-expression context")
def __init__(self, e):
self.stmt = None
if not in_constraint_scope():
raise Exception("Attempting to use if_then constraint outside constraint scope")
last_stmt = last_constraint_stmt()
if last_stmt == None or not isinstance(last_stmt, ConstraintIfElseModel):
raise Exception("Attempting to use else_if where it doesn't follow if_then")
to_expr(e)
# Need to find where to think this in
while last_stmt.false_c != None:
last_stmt = last_stmt.false_c
self.stmt = ConstraintIfElseModel(pop_expr())
last_stmt.false_c = self.stmt
def not_inside(self, rhs):
self.to_expr()
lhs_e = pop_expr()
if isinstance(rhs, rangelist):
return expr(
ExprUnaryModel(UnaryExprType.Not,
ExprInModel(lhs_e, rhs.range_l)))
elif isinstance(rhs, list_t):
return expr(
ExprUnaryModel(
UnaryExprType.Not,
ExprInModel(
lhs_e,
ExprRangelistModel(
[ExprFieldRefModel(rhs.get_model())]))))
else:
raise Exception("Unsupported 'not_inside' argument of type " +
str(type(rhs)) + " expect rangelist or list_t")
def __getitem__(self, k):
model = self._int_field_info.model
if get_expr_mode():
# TODO: must determine whether we're within a foreach or just on our own
to_expr(k)
idx_e = pop_expr()
return expr_subscript(
ExprArraySubscriptModel(ExprFieldRefModel(self.get_model()),
idx_e))
# if is_foreach_arr(self):
# to_expr(k)
# idx_e = pop_expr()
#
# return expr_subscript(ExprArraySubscriptModel(
# ExprFieldRefModel(self.get_model()),
# idx_e))
# else:
# to_expr(k)
# idx_e = pop_expr()
# return expr_subscript(ExprArraySubscriptModel(
# ExprFieldRefModel(self.get_model()),
# idx_e))
else:
if self.is_enum:
ei: EnumInfo = self.t.enum_i
return ei.v2e(model.field_l[k].get_val())
elif self.is_scalar:
# The model's view is always masked 2's complement
v = int(model.field_l[k].get_val())
if self.t.is_signed:
if (v & (1 << (self.t.width - 1))) != 0:
v = -((~v & self.mask) + 1)
return v
else:
return self.backing_arr[k]
def __contains__(self, lhs):
if get_expr_mode():
to_expr(lhs)
return expr(
ExprInModel(
pop_expr(),
ExprRangelistModel([ExprFieldRefModel(self.get_model())])))
else:
model = self.get_model()
if self.is_enum:
ei: EnumInfo = self.t.enum_i
val = ei.e2v(lhs)
for f in model.field_l:
if int(f.get_val()) == val:
return True
elif self.is_scalar:
for f in model.field_l:
if int(f.get_val()) == int(lhs):
return True
else:
return lhs in self.backing_arr
return False
def __contains__(self, lhs):
to_expr(lhs)
return expr(
ExprInModel(
pop_expr(),
ExprRangelistModel([ExprFieldRefModel(self.get_model())])))
def __init__(self, e):
if not in_constraint_scope():
raise Exception("Attempting to use if_then constraint outside constraint scope")
to_expr(e)
self.stmt = ConstraintImpliesModel(pop_expr())
def __invert__(self):
self.to_expr()
lhs = pop_expr()
return expr(ExprUnaryModel(UnaryExprType.Not, lhs))
def __contains__(self, lhs):
to_expr(lhs)
return expr(ExprInModel(pop_expr(), self.range_l))
def soft(e):
to_expr(e)
push_constraint_stmt(ConstraintSoftModel(pop_expr()))
def __init__(self, low, high):
to_expr(low)
self.low = pop_expr()
to_expr(high)
self.high = pop_expr()
