# -*- coding: utf-8 -*- import sys from fixedint.compat import * from weakref import WeakValueDictionary class FixedProperty(object): def __init__(self, val, doc): self.val = val self.__doc__ = doc def __get__(self, obj, type=None): return self.val def __set__(self, obj, value): raise AttributeError("property is read-only") class FixedMetaProperty(object): def __init__(self, name, doc): self.name = name self.__doc__ = doc def __get__(self, obj, type=None): if self.name not in obj.__dict__: # this should only happen when trying to access FixedInt.prop, which help() does raise AttributeError("Attribute %s not defined on base class" % self.name) prop = obj.__dict__[self.name] return prop.__get__(obj) def __set__(self, obj, value): raise AttributeError("property %s is read-only" % self.name) if not PY3K: # While it'd be nice to put machine-sized integers into Python 2.x "int"s, # it turns out that the int methods occasionally freak out when given longs. # So, we use arbitrary-precision ints for all Pythons. int = long _class_cache = WeakValueDictionary() _doc_width = "Bit width of this integer, including the sign bit." _doc_signed = "True if this integer is a twos-complement signed type." _doc_mutable = "True if this integer is mutable (modifiable in-place)." _doc_minval = "Minimum representable value of this integer type" _doc_maxval = "Maximum representable value of this integer type" _subclass_token = object() class _FixedIntBaseMeta(type): def __new__(cls, name, bases, dict): if dict.get('_subclass_enable', None) == _subclass_token: del dict['_subclass_enable'] return type.__new__(cls, name, bases, dict) for base in bases: if issubclass(base, FixedInt): basename = base.__name__ raise Exception("Cannot subclass %s; use the %s constructor to produce new subclasses." % (basename, basename)) raise Exception("Cannot subclass this class.") def __call__(self, width, signed=True, mutable=None): signed = bool(signed) if mutable is None: # Take mutable from constructor used (FixedInt or MutableFixedInt) mutable = (self == MutableFixedInt) cachekey = (width, signed, mutable) try: return _class_cache[cachekey] except KeyError: pass if signed: min = -1<<(width-1) max = (1<<(width-1))-1 else: min = 0 max = (1<> 1 x[:5]: equal to (x & 31) ''' if isinstance(item, slice): start, stop = self._canonicalize_slice(item) return FixedInt(stop - start, signed=False)(int(self) >> start) else: item = self._canonicalize_index(item) if 0 <= item < self.width: return bool(int(self) & (1 << item)) else: raise IndexError("index %d out of range" % item) def to_bytes(self, length=None, byteorder=sys.byteorder): if length is None: length = (self.width + 7) // 8 try: return int(self).to_bytes(length, byteorder=byteorder, signed=self.signed) except (OverflowError, AttributeError): pass val = int(self) & ((1 << (length * 8)) - 1) out = [] while length > 0: out.append(val & 0xff) val >>= 8 length -= 1 if byteorder == 'big': out = reversed(out) if PY3K: return bytes(out) else: return ''.join(map(chr, out)) @classmethod def from_bytes(cls, bytes, byteorder=sys.byteorder, signed=None): if cls in (FixedInt, MutableFixedInt): if signed is None: signed = False elif signed is None: signed = cls.signed else: raise ValueError("can't set signed with a concrete FixedInt") blen = len(bytes) try: val = int.from_bytes(bytes, byteorder=byteorder, signed=signed) except AttributeError: val = 0 if byteorder == 'big': bytes = reversed(bytes) if PY3K: for i,c in enumerate(bytes): val |= c << (8 * i) else: for i,c in enumerate(bytes): val |= ord(c) << (8 * i) if cls in (FixedInt, MutableFixedInt): return cls(blen*8, signed=signed)(val) else: return cls(val) if PY3K: @int_method def __round__(self, n=0): return int(self) # Inherited methods which are fine as-is: # complex, int, long, float, index # truediv, rtruediv, divmod, rdivmod, rlshift, rrshift # format FixedInt = add_metaclass(_FixedIntBaseMeta)(FixedInt) class MutableFixedInt(FixedInt): _subclass_enable = _subclass_token def __init__(self, val=0, base=None): ''' Convert an integer into a fixed-width integer. ''' if base is None: val = int(val) else: val = int(val, base) self._val = self._rectify(val) if PY3K: @int_method def __format__(self, format_spec): return format(self._val, format_spec) def __ipow__(self, other, modulo=None): if modulo is None: self._val = self._rectify(int.__pow__(int(self), int(other))) else: self._val = self._rectify(int.__pow__(int(self), int(other), modulo)) return self def __setitem__(self, item, value): ''' Modify a slice of an integer. x[a]=y sets a single bit at position a. x[a:b]=y sets a range of bits from an integer. See __getitem__ for more details on the slice notation. ''' value = int(value) if isinstance(item, slice): start, stop = self._canonicalize_slice(item) mask = (1 << (stop - start)) - 1 self._val = (self._val & ~(mask << start)) | ((value & mask) << start) else: item = self._canonicalize_index(item) if 0 <= item < self.width: if value: self._val |= (1 << item) else: self._val &= ~(1 << item) return bool(int(self) & (1 << item)) else: raise IndexError("index %d out of range" % item) ## Arithmetic methods def _arith_unary_factory(name, mutable): ''' Factory function producing methods for unary operations. ''' intfunc = getattr(int, name) if mutable: @int_method(name) def _f(self): return type(self)(intfunc(self._val)) else: @int_method(name) def _f(self): return type(self)(intfunc(self)) return _f _arith_unary = 'neg pos abs invert'.split() for f in _arith_unary: s = '__%s__' % f setattr(FixedInt, s, _arith_unary_factory(s, mutable=False)) setattr(MutableFixedInt, s, _arith_unary_factory(s, mutable=True)) def _arith_convert(t1, t2): if not issubclass(t2, FixedInt): return t1 # Follow C conversion rules (ISO/IEC 9899:TC3 ยง6.3.1.8) if t1.signed == t2.signed: # If both are signed or both are unsigned, return the larger type. if t1.width >= t2.width: return t1 return t2 if not t1.signed: ut, st = t1, t2 else: ut, st = t2, t1 if ut.width >= st.width: # If the unsigned type has rank >= the signed type, convert the signed type to the unsigned type. return ut else: return st def _arith_binfunc_factory(name): ''' Factory function producing methods for arithmetic operators ''' intfunc = getattr(int, name) @int_method(name) def _f(self, other): nt = _arith_convert(type(self), type(other)) return nt(intfunc(int(self), int(other))) return _f # divmod, rdivmod, truediv, rtruediv are considered non-arithmetic since they don't return ints # pow, rpow, rlshift, and rrshift are special since the LHS and RHS are very different _arith_binfunc = 'add sub mul floordiv mod lshift rshift and xor or'.split() _arith_binfunc += 'radd rsub rmul rfloordiv rmod rand rxor ror'.split() if not PY3K: _arith_binfunc += 'div rdiv'.split() for f in _arith_binfunc: s = '__%s__' % f setattr(FixedInt, s, _arith_binfunc_factory(s)) ## Non-arithmetic methods (Mutable only) def _nonarith_unary_factory_mutable(name): ''' Factory function producing methods for unary operations. ''' intfunc = getattr(int, name) @int_method(name) def _f(self): return intfunc(self._val) return _f _mutable_unary = 'int float'.split() if sys.version_info[:2] >= (2,5): _mutable_unary += ['index'] if sys.version_info[:2] >= (2,6): _mutable_unary += ['trunc'] if PY3K: _mutable_unary += 'bool'.split() else: _mutable_unary += 'nonzero long'.split() for f in _mutable_unary: s = '__%s__' % f setattr(MutableFixedInt, s, _nonarith_unary_factory_mutable(s)) def _nonarith_binfunc_factory_mutable(name): ''' Factory function producing methods for non-arithmetic binary operators on Mutable instances. ''' intfunc = getattr(int, name) @int_method(name) def _f(self, other): return intfunc(self._val, int(other)) return _f _mutable_binfunc = 'truediv rtruediv divmod rdivmod rlshift rrshift'.split() if hasattr(int, '__cmp__'): _mutable_binfunc += ['cmp'] else: _mutable_binfunc += 'lt le eq ne gt ge'.split() for f in _mutable_binfunc: s = '__%s__' % f setattr(MutableFixedInt, s, _nonarith_binfunc_factory_mutable(s)) ## In-place operators def _inplace_factory_mutable(iname, name, op): ''' Factory function producing methods for augmented assignments on Mutable instances. ''' # This uses compiled operators instead of an int.__X__ function call for speed. # Measured improvement is about 15% speed increase. exec(""" def _f(self, other): self._val = self._rectify(self._val %s int(other)) return self globals()['_f'] = _f""" % op) _f.__name__ = iname doc = list.__iadd__.__doc__ if doc: _f.__doc__ = doc.replace('__iadd__', name).replace('+=', op+'=') return _f # pow is special because it takes three arguments. _inplace_func = 'add,+ sub,- mul,* truediv,/ floordiv,// mod,% lshift,<< rshift,<< and,& or,| xor,^'.split() if not PY3K: _inplace_func += ['div,/'] for f in _inplace_func: fn, op = f.split(',') si = '__i%s__' % fn so = '__%s__' % fn setattr(MutableFixedInt, si, _inplace_factory_mutable(si, so, op))