def descr__new__(space, w_complextype, w_real=0.0, w_imag=None):
from pypy.objspace.std.complexobject import W_ComplexObject
# 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 = space.is_w(w_imag, space.w_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_str) or \
space.isinstance_w(w_real, space.w_unicode):
# a string argument
if not noarg2:
raise OperationError(
space.w_TypeError,
space.wrap("complex() can't take second arg"
" if first is a string"))
try:
realstr, imagstr = _split_complex(space.str_w(w_real))
except ValueError:
raise OperationError(space.w_ValueError, space.wrap(ERR_MALFORMED))
try:
realval = string_to_float(realstr)
imagval = string_to_float(imagstr)
except ParseStringError:
raise OperationError(space.w_ValueError, space.wrap(ERR_MALFORMED))
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)
# 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_complextype, w_real=0.0, w_imag=None):
from pypy.objspace.std.complexobject import W_ComplexObject
# 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 = space.is_w(w_imag, space.w_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_str) or \
space.isinstance_w(w_real, space.w_unicode):
# a string argument
if not noarg2:
raise OperationError(space.w_TypeError,
space.wrap("complex() can't take second arg"
" if first is a string"))
try:
realstr, imagstr = _split_complex(space.str_w(w_real))
except ValueError:
raise OperationError(space.w_ValueError, space.wrap(ERR_MALFORMED))
try:
realval = string_to_float(realstr)
imagval = string_to_float(imagstr)
except ParseStringError:
raise OperationError(space.w_ValueError, space.wrap(ERR_MALFORMED))
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)
# 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_floattype, w_x=0.0):
from pypy.objspace.std.floatobject import W_FloatObject
w_value = w_x # 'x' is the keyword argument name in CPython
if space.is_true(space.isinstance(w_value, space.w_str)):
strvalue = space.str_w(w_value)
try:
if USE_NEW_S2F:
value = interp_string_to_float(space, strvalue)
else:
value = string_to_float(strvalue)
except ParseStringError, e:
raise OperationError(space.w_ValueError, space.wrap(e.msg))
def descr__new__(space, w_floattype, w_x=0.0):
from pypy.objspace.std.floatobject import W_FloatObject
w_value = w_x # 'x' is the keyword argument name in CPython
if space.is_true(space.isinstance(w_value, space.w_str)):
strvalue = space.str_w(w_value)
try:
if USE_NEW_S2F:
value = interp_string_to_float(space, strvalue)
else:
value = string_to_float(strvalue)
except ParseStringError, e:
raise OperationError(space.w_ValueError,
space.wrap(e.msg))
def descr__new__(space, w_floattype, w_x=0.0):
from pypy.objspace.std.floatobject import W_FloatObject
w_value = w_x # 'x' is the keyword argument name in CPython
w_special = space.lookup(w_value, "__float__")
if w_special is not None:
w_obj = space.get_and_call_function(w_special, w_value)
if not space.isinstance_w(w_obj, space.w_float):
raise OperationError(space.w_TypeError,
space.wrap("__float__ returned non-float"))
if space.is_w(w_floattype, space.w_float):
return w_obj
value = space.float_w(w_obj)
elif space.isinstance_w(w_value, space.w_str):
strvalue = space.str_w(w_value)
try:
value = string_to_float(strvalue)
except ParseStringError, e:
raise OperationError(space.w_ValueError, space.wrap(e.msg))
def descr__new__(space, w_floattype, w_x=0.0):
from pypy.objspace.std.floatobject import W_FloatObject
w_value = w_x # 'x' is the keyword argument name in CPython
w_special = space.lookup(w_value, "__float__")
if w_special is not None:
w_obj = space.get_and_call_function(w_special, w_value)
if not space.isinstance_w(w_obj, space.w_float):
raise OperationError(space.w_TypeError,
space.wrap("__float__ returned non-float"))
if space.is_w(w_floattype, space.w_float):
return w_obj
value = space.float_w(w_obj)
elif space.is_true(space.isinstance(w_value, space.w_str)):
strvalue = space.str_w(w_value)
try:
value = string_to_float(strvalue)
except ParseStringError, e:
raise OperationError(space.w_ValueError,
space.wrap(e.msg))
else:
value = string_to_float(strvalue)
except ParseStringError, e:
raise OperationError(space.w_ValueError,
space.wrap(e.msg))
elif space.is_true(space.isinstance(w_value, space.w_unicode)):
if space.config.objspace.std.withropeunicode:
from pypy.objspace.std.ropeunicodeobject import unicode_to_decimal_w
else:
from unicodeobject import unicode_to_decimal_w
strvalue = unicode_to_decimal_w(space, w_value)
try:
if USE_NEW_S2F:
value = interp_string_to_float(space, strvalue)
else:
value = string_to_float(strvalue)
except ParseStringError, e:
raise OperationError(space.w_ValueError,
space.wrap(e.msg))
else:
w_obj = space.float(w_value)
if space.is_w(w_floattype, space.w_float):
return w_obj # 'float(x)' should return
# whatever x.__float__() returned
value = space.float_w(w_obj)
w_obj = space.allocate_instance(W_FloatObject, w_floattype)
W_FloatObject.__init__(w_obj, value)
return w_obj
# ____________________________________________________________
