def __rpow__(self,
value,
mod=None,
/): # <slot wrapper '__rpow__' of 'int' objects> TODO
"""Return pow(value, self, mod)."""
log.debug("ConInt, __rpow__ is called")
return ConcolicObject(super().__rpow__(unwrap(value), unwrap(mod)))
def _is(obj1, obj2):
from libct.concolic import Concolic
from libct.utils import unwrap
if obj1 is obj2: return True
if isinstance(obj1, Concolic): obj1 = unwrap(obj1)
if isinstance(obj2, Concolic): obj2 = unwrap(obj2)
return obj1 is obj2
def __reversed__(self, *args,
**kwargs): # <method '__reversed__' of 'range' objects>
"""Return a reverse iterator."""
log.debug("ConRange, __reversed__ is called")
args = [unwrap(arg) for arg in args]
kwargs = {k: unwrap(v)
for (k, v) in kwargs.items()}
return ConcolicObject(self.super.__reversed__(*args, **kwargs))
def __round__(self, *args,
**kwargs): # <method '__round__' of 'int' objects>
"""Rounding an Integral returns itself.\nRounding with an ndigits argument also returns an integer."""
log.debug("ConInt, __round__ is called")
args = [unwrap(arg) for arg in args]
kwargs = {k: unwrap(v)
for (k, v) in kwargs.items()}
value = super().__round__(*args, **kwargs)
return ConcolicObject(value, self)
def conjugate(self, *args,
**kwargs): # <method 'conjugate' of 'int' objects>
"""Returns self, the complex conjugate of any int."""
log.debug("ConInt, conjugate is called")
args = [unwrap(arg) for arg in args]
kwargs = {k: unwrap(v)
for (k, v) in kwargs.items()}
value = super().conjugate(*args, **kwargs)
return ConcolicObject(value, self)
def __floor__(self, *args,
**kwargs): # <method '__floor__' of 'int' objects>
"""Flooring an Integral returns itself."""
log.debug("ConInt, __floor__ is called")
args = [unwrap(arg) for arg in args]
kwargs = {k: unwrap(v)
for (k, v) in kwargs.items()}
value = super().__floor__(*args, **kwargs)
return ConcolicObject(value, self)
def _get_concolic_arguments(self, func, prim_args):
ccc_args = []
ccc_kwargs = {}
for v in inspect.signature(func).parameters.values():
if v.kind in (inspect.Parameter.VAR_POSITIONAL,
inspect.Parameter.VAR_KEYWORD):
prim_args.pop(v.name, None)
continue # do not support *args, **kwargs currently
if v.name in prim_args:
value = prim_args[v.name]
else:
has_value = False
if (t := v.annotation) is not inspect._empty:
try:
value = t()
has_value = True # may raise TypeError: Cannot instantiate ...
except:
pass
if not has_value:
if (t := v.default) is not inspect._empty:
value = unwrap(t) # default values may also be wrapped
else:
value = ''
prim_args[v.name] = value if type(value) in (
bool, float, int, str) else self.LazyLoading
def add_branch(self, conbool):
p = Predicate(conbool.expr, unwrap(conbool))
c = self.current_constraint.find_child(p)
pneg = Predicate(conbool.expr, not unwrap(conbool))
cneg = self.current_constraint.find_child(pneg)
if c is None and cneg is None:
c = self.current_constraint.add_child(p)
c.processed = True # for debugging purposes
cneg = self.current_constraint.add_child(pneg)
conbool.engine.constraints_to_solve.append(
cneg
) # add the negated constraint to the queue for later traversal
log.smtlib2(f"Now constraint: {c}")
log.smtlib2(f"Add constraint: {cneg}")
else:
assert c is not None and cneg is not None
self.current_constraint = c # move the current constraint to the child we want now
def __ge__(self, other, /):
try:
if (value := super().__ge__(unwrap(other))) is NotImplemented:
raise NotImplementedError
except:
value = unwrap(other).__le__(unwrap(self))
if isinstance(other, Concolic):
if hasattr(other, 'isBool'): other = other.__float2__()
assert not (hasattr(other, 'super')
and isinstance(other.super, range))
assert not isinstance(other, str)
# other cannot be of type "range" and "str" here, since Exception should be thrown at the statement: value = unwrap(other).__ge__(unwrap(self))
else:
if type(other) is bool: other = float(other)
if type(other) is not int and type(other) is not float:
return ConcolicObject(
value
) # discard the symbolic expression if it cannot match the concrete value
other = ConcolicObject(other)
expr = ['>=', self, other]
return ConcolicObject(value, expr)
def __truediv__(self,
other): # <slot wrapper '__truediv__' of 'float' objects>
log.debug("ConFloat, __truediv__ is called")
value = super().__truediv__(unwrap(other))
if isinstance(other, Concolic):
if hasattr(other, '__float2__'): other = other.__float2__()
else:
try:
other = float(other)
except:
other = 1.0
other = self.__class__(other)
expr = ['/', self, other]
return ConcolicObject(value, expr)
def __getitem__(self, key,
/): # <slot wrapper '__getitem__' of 'range' objects>
value = self.value.__getitem__(unwrap(key))
if isinstance(
key, slice
) and key.start is None and key.stop is None and key.step == -1:
if self.step > 0:
k = (self.stop - self.start) // self.step - int(
(self.stop - self.start) % self.step == 0)
start = self.start + k * self.step
stop = self.start - self.step
step = -self.step
if start == value.start and stop == value.stop and step == value.step:
return self.__class__(start, stop, step)
return ConcolicObject(value) # TODO
def index(self, key): # <method 'index' of 'range' objects>
"""rangeobject.index(value) -> integer -- return index of value.\nRaise ValueError if the value is not present."""
log.debug(
"ConRange, index is called"
) #; args = [unwrap(arg) for arg in args]; kwargs = {k: unwrap(v) for (k, v) in kwargs.items()}
value = self.super.index(unwrap(
key)) # raise Exception when "key" is not in the range object
if isinstance(key, Concolic) and hasattr(key, '__int2__'):
key = key.__int2__()
else:
try:
key = int(key)
except:
key = 0
key = ConcolicObject(key)
return ConcolicObject(value, (key - self.start) // self.step)
def __init__(self, *args):
self.super = range(*[unwrap(arg)
for arg in args]) # emulate inheritance
if len(args) < 2:
self.start = 0
self.stop = args[0]
else:
self.start = args[0]
self.stop = args[1]
if len(args) < 3:
self.step = 1
else:
self.step = args[2]
# We must ensure that all attributes are concolic integers in order to
# make the overridden __getitem__ and __iter__ work!
if not (isinstance(self.start, int)
and isinstance(self.start, Concolic)): # not ConcolicInt
if isinstance(self.start, Concolic) and hasattr(
self.start, '__int2__'):
self.start = self.start.__int2__()
if self.start != self.super.start:
self.start = ConcolicObject(
self.super.start) # ConcolicInt
else:
self.start = ConcolicObject(self.super.start) # ConcolicInt
if not (isinstance(self.stop, int)
and isinstance(self.stop, Concolic)): # not ConcolicInt
if isinstance(self.stop, Concolic) and hasattr(
self.stop, '__int2__'):
self.stop = self.stop.__int2__()
if self.stop != self.super.stop:
self.stop = ConcolicObject(self.super.stop) # ConcolicInt
else:
self.stop = ConcolicObject(self.super.stop) # ConcolicInt
if not (isinstance(self.step, int)
and isinstance(self.step, Concolic)): # not ConcolicInt
if isinstance(self.step, Concolic) and hasattr(
self.step, '__int2__'):
self.step = self.step.__int2__()
if self.step != self.super.step:
self.step = ConcolicObject(self.super.step) # ConcolicInt
else:
self.step = ConcolicObject(self.super.step) # ConcolicInt
def __contains__(self, key,
/): # <slot wrapper '__contains__' of 'range' objects>
"""Return key in self."""
log.debug("ConRange, __contains__ is called")
value = self.super.__contains__(unwrap(key))
if isinstance(key, Concolic) and hasattr(key, '__int2__'):
key = key.__int2__()
else:
try:
key = int(key)
except:
key = 0
key = ConcolicObject(key)
if self.start < self.stop:
return ConcolicObject(value, self.start <= key < self.stop and \
(key - self.start) % self.step == 0)
if self.start > self.stop:
return ConcolicObject(value, self.start >= key > self.stop and \
(key - self.start) % self.step == 0)
return ConcolicObject(value)
def count(self, key): # <method 'count' of 'range' objects>
"""rangeobject.count(value) -> integer -- return number of occurrences of value"""
log.debug(
"ConRange, count is called"
) #; args = [unwrap(arg) for arg in args]; kwargs = {k: unwrap(v) for (k, v) in kwargs.items()}
value = self.super.count(unwrap(key))
if isinstance(key, Concolic) and hasattr(key, '__int2__'):
key = key.__int2__()
else:
try:
key = int(key)
except:
key = 0
key = ConcolicObject(key)
if self.start < self.stop:
return ConcolicObject(value, (self.start <= key < self.stop and \
(key - self.start) % self.step == 0).__int2__())
if self.start > self.stop:
return ConcolicObject(value, (self.start >= key > self.stop and \
(key - self.start) % self.step == 0).__int2__())
return ConcolicObject(value)
def __format__(self, format_spec,
/): # <method '__format__' of 'int' objects> TODO
"""Default object formatter."""
log.debug("ConInt, __format__ is called")
return ConcolicObject(super().__format__(unwrap(format_spec)))
def socket_getaddrinfo(*args, **kwargs):
return _socket_getaddrinfo(
*map(unwrap, args), **{k: unwrap(v)
for (k, v) in kwargs.items()})
def __divmod__(self, value,
/): # <slot wrapper '__divmod__' of 'int' objects> TODO
"""Return divmod(self, value)."""
log.debug("ConInt, __divmod__ is called")
return ConcolicObject(super().__divmod__(unwrap(value)))
def _bin_op(self, op, other):
if op == '__add__':
try:
if (value := super().__add__(unwrap(other))) is NotImplemented:
raise NotImplementedError
except:
value = unwrap(other).__radd__(unwrap(self))
if isinstance(other, Concolic):
if hasattr(other, 'isBool'): other = other.__int2__()
# Please note that int + float -> float instead of int, so we cannot convert float to int here!
assert not (hasattr(other, 'super')
and isinstance(other.super, range))
assert not isinstance(other, str)
# other cannot be of type "range" and "str" here, since Exception should be thrown at the statement: value = unwrap(other).__radd__(unwrap(self))
else:
if type(other) is bool: other = int(other)
if type(other) is not int and type(other) is not float:
return ConcolicObject(
value
) # discard the symbolic expression if it cannot match the concrete value
other = ConcolicObject(other)
expr = ['+', self, other]
return ConcolicObject(value, expr)
if op == '__eq__':
try:
if (value := super().__eq__(unwrap(other))) is NotImplemented:
raise NotImplementedError
except:
value = unwrap(other).__eq__(unwrap(self))
if isinstance(other, Concolic):
if hasattr(other, 'isBool'):
other = other.__int2__()
# Please note that (int = float) will convert int to float, so we cannot convert float to int here!
elif (hasattr(other, 'super')
and isinstance(other.super, range)) or isinstance(
other, str):
return ConcolicObject(
value
) # smtlib2 cannot compare int with range and str.
else:
if type(other) is bool: other = int(other)
if type(other) is not int and type(other) is not float:
return ConcolicObject(
value
) # discard the symbolic expression if it cannot match the concrete value
other = ConcolicObject(other)
expr = ['=', self, other]
return ConcolicObject(value, expr)
if op == '__floordiv__':
# TODO: not sure in the following statement what if "other" does not support the "!=" operator.
try:
(other != 0).__bool__(
) # insert a handmade branch since a number cannot be divided by zero.
except:
pass
try:
if (value := super().__floordiv__(
unwrap(other))) is NotImplemented:
raise NotImplementedError
except:
value = unwrap(other).__rfloordiv__(unwrap(self))
if isinstance(other, Concolic):
if hasattr(other, 'isBool'):
other = other.__int2__()
# Please note that int.__floordiv__(float) will be changed to float.__rfloordiv__(int) in Python!
elif isinstance(other, float):
return ConcolicObject(
value) # TODO: smtlib2 cannot perform int // float
elif isinstance(other, int) and unwrap(other) < 0:
return ConcolicObject(
value
) # TODO: Currently not support the case when "other" is negative.
assert not (hasattr(other, 'super')
and isinstance(other.super, range))
assert not isinstance(other, str)
# other cannot be of type "range" and "str" here, since Exception should be thrown at the statement: value = unwrap(other).__rfloordiv__(unwrap(self))
else:
if type(other) is bool: other = int(other)
if not (type(other) is int and other > 0):
return ConcolicObject(
value
) # discard the symbolic expression if it cannot match the concrete value
other = self.__class__(other)
expr = ['div', self, other]
return ConcolicObject(value, expr)
if op == '__ge__':
try:
if (value := super().__ge__(unwrap(other))) is NotImplemented:
raise NotImplementedError
except:
value = unwrap(other).__le__(unwrap(self))
if isinstance(other, Concolic):
if hasattr(other, 'isBool'): other = other.__int2__()
# Please note that (int >= float) will convert int to float, so we cannot convert float to int here!
assert not (hasattr(other, 'super')
and isinstance(other.super, range))
assert not isinstance(other, str)
# other cannot be of type "range" and "str" here, since Exception should be thrown at the statement: value = unwrap(other).__le__(unwrap(self))
else:
if type(other) is bool: other = int(other)
if type(other) is not int and type(other) is not float:
return ConcolicObject(
value
) # discard the symbolic expression if it cannot match the concrete value
other = ConcolicObject(other)
expr = ['>=', self, other]
return ConcolicObject(value, expr)
if op == '__gt__':
try:
if (value := super().__gt__(unwrap(other))) is NotImplemented:
raise NotImplementedError
except:
value = unwrap(other).__lt__(unwrap(self))
if isinstance(other, Concolic):
if hasattr(other, 'isBool'): other = other.__int2__()
# Please note that (int > float) will convert int to float, so we cannot convert float to int here!
assert not (hasattr(other, 'super')
and isinstance(other.super, range))
assert not isinstance(other, str)
# other cannot be of type "range" and "str" here, since Exception should be thrown at the statement: value = unwrap(other).__lt__(unwrap(self))
else:
if type(other) is bool: other = int(other)
if type(other) is not int and type(other) is not float:
return ConcolicObject(
value
) # discard the symbolic expression if it cannot match the concrete value
other = ConcolicObject(other)
expr = ['>', self, other]
return ConcolicObject(value, expr)
if op == '__le__':
try:
if (value := super().__le__(unwrap(other))) is NotImplemented:
raise NotImplementedError
except:
value = unwrap(other).__ge__(unwrap(self))
if isinstance(other, Concolic):
if hasattr(other, 'isBool'): other = other.__int2__()
# Please note that (int <= float) will convert int to float, so we cannot convert float to int here!
assert not (hasattr(other, 'super')
and isinstance(other.super, range))
assert not isinstance(other, str)
# other cannot be of type "range" and "str" here, since Exception should be thrown at the statement: value = unwrap(other).__ge__(unwrap(self))
else:
if type(other) is bool: other = int(other)
if type(other) is not int and type(other) is not float:
return ConcolicObject(
value
) # discard the symbolic expression if it cannot match the concrete value
other = ConcolicObject(other)
expr = ['<=', self, other]
return ConcolicObject(value, expr)
if op == '__lt__':
try:
if (value := super().__lt__(unwrap(other))) is NotImplemented:
raise NotImplementedError
except:
value = unwrap(other).__gt__(unwrap(self))
if isinstance(other, Concolic):
if hasattr(other, 'isBool'): other = other.__int2__()
# Please note that (int < float) will convert int to float, so we cannot convert float to int here!
assert not (hasattr(other, 'super')
and isinstance(other.super, range))
assert not isinstance(other, str)
# other cannot be of type "range" and "str" here, since Exception should be thrown at the statement: value = unwrap(other).__gt__(unwrap(self))
else:
if type(other) is bool: other = int(other)
if type(other) is not int and type(other) is not float:
return ConcolicObject(
value
) # discard the symbolic expression if it cannot match the concrete value
other = ConcolicObject(other)
expr = ['<', self, other]
return ConcolicObject(value, expr)
if op == '__mod__':
# TODO: not sure in the following statement what if "other" does not support the "!=" operator.
try:
(other != 0).__bool__(
) # insert a handmade branch since a number cannot be divided by zero.
except:
pass
try:
if (value := super().__mod__(unwrap(other))) is NotImplemented:
raise NotImplementedError
except:
value = unwrap(other).__rmod__(unwrap(self))
if isinstance(other, Concolic):
if hasattr(other, 'isBool'):
other = other.__int2__()
# Please note that int.__mod__(float) will be changed to float.__rmod__(int) in Python!
elif isinstance(other, float):
return ConcolicObject(
value) # TODO: smtlib2 cannot perform int // float
elif isinstance(other, int) and unwrap(other) < 0:
return ConcolicObject(
value
) # TODO: Currently not support the case when "other" is negative.
assert not (hasattr(other, 'super')
and isinstance(other.super, range))
assert not isinstance(other, str)
# other cannot be of type "range" and "str" here, since Exception should be thrown at the statement: value = unwrap(other).__rmod__(unwrap(self))
else:
if type(other) is bool: other = int(other)
if not (type(other) is int and other > 0):
return ConcolicObject(
value
) # discard the symbolic expression if it cannot match the concrete value
other = self.__class__(other)
expr = ['mod', self, other]
return ConcolicObject(value, expr)
if op == '__mul__':
try:
if (value := super().__mul__(unwrap(other))) is NotImplemented:
raise NotImplementedError
except:
value = unwrap(other).__rmul__(unwrap(self))
if isinstance(other, Concolic):
if hasattr(other, 'isBool'): other = other.__int2__()
# Please note that int * float -> float instead of int, so we cannot convert float to int here!
if isinstance(other, str): return other.__mul__(self)
assert not (hasattr(other, 'super')
and isinstance(other.super, range))
# other cannot be of type "range" here, since Exception should be thrown at the statement: value = unwrap(other).__rmul__(unwrap(self))
else:
if type(other) is str:
return ConcolicObject(other).__mul__(self)
if type(other) is bool: other = int(other)
if type(other) is not int and type(other) is not float:
return ConcolicObject(
value
) # discard the symbolic expression if it cannot match the concrete value
other = ConcolicObject(other)
expr = ['*', self, other]
return ConcolicObject(value, expr)
if op == '__ne__':
try:
if (value := super().__ne__(unwrap(other))) is NotImplemented:
raise NotImplementedError
except:
value = unwrap(other).__ne__(unwrap(self))
if isinstance(other, Concolic):
if hasattr(other, 'isBool'):
other = other.__int2__()
# Please note that (int != float) will convert int to float, so we cannot convert float to int here!
elif (hasattr(other, 'super')
and isinstance(other.super, range)) or isinstance(
other, str):
return ConcolicObject(
value
) # smtlib2 cannot compare int with range and str.
else:
if type(other) is bool: other = int(other)
if type(other) is not int and type(other) is not float:
return ConcolicObject(
value
) # discard the symbolic expression if it cannot match the concrete value
other = ConcolicObject(other)
expr = ['not', ['=', self, other]]
return ConcolicObject(value, expr)
if op == '__radd__':
value = super().__radd__(unwrap(other))
if isinstance(other, Concolic):
if hasattr(other, 'isBool'): other = other.__int2__()
# Please note that float + int -> float instead of int, so we cannot convert float to int here!
assert not (hasattr(other, 'super')
and isinstance(other.super, range))
assert not isinstance(other, str)
# other cannot be of type "range" and "str" here, since Exception should be thrown at the statement: value = unwrap(other).__radd__(unwrap(self))
else:
if type(other) is bool: other = int(other)
if type(other) is not int and type(other) is not float:
return ConcolicObject(
value
) # discard the symbolic expression if it cannot match the concrete value
other = ConcolicObject(other)
expr = ['+', other, self]
return ConcolicObject(value, expr)
if op == '__rfloordiv__':
# TODO: not sure in the following statement what if "other" does not support the "!=" operator.
try:
(self != 0).__bool__(
) # insert a handmade branch since a number cannot be divided by zero.
except:
pass
value = super().__rfloordiv__(unwrap(other))
if isinstance(other, Concolic):
if hasattr(other, 'isBool'): other = other.__int2__()
elif isinstance(other, float):
return ConcolicObject(
value) # TODO: smtlib2 cannot perform float // int
elif isinstance(other, int) and unwrap(other) < 0:
return ConcolicObject(
value
) # TODO: Currently not support the case when "other" is negative.
assert not (hasattr(other, 'super')
and isinstance(other.super, range))
assert not isinstance(other, str)
# other cannot be of type "range" and "str" here, since Exception should be thrown at the statement: value = super().__rfloordiv__(unwrap(other))
else:
if type(other) is bool: other = int(other)
if not (type(other) is int and other > 0):
return ConcolicObject(
value
) # discard the symbolic expression if it cannot match the concrete value
other = self.__class__(other)
expr = ['div', other, self]
return ConcolicObject(value, expr)
if op == '__rmod__':
# TODO: not sure in the following statement what if "other" does not support the "!=" operator.
try:
(self != 0).__bool__(
) # insert a handmade branch since a number cannot be divided by zero.
except:
pass
value = super().__rmod__(unwrap(other))
if isinstance(other, Concolic):
if hasattr(other, 'isBool'): other = other.__int2__()
elif isinstance(other, float):
return ConcolicObject(
value) # TODO: smtlib2 cannot perform float // int
elif isinstance(other, int) and unwrap(other) < 0:
return ConcolicObject(
value
) # TODO: Currently not support the case when "other" is negative.
assert not (hasattr(other, 'super')
and isinstance(other.super, range))
assert not isinstance(other, str)
# other cannot be of type "range" and "str" here, since Exception should be thrown at the statement: value = super().__rmod__(unwrap(other))
else:
if type(other) is bool: other = int(other)
if not (type(other) is int and other > 0):
return ConcolicObject(
value
) # discard the symbolic expression if it cannot match the concrete value
other = self.__class__(other)
expr = ['mod', other, self]
return ConcolicObject(value, expr)
if op == '__rmul__':
value = super().__rmul__(unwrap(other))
if isinstance(other, Concolic):
if hasattr(other, 'isBool'): other = other.__int2__()
# Please note that float * int -> float instead of int, so we cannot convert float to int here!
if isinstance(other, str): return other.__mul__(self)
assert not (hasattr(other, 'super')
and isinstance(other.super, range))
# other cannot be of type "range" here, since Exception should be thrown at the statement: value = unwrap(other).__rmul__(unwrap(self))
else:
if type(other) is str:
return ConcolicObject(other).__mul__(self)
if type(other) is bool: other = int(other)
if type(other) is not int and type(other) is not float:
return ConcolicObject(
value
) # discard the symbolic expression if it cannot match the concrete value
other = ConcolicObject(other)
expr = ['*', other, self]
return ConcolicObject(value, expr)
if op == '__rsub__':
value = super().__rsub__(unwrap(other))
if isinstance(other, Concolic):
if hasattr(other, 'isBool'): other = other.__int2__()
# Please note that float - int -> float instead of int, so we cannot convert float to int here!
assert not (hasattr(other, 'super')
and isinstance(other.super, range))
assert not isinstance(other, str)
# other cannot be of type "range" and "str" here, since Exception should be thrown at the statement: value = super().__rsub__(unwrap(other))
else:
if type(other) is bool: other = int(other)
if type(other) is not int and type(other) is not float:
return ConcolicObject(
value
) # discard the symbolic expression if it cannot match the concrete value
other = ConcolicObject(other)
expr = ['-', other, self]
return ConcolicObject(value, expr)
if op == '__rtruediv__':
# TODO: not sure in the following statement what if "other" does not support the "!=" operator.
try:
(self != 0).__bool__(
) # insert a handmade branch since a number cannot be divided by zero.
except:
pass
value = super().__rtruediv__(unwrap(other))
if isinstance(other, Concolic):
if hasattr(other, 'isBool'): other = other.__int2__()
# Please note that int / float -> float instead of int, so we cannot convert float to int here!
assert not (hasattr(other, 'super')
and isinstance(other.super, range))
assert not isinstance(other, str)
# other cannot be of type "range" and "str" here, since Exception should be thrown at the statement: super().__rtruediv__(unwrap(other))
else:
if type(other) is bool: other = int(other)
if type(other) is not int and type(other) is not float:
return ConcolicObject(
value
) # discard the symbolic expression if it cannot match the concrete value
other = ConcolicObject(other)
expr = ['/', other, self]
return ConcolicObject(value, expr)
if op == '__sub__':
try:
if (value := super().__sub__(unwrap(other))) is NotImplemented:
raise NotImplementedError
except:
value = unwrap(other).__rsub__(unwrap(self))
if isinstance(other, Concolic):
if hasattr(other, 'isBool'): other = other.__int2__()
# Please note that int - float -> float instead of int, so we cannot convert float to int here!
assert not (hasattr(other, 'super')
and isinstance(other.super, range))
assert not isinstance(other, str)
# other cannot be of type "range" and "str" here, since Exception should be thrown at the statement: value = unwrap(other).__rsub__(unwrap(self))
else:
if type(other) is bool: other = int(other)
if type(other) is not int and type(other) is not float:
return ConcolicObject(
value
) # discard the symbolic expression if it cannot match the concrete value
other = ConcolicObject(other)
expr = ['-', self, other]
return ConcolicObject(value, expr)
if op == '__truediv__':
# TODO: not sure in the following statement what if "other" does not support the "!=" operator.
try:
(other != 0).__bool__(
) # insert a handmade branch since a number cannot be divided by zero.
except:
pass
try:
if (value := super().__truediv__(
unwrap(other))) is NotImplemented:
raise NotImplementedError
except:
value = unwrap(other).__rtruediv__(unwrap(self))
if isinstance(other, Concolic):
if hasattr(other, 'isBool'): other = other.__int2__()
# Please note that int / float -> float instead of int, so we cannot convert float to int here!
assert not (hasattr(other, 'super')
and isinstance(other.super, range))
assert not isinstance(other, str)
# other cannot be of type "range" and "str" here, since Exception should be thrown at the statement: value = unwrap(other).__rtruediv__(unwrap(self))
else:
if type(other) is bool: other = int(other)
if type(other) is not int and type(other) is not float:
return ConcolicObject(
value
) # discard the symbolic expression if it cannot match the concrete value
other = ConcolicObject(other)
expr = ['/', self, other]
return ConcolicObject(value, expr)
raise NotImplementedError
def __rshift__(self, value,
/): # <slot wrapper '__rshift__' of 'int' objects>
"""Return self>>value."""
log.debug("ConInt, __rshift__ is called")
return ConcolicObject(super().__rshift__(unwrap(value)))
@property
def real(self): # <attribute 'real' of 'int' objects>
"""the real part of a complex number"""
log.debug("ConInt, real is called")
value = super().real
return ConcolicObject(value, self)
def to_bytes(self,
/,
length,
byteorder,
*,
signed=False): # <method 'to_bytes' of 'int' objects> TODO
"""Return an array of bytes representing an integer."""
log.debug("ConInt, to_bytes is called")
return ConcolicObject(super().to_bytes(unwrap(length),
unwrap(byteorder),
signed=unwrap(signed)))
################################################################
# Other helper methods are implemented in the following section.
################################################################
def __bool2__(self):
log.debug("ConInt, __bool2__ is called")
value = super().__bool__()
expr = ["not", ["=", self, "0"]]
return ConcolicObject(value, expr)
def __float2__(self, /): # our version of "def __float__(self, /):"
log.debug("ConInt, __float2__ is called")
def __ge__(self, value, /): # <slot wrapper '__ge__' of 'range' objects>
"""Return self>=value."""
log.debug("ConRange, __ge__ is called")
return ConcolicObject((self.super.__ge__(unwrap(value))))
