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