def __len__(self, /): # <slot wrapper '__len__' of 'range' objects> """Return len(self).""" log.debug("ConRange, __len__ is called") value = self.super.__len__() expr = ((self.stop - self.start) // self.step) + ( (self.stop - self.start) % self.step != 0).__int2__() return ConcolicObject(value, expr)
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 __bool__(self, /): # <slot wrapper '__bool__' of 'int' objects> """self != 0""" log.debug("ConInt, __bool__ is called") value = super().__bool__() expr = ["not", ["=", self, "0"]] ConcolicObject(value, expr).__bool__() # insert handmade branch, since return value # "__bool__" can only return primitive objects...
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 __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 __str2__(self): log.debug("ConInt, __str2__ is called") value = super().__str__() expr = [ 'ite', ['<', self, '0'], ['str.++', py2smt('-'), ["int.to.str", ['-', self]]], ["int.to.str", self] ] return ConcolicObject(value, expr)
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 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 __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 __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 __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 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 __int2__(self): log.debug("ConFloat, __int2__ is called") value = super().__int__() expr = [ '+', ['to_int', self], [ 'ite', ['and', ['<', self, '0'], ['not', ['is_int', self]]], '1', '0' ] ] # Please note that ['to_int', -2.5] evaluates to -3 in smtlib2, but int(-2.5) evaluates to -2 in Python! 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 __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 bit_length(self, /): # <method 'bit_length' of 'int' objects> TODO """Number of bits necessary to represent self in binary.\n\n>>> bin(37)\n'0b100101'\n>>> (37).bit_length()\n6""" log.debug("ConInt, bit_length is called") return ConcolicObject(super().bit_length())
def __float2__(self, /): # our version of "def __float__(self, /):" log.debug("ConInt, __float2__ is called") value = super().__float__() expr = ['to_real', self] return ConcolicObject(value, expr)
def __bool2__(self): log.debug("ConInt, __bool2__ is called") value = super().__bool__() expr = ["not", ["=", self, "0"]] return ConcolicObject(value, expr)
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 numerator(self): # <attribute 'numerator' of 'int' objects> """the numerator of a rational number in lowest terms""" log.debug("ConInt, numerator is called") value = super().numerator return ConcolicObject(value, self)
def imag(self): # <attribute 'imag' of 'int' objects> """the imaginary part of a complex number""" log.debug("ConInt, imag is called") return ConcolicObject(super().imag) # should always return 0
def denominator(self): # <attribute 'denominator' of 'int' objects> """the denominator of a rational number in lowest terms""" log.debug("ConInt, denominator is called") return ConcolicObject(super().denominator) # should always return 1
def __abs__(self, /): # <slot wrapper '__abs__' of 'int' objects> """abs(self)""" log.debug("ConInt, __abs__ is called") value = super().__abs__() expr = ["abs", self] return ConcolicObject(value, expr)
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 __pos__(self, /): # <slot wrapper '__pos__' of 'int' objects> """+self""" log.debug("ConInt, __pos__ is called") value = super().__pos__() return ConcolicObject(value, self)
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 __rshift__(self, value, /): # <slot wrapper '__rshift__' of 'int' objects> """Return self>>value.""" log.debug("ConInt, __rshift__ is called") return ConcolicObject(super().__rshift__(unwrap(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 as_integer_ratio( self, /): # <method 'as_integer_ratio' of 'int' objects> TODO """Return integer ratio.\n\nReturn a pair of integers, whose ratio is exactly equal to the original int\nand with a positive denominator.\n\n>>> (10).as_integer_ratio()\n(10, 1)\n>>> (-10).as_integer_ratio()\n(-10, 1)\n>>> (0).as_integer_ratio()\n(0, 1)""" log.debug("ConInt, as_integer_ratio is called") return ConcolicObject(super().as_integer_ratio())