On Sat, Mar 23, 2013 at 1:32 PM, Carl Friedrich Bolz <cfb...@gmx.de> wrote: > Hi Maciej, Alex, > > I really don't like this commit. It does two unrelated pretty > fundamental changes together, killing small integers and making int a > normal method. The first of these is not even explained in the commit > message. > > I understand the reasons for removing small integers (they don't work > with the JIT anyway, fixing that would be hard, ...). But it would > still be good to have two commits, one that removes them, the other one > that does your refactoring. This would give people that want to revive > them at a later point a place to start. > > I don't actually know what should be done now. Backing out your change > and doing it in two steps would be the right approach somehow, even if > it requires some work. > > Cheers, > > Carl Friedrich >
ok, fixed I think > > > On 03/23/2013 08:02 PM, fijal wrote: >> >> Author: Maciej Fijalkowski <fij...@gmail.com> >> Branch: >> Changeset: r62700:e258f1470515 >> Date: 2013-03-23 12:01 -0700 >> http://bitbucket.org/pypy/pypy/changeset/e258f1470515/ >> >> Log: (fijal, alex) kill 'int' as a multimethod >> >> diff --git a/pypy/config/pypyoption.py b/pypy/config/pypyoption.py >> --- a/pypy/config/pypyoption.py >> +++ b/pypy/config/pypyoption.py >> @@ -189,11 +189,6 @@ >> BoolOption("withtproxy", "support transparent proxies", >> default=True), >> >> - BoolOption("withsmallint", "use tagged integers", >> - default=False, >> - requires=[("objspace.std.withprebuiltint", False), >> - ("translation.taggedpointers", True)]), >> - >> BoolOption("withprebuiltint", "prebuild commonly used int >> objects", >> default=False), >> >> @@ -204,9 +199,7 @@ >> default=100, cmdline="--prebuiltintto"), >> >> BoolOption("withsmalllong", "use a version of 'long' in a C long >> long", >> - default=False, >> - requires=[("objspace.std.withsmallint", False)]), >> - # ^^^ because of missing delegate_xx2yy >> + default=False), >> >> BoolOption("withstrbuf", "use strings optimized for addition >> (ver 2)", >> default=False), >> diff --git a/pypy/interpreter/baseobjspace.py >> b/pypy/interpreter/baseobjspace.py >> --- a/pypy/interpreter/baseobjspace.py >> +++ b/pypy/interpreter/baseobjspace.py >> @@ -223,6 +223,22 @@ >> raise OperationError(space.w_TypeError, >> typed_unwrap_error_msg(space, "integer", >> self)) >> >> + def int(self, space): >> + w_impl = space.lookup(self, '__int__') >> + if w_impl is None: >> + typename = space.type(self).getname(space) >> + raise operationerrfmt(space.w_TypeError, >> + "unsupported operand type for int(): '%s'", >> + typename) >> + w_result = space.get_and_call_function(w_impl, self) >> + >> + if (space.isinstance_w(w_result, space.w_int) or >> + space.isinstance_w(w_result, space.w_long)): >> + return w_result >> + typename = space.type(w_result).getname(space) >> + msg = "__int__ returned non-int (type '%s')" >> + raise operationerrfmt(space.w_TypeError, msg, typename) >> + >> def __spacebind__(self, space): >> return self >> >> @@ -1306,6 +1322,9 @@ >> def int_w(self, w_obj): >> return w_obj.int_w(self) >> >> + def int(self, w_obj): >> + return w_obj.int(self) >> + >> def uint_w(self, w_obj): >> return w_obj.uint_w(self) >> >> diff --git a/pypy/objspace/descroperation.py >> b/pypy/objspace/descroperation.py >> --- a/pypy/objspace/descroperation.py >> +++ b/pypy/objspace/descroperation.py >> @@ -808,7 +808,6 @@ >> # more of the above manually-coded operations as well) >> >> for targetname, specialname, checkerspec in [ >> - ('int', '__int__', ("space.w_int", "space.w_long")), >> ('index', '__index__', ("space.w_int", "space.w_long")), >> ('long', '__long__', ("space.w_int", "space.w_long")), >> ('float', '__float__', ("space.w_float",))]: >> diff --git a/pypy/objspace/std/complexobject.py >> b/pypy/objspace/std/complexobject.py >> --- a/pypy/objspace/std/complexobject.py >> +++ b/pypy/objspace/std/complexobject.py >> @@ -111,6 +111,9 @@ >> >> return w_result >> >> + def int(self, space): >> + raise OperationError(space.w_TypeError, space.wrap("can't convert >> complex to int; use int(abs(z))")) >> + >> registerimplementation(W_ComplexObject) >> >> w_one = W_ComplexObject(1, 0) >> @@ -245,9 +248,6 @@ >> def float__Complex(space, w_complex): >> raise OperationError(space.w_TypeError, space.wrap("can't convert >> complex to float; use abs(z)")) >> >> -def int__Complex(space, w_complex): >> - raise OperationError(space.w_TypeError, space.wrap("can't convert >> complex to int; use int(abs(z))")) >> - >> def complex_conjugate__Complex(space, w_self): >> #w_real = >> space.call_function(space.w_float,space.wrap(w_self.realval)) >> #w_imag = >> space.call_function(space.w_float,space.wrap(-w_self.imagval)) >> diff --git a/pypy/objspace/std/floatobject.py >> b/pypy/objspace/std/floatobject.py >> --- a/pypy/objspace/std/floatobject.py >> +++ b/pypy/objspace/std/floatobject.py >> @@ -58,6 +58,14 @@ >> def float_w(self, space): >> return self.floatval >> >> + def int(self, space): >> + try: >> + value = ovfcheck_float_to_int(self.floatval) >> + except OverflowError: >> + return space.long(self) >> + else: >> + return space.newint(value) >> + >> def __repr__(self): >> return "<W_FloatObject(%f)>" % self.floatval >> >> @@ -89,14 +97,6 @@ >> a = w_float1.floatval >> return W_FloatObject(a) >> >> -def int__Float(space, w_value): >> - try: >> - value = ovfcheck_float_to_int(w_value.floatval) >> - except OverflowError: >> - return space.long(w_value) >> - else: >> - return space.newint(value) >> - >> def long__Float(space, w_floatobj): >> try: >> return W_LongObject.fromfloat(space, w_floatobj.floatval) >> diff --git a/pypy/objspace/std/frame.py b/pypy/objspace/std/frame.py >> --- a/pypy/objspace/std/frame.py >> +++ b/pypy/objspace/std/frame.py >> @@ -6,7 +6,7 @@ >> from pypy.interpreter import pyopcode >> from pypy.interpreter.pyframe import PyFrame >> from pypy.interpreter.error import OperationError >> -from pypy.objspace.std import intobject, smallintobject >> +from pypy.objspace.std import intobject >> from pypy.objspace.std.multimethod import FailedToImplement >> from pypy.objspace.std.listobject import W_ListObject >> >> @@ -23,20 +23,6 @@ >> raise AssertionError >> >> >> -def small_int_BINARY_ADD(f, oparg, next_instr): >> - w_2 = f.popvalue() >> - w_1 = f.popvalue() >> - if (type(w_1) is smallintobject.W_SmallIntObject and >> - type(w_2) is smallintobject.W_SmallIntObject): >> - try: >> - w_result = smallintobject.add__SmallInt_SmallInt(f.space, >> w_1, w_2) >> - except FailedToImplement: >> - w_result = f.space.add(w_1, w_2) >> - else: >> - w_result = f.space.add(w_1, w_2) >> - f.pushvalue(w_result) >> - >> - >> def int_BINARY_ADD(f, oparg, next_instr): >> w_2 = f.popvalue() >> w_1 = f.popvalue() >> @@ -102,10 +88,7 @@ >> class StdObjSpaceFrame(BaseFrame): >> pass >> if space.config.objspace.std.optimized_int_add: >> - if space.config.objspace.std.withsmallint: >> - StdObjSpaceFrame.BINARY_ADD = small_int_BINARY_ADD >> - else: >> - StdObjSpaceFrame.BINARY_ADD = int_BINARY_ADD >> + StdObjSpaceFrame.BINARY_ADD = int_BINARY_ADD >> if space.config.objspace.std.optimized_list_getitem: >> StdObjSpaceFrame.BINARY_SUBSCR = list_BINARY_SUBSCR >> if space.config.objspace.opcodes.CALL_METHOD: >> diff --git a/pypy/objspace/std/intobject.py >> b/pypy/objspace/std/intobject.py >> --- a/pypy/objspace/std/intobject.py >> +++ b/pypy/objspace/std/intobject.py >> @@ -1,6 +1,6 @@ >> from pypy.interpreter.error import OperationError >> from pypy.objspace.std import newformat >> -from pypy.objspace.std.inttype import wrapint >> +from pypy.objspace.std.inttype import wrapint, W_AbstractIntObject >> from pypy.objspace.std.model import registerimplementation, W_Object >> from pypy.objspace.std.multimethod import FailedToImplementArgs >> from pypy.objspace.std.noneobject import W_NoneObject >> @@ -16,25 +16,6 @@ >> something CPython does not do anymore. >> """ >> >> -class W_AbstractIntObject(W_Object): >> - __slots__ = () >> - >> - def is_w(self, space, w_other): >> - if not isinstance(w_other, W_AbstractIntObject): >> - return False >> - if self.user_overridden_class or w_other.user_overridden_class: >> - return self is w_other >> - return space.int_w(self) == space.int_w(w_other) >> - >> - def immutable_unique_id(self, space): >> - if self.user_overridden_class: >> - return None >> - from pypy.objspace.std.model import IDTAG_INT as tag >> - b = space.bigint_w(self) >> - b = b.lshift(3).or_(rbigint.fromint(tag)) >> - return space.newlong_from_rbigint(b) >> - >> - >> class W_IntObject(W_AbstractIntObject): >> __slots__ = 'intval' >> _immutable_fields_ = ['intval'] >> @@ -67,6 +48,17 @@ >> def float_w(self, space): >> return float(self.intval) >> >> + def int(self, space): >> + # XXX find a better way to do it >> + if (type(self) != W_IntObject and >> + space.lookup(self, '__int__') is not >> + space.lookup_in_type_where(space.w_int, '__int__')[1]): >> + return W_Object.int(self, space) >> + if space.is_w(space.type(self), space.w_int): >> + return self >> + a = self.intval >> + return wrapint(space, a) >> + >> registerimplementation(W_IntObject) >> >> # NB: This code is shared by smallintobject.py, and thus no other Int >> @@ -104,7 +96,7 @@ >> # unlike CPython, we don't special-case the value -1 in most of our >> # hash functions, so there is not much sense special-casing it here >> either. >> # Make sure this is consistent with the hash of floats and longs. >> - return get_integer(space, w_int1) >> + return w_int1.int(space) >> >> # coerce >> def coerce__Int_Int(space, w_int1, w_int2): >> @@ -251,7 +243,7 @@ >> >> def abs__Int(space, w_int1): >> if w_int1.intval >= 0: >> - return get_integer(space, w_int1) >> + return w_int1.int(space) >> else: >> return get_negint(space, w_int1) >> >> @@ -278,7 +270,7 @@ >> space.wrap("negative shift count")) >> else: #b >= LONG_BIT >> if a == 0: >> - return get_integer(space, w_int1) >> + return w_int1.int(space) >> raise FailedToImplementArgs(space.w_OverflowError, >> space.wrap("integer left shift")) >> >> @@ -291,7 +283,7 @@ >> space.wrap("negative shift count")) >> else: # b >= LONG_BIT >> if a == 0: >> - return get_integer(space, w_int1) >> + return w_int1.int(space) >> if a < 0: >> a = -1 >> else: >> @@ -321,17 +313,13 @@ >> # int__Int is supposed to do nothing, unless it has >> # a derived integer object, where it should return >> # an exact one. >> -def int__Int(space, w_int1): >> - if space.is_w(space.type(w_int1), space.w_int): >> - return w_int1 >> - a = w_int1.intval >> - return wrapint(space, a) >> -get_integer = int__Int >> -pos__Int = int__Int >> -trunc__Int = int__Int >> + >> +def pos__Int(self, space): >> + return self.int(space) >> +trunc__Int = pos__Int >> >> def index__Int(space, w_int1): >> - return get_integer(space, w_int1) >> + return w_int1.int(space) >> >> def float__Int(space, w_int1): >> a = w_int1.intval >> diff --git a/pypy/objspace/std/inttype.py b/pypy/objspace/std/inttype.py >> --- a/pypy/objspace/std/inttype.py >> +++ b/pypy/objspace/std/inttype.py >> @@ -1,5 +1,6 @@ >> from pypy.interpreter import typedef >> -from pypy.interpreter.gateway import interp2app, unwrap_spec, >> WrappedDefault >> +from pypy.interpreter.gateway import interp2app, unwrap_spec, >> WrappedDefault,\ >> + interpindirect2app >> from pypy.interpreter.error import OperationError, operationerrfmt >> from pypy.interpreter.buffer import Buffer >> from pypy.objspace.std.register_all import register_all >> @@ -7,8 +8,10 @@ >> from pypy.objspace.std.strutil import (string_to_int, string_to_bigint, >> ParseStringError, >> ParseStringOverflowError) >> +from pypy.objspace.std.model import W_Object >> from rpython.rlib.rarithmetic import r_uint >> from rpython.rlib.objectmodel import instantiate >> +from rpython.rlib.rbigint import rbigint >> >> # ____________________________________________________________ >> >> @@ -36,14 +39,7 @@ >> >> >> def wrapint(space, x): >> - if space.config.objspace.std.withsmallint: >> - from pypy.objspace.std.smallintobject import W_SmallIntObject >> - try: >> - return W_SmallIntObject(x) >> - except OverflowError: >> - from pypy.objspace.std.intobject import W_IntObject >> - return W_IntObject(x) >> - elif space.config.objspace.std.withprebuiltint: >> + if space.config.objspace.std.withprebuiltint: >> from pypy.objspace.std.intobject import W_IntObject >> lower = space.config.objspace.std.prebuiltintfrom >> upper = space.config.objspace.std.prebuiltintto >> @@ -185,6 +181,27 @@ >> >> # ____________________________________________________________ >> >> +class W_AbstractIntObject(W_Object): >> + __slots__ = () >> + >> + def is_w(self, space, w_other): >> + if not isinstance(w_other, W_AbstractIntObject): >> + return False >> + if self.user_overridden_class or w_other.user_overridden_class: >> + return self is w_other >> + return space.int_w(self) == space.int_w(w_other) >> + >> + def immutable_unique_id(self, space): >> + if self.user_overridden_class: >> + return None >> + from pypy.objspace.std.model import IDTAG_INT as tag >> + b = space.bigint_w(self) >> + b = b.lshift(3).or_(rbigint.fromint(tag)) >> + return space.newlong_from_rbigint(b) >> + >> + def int(self, space): >> + raise NotImplementedError >> + >> int_typedef = StdTypeDef("int", >> __doc__ = '''int(x[, base]) -> integer >> >> @@ -201,5 +218,6 @@ >> denominator = typedef.GetSetProperty(descr_get_denominator), >> real = typedef.GetSetProperty(descr_get_real), >> imag = typedef.GetSetProperty(descr_get_imag), >> + __int__ = interpindirect2app(W_AbstractIntObject.int), >> ) >> int_typedef.registermethods(globals()) >> diff --git a/pypy/objspace/std/longobject.py >> b/pypy/objspace/std/longobject.py >> --- a/pypy/objspace/std/longobject.py >> +++ b/pypy/objspace/std/longobject.py >> @@ -87,6 +87,12 @@ >> def float_w(self, space): >> return self.num.tofloat() >> >> + def int(self, space): >> + try: >> + return space.newint(self.num.toint()) >> + except OverflowError: >> + return long__Long(space, self) >> + >> def __repr__(self): >> return '<W_LongObject(%d)>' % self.num.tolong() >> >> @@ -130,12 +136,6 @@ >> def long__Int(space, w_intobj): >> return space.newlong(w_intobj.intval) >> >> -def int__Long(space, w_value): >> - try: >> - return space.newint(w_value.num.toint()) >> - except OverflowError: >> - return long__Long(space, w_value) >> - >> def index__Long(space, w_value): >> return long__Long(space, w_value) >> >> diff --git a/pypy/objspace/std/model.py b/pypy/objspace/std/model.py >> --- a/pypy/objspace/std/model.py >> +++ b/pypy/objspace/std/model.py >> @@ -17,7 +17,6 @@ >> option_to_typename = { >> "withspecialisedtuple" : >> ["specialisedtupleobject.W_SpecialisedTupleObject"], >> "withsmalltuple" : ["smalltupleobject.W_SmallTupleObject"], >> - "withsmallint" : ["smallintobject.W_SmallIntObject"], >> "withsmalllong" : ["smalllongobject.W_SmallLongObject"], >> "withstrbuf" : ["strbufobject.W_StringBufferObject"], >> } >> @@ -158,18 +157,6 @@ >> # when trying to dispatch multimethods. >> # XXX build these lists a bit more automatically later >> >> - if config.objspace.std.withsmallint: >> - from pypy.objspace.std import smallintobject >> - self.typeorder[boolobject.W_BoolObject] += [ >> - (smallintobject.W_SmallIntObject, >> boolobject.delegate_Bool2SmallInt), >> - ] >> - self.typeorder[smallintobject.W_SmallIntObject] += [ >> - (intobject.W_IntObject, >> smallintobject.delegate_SmallInt2Int), >> - (floatobject.W_FloatObject, >> smallintobject.delegate_SmallInt2Float), >> - (longobject.W_LongObject, >> smallintobject.delegate_SmallInt2Long), >> - (complexobject.W_ComplexObject, >> smallintobject.delegate_SmallInt2Complex), >> - ] >> - >> if config.objspace.usemodules.micronumpy: >> from pypy.module.micronumpy.stdobjspace import >> register_delegates >> register_delegates(self.typeorder) >> @@ -424,7 +411,7 @@ >> ['delattr', 'delete', 'get', 'id', 'inplace_div', >> 'inplace_floordiv', >> 'inplace_lshift', 'inplace_mod', 'inplace_pow', 'inplace_rshift', >> 'inplace_truediv', 'is_', 'set', 'setattr', 'type', 'userdel', >> - 'isinstance', 'issubtype']) >> + 'isinstance', 'issubtype', 'int']) >> # XXX should we just remove those from the method table or we're happy >> # with just not having multimethods? >> >> @@ -442,7 +429,7 @@ >> >> # add all regular multimethods here >> for _name, _symbol, _arity, _specialnames in ObjSpace.MethodTable: >> - if _name not in locals() or _name in NOT_MULTIMETHODS: >> + if _name not in locals() and _name not in NOT_MULTIMETHODS: >> mm = StdObjSpaceMultiMethod(_symbol, _arity, _specialnames) >> locals()[_name] = mm >> del mm >> diff --git a/pypy/objspace/std/objspace.py b/pypy/objspace/std/objspace.py >> --- a/pypy/objspace/std/objspace.py >> +++ b/pypy/objspace/std/objspace.py >> @@ -26,7 +26,6 @@ >> from pypy.objspace.std.iterobject import W_SeqIterObject >> from pypy.objspace.std.setobject import W_SetObject, W_FrozensetObject >> from pypy.objspace.std.sliceobject import W_SliceObject >> -from pypy.objspace.std.smallintobject import W_SmallIntObject >> from pypy.objspace.std.stringobject import W_StringObject >> from pypy.objspace.std.unicodeobject import W_UnicodeObject >> from pypy.objspace.std.tupleobject import W_AbstractTupleObject >> @@ -580,16 +579,8 @@ >> self.setitem(w_obj, self.wrap(key), w_value) >> >> def getindex_w(self, w_obj, w_exception, objdescr=None): >> - # Performance shortcut for the common case of w_obj being an int. >> - # If withsmallint is disabled, we check for W_IntObject. >> - # If withsmallint is enabled, we only check for W_SmallIntObject >> - it's >> - # probably not useful to have a shortcut for W_IntObject at all >> then. >> - if self.config.objspace.std.withsmallint: >> - if type(w_obj) is W_SmallIntObject: >> - return w_obj.intval >> - else: >> - if type(w_obj) is W_IntObject: >> - return w_obj.intval >> + if type(w_obj) is W_IntObject: >> + return w_obj.intval >> return ObjSpace.getindex_w(self, w_obj, w_exception, objdescr) >> >> def call_method(self, w_obj, methname, *arg_w): >> diff --git a/pypy/objspace/std/smallintobject.py >> b/pypy/objspace/std/smallintobject.py >> deleted file mode 100644 >> --- a/pypy/objspace/std/smallintobject.py >> +++ /dev/null >> @@ -1,87 +0,0 @@ >> -""" >> -Implementation of small ints, stored as odd-valued pointers in the >> -translated PyPy. To enable them, see inttype.py. >> -""" >> -from pypy.objspace.std import intobject >> -from pypy.objspace.std.model import registerimplementation, W_Object >> -from pypy.objspace.std.register_all import register_all >> -from pypy.objspace.std.noneobject import W_NoneObject >> -from pypy.objspace.std.intobject import W_AbstractIntObject, W_IntObject >> -from pypy.interpreter.error import OperationError >> -from rpython.rlib.objectmodel import UnboxedValue >> -from rpython.rlib.rbigint import rbigint >> -from rpython.rlib.rarithmetic import r_uint >> -from rpython.tool.sourcetools import func_with_new_name >> -from pypy.objspace.std.inttype import wrapint >> - >> -class W_SmallIntObject(W_AbstractIntObject, UnboxedValue): >> - __slots__ = 'intval' >> - from pypy.objspace.std.inttype import int_typedef as typedef >> - >> - def unwrap(w_self, space): >> - return int(w_self.intval) >> - int_w = unwrap >> - >> - def uint_w(w_self, space): >> - intval = w_self.intval >> - if intval < 0: >> - raise OperationError(space.w_ValueError, >> - space.wrap("cannot convert negative >> integer to unsigned")) >> - else: >> - return r_uint(intval) >> - >> - def bigint_w(w_self, space): >> - return rbigint.fromint(w_self.intval) >> - >> - >> -registerimplementation(W_SmallIntObject) >> - >> - >> -def delegate_SmallInt2Int(space, w_small): >> - return W_IntObject(w_small.intval) >> - >> -def delegate_SmallInt2Long(space, w_small): >> - return space.newlong(w_small.intval) >> - >> -def delegate_SmallInt2Float(space, w_small): >> - return space.newfloat(float(w_small.intval)) >> - >> -def delegate_SmallInt2Complex(space, w_small): >> - return space.newcomplex(float(w_small.intval), 0.0) >> - >> -def add__SmallInt_SmallInt(space, w_a, w_b): >> - return wrapint(space, w_a.intval + w_b.intval) # cannot overflow >> - >> -def sub__SmallInt_SmallInt(space, w_a, w_b): >> - return wrapint(space, w_a.intval - w_b.intval) # cannot overflow >> - >> -def floordiv__SmallInt_SmallInt(space, w_a, w_b): >> - return wrapint(space, w_a.intval // w_b.intval) # cannot overflow >> - >> -div__SmallInt_SmallInt = floordiv__SmallInt_SmallInt >> - >> -def mod__SmallInt_SmallInt(space, w_a, w_b): >> - return wrapint(space, w_a.intval % w_b.intval) # cannot overflow >> - >> -def divmod__SmallInt_SmallInt(space, w_a, w_b): >> - w = wrapint(space, w_a.intval // w_b.intval) # cannot overflow >> - z = wrapint(space, w_a.intval % w_b.intval) >> - return space.newtuple([w, z]) >> - >> -def copy_multimethods(ns): >> - """Copy integer multimethods for small int.""" >> - for name, func in intobject.__dict__.iteritems(): >> - if "__Int" in name: >> - new_name = name.replace("Int", "SmallInt") >> - if new_name not in ns: >> - # Copy the function, so the annotator specializes it for >> - # W_SmallIntObject. >> - ns[new_name] = func = func_with_new_name(func, new_name, >> globals=ns) >> - else: >> - ns[name] = func >> - ns["get_integer"] = ns["pos__SmallInt"] = ns["int__SmallInt"] >> - ns["get_negint"] = ns["neg__SmallInt"] >> - >> -copy_multimethods(globals()) >> - >> -register_all(vars()) >> diff --git a/pypy/objspace/std/smalllongobject.py >> b/pypy/objspace/std/smalllongobject.py >> --- a/pypy/objspace/std/smalllongobject.py >> +++ b/pypy/objspace/std/smalllongobject.py >> @@ -69,7 +69,15 @@ >> def float_w(self, space): >> return float(self.longlong) >> >> + def int(self, space): >> + a = self.longlong >> + b = intmask(a) >> + if b == a: >> + return space.newint(b) >> + else: >> + return self >> >> + >> registerimplementation(W_SmallLongObject) >> >> # ____________________________________________________________ >> @@ -119,14 +127,6 @@ >> def long__SmallLong(space, w_value): >> return w_value >> >> -def int__SmallLong(space, w_value): >> - a = w_value.longlong >> - b = intmask(a) >> - if b == a: >> - return space.newint(b) >> - else: >> - return w_value >> - >> def index__SmallLong(space, w_value): >> return w_value >> >> diff --git a/pypy/objspace/std/test/test_intobject.py >> b/pypy/objspace/std/test/test_intobject.py >> --- a/pypy/objspace/std/test/test_intobject.py >> +++ b/pypy/objspace/std/test/test_intobject.py >> @@ -268,7 +268,7 @@ >> >> def test_int(self): >> f1 = iobj.W_IntObject(1) >> - result = iobj.int__Int(self.space, f1) >> + result = f1.int(self.space) >> assert result == f1 >> >> def test_oct(self): >> diff --git a/pypy/objspace/std/test/test_smallintobject.py >> b/pypy/objspace/std/test/test_smallintobject.py >> deleted file mode 100644 >> --- a/pypy/objspace/std/test/test_smallintobject.py >> +++ /dev/null >> @@ -1,229 +0,0 @@ >> -import sys, py >> - >> -#from pypy.objspace.std.model import WITHSMALLINT >> -#if not WITHSMALLINT: >> -# py.test.skip("WITHSMALLINT is not enabled") >> - >> -from pypy.objspace.std.inttype import wrapint >> -from pypy.objspace.std.multimethod import FailedToImplement >> -from rpython.rlib.rarithmetic import r_uint >> - >> -from pypy.objspace.std.test.test_intobject import AppTestInt >> - >> -class TestW_IntObject: >> - spaceconfig = {"objspace.std.withsmallint": True} >> - >> - def test_int_w(self): >> - assert self.space.int_w(self.space.wrap(42)) == 42 >> - >> - def test_uint_w(self): >> - space = self.space >> - assert space.uint_w(space.wrap(42)) == 42 >> - assert isinstance(space.uint_w(space.wrap(42)), r_uint) >> - space.raises_w(space.w_ValueError, space.uint_w, space.wrap(-1)) >> - >> - def test_repr(self): >> - x = 1 >> - f1 = wrapint(self.space, x) >> - result = self.space.repr(f1) >> - assert self.space.unwrap(result) == repr(x) >> - >> - def test_str(self): >> - x = 12345 >> - f1 = wrapint(self.space, x) >> - result = self.space.str(f1) >> - assert self.space.unwrap(result) == str(x) >> - >> - def test_hash(self): >> - x = 42 >> - f1 = wrapint(self.space, x) >> - result = self.space.hash(f1) >> - assert result.intval == hash(x) >> - >> - def test_compare(self): >> - import operator >> - optab = ['lt', 'le', 'eq', 'ne', 'gt', 'ge'] >> - for x in (-10, -1, 0, 1, 2, 1000, sys.maxint): >> - for y in (-sys.maxint-1, -11, -9, -2, 0, 1, 3, 1111, >> sys.maxint): >> - for op in optab: >> - wx = wrapint(self.space, x) >> - wy = wrapint(self.space, y) >> - res = getattr(operator, op)(x, y) >> - method = getattr(self.space, op) >> - myres = method(wx, wy) >> - assert self.space.unwrap(myres) == res >> - >> - def test_add(self): >> - for x in [1, 100, sys.maxint // 2 - 50, >> - sys.maxint // 2, sys.maxint - 1000, sys.maxint]: >> - for y in [1, 100, sys.maxint // 2 - 50, >> - sys.maxint // 2, sys.maxint - 1000, sys.maxint]: >> - f1 = wrapint(self.space, x) >> - f2 = wrapint(self.space, y) >> - result = self.space.unwrap(self.space.add(f1, f2)) >> - assert result == x+y >> - >> - def test_sub(self): >> - for x in [1, 100, sys.maxint // 2 - 50, >> - sys.maxint // 2, sys.maxint - 1000, sys.maxint]: >> - for y in [1, 100, sys.maxint // 2 - 50, >> - sys.maxint // 2, sys.maxint - 1000, sys.maxint]: >> - f1 = wrapint(self.space, x) >> - f2 = wrapint(self.space, y) >> - result = self.space.unwrap(self.space.sub(f1, f2)) >> - assert result == x-y >> - >> - def test_mul(self): >> - for x in [0, 1, 100, sys.maxint // 2 - 50, sys.maxint - 1000]: >> - for y in [0, 1, 100, sys.maxint // 2 - 50, sys.maxint - >> 1000]: >> - f1 = wrapint(self.space, x) >> - f2 = wrapint(self.space, y) >> - result = self.space.unwrap(self.space.mul(f1, f2)) >> - assert result == x*y >> - >> - >> - def test_div(self): >> - for i in range(10): >> - res = i//3 >> - f1 = wrapint(self.space, i) >> - f2 = wrapint(self.space, 3) >> - result = self.space.div(f1, f2) >> - assert result.intval == res >> - >> - def test_mod(self): >> - x = 1 >> - y = 2 >> - f1 = wrapint(self.space, x) >> - f2 = wrapint(self.space, y) >> - v = self.space.mod(f1, f2) >> - assert v.intval == x % y >> - # not that mod cannot overflow >> - >> - def test_divmod(self): >> - x = 1 >> - y = 2 >> - f1 = wrapint(self.space, x) >> - f2 = wrapint(self.space, y) >> - ret = self.space.divmod(f1, f2) >> - v, w = self.space.unwrap(ret) >> - assert (v, w) == divmod(x, y) >> - >> - def test_pow_iii(self): >> - x = 10 >> - y = 2 >> - z = 13 >> - f1 = wrapint(self.space, x) >> - f2 = wrapint(self.space, y) >> - f3 = wrapint(self.space, z) >> - v = self.space.pow(f1, f2, f3) >> - assert v.intval == pow(x, y, z) >> - f1, f2, f3 = [wrapint(self.space, i) for i in (10, -1, 42)] >> - self.space.raises_w(self.space.w_TypeError, >> - self.space.pow, >> - f1, f2, f3) >> - f1, f2, f3 = [wrapint(self.space, i) for i in (10, 5, 0)] >> - self.space.raises_w(self.space.w_ValueError, >> - self.space.pow, >> - f1, f2, f3) >> - >> - def test_pow_iin(self): >> - x = 10 >> - y = 2 >> - f1 = wrapint(self.space, x) >> - f2 = wrapint(self.space, y) >> - v = self.space.pow(f1, f2, self.space.w_None) >> - assert v.intval == x ** y >> - >> - def test_neg(self): >> - x = 42 >> - f1 = wrapint(self.space, x) >> - v = self.space.neg(f1) >> - assert v.intval == -x >> - >> - def test_pos(self): >> - x = 42 >> - f1 = wrapint(self.space, x) >> - v = self.space.pos(f1) >> - assert v.intval == +x >> - x = -42 >> - f1 = wrapint(self.space, x) >> - v = self.space.pos(f1) >> - assert v.intval == +x >> - >> - def test_abs(self): >> - x = 42 >> - f1 = wrapint(self.space, x) >> - v = self.space.abs(f1) >> - assert v.intval == abs(x) >> - x = -42 >> - f1 = wrapint(self.space, x) >> - v = self.space.abs(f1) >> - assert v.intval == abs(x) >> - >> - def test_invert(self): >> - x = 42 >> - f1 = wrapint(self.space, x) >> - v = self.space.invert(f1) >> - assert v.intval == ~x >> - >> - def test_lshift(self): >> - x = 12345678 >> - y = 2 >> - f1 = wrapint(self.space, x) >> - f2 = wrapint(self.space, y) >> - v = self.space.lshift(f1, f2) >> - assert v.intval == x << y >> - >> - def test_rshift(self): >> - x = 12345678 >> - y = 2 >> - f1 = wrapint(self.space, x) >> - f2 = wrapint(self.space, y) >> - v = self.space.rshift(f1, f2) >> - assert v.intval == x >> y >> - >> - def test_and(self): >> - x = 12345678 >> - y = 2 >> - f1 = wrapint(self.space, x) >> - f2 = wrapint(self.space, y) >> - v = self.space.and_(f1, f2) >> - assert v.intval == x & y >> - >> - def test_xor(self): >> - x = 12345678 >> - y = 2 >> - f1 = wrapint(self.space, x) >> - f2 = wrapint(self.space, y) >> - v = self.space.xor(f1, f2) >> - assert v.intval == x ^ y >> - >> - def test_or(self): >> - x = 12345678 >> - y = 2 >> - f1 = wrapint(self.space, x) >> - f2 = wrapint(self.space, y) >> - v = self.space.or_(f1, f2) >> - assert v.intval == x | y >> - >> - def test_int(self): >> - f1 = wrapint(self.space, 1) >> - result = self.space.int(f1) >> - assert result == f1 >> - >> - def test_oct(self): >> - x = 012345 >> - f1 = wrapint(self.space, x) >> - result = self.space.oct(f1) >> - assert self.space.unwrap(result) == oct(x) >> - >> - def test_hex(self): >> - x = 0x12345 >> - f1 = wrapint(self.space, x) >> - result = self.space.hex(f1) >> - assert self.space.unwrap(result) == hex(x) >> - >> - >> -class AppTestSmallInt(AppTestInt): >> - spaceconfig = {"objspace.std.optimized_int_add" : True, >> - "objspace.std.withsmallint" : True} >> diff --git a/pypy/objspace/std/typeobject.py >> b/pypy/objspace/std/typeobject.py >> --- a/pypy/objspace/std/typeobject.py >> +++ b/pypy/objspace/std/typeobject.py >> @@ -857,12 +857,6 @@ >> def _pure_issubtype(w_sub, w_type, version_tag1, version_tag2): >> return _issubtype(w_sub, w_type) >> >> -def issubtype__Type_Type(space, w_type, w_sub): >> - return space.newbool(w_sub.issubtype(w_type)) >> - >> -def isinstance__Type_ANY(space, w_type, w_inst): >> - return space.newbool(space.type(w_inst).issubtype(w_type)) >> - >> def repr__Type(space, w_obj): >> w_mod = w_obj.get_module() >> if not space.isinstance_w(w_mod, space.w_str): >> _______________________________________________ >> pypy-commit mailing list >> pypy-com...@python.org >> http://mail.python.org/mailman/listinfo/pypy-commit >> > > _______________________________________________ > pypy-dev mailing list > pypy-dev@python.org > http://mail.python.org/mailman/listinfo/pypy-dev _______________________________________________ pypy-dev mailing list pypy-dev@python.org http://mail.python.org/mailman/listinfo/pypy-dev
