def to_num(value):
if value[0] == "+":
value = value[1:]
if value == "inf.0":
return W_Flonum.INF
elif value == "-inf.0":
return W_Flonum.NEGINF
elif value == "nan.0":
return W_Flonum.NAN
if "/" in value:
if len(re.findall('/', value)) > 1:
raise Exception(
"Something's wrong with this rational number : %s" % value)
sides = value.split("/")
numer = sides[0]
denom = sides[1]
return W_Rational.make(to_num(numer), to_num(denom))
v = float(value)
if "." in value:
return W_Flonum(v)
else:
try:
return W_Fixnum.make(string_to_int(value))
except ParseStringOverflowError:
val = rbigint.fromdecimalstr(value)
return W_Bignum(val)
raise Exception("Didn't know what to do with this number : %s" % value)
def string_to_int_or_long(space, string, base=10):
w_longval = None
value = 0
try:
value = string_to_int(string, base)
except ParseStringError, e:
raise OperationError(space.w_ValueError, space.wrap(e.msg))
def _to_num(json):
assert json.is_object
obj = json.value_object()
if "real" in obj:
r = obj["real"]
return values.W_Flonum.make(r.value_float())
if "real-part" in obj:
r = obj["real-part"]
i = obj["imag-part"]
return values.W_Complex.make(_to_num(r), _to_num(i))
if "numerator" in obj:
n = obj["numerator"]
d = obj["denominator"]
return values.W_Rational.make(_to_num(n), _to_num(d))
if "extended-real" in obj:
rs = obj["extended-real"].value_string()
if rs == "+inf.0":
return values.W_Flonum.INF
if rs == "-inf.0":
return values.W_Flonum.NEGINF
if rs == "+nan.0":
return values.W_Flonum.NAN
if "integer" in obj:
rs = obj["integer"].value_string()
try:
return values.W_Fixnum.make(string_to_int(rs))
except ParseStringOverflowError:
val = rbigint.fromdecimalstr(rs)
return values.W_Bignum(val)
assert False
def read_number_or_id(f, init):
sofar = StringBuilder(64)
sofar.append(init)
while True:
c = f.peek()
if c == "":
break
if idchar(c):
v = f.read(1)
assert v == c
sofar.append(v)
else:
break
got = sofar.build()
try:
val = string_to_int(got)
return values.W_Fixnum.make_or_interned(val)
except ParseStringOverflowError:
val = rbigint.fromdecimalstr(got)
return values.W_Bignum(val)
except ParseStringError:
try:
return values.W_Flonum(float(got))
except:
return values.W_Symbol.make(got)
def read_number_or_id(f, init):
sofar = StringBuilder(64)
sofar.append(init)
while True:
c = f.peek()
if c == "":
break
if idchar(c):
v = f.read(1)
assert v == c
sofar.append(v)
else:
break
got = sofar.build()
try:
val = string_to_int(got)
return values.W_Fixnum.make_or_interned(val)
except ParseStringOverflowError:
val = rbigint.fromdecimalstr(got)
return values.W_Bignum(val)
except ParseStringError:
try:
return values.W_Flonum(float(got))
except:
return values.W_Symbol.make(got)
def _to_num(json):
assert json.is_object
obj = json.value_object()
if "real" in obj:
r = obj["real"]
return values.W_Flonum.make(r.value_float())
if "real-part" in obj:
r = obj["real-part"]
i = obj["imag-part"]
return values.W_Complex.make(_to_num(r), _to_num(i))
if "numerator" in obj:
n = obj["numerator"]
d = obj["denominator"]
return values.W_Rational.make(_to_num(n), _to_num(d))
if "extended-real" in obj:
rs = obj["extended-real"].value_string()
if rs == "+inf.0":
return INF
if rs == "-inf.0":
return NEGINF
if rs == "+nan.0":
return NAN
if "integer" in obj:
rs = obj["integer"].value_string()
try:
return values.W_Fixnum.make(string_to_int(rs))
except ParseStringOverflowError:
val = rbigint.fromdecimalstr(rs)
return values.W_Bignum(val)
assert False
def string_to_int_or_long(space, string, base=10):
w_longval = None
value = 0
try:
value = string_to_int(string, base)
except ParseStringError, e:
raise OperationError(space.w_ValueError,
space.wrap(e.msg))
def _string_to_int_or_long(space, w_source, string, base=10):
w_longval = None
value = 0
try:
value = string_to_int(string, base)
except ParseStringError as e:
raise wrap_parsestringerror(space, e, w_source)
except ParseStringOverflowError as e:
w_longval = _retry_to_w_long(space, e.parser, w_source)
return value, w_longval
def _string_to_int_or_long(space, w_source, string, base=10):
w_longval = None
value = 0
try:
value = string_to_int(string, base)
except ParseStringError as e:
raise wrap_parsestringerror(space, e, w_source)
except ParseStringOverflowError as e:
w_longval = _retry_to_w_long(space, e.parser, w_source)
return value, w_longval
def _str2num(s, radix):
from rpython.rlib import rarithmetic, rfloat, rbigint
from rpython.rlib.rstring import ParseStringError, ParseStringOverflowError
from rpython.rlib.rsre import rsre_re as re
import math
try:
if ((radix == 16 and re.match("^[0-9A-Fa-f]+$", s))
or (radix == 8 and re.match("^[0-7]+$", s))
or (radix == 10 and re.match("^[0-9]+$", s))):
try:
return values.W_Fixnum(rarithmetic.string_to_int(s,
base=radix))
except ParseStringOverflowError:
return values.W_Bignum(rbigint.rbigint.fromstr(s, base=radix))
if re.match("[+-]?([\d]+)?.?\d+[tT]\d", s):
# it's an extflonum
return values.W_ExtFlonum(s)
if re.match("[+-]?([\d]+)?.?\d+[sf]\d", s):
if "f" in s:
f_parts = s.split("f")
elif "s" in s:
f_parts = s.split("s")
else:
raise ParseStringError("invalid floating point number : %s" %
s)
if len(f_parts) > 2:
raise ParseStringError("invalid floating point number : %s" %
s)
try:
numb = float(f_parts[0])
prec = int(f_parts[1])
p = math.pow(10, prec)
except ValueError, e:
return values.w_false
return values.W_Flonum.make(numb * p, True)
if re.match("[+-]?([\d]+)?.?\d+e\d", s):
e_parts = s.split("e")
if len(e_parts) > 2:
raise ParseStringError("invalid floating point number : %s" %
s)
try:
num = float(e_parts[0])
exp = int(e_parts[1])
p = math.pow(10, exp)
except ValueError, e:
return values.w_false
return values.W_Flonum(num * p)
def _string_to_int_or_long(space, w_source, string, base=10):
try:
value = string_to_int(string,
base,
allow_underscores=True,
no_implicit_octal=True)
return wrapint(space, value)
except ParseStringError as e:
raise wrap_parsestringerror(space, e, w_source)
except ParseStringOverflowError as e:
return _retry_to_w_long(space, e.parser, w_source)
def _str2num(s, radix):
from rpython.rlib import rarithmetic, rfloat, rbigint
from rpython.rlib.rstring import ParseStringError, ParseStringOverflowError
from rpython.rlib.rsre import rsre_re as re
import math
try:
if ((radix == 16 and re.match("^[0-9A-Fa-f]+$", s)) or
(radix == 8 and re.match("^[0-7]+$", s)) or
(radix == 10 and re.match("^[0-9]+$", s))):
try:
return values.W_Fixnum(rarithmetic.string_to_int(s, base=radix))
except ParseStringOverflowError:
return values.W_Bignum(rbigint.rbigint.fromstr(s, base=radix))
if re.match("[+-]?([\d]+)?.?\d+[tT]\d", s):
# it's an extflonum
return values.W_ExtFlonum(s)
if re.match("[+-]?([\d]+)?.?\d+[sf]\d", s):
if "f" in s:
f_parts = s.split("f")
elif "s" in s:
f_parts = s.split("s")
else:
raise ParseStringError("invalid floating point number : %s" % s)
if len(f_parts) > 2:
raise ParseStringError("invalid floating point number : %s" % s)
try:
numb = float(f_parts[0])
prec = int(f_parts[1])
p = math.pow(10, prec)
except ValueError, e:
return values.w_false
return values.W_Flonum.make(numb*p, True)
if re.match("[+-]?([\d]+)?.?\d+e\d", s):
e_parts = s.split("e")
if len(e_parts) > 2:
raise ParseStringError("invalid floating point number : %s" % s)
try:
num = float(e_parts[0])
exp = int(e_parts[1])
p = math.pow(10, exp)
except ValueError, e:
return values.w_false
return values.W_Flonum(num*p)
def _string_to_int_or_long(space, w_inttype, w_source, string, base=10):
try:
value = string_to_int(string, base)
except ParseStringError as e:
raise wrap_parsestringerror(space, e, w_source)
except ParseStringOverflowError as e:
return _retry_to_w_long(space, e.parser, w_inttype, w_source)
if space.is_w(w_inttype, space.w_int):
w_result = wrapint(space, value)
else:
w_result = space.allocate_instance(W_IntObject, w_inttype)
W_IntObject.__init__(w_result, value)
return w_result
def _string_to_int_or_long(space, w_inttype, w_source, string, base=10):
try:
value = string_to_int(string, base)
except ParseStringError as e:
raise wrap_parsestringerror(space, e, w_source)
except ParseStringOverflowError as e:
return _retry_to_w_long(space, e.parser, w_inttype, w_source)
if space.is_w(w_inttype, space.w_int):
w_result = wrapint(space, value)
else:
w_result = space.allocate_instance(W_IntObject, w_inttype)
W_IntObject.__init__(w_result, value)
return w_result
def str2num(w_s):
from rpython.rlib import rarithmetic, rfloat, rbigint
from rpython.rlib.rstring import ParseStringError, ParseStringOverflowError
try:
s = w_s.as_str_utf8()
if "." in s:
return values.W_Flonum(rfloat.string_to_float(s))
else:
try:
return values.W_Fixnum(rarithmetic.string_to_int(s, base=0))
except ParseStringOverflowError:
return values.W_Bignum(rbigint.rbigint.fromstr(s))
except ParseStringError as e:
return values.w_false
def str2num(w_s):
from rpython.rlib import rarithmetic, rfloat, rbigint
from rpython.rlib.rstring import ParseStringError, ParseStringOverflowError
s = w_s.as_str_utf8()
try:
if "." in s:
return values.W_Flonum(rfloat.string_to_float(s))
else:
try:
return values.W_Fixnum(rarithmetic.string_to_int(s, base=10))
except ParseStringOverflowError:
return values.W_Bignum(rbigint.rbigint.fromstr(s))
except ParseStringError as e:
return values.w_false
def exact_from_node(self, node, radix):
s = node.token.source
i = 0
# Skip prefixes
while s[i] == "#":
i += 2
s = s[i:]
src_pos = self.make_src_pos(node)
try:
return kt.Fixnum(string_to_int(s, radix), src_pos)
except rstring.ParseStringOverflowError:
if radix == 10:
bi = rbigint.fromdecimalstr(s)
else:
bi = rbigint.fromstr(s, radix)
return kt.Bignum(bi, src_pos)
def _literal_integer(self, negate_value):
try:
i = string_to_int(self._text)
if negate_value:
i = 0 - i
result = self._universe.new_integer(i)
except ParseStringOverflowError:
bigint = rbigint.fromstr(self._text)
if negate_value:
bigint.sign = -1
result = self._universe.new_biginteger(bigint)
except ValueError:
raise ParseError("Could not parse integer. "
"Expected a number but got '%s'" % self._text,
Symbol.NONE, self)
self._expect(Symbol.Integer)
return result
def _literal_integer(self, negate_value):
try:
i = string_to_int(self._text)
if negate_value:
i = 0 - i
result = self._universe.new_integer(i)
except ParseStringOverflowError:
bigint = rbigint.fromstr(self._text)
if negate_value:
bigint.sign = -1
result = self._universe.new_biginteger(bigint)
except ValueError:
raise ParseError(
"Could not parse integer. "
"Expected a number but got '%s'" % self._text, Symbol.NONE,
self)
self._expect(Symbol.Integer)
return result
def read_number_or_id(f, init):
sofar = [init]
while True:
(count, c) = f.peek()
if c == "":
break
c = c[0]
if c.isalnum():
sofar.append(f.read(1))
else:
break
got = "".join(sofar)
try:
return NumberToken(values.W_Fixnum.make(string_to_int(got)))
except ParseStringOverflowError:
val = rbigint.fromdecimalstr(got)
return NumberToken(values.W_Bignum(val))
except ParseStringError:
try:
return NumberToken(values.W_Flonum.make(float(got)))
except:
return SymbolToken(values.W_Symbol.make(got))
def read_number_or_id(f, init):
sofar = [init]
while True:
c = f.peek()
if c == "":
break
if idchar(c):
v = f.read(1)
assert v == c
sofar.append(v)
else:
break
got = "".join(sofar)
try:
return NumberToken(values.W_Fixnum.make(string_to_int(got)))
except ParseStringOverflowError:
val = rbigint.fromdecimalstr(got)
return NumberToken(values.W_Bignum(val))
except ParseStringError:
try:
return NumberToken(values.W_Flonum.make(float(got)))
except:
return SymbolToken(values.W_Symbol.make(got))
def read_number_or_id(f, init):
sofar = [init]
while True:
c = f.peek()
if c == "":
break
if idchar(c):
v = f.read(1)
assert v == c
sofar.append(v)
else:
break
got = "".join(sofar)
try:
return NumberToken(values.W_Fixnum.make(string_to_int(got)))
except ParseStringOverflowError:
val = rbigint.fromdecimalstr(got)
return NumberToken(values.W_Bignum(val))
except ParseStringError:
try:
return NumberToken(values.W_Flonum.make(float(got)))
except:
return SymbolToken(values.W_Symbol.make(got))
def cons_to_num(charlist):
from prolog.interpreter.helper import unwrap_list, unwrap_atom
unwrapped = unwrap_list(charlist)
numlist = []
saw_dot = False
first = True
i = 0
for elem in unwrapped:
if not isinstance(elem, term.Atom):
error.throw_type_error("text", charlist)
digit = elem.name()
if digit not in digits:
if digit == ".":
if saw_dot or first or (i == 1 and numlist[0] == "-"):
error.throw_syntax_error("Illegal number")
else:
saw_dot = True
elif digit == "-":
if not first:
error.throw_syntax_error("Illegal number")
else:
error.throw_syntax_error("Illegal number")
numlist.append(digit)
i += 1
first = False
numstr = "".join(numlist)
if numstr.find(".") == -1: # no float
try:
return term.Number(string_to_int(numstr))
except ParseStringOverflowError:
return term.BigInt(rbigint.fromdecimalstr(numstr))
try:
return term.Float(float(numstr))
except ValueError:
error.throw_syntax_error("Illegal number")
def string_to_int(s):
return model.w_integer(
rarithmetic.string_to_int(rstring.replace(s, "_", ""), base=0))
try:
num = float(e_parts[0])
exp = int(e_parts[1])
p = math.pow(10, exp)
except ValueError, e:
return values.w_false
return values.W_Flonum(num*p)
if "." in s or re.match("[+-]?([\d]+)(\.[\d]+)?e[+-][\d]+$", s):
if not radix == 10: # FIXME
raise SchemeException("string->number : floats with base different than 10 are not supported yet : given number : %s - radix : %s" % (s, str(radix)))
return values.W_Flonum(rfloat.string_to_float(s))
else:
try:
return values.W_Fixnum(rarithmetic.string_to_int(s, base=radix))
except ParseStringOverflowError:
return values.W_Bignum(rbigint.rbigint.fromstr(s, base=radix))
except ParseStringError as e:
return values.w_false
@expose("number->string",
[values.W_Number, default(values.W_Fixnum, values.W_Fixnum.make(10))])
def num2str(a, radix):
from rpython.rlib.rbigint import BASE8, BASE16
if radix.value == 10:
return W_String.fromascii(a.tostring())
else:
if isinstance(a, values.W_Fixnum):
if radix.value == 16:
res = hex(a.value)
def str2num(w_s, radix, convert_mode, decimal_mode):
from rpython.rlib import rarithmetic, rfloat, rbigint
from rpython.rlib.rstring import ParseStringError, ParseStringOverflowError
from rpython.rlib.rsre import rsre_re as re
import math
s = w_s.as_str_utf8()
try:
if re.match("[+-]?([\d]+)?.?\d+[tT]\d", s):
# it's an extflonum
return values.W_ExtFlonum(s)
if re.match("[+-]?([\d]+)?.?\d+[sf]\d", s):
if "f" in s:
f_parts = s.split("f")
elif "s" in s:
f_parts = s.split("s")
else:
raise ParseStringError("invalid floating point number : %s" %
s)
if len(f_parts) > 2:
raise ParseStringError("invalid floating point number : %s" %
s)
try:
numb = float(f_parts[0])
prec = int(f_parts[1])
p = math.pow(10, prec)
except ValueError:
return values.w_false
return values.W_Flonum.make(numb * p, True)
if re.match("[+-]?([\d]+)?.?\d+e\d", s):
e_parts = s.split("e")
if len(e_parts) > 2:
raise ParseStringError("invalid floating point number : %s" %
s)
try:
num = float(e_parts[0])
exp = int(e_parts[1])
p = math.pow(10, exp)
except ValueError:
return values.w_false
return values.W_Flonum(num * p)
if "." in s or re.match("[+-]?([\d]+)(\.[\d]+)?e[+-][\d]+$", s):
if not radix.equal(values.W_Fixnum(10)): # FIXME
raise SchemeException(
"string->number : floats with base different than 10 are not supported yet : given number : %s - radix : %s"
% (w_s.tostring(), radix.tostring()))
return values.W_Flonum(rfloat.string_to_float(s))
else:
try:
return values.W_Fixnum(
rarithmetic.string_to_int(s, base=radix.toint()))
except ParseStringOverflowError:
return values.W_Bignum(rbigint.rbigint.fromstr(s))
except ParseStringError as e:
return values.w_false
try:
num = float(e_parts[0])
exp = int(e_parts[1])
p = math.pow(10, exp)
except ValueError, e:
return values.w_false
return values.W_Flonum(num*p)
if "." in s or re.match("[+-]?([\d]+)(\.[\d]+)?e[+-][\d]+$", s):
if not radix == 10: # FIXME
raise SchemeException("string->number : floats with base different than 10 are not supported yet : given number : %s - radix : %s" % (w_s.tostring(), str(radix)))
return values.W_Flonum(rfloat.string_to_float(s))
else:
try:
return values.W_Fixnum(rarithmetic.string_to_int(s, base=radix))
except ParseStringOverflowError:
return values.W_Bignum(rbigint.rbigint.fromstr(s, base=radix))
except ParseStringError as e:
return values.w_false
@expose("number->string",
[values.W_Number, default(values.W_Fixnum, values.W_Fixnum.make(10))])
def num2str(a, radix):
from rpython.rlib.rbigint import BASE8, BASE16
if radix.value == 10:
return W_String.fromascii(a.tostring())
else:
if isinstance(a, values.W_Fixnum):
if radix.value == 16:
res = hex(a.value)
