def descr__new__(space, w_longtype, w_x, w_base=None):
from pypy.objspace.std.longobject import W_LongObject
if space.config.objspace.std.withsmalllong:
from pypy.objspace.std.smalllongobject import W_SmallLongObject
else:
W_SmallLongObject = None
w_value = w_x # 'x' is the keyword argument name in CPython
if w_base is None:
# check for easy cases
if (W_SmallLongObject and type(w_value) is W_SmallLongObject
and space.is_w(w_longtype, space.w_long)):
return w_value
elif type(w_value) is W_LongObject:
return newbigint(space, w_longtype, w_value.num)
elif space.isinstance_w(w_value, space.w_str):
return string_to_w_long(space, w_longtype, space.str_w(w_value))
elif space.isinstance_w(w_value, space.w_unicode):
from pypy.objspace.std.unicodeobject import unicode_to_decimal_w
return string_to_w_long(space, w_longtype,
unicode_to_decimal_w(space, w_value))
else:
# otherwise, use the __long__() or the __trunc__ methods
w_obj = w_value
if (space.lookup(w_obj, '__long__') is not None
or space.lookup(w_obj, '__int__') is not None):
w_obj = space.long(w_obj)
else:
w_obj = space.trunc(w_obj)
# :-( blame CPython 2.7
if space.lookup(w_obj, '__long__') is not None:
w_obj = space.long(w_obj)
else:
w_obj = space.int(w_obj)
bigint = space.bigint_w(w_obj)
return newbigint(space, w_longtype, bigint)
else:
base = space.int_w(w_base)
if space.isinstance_w(w_value, space.w_unicode):
from pypy.objspace.std.unicodeobject import unicode_to_decimal_w
s = unicode_to_decimal_w(space, w_value)
else:
try:
s = space.str_w(w_value)
except OperationError:
raise OperationError(
space.w_TypeError,
space.wrap("long() can't convert non-string "
"with explicit base"))
return string_to_w_long(space, w_longtype, s, base)
def descr__new__(space, w_longtype, w_x, w_base=None):
from pypy.objspace.std.longobject import W_LongObject
if space.config.objspace.std.withsmalllong:
from pypy.objspace.std.smalllongobject import W_SmallLongObject
else:
W_SmallLongObject = None
w_value = w_x # 'x' is the keyword argument name in CPython
if w_base is None:
# check for easy cases
if (W_SmallLongObject and type(w_value) is W_SmallLongObject
and space.is_w(w_longtype, space.w_long)):
return w_value
elif type(w_value) is W_LongObject:
return newbigint(space, w_longtype, w_value.num)
elif space.isinstance_w(w_value, space.w_str):
return string_to_w_long(space, w_longtype, space.str_w(w_value))
elif space.isinstance_w(w_value, space.w_unicode):
from pypy.objspace.std.unicodeobject import unicode_to_decimal_w
return string_to_w_long(space, w_longtype,
unicode_to_decimal_w(space, w_value))
else:
# otherwise, use the __long__() or the __trunc__ methods
w_obj = w_value
if (space.lookup(w_obj, '__long__') is not None or
space.lookup(w_obj, '__int__') is not None):
w_obj = space.long(w_obj)
else:
w_obj = space.trunc(w_obj)
# :-( blame CPython 2.7
if space.lookup(w_obj, '__long__') is not None:
w_obj = space.long(w_obj)
else:
w_obj = space.int(w_obj)
bigint = space.bigint_w(w_obj)
return newbigint(space, w_longtype, bigint)
else:
base = space.int_w(w_base)
if space.isinstance_w(w_value, space.w_unicode):
from pypy.objspace.std.unicodeobject import unicode_to_decimal_w
s = unicode_to_decimal_w(space, w_value)
else:
try:
s = space.str_w(w_value)
except OperationError:
raise OperationError(space.w_TypeError,
space.wrap("long() can't convert non-string "
"with explicit base"))
return string_to_w_long(space, w_longtype, s, base)
def descr__new__(space, w_inttype, w_x, w_base=None):
from pypy.objspace.std.intobject import W_IntObject
w_longval = None
w_value = w_x # 'x' is the keyword argument name in CPython
value = 0
if w_base is None:
ok = False
# check for easy cases
if type(w_value) is W_IntObject:
value = w_value.intval
ok = True
elif space.isinstance_w(w_value, space.w_str):
value, w_longval = string_to_int_or_long(space,
space.str_w(w_value))
ok = True
elif space.isinstance_w(w_value, space.w_unicode):
from pypy.objspace.std.unicodeobject import unicode_to_decimal_w
string = unicode_to_decimal_w(space, w_value)
value, w_longval = string_to_int_or_long(space, string)
ok = True
else:
# If object supports the buffer interface
try:
w_buffer = space.buffer(w_value)
except OperationError, e:
if not e.match(space, space.w_TypeError):
raise
else:
buf = space.interp_w(Buffer, w_buffer)
value, w_longval = string_to_int_or_long(space, buf.as_str())
ok = True
def descr__new__(space, w_inttype, w_x, w_base=None):
from pypy.objspace.std.intobject import W_IntObject
w_longval = None
w_value = w_x # 'x' is the keyword argument name in CPython
value = 0
if w_base is None:
ok = False
# check for easy cases
if type(w_value) is W_IntObject:
value = w_value.intval
ok = True
elif space.isinstance_w(w_value, space.w_str):
value, w_longval = string_to_int_or_long(space, space.str_w(w_value))
ok = True
elif space.isinstance_w(w_value, space.w_unicode):
from pypy.objspace.std.unicodeobject import unicode_to_decimal_w
string = unicode_to_decimal_w(space, w_value)
value, w_longval = string_to_int_or_long(space, string)
ok = True
else:
# If object supports the buffer interface
try:
w_buffer = space.buffer(w_value)
except OperationError, e:
if not e.match(space, space.w_TypeError):
raise
else:
buf = space.interp_w(Buffer, w_buffer)
value, w_longval = string_to_int_or_long(space, buf.as_str())
ok = True
def descr__new__(space, w_complextype, w_real, w_imag=None):
# if w_real is already a complex number and there is no second
# argument, return it. Note that we cannot return w_real if
# it is an instance of a *subclass* of complex, or if w_complextype
# is itself a subclass of complex.
noarg2 = w_imag is None
if (noarg2 and space.is_w(w_complextype, space.w_complex)
and space.is_w(space.type(w_real), space.w_complex)):
return w_real
if space.isinstance_w(w_real, space.w_text):
# a string argument
if not noarg2:
raise oefmt(
space.w_TypeError, "complex() can't take second"
" arg if first is a string")
unistr = unicode_to_decimal_w(space, w_real)
try:
unistr = _remove_underscores(unistr)
except ValueError:
raise oefmt(space.w_ValueError,
"complex() arg is a malformed string")
try:
realstr, imagstr = _split_complex(unistr)
except ValueError:
raise oefmt(space.w_ValueError,
"complex() arg is a malformed string")
try:
realval = string_to_float(realstr)
imagval = string_to_float(imagstr)
except ParseStringError:
raise oefmt(space.w_ValueError,
"complex() arg is a malformed string")
else:
# non-string arguments
realval, imagval = unpackcomplex(space, w_real)
# now take w_imag into account
if not noarg2:
# complex(x, y) == x+y*j, even if 'y' is already a complex.
realval2, imagval2 = unpackcomplex(space,
w_imag,
firstarg=False)
# try to preserve the signs of zeroes of realval and realval2
if imagval2 != 0.0:
realval -= imagval2
if imagval != 0.0:
imagval += realval2
else:
imagval = realval2
# done
w_obj = space.allocate_instance(W_ComplexObject, w_complextype)
W_ComplexObject.__init__(w_obj, realval, imagval)
return w_obj
def descr__new__(space, w_longtype, w_x, w_base=None):
if space.config.objspace.std.withsmalllong:
from pypy.objspace.std.smalllongobject import W_SmallLongObject
else:
W_SmallLongObject = None
w_value = w_x # 'x' is the keyword argument name in CPython
if w_base is None:
# check for easy cases
if (W_SmallLongObject and type(w_value) is W_SmallLongObject
and space.is_w(w_longtype, space.w_long)):
return w_value
elif type(w_value) is W_LongObject:
return newbigint(space, w_longtype, w_value.num)
elif (space.lookup(w_value, '__long__') is not None
or space.lookup(w_value, '__int__') is not None):
w_obj = space.long(w_value)
return newbigint(space, w_longtype, space.bigint_w(w_obj))
elif space.lookup(w_value, '__trunc__') is not None:
w_obj = space.trunc(w_value)
# :-( blame CPython 2.7
if space.lookup(w_obj, '__long__') is not None:
w_obj = space.long(w_obj)
else:
w_obj = space.int(w_obj)
return newbigint(space, w_longtype, space.bigint_w(w_obj))
elif space.isinstance_w(w_value, space.w_str):
return _string_to_w_long(space, w_longtype, w_value,
space.str_w(w_value))
elif space.isinstance_w(w_value, space.w_unicode):
from pypy.objspace.std.unicodeobject import unicode_to_decimal_w
return _string_to_w_long(space, w_longtype, w_value,
unicode_to_decimal_w(space, w_value))
else:
try:
buf = space.charbuf_w(w_value)
except OperationError, e:
if not e.match(space, space.w_TypeError):
raise
raise oefmt(
space.w_TypeError,
"long() argument must be a string or a number, "
"not '%T'", w_value)
else:
return _string_to_w_long(space, w_longtype, w_value, buf)
def descr__new__(space, w_longtype, w_x, w_base=None):
if space.config.objspace.std.withsmalllong:
from pypy.objspace.std.smalllongobject import W_SmallLongObject
else:
W_SmallLongObject = None
w_value = w_x # 'x' is the keyword argument name in CPython
if w_base is None:
# check for easy cases
if (W_SmallLongObject and type(w_value) is W_SmallLongObject
and space.is_w(w_longtype, space.w_long)):
return w_value
elif type(w_value) is W_LongObject:
return newbigint(space, w_longtype, w_value.num)
elif (space.lookup(w_value, '__long__') is not None or
space.lookup(w_value, '__int__') is not None):
w_obj = space.long(w_value)
return newbigint(space, w_longtype, space.bigint_w(w_obj))
elif space.lookup(w_value, '__trunc__') is not None:
w_obj = space.trunc(w_value)
# :-( blame CPython 2.7
if space.lookup(w_obj, '__long__') is not None:
w_obj = space.long(w_obj)
else:
w_obj = space.int(w_obj)
return newbigint(space, w_longtype, space.bigint_w(w_obj))
elif space.isinstance_w(w_value, space.w_str):
return _string_to_w_long(space, w_longtype, w_value,
space.str_w(w_value))
elif space.isinstance_w(w_value, space.w_unicode):
from pypy.objspace.std.unicodeobject import unicode_to_decimal_w
return _string_to_w_long(space, w_longtype, w_value,
unicode_to_decimal_w(space, w_value))
else:
try:
buf = space.charbuf_w(w_value)
except OperationError, e:
if not e.match(space, space.w_TypeError):
raise
raise oefmt(space.w_TypeError,
"long() argument must be a string or a number, "
"not '%T'", w_value)
else:
return _string_to_w_long(space, w_longtype, w_value, buf)
def _new_int(space, w_inttype, w_x, w_base=None):
w_longval = None
w_value = w_x # 'x' is the keyword argument name in CPython
value = 0
if w_base is None:
# check for easy cases
if type(w_value) is W_IntObject:
value = w_value.intval
elif (space.lookup(w_value, '__int__') is not None or
space.lookup(w_value, '__trunc__') is not None):
# otherwise, use the __int__() or the __trunc__() methods
w_obj = w_value
if space.lookup(w_obj, '__int__') is None:
w_obj = space.trunc(w_obj)
w_obj = space.int(w_obj)
# 'int(x)' should return what x.__int__() returned, which should
# be an int or long or a subclass thereof.
if space.is_w(w_inttype, space.w_int):
return w_obj
# int_w is effectively what we want in this case,
# we cannot construct a subclass of int instance with an
# an overflowing long
value = space.int_w(w_obj, allow_conversion=False)
elif space.isinstance_w(w_value, space.w_str):
value, w_longval = _string_to_int_or_long(space, w_value,
space.str_w(w_value))
elif space.isinstance_w(w_value, space.w_unicode):
from pypy.objspace.std.unicodeobject import unicode_to_decimal_w
string = unicode_to_decimal_w(space, w_value)
value, w_longval = _string_to_int_or_long(space, w_value, string)
else:
# If object supports the buffer interface
try:
buf = space.charbuf_w(w_value)
except OperationError as e:
if not e.match(space, space.w_TypeError):
raise
raise oefmt(space.w_TypeError,
"int() argument must be a string or a number, "
"not '%T'", w_value)
else:
value, w_longval = _string_to_int_or_long(space, w_value, buf)
else:
base = space.int_w(w_base)
if space.isinstance_w(w_value, space.w_unicode):
from pypy.objspace.std.unicodeobject import unicode_to_decimal_w
s = unicode_to_decimal_w(space, w_value)
else:
try:
s = space.str_w(w_value)
except OperationError as e:
raise oefmt(space.w_TypeError,
"int() can't convert non-string with explicit "
"base")
value, w_longval = _string_to_int_or_long(space, w_value, s, base)
if w_longval is not None:
if not space.is_w(w_inttype, space.w_int):
raise oefmt(space.w_OverflowError,
"long int too large to convert to int")
return w_longval
elif space.is_w(w_inttype, space.w_int):
# common case
return wrapint(space, value)
else:
w_obj = space.allocate_instance(W_IntObject, w_inttype)
W_IntObject.__init__(w_obj, value)
return w_obj
# we cannot construct a subclass of int instance with an
# an overflowing long
try:
value = space.int_w(w_obj)
except OperationError, e:
if e.match(space, space.w_TypeError):
raise OperationError(
space.w_ValueError,
space.wrap("value can't be converted to int"))
raise e
else:
base = space.int_w(w_base)
if space.isinstance_w(w_value, space.w_unicode):
from pypy.objspace.std.unicodeobject import unicode_to_decimal_w
s = unicode_to_decimal_w(space, w_value)
else:
try:
s = space.str_w(w_value)
except OperationError, e:
raise OperationError(
space.w_TypeError,
space.wrap("int() can't convert non-string "
"with explicit base"))
value, w_longval = string_to_int_or_long(space, s, base)
if w_longval is not None:
if not space.is_w(w_inttype, space.w_int):
raise OperationError(
space.w_OverflowError,
def test_unicode_to_decimal_w_wide(self, space):
from pypy.objspace.std.unicodeobject import unicode_to_decimal_w
w_s = space.wrap(u'\U0001D7CF\U0001D7CE') # 𝟏𝟎
s2 = unicode_to_decimal_w(space, w_s)
assert s2 == "10"
def descr__new__(space, w_longtype, w_x, w_base=None):
if space.config.objspace.std.withsmalllong:
from pypy.objspace.std.smalllongobject import W_SmallLongObject
else:
W_SmallLongObject = None
w_value = w_x # 'x' is the keyword argument name in CPython
if w_base is None:
# check for easy cases
if (W_SmallLongObject and type(w_value) is W_SmallLongObject
and space.is_w(w_longtype, space.w_long)):
return w_value
elif type(w_value) is W_LongObject:
return newbigint(space, w_longtype, w_value.num)
elif (space.lookup(w_value, '__long__') is not None
or space.lookup(w_value, '__int__') is not None):
w_obj = space.long(w_value)
if (space.is_w(w_longtype, space.w_long)
and space.isinstance_w(w_obj, space.w_long)):
return w_obj
return newbigint(space, w_longtype, space.bigint_w(w_obj))
elif space.lookup(w_value, '__trunc__') is not None:
w_obj = space.trunc(w_value)
if (space.is_w(w_longtype, space.w_long)
and space.isinstance_w(w_obj, space.w_long)):
return w_obj
# :-( blame CPython 2.7
if space.lookup(w_obj, '__long__') is not None:
w_obj = space.long(w_obj)
else:
w_obj = space.int(w_obj)
return newbigint(space, w_longtype, space.bigint_w(w_obj))
elif space.isinstance_w(w_value, space.w_bytes):
return _string_to_w_long(space, w_longtype, w_value,
space.bytes_w(w_value))
elif space.isinstance_w(w_value, space.w_unicode):
from pypy.objspace.std.unicodeobject import unicode_to_decimal_w
return _string_to_w_long(space, w_longtype, w_value,
unicode_to_decimal_w(space, w_value))
else:
try:
buf = space.charbuf_w(w_value)
except OperationError as e:
if not e.match(space, space.w_TypeError):
raise
raise oefmt(
space.w_TypeError,
"larg() argumento tiene que ser palabra o número, "
"no '%T'", w_value)
else:
return _string_to_w_long(space, w_longtype, w_value, buf)
else:
base = space.int_w(w_base)
if space.isinstance_w(w_value, space.w_unicode):
from pypy.objspace.std.unicodeobject import unicode_to_decimal_w
s = unicode_to_decimal_w(space, w_value)
else:
try:
s = space.bytes_w(w_value)
except OperationError:
raise oefmt(
space.w_TypeError,
"larg() no puede convertir no-palabra con base "
"explícito")
return _string_to_w_long(space, w_longtype, w_value, s, base)
def _new_baseint(space, w_value, w_base=None):
if w_base is None:
if space.is_w(space.type(w_value), space.w_int):
assert isinstance(w_value, W_AbstractIntObject)
return w_value
elif space.lookup(w_value, '__int__') is not None:
w_intvalue = space.int(w_value)
return _ensure_baseint(space, w_intvalue)
elif space.lookup(w_value, '__trunc__') is not None:
w_obj = space.trunc(w_value)
if not space.isinstance_w(w_obj, space.w_int):
w_obj = space.int(w_obj)
assert isinstance(w_obj, W_AbstractIntObject)
return _ensure_baseint(space, w_obj)
elif space.isinstance_w(w_value, space.w_unicode):
from pypy.objspace.std.unicodeobject import unicode_to_decimal_w
try:
b = unicode_to_decimal_w(space, w_value)
except Exception:
raise oefmt(space.w_ValueError,
'invalid literal for int() with base 10: %R',
w_value)
return _string_to_int_or_long(space, w_value, b)
elif (space.isinstance_w(w_value, space.w_bytearray)
or space.isinstance_w(w_value, space.w_bytes)):
return _string_to_int_or_long(space, w_value,
space.charbuf_w(w_value))
else:
# If object supports the buffer interface
try:
buf = space.charbuf_w(w_value)
except OperationError as e:
if not e.match(space, space.w_TypeError):
raise
raise oefmt(
space.w_TypeError,
"int() argument must be a string, a bytes-like "
"object or a number, not '%T'", w_value)
else:
return _string_to_int_or_long(space, w_value, buf)
else:
try:
base = space.getindex_w(w_base, None)
except OperationError as e:
if not e.match(space, space.w_OverflowError):
raise
base = 37 # this raises the right error in string_to_bigint()
if space.isinstance_w(w_value, space.w_unicode):
from pypy.objspace.std.unicodeobject import unicode_to_decimal_w
try:
s = unicode_to_decimal_w(space, w_value)
except Exception:
raise oefmt(space.w_ValueError,
'invalid literal for int() with base %d: %R', base,
w_value)
elif (space.isinstance_w(w_value, space.w_bytes)
or space.isinstance_w(w_value, space.w_bytearray)):
s = space.charbuf_w(w_value)
else:
raise oefmt(space.w_TypeError,
"int() can't convert non-string with explicit base")
return _string_to_int_or_long(space, w_value, s, base)
def test_unicode_to_decimal_w(self, space):
from pypy.objspace.std.unicodeobject import unicode_to_decimal_w
w_s = space.wrap(u"\N{EM SPACE}-3\N{EN SPACE}")
s2 = unicode_to_decimal_w(space, w_s)
assert s2 == " -3 "
def test_unicode_to_decimal_w_wide(self, space):
from pypy.objspace.std.unicodeobject import unicode_to_decimal_w
w_s = space.wrap(u'\U0001D7CF\U0001D7CE') # 𝟏𝟎
s2 = unicode_to_decimal_w(space, w_s)
assert s2 == "10"
def _new_int(space, w_inttype, w_x, w_base=None):
w_longval = None
w_value = w_x # 'x' is the keyword argument name in CPython
value = 0
if w_base is None:
# check for easy cases
if type(w_value) is W_IntObject:
value = w_value.intval
elif (space.lookup(w_value, '__int__') is not None
or space.lookup(w_value, '__trunc__') is not None):
# otherwise, use the __int__() or the __trunc__() methods
w_obj = w_value
if space.lookup(w_obj, '__int__') is None:
w_obj = space.trunc(w_obj)
w_obj = space.int(w_obj)
# 'int(x)' should return what x.__int__() returned, which should
# be an int or long or a subclass thereof.
if space.is_w(w_inttype, space.w_int):
return w_obj
# int_w is effectively what we want in this case,
# we cannot construct a subclass of int instance with an
# an overflowing long
value = space.int_w(w_obj, allow_conversion=False)
elif space.isinstance_w(w_value, space.w_str):
value, w_longval = _string_to_int_or_long(space, w_value,
space.str_w(w_value))
elif space.isinstance_w(w_value, space.w_unicode):
from pypy.objspace.std.unicodeobject import unicode_to_decimal_w
string = unicode_to_decimal_w(space, w_value)
value, w_longval = _string_to_int_or_long(space, w_value, string)
else:
# If object supports the buffer interface
try:
buf = space.charbuf_w(w_value)
except OperationError as e:
if not e.match(space, space.w_TypeError):
raise
raise oefmt(
space.w_TypeError,
"int() argument must be a string or a number, "
"not '%T'", w_value)
else:
value, w_longval = _string_to_int_or_long(space, w_value, buf)
else:
base = space.int_w(w_base)
if space.isinstance_w(w_value, space.w_unicode):
from pypy.objspace.std.unicodeobject import unicode_to_decimal_w
s = unicode_to_decimal_w(space, w_value)
else:
try:
s = space.str_w(w_value)
except OperationError as e:
raise oefmt(
space.w_TypeError,
"int() can't convert non-string with explicit "
"base")
value, w_longval = _string_to_int_or_long(space, w_value, s, base)
if w_longval is not None:
if not space.is_w(w_inttype, space.w_int):
raise oefmt(space.w_OverflowError,
"long int too large to convert to int")
return w_longval
elif space.is_w(w_inttype, space.w_int):
# common case
return wrapint(space, value)
else:
w_obj = space.allocate_instance(W_IntObject, w_inttype)
W_IntObject.__init__(w_obj, value)
return w_obj
try:
buf = space.charbuf_w(w_value)
except OperationError, e:
if not e.match(space, space.w_TypeError):
raise
raise oefmt(space.w_TypeError,
"long() argument must be a string or a number, "
"not '%T'", w_value)
else:
return _string_to_w_long(space, w_longtype, w_value, buf)
else:
base = space.int_w(w_base)
if space.isinstance_w(w_value, space.w_unicode):
from pypy.objspace.std.unicodeobject import unicode_to_decimal_w
s = unicode_to_decimal_w(space, w_value)
else:
try:
s = space.str_w(w_value)
except OperationError:
raise oefmt(space.w_TypeError,
"long() can't convert non-string with explicit "
"base")
return _string_to_w_long(space, w_longtype, w_value, s, base)
def _string_to_w_long(space, w_longtype, w_source, string, base=10):
try:
bigint = rbigint.fromstr(string, base)
except ParseStringError as e:
raise wrap_parsestringerror(space, e, w_source)
def test_unicode_to_decimal_w(self, space):
from pypy.objspace.std.unicodeobject import unicode_to_decimal_w
w_s = space.wrap(u"\N{EM SPACE}-3\N{EN SPACE}")
s2 = unicode_to_decimal_w(space, w_s)
assert s2 == " -3 "
def _new_int(space, w_inttype, w_x, w_base=None):
from pypy.objspace.std.longobject import W_LongObject, newbigint
if space.config.objspace.std.withsmalllong:
from pypy.objspace.std.smalllongobject import W_SmallLongObject
else:
W_SmallLongObject = None
w_longval = None
w_value = w_x # 'x' is the keyword argument name in CPython
value = 0
if w_base is None:
# check for easy cases
if type(w_value) is W_IntObject:
if space.is_w(w_inttype, space.w_int):
return w_value
value = w_value.intval
w_obj = space.allocate_instance(W_IntObject, w_inttype)
W_IntObject.__init__(w_obj, value)
return w_obj
elif type(w_value) is W_LongObject:
if space.is_w(w_inttype, space.w_int):
return w_value
return newbigint(space, w_inttype, w_value.num)
elif W_SmallLongObject and type(w_value) is W_SmallLongObject:
if space.is_w(w_inttype, space.w_int):
return w_value
return newbigint(space, w_inttype, space.bigint_w(w_value))
elif space.lookup(w_value, '__int__') is not None:
return _from_intlike(space, w_inttype, w_value)
elif space.lookup(w_value, '__trunc__') is not None:
return _from_intlike(space, w_inttype, space.trunc(w_value))
elif space.isinstance_w(w_value, space.w_unicode):
from pypy.objspace.std.unicodeobject import unicode_to_decimal_w
return _string_to_int_or_long(space, w_inttype, w_value,
unicode_to_decimal_w(space, w_value))
elif (space.isinstance_w(w_value, space.w_bytearray) or
space.isinstance_w(w_value, space.w_bytes)):
return _string_to_int_or_long(space, w_inttype, w_value,
space.bufferstr_w(w_value))
else:
# If object supports the buffer interface
try:
buf = space.charbuf_w(w_value)
except OperationError as e:
if not e.match(space, space.w_TypeError):
raise
raise oefmt(space.w_TypeError,
"int() argument must be a string or a number, "
"not '%T'", w_value)
else:
return _string_to_int_or_long(space, w_inttype, w_value, buf)
else:
try:
base = space.int_w(w_base)
except OperationError, e:
if not e.match(space, space.w_OverflowError):
raise
base = 37 # this raises the right error in string_to_bigint()
if space.isinstance_w(w_value, space.w_unicode):
from pypy.objspace.std.unicodeobject import unicode_to_decimal_w
s = unicode_to_decimal_w(space, w_value)
else:
try:
s = space.bufferstr_w(w_value)
except OperationError as e:
raise oefmt(space.w_TypeError,
"int() can't convert non-string with explicit "
"base")
return _string_to_int_or_long(space, w_inttype, w_value, s, base)
def _new_int(space, w_inttype, w_x, w_base=None):
from pypy.objspace.std.longobject import W_LongObject, newbigint
if space.config.objspace.std.withsmalllong:
from pypy.objspace.std.smalllongobject import W_SmallLongObject
else:
W_SmallLongObject = None
w_longval = None
w_value = w_x # 'x' is the keyword argument name in CPython
value = 0
if w_base is None:
# check for easy cases
if type(w_value) is W_IntObject:
if space.is_w(w_inttype, space.w_int):
return w_value
value = w_value.intval
w_obj = space.allocate_instance(W_IntObject, w_inttype)
W_IntObject.__init__(w_obj, value)
return w_obj
elif type(w_value) is W_LongObject:
if space.is_w(w_inttype, space.w_int):
return w_value
return newbigint(space, w_inttype, w_value.num)
elif W_SmallLongObject and type(w_value) is W_SmallLongObject:
if space.is_w(w_inttype, space.w_int):
return w_value
return newbigint(space, w_inttype, space.bigint_w(w_value))
elif space.lookup(w_value, "__int__") is not None:
return _from_intlike(space, w_inttype, w_value)
elif space.lookup(w_value, "__trunc__") is not None:
return _from_intlike(space, w_inttype, space.trunc(w_value))
elif space.isinstance_w(w_value, space.w_unicode):
from pypy.objspace.std.unicodeobject import unicode_to_decimal_w
return _string_to_int_or_long(space, w_inttype, w_value, unicode_to_decimal_w(space, w_value))
elif space.isinstance_w(w_value, space.w_bytearray) or space.isinstance_w(w_value, space.w_bytes):
return _string_to_int_or_long(space, w_inttype, w_value, space.bufferstr_w(w_value))
else:
# If object supports the buffer interface
try:
buf = space.charbuf_w(w_value)
except OperationError as e:
if not e.match(space, space.w_TypeError):
raise
raise oefmt(space.w_TypeError, "int() argument must be a string or a number, " "not '%T'", w_value)
else:
return _string_to_int_or_long(space, w_inttype, w_value, buf)
else:
try:
base = space.int_w(w_base)
except OperationError, e:
if not e.match(space, space.w_OverflowError):
raise
base = 37 # this raises the right error in string_to_bigint()
if space.isinstance_w(w_value, space.w_unicode):
from pypy.objspace.std.unicodeobject import unicode_to_decimal_w
s = unicode_to_decimal_w(space, w_value)
else:
try:
s = space.bufferstr_w(w_value)
except OperationError as e:
raise oefmt(space.w_TypeError, "int() can't convert non-string with explicit " "base")
return _string_to_int_or_long(space, w_inttype, w_value, s, base)
