def _impl_pow(space, iv, w_int2, iz=r_longlong(0)):
iw = w_int2.intval
if iw < 0:
if iz != 0:
raise OperationError(space.w_TypeError,
space.wrap("pow() 2nd argument "
"cannot be negative when 3rd argument specified"))
## bounce it, since it always returns float
raise FailedToImplementArgs(space.w_ValueError,
space.wrap("integer exponentiation"))
temp = iv
ix = r_longlong(1)
try:
while iw > 0:
if iw & 1:
ix = llong_mul_ovf(ix, temp)
iw >>= 1 #/* Shift exponent down by 1 bit */
if iw==0:
break
temp = llong_mul_ovf(temp, temp) #/* Square the value of temp */
if iz:
#/* If we did a multiplication, perform a modulo */
ix = ix % iz
temp = temp % iz
if iz:
ix = ix % iz
except OverflowError:
raise FailedToImplementArgs(space.w_OverflowError,
space.wrap("integer exponentiation"))
return W_SmallLongObject(ix)
def g(n, m, o):
# This function should be completely marked as residual by
# codewriter.py on 32-bit platforms. On 64-bit platforms,
# this function should be JITted and the test should pass too.
n = r_longlong(n)
m = r_longlong(m)
return intmask((n*m) // o)
def g(n, m, o):
# This function should be completely marked as residual by
# codewriter.py on 32-bit platforms. On 64-bit platforms,
# this function should be JITted and the test should pass too.
n = r_longlong(n)
m = r_longlong(m)
return intmask((n * m) // o)
def _impl_pow(space, iv, w_int2, iz=r_longlong(0)):
iw = w_int2.intval
if iw < 0:
if iz != 0:
raise OperationError(
space.w_TypeError,
space.wrap("pow() 2nd argument "
"cannot be negative when 3rd argument specified"))
## bounce it, since it always returns float
raise FailedToImplementArgs(space.w_ValueError,
space.wrap("integer exponentiation"))
temp = iv
ix = r_longlong(1)
try:
while iw > 0:
if iw & 1:
ix = llong_mul_ovf(ix, temp)
iw >>= 1 #/* Shift exponent down by 1 bit */
if iw == 0:
break
temp = llong_mul_ovf(temp, temp) #/* Square the value of temp */
if iz:
#/* If we did a multiplication, perform a modulo */
ix = ix % iz
temp = temp % iz
if iz:
ix = ix % iz
except OverflowError:
raise FailedToImplementArgs(space.w_OverflowError,
space.wrap("integer exponentiation"))
return W_SmallLongObject(ix)
def test_cast_float_to_ulonglong():
f = 12350000000000000000.0
py.test.raises(OverflowError, r_longlong, f)
r_longlong(f / 2) # does not raise OverflowError
#
x = llop.cast_float_to_ulonglong(lltype.UnsignedLongLong, f)
assert x == r_ulonglong(f)
def test_direct():
space = gettestobjspace(**{"objspace.std.withsmalllong": True})
w5 = space.wrap(r_longlong(5))
assert isinstance(w5, W_SmallLongObject)
wlarge = space.wrap(r_longlong(0x123456789ABCDEFL))
#
assert space.int_w(w5) == 5
if sys.maxint < 0x123456789ABCDEFL:
py.test.raises(OperationError, space.int_w, wlarge)
else:
assert space.int_w(wlarge) == 0x123456789ABCDEF
#
assert space.pos(w5) is w5
assert space.abs(w5) is w5
wm5 = space.wrap(r_longlong(-5))
assert space.int_w(space.abs(wm5)) == 5
assert space.int_w(space.neg(w5)) == -5
assert space.is_true(w5) is True
assert space.is_true(wm5) is True
w0 = space.wrap(r_longlong(0))
assert space.is_true(w0) is False
#
w14000000000000 = space.wrap(r_longlong(0x14000000000000L))
assert space.is_true(space.eq(
space.lshift(w5, space.wrap(49)), w14000000000000)) is False
assert space.is_true(space.eq(
space.lshift(w5, space.wrap(50)), w14000000000000)) is True
#
w_huge = space.sub(space.lshift(w5, space.wrap(150)), space.wrap(1))
wx = space.and_(w14000000000000, w_huge)
assert space.is_true(space.eq(wx, w14000000000000))
def f(n1, n2):
# n == -30000000000000
n = (r_longlong(n1) << 32) | r_longlong(n2)
compare(n < n, 0, 0)
compare(n <= n, 0, 1)
compare(n == n, 0, 1)
compare(n != n, 0, 0)
compare(n > n, 0, 0)
compare(n >= n, 0, 1)
o = n + 2000000000
compare(o, -6985, -1948404736)
compare(n < o, 0, 1) # low word differs
compare(n <= o, 0, 1)
compare(o < n, 0, 0)
compare(o <= n, 0, 0)
compare(n > o, 0, 0)
compare(n >= o, 0, 0)
compare(o > n, 0, 1)
compare(o >= n, 0, 1)
compare(n == o, 0, 0)
compare(n != o, 0, 1)
p = -o
compare(n < p, 0, 1) # high word differs
compare(n <= p, 0, 1)
compare(p < n, 0, 0)
compare(p <= n, 0, 0)
compare(n > p, 0, 0)
compare(n >= p, 0, 0)
compare(p > n, 0, 1)
compare(p >= n, 0, 1)
compare(n == p, 0, 0)
compare(n != p, 0, 1)
return 1
def min_max_acc_method(size, signed):
if signed:
min = -(2 ** (8*size-1))
max = (2 ** (8*size-1)) - 1
if size <= native_int_size:
accept_method = 'accept_int_arg'
min = int(min)
max = int(max)
else:
accept_method = 'accept_longlong_arg'
min = r_longlong(min)
max = r_longlong(max)
else:
min = 0
max = (2 ** (8*size)) - 1
if size < native_int_size:
accept_method = 'accept_int_arg'
elif size == native_int_size:
accept_method = 'accept_uint_arg'
min = r_uint(min)
max = r_uint(max)
else:
accept_method = 'accept_ulonglong_arg'
min = r_ulonglong(min)
max = r_ulonglong(max)
return min, max, accept_method
def f(n1, n2):
# n == -30000000000000
n = (r_longlong(n1) << 32) | r_longlong(n2)
compare(n < n, 0, 0)
compare(n <= n, 0, 1)
compare(n == n, 0, 1)
compare(n != n, 0, 0)
compare(n > n, 0, 0)
compare(n >= n, 0, 1)
o = n + 2000000000
compare(o, -6985, -1948404736)
compare(n < o, 0, 1) # low word differs
compare(n <= o, 0, 1)
compare(o < n, 0, 0)
compare(o <= n, 0, 0)
compare(n > o, 0, 0)
compare(n >= o, 0, 0)
compare(o > n, 0, 1)
compare(o >= n, 0, 1)
compare(n == o, 0, 0)
compare(n != o, 0, 1)
p = -o
compare(n < p, 0, 1) # high word differs
compare(n <= p, 0, 1)
compare(p < n, 0, 0)
compare(p <= n, 0, 0)
compare(n > p, 0, 0)
compare(n >= p, 0, 0)
compare(p > n, 0, 1)
compare(p >= n, 0, 1)
compare(n == p, 0, 0)
compare(n != p, 0, 1)
return 1
def test_cast_float_to_ulonglong():
f = 12350000000000000000.0
py.test.raises(OverflowError, r_longlong, f)
r_longlong(f / 2) # does not raise OverflowError
#
x = llop.cast_float_to_ulonglong(lltype.UnsignedLongLong, f)
assert x == r_ulonglong(f)
def min_max_acc_method(size, signed):
if signed:
min = -(2**(8 * size - 1))
max = (2**(8 * size - 1)) - 1
if size <= native_int_size:
accept_method = 'accept_int_arg'
min = int(min)
max = int(max)
else:
accept_method = 'accept_longlong_arg'
min = r_longlong(min)
max = r_longlong(max)
else:
min = 0
max = (2**(8 * size)) - 1
if size < native_int_size:
accept_method = 'accept_int_arg'
elif size == native_int_size:
accept_method = 'accept_uint_arg'
min = r_uint(min)
max = r_uint(max)
else:
accept_method = 'accept_ulonglong_arg'
min = r_ulonglong(min)
max = r_ulonglong(max)
return min, max, accept_method
def test_slonglong_args(self):
"""
long long sum_xy_longlong(long long x, long long y)
{
return x+y;
}
"""
maxint32 = 2147483647 # we cannot really go above maxint on 64 bits
# (and we would not test anything, as there long
# is the same as long long)
libfoo = self.get_libfoo()
func = (libfoo, 'sum_xy_longlong', [types.slonglong, types.slonglong],
types.slonglong)
if IS_32_BIT:
x = r_longlong(maxint32+1)
y = r_longlong(maxint32+2)
zero = longlong2float(r_longlong(0))
else:
x = maxint32+1
y = maxint32+2
zero = 0
res = self.call(func, [x, y], rffi.LONGLONG, init_result=zero)
if IS_32_BIT:
# obscure, on 32bit it's really a long long, so it returns a
# DOUBLE because of the JIT hack
res = float2longlong(res)
expected = maxint32*2 + 3
assert res == expected
def f(x):
if x == r_longlong(3):
return 9
elif x == r_longlong(9):
return 27
elif x == r_longlong(27):
return 3
return 0
def f(x):
if x == r_longlong(3):
return 9
elif x == r_longlong(9):
return 27
elif x == r_longlong(27):
return 3
return 0
def unmarshal_Int64(space, u, tc):
lo = u.get_int() # get the first 32 bits
hi = u.get_int() # get the next 32 bits
if LONG_BIT >= 64:
x = (hi << 32) | (lo & (2**32 - 1)) # result fits in an int
else:
x = (r_longlong(hi) << 32) | r_longlong(r_uint(lo)) # get a r_longlong
return space.wrap(x)
def g(n, m, o, p):
# On 64-bit platforms, long longs == longs. On 32-bit platforms,
# this function should be either completely marked as residual
# (with supports_longlong==False), or be compiled as a
# sequence of residual calls (with long long arguments).
n = r_longlong(n)
m = r_longlong(m)
return intmask((n * m + p) // o)
def g(n, m, o, p):
# On 64-bit platforms, long longs == longs. On 32-bit platforms,
# this function should be either completely marked as residual
# (with supports_longlong==False), or be compiled as a
# sequence of residual calls (with long long arguments).
n = r_longlong(n)
m = r_longlong(m)
return intmask((n*m + p) // o)
def unmarshal_Int64(space, u, tc):
lo = u.get_int() # get the first 32 bits
hi = u.get_int() # get the next 32 bits
if LONG_BIT >= 64:
x = (hi << 32) | (lo & (2**32-1)) # result fits in an int
else:
x = (r_longlong(hi) << 32) | r_longlong(r_uint(lo)) # get a r_longlong
return space.wrap(x)
def test_float_conversion_implicit(self):
def f(ii):
return 1.0 + ii
res = self.interpret(f, [r_longlong(100000000)])
assert type(res) is float
assert res == 100000001.
res = self.interpret(f, [r_longlong(1234567890123456789)])
assert type(res) is float
assert self.float_eq(res, 1.2345678901234568e+18)
def pack_float(result, number, size, bigendian):
"""Append to 'result' the 'size' characters of the 32-bit or 64-bit
IEEE representation of the number.
"""
if size == 4:
bias = 127
exp = 8
prec = 23
else:
bias = 1023
exp = 11
prec = 52
if isnan(number):
sign = 0x80
man, e = 1.5, bias + 1
else:
if number < 0:
sign = 0x80
number *= -1
elif number == 0.0:
for i in range(size):
result.append('\x00')
return
else:
sign = 0x00
if isinf(number):
man, e = 1.0, bias + 1
else:
man, e = math.frexp(number)
if 0.5 <= man and man < 1.0:
man *= 2
e -= 1
man -= 1
e += bias
power_of_two = r_longlong(1) << prec
mantissa = r_longlong(power_of_two * man + 0.5)
if mantissa >> prec:
mantissa = 0
e += 1
for i in range(size - 2):
result.append(chr(mantissa & 0xff))
mantissa >>= 8
x = (mantissa & ((1 << (15 - exp)) - 1)) | ((e & ((1 << (exp - 7)) - 1)) <<
(15 - exp))
result.append(chr(x))
x = sign | e >> (exp - 7)
result.append(chr(x))
if bigendian:
first = len(result) - size
last = len(result) - 1
for i in range(size // 2):
(result[first + i], result[last - i]) = (result[last - i],
result[first + i])
def pack_float(result, number, size, bigendian):
"""Append to 'result' the 'size' characters of the 32-bit or 64-bit
IEEE representation of the number.
"""
if size == 4:
bias = 127
exp = 8
prec = 23
else:
bias = 1023
exp = 11
prec = 52
if isnan(number):
sign = 0x80
man, e = 1.5, bias + 1
else:
if number < 0:
sign = 0x80
number *= -1
elif number == 0.0:
for i in range(size):
result.append('\x00')
return
else:
sign = 0x00
if isinf(number):
man, e = 1.0, bias + 1
else:
man, e = math.frexp(number)
if 0.5 <= man and man < 1.0:
man *= 2
e -= 1
man -= 1
e += bias
power_of_two = r_longlong(1) << prec
mantissa = r_longlong(power_of_two * man + 0.5)
if mantissa >> prec :
mantissa = 0
e += 1
for i in range(size-2):
result.append(chr(mantissa & 0xff))
mantissa >>= 8
x = (mantissa & ((1<<(15-exp))-1)) | ((e & ((1<<(exp-7))-1))<<(15-exp))
result.append(chr(x))
x = sign | e >> (exp - 7)
result.append(chr(x))
if bigendian:
first = len(result) - size
last = len(result) - 1
for i in range(size // 2):
(result[first + i], result[last - i]) = (
result[last - i], result[first + i])
def f(n1, n2, m1, m2, ii):
# n == -30000000000000, m == -20000000000, ii == 42
n = (r_longlong(n1) << 32) | r_longlong(n2)
m = (r_longlong(m1) << 32) | r_longlong(m2)
compare(n & m, -6989, 346562560)
compare(n | m, -1, 1474836480)
compare(n ^ m, 6988, 1128273920)
compare(n << 1, -13970, 693125120)
compare(r_longlong(5) << ii, 5120, 0)
compare(n >> 1, -3493, -1974202368)
compare(n >> 42, -1, -7)
return 1
def f(n1, n2, m1, m2, ii):
# n == -30000000000000, m == -20000000000, ii == 42
n = (r_longlong(n1) << 32) | r_longlong(n2)
m = (r_longlong(m1) << 32) | r_longlong(m2)
compare(n & m, -6989, 346562560)
compare(n | m, -1, 1474836480)
compare(n ^ m, 6988, 1128273920)
compare(n << 1, -13970, 693125120)
compare(r_longlong(5) << ii, 5120, 0)
compare(n >> 1, -3493, -1974202368)
compare(n >> 42, -1, -7)
return 1
def expose_value_as_rpython(value):
if intmask(value) == value:
return value
if r_uint(value) == value:
return r_uint(value)
try:
if r_longlong(value) == value:
return r_longlong(value)
except OverflowError:
pass
if r_ulonglong(value) == value:
return r_ulonglong(value)
raise OverflowError("value %d does not fit into any RPython integer type" % (value,))
def test_args_from_int(self):
BASE = 1 << SHIFT
MAX = int(BASE-1)
assert rbigint.fromrarith_int(0).eq(bigint([0], 0))
assert rbigint.fromrarith_int(17).eq(bigint([17], 1))
assert rbigint.fromrarith_int(MAX).eq(bigint([MAX], 1))
assert rbigint.fromrarith_int(r_longlong(BASE)).eq(bigint([0, 1], 1))
assert rbigint.fromrarith_int(r_longlong(BASE**2)).eq(
bigint([0, 0, 1], 1))
assert rbigint.fromrarith_int(-17).eq(bigint([17], -1))
assert rbigint.fromrarith_int(-MAX).eq(bigint([MAX], -1))
assert rbigint.fromrarith_int(-MAX-1).eq(bigint([0, 1], -1))
assert rbigint.fromrarith_int(r_longlong(-(BASE**2))).eq(
bigint([0, 0, 1], -1))
def expose_value_as_rpython(value):
if intmask(value) == value:
return value
if r_uint(value) == value:
return r_uint(value)
try:
if r_longlong(value) == value:
return r_longlong(value)
except OverflowError:
pass
if r_ulonglong(value) == value:
return r_ulonglong(value)
raise OverflowError("value %d does not fit into any RPython integer type"
% (value,))
def dump_int(buf, x):
# only use TYPE_INT on 32-bit platforms
if LONG_BIT > 32:
dump_longlong(buf, r_longlong(x))
else:
buf.append(TYPE_INT)
w_long(buf, x)
def test_float_constant_conversions(self):
DIV = r_longlong(10 ** 10)
def fn():
return 420000000000.0 / DIV
res = self.interpret(fn, [])
assert self.float_eq(res, 42.0)
def test_wrap():
def _is(box1, box2):
return box1.__class__ == box2.__class__ and box1.value == box2.value
p = lltype.malloc(lltype.GcStruct("S"))
po = lltype.cast_opaque_ptr(llmemory.GCREF, p)
assert _is(wrap(None, 42), BoxInt(42))
assert _is(wrap(None, 42.5), boxfloat(42.5))
assert _is(wrap(None, p), BoxPtr(po))
assert _is(wrap(None, 42, in_const_box=True), ConstInt(42))
assert _is(wrap(None, 42.5, in_const_box=True), constfloat(42.5))
assert _is(wrap(None, p, in_const_box=True), ConstPtr(po))
if longlong.supports_longlong:
import sys
from pypy.rlib.rarithmetic import r_longlong, r_ulonglong
value = r_longlong(-sys.maxint * 17)
assert _is(wrap(None, value), BoxFloat(value))
assert _is(wrap(None, value, in_const_box=True), ConstFloat(value))
value_unsigned = r_ulonglong(-sys.maxint * 17)
assert _is(wrap(None, value_unsigned), BoxFloat(value))
sfval = r_singlefloat(42.5)
ival = longlong.singlefloat2int(sfval)
assert _is(wrap(None, sfval), BoxInt(ival))
assert _is(wrap(None, sfval, in_const_box=True), ConstInt(ival))
def test_contains_unsupported_variable_type():
def f(x):
return x
graph = support.getgraph(f, [5])
for sf in [False, True]:
for sll in [False, True]:
for ssf in [False, True]:
assert not contains_unsupported_variable_type(graph, sf,
sll, ssf)
#
graph = support.getgraph(f, [5.5])
for sf in [False, True]:
for sll in [False, True]:
for ssf in [False, True]:
res = contains_unsupported_variable_type(graph, sf, sll, ssf)
assert res is not sf
#
graph = support.getgraph(f, [r_singlefloat(5.5)])
for sf in [False, True]:
for sll in [False, True]:
for ssf in [False, True]:
res = contains_unsupported_variable_type(graph, sf, sll, ssf)
assert res == (not ssf)
#
graph = support.getgraph(f, [r_longlong(5)])
for sf in [False, True]:
for sll in [False, True]:
for ssf in [False, True]:
res = contains_unsupported_variable_type(graph, sf, sll, ssf)
assert res == (sys.maxint == 2147483647 and not sll)
def dump_int(buf, x):
# only use TYPE_INT on 32-bit platforms
if LONG_BIT > 32:
dump_longlong(buf, r_longlong(x))
else:
buf.append(TYPE_INT)
w_long(buf, x)
def f(n1, n2, m1, m2):
# n == -30000000000000, m == -20000000000
n = (r_longlong(n1) << 32) | r_longlong(n2)
m = (r_longlong(m1) << 32) | r_longlong(m2)
compare(n, -6985, 346562560)
compare(m, -5, 1474836480)
if not n: raise WrongResult
if not r_longlong(m2): raise WrongResult
if n-n: raise WrongResult
compare(-n, 6984, -346562560)
compare(~n, 6984, -346562561)
compare(n + m, -6990, 1821399040)
compare(n - m, -6981, -1128273920)
compare(n * (-3), 20954, -1039687680)
compare((-4) * m, 18, -1604378624)
return 1
def f(n1, n2, m1, m2):
# n == -30000000000000, m == -20000000000
n = (r_longlong(n1) << 32) | r_longlong(n2)
m = (r_longlong(m1) << 32) | r_longlong(m2)
compare(n, -6985, 346562560)
compare(m, -5, 1474836480)
if not n: raise WrongResult
if not r_longlong(m2): raise WrongResult
if n - n: raise WrongResult
compare(-n, 6984, -346562560)
compare(~n, 6984, -346562561)
compare(n + m, -6990, 1821399040)
compare(n - m, -6981, -1128273920)
compare(n * (-3), 20954, -1039687680)
compare((-4) * m, 18, -1604378624)
return 1
def op_cast_float_to_longlong(f):
assert type(f) is float
r = float(0x100000000)
small = f / r
high = int(small)
truncated = int((small - high) * r)
return r_longlong(high) * 0x100000000 + truncated
def op_cast_float_to_longlong(f):
assert type(f) is float
r = float(0x100000000)
small = f / r
high = int(small)
truncated = int((small - high) * r)
return r_longlong(high) * 0x100000000 + truncated
def test_neg_abs_ovf(self):
for op in (operator.neg, abs):
def f(x):
try:
return ovfcheck(op(x))
except OverflowError:
return 0
res = self.interpret(f, [-1])
assert res == 1
res = self.interpret(f, [int(-1<<(r_int.BITS-1))])
assert res == 0
res = self.interpret(f, [r_longlong(-1)])
assert res == 1
res = self.interpret(f, [r_longlong(-1)<<(r_longlong.BITS-1)])
assert res == 0
def test_float_constant_conversions(self):
DIV = r_longlong(10 ** 10)
def fn():
return 420000000000.0 / DIV
res = self.interpret(fn, [])
assert self.float_eq(res, 42.0)
def test_contains_unsupported_variable_type():
def f(x):
return x
graph = support.getgraph(f, [5])
for sf in [False, True]:
for sll in [False, True]:
for ssf in [False, True]:
assert not contains_unsupported_variable_type(
graph, sf, sll, ssf)
#
graph = support.getgraph(f, [5.5])
for sf in [False, True]:
for sll in [False, True]:
for ssf in [False, True]:
res = contains_unsupported_variable_type(graph, sf, sll, ssf)
assert res is not sf
#
graph = support.getgraph(f, [r_singlefloat(5.5)])
for sf in [False, True]:
for sll in [False, True]:
for ssf in [False, True]:
res = contains_unsupported_variable_type(graph, sf, sll, ssf)
assert res == (not ssf)
#
graph = support.getgraph(f, [r_longlong(5)])
for sf in [False, True]:
for sll in [False, True]:
for ssf in [False, True]:
res = contains_unsupported_variable_type(graph, sf, sll, ssf)
assert res == (sys.maxint == 2147483647 and not sll)
def test_wraplonglongs():
space = CPyObjSpace()
w = space.wrap
w_res = space.add(w(r_longlong(1)), w(r_ulonglong(1)))
assert space.eq_w(w_res, w(2))
res = space.int_w(w_res)
assert res == 2
def pow_ovr(space, w_int1, w_int2):
try:
return _impl_pow(space, r_longlong(w_int1.intval), w_int2)
except FailedToImplementArgs:
from pypy.objspace.std import longobject
w_a = W_LongObject.fromint(space, w_int1.intval)
w_b = W_LongObject.fromint(space, w_int2.intval)
return longobject.pow__Long_Long_None(space, w_a, w_b, space.w_None)
def pow_ovr(space, w_int1, w_int2):
try:
return _impl_pow(space, r_longlong(w_int1.intval), w_int2)
except FailedToImplementArgs:
from pypy.objspace.std import longobject
w_a = W_LongObject.fromint(space, w_int1.intval)
w_b = W_LongObject.fromint(space, w_int2.intval)
return longobject.pow__Long_Long_None(space, w_a, w_b, space.w_None)
def test_array_longlong(self):
from pypy.rlib.rarithmetic import r_longlong
A = GcArray(('v', Signed))
one = r_longlong(1)
def llf():
a = malloc(A, one)
return a[0].v
s = self.annotate(llf, [])
assert s.knowntype == int
def test_array_longlong(self):
from pypy.rlib.rarithmetic import r_longlong
A = GcArray(('v', Signed))
one = r_longlong(1)
def llf():
a = malloc(A, one)
return a[0].v
s = self.annotate(llf, [])
assert s.knowntype == int
def lshift_ovr(space, w_int1, w_int2):
a = r_longlong(w_int1.intval)
try:
return lshift__SmallLong_Int(space, W_SmallLongObject(a), w_int2)
except FailedToImplementArgs:
from pypy.objspace.std import longobject
w_a = W_LongObject.fromint(space, w_int1.intval)
w_b = W_LongObject.fromint(space, w_int2.intval)
return longobject.lshift__Long_Long(space, w_a, w_b)
def test_signed_longlong(self):
space = self.space
maxint32 = 2147483647 # we cannot really go above maxint on 64 bits
# (and we would not test anything, as there long
# is the same as long long)
expected = maxint32+1
if IS_32_BIT:
expected = r_longlong(expected)
self.check(app_types.slonglong, space.wrap(maxint32+1), expected)
def lshift_ovr(space, w_int1, w_int2):
a = r_longlong(w_int1.intval)
try:
return lshift__SmallLong_Int(space, W_SmallLongObject(a), w_int2)
except FailedToImplementArgs:
from pypy.objspace.std import longobject
w_a = W_LongObject.fromint(space, w_int1.intval)
w_b = W_LongObject.fromint(space, w_int2.intval)
return longobject.lshift__Long_Long(space, w_a, w_b)
def test_signed_longlong(self):
space = self.space
maxint32 = 2147483647 # we cannot really go above maxint on 64 bits
# (and we would not test anything, as there long
# is the same as long long)
expected = maxint32 + 1
if IS_32_BIT:
expected = r_longlong(expected)
self.check(app_types.slonglong, space.wrap(maxint32 + 1), expected)
def test_assemble_llong_consts():
if sys.maxint > 2147483647:
py.test.skip("only for 32-bit platforms")
from pypy.rlib.rarithmetic import r_longlong, r_ulonglong
ssarepr = SSARepr("test")
ssarepr.insns = [
('float_return', Constant(r_longlong(-18000000000000000),
lltype.SignedLongLong)),
('float_return', Constant(r_ulonglong(9900000000000000000),
lltype.UnsignedLongLong)),
]
assembler = Assembler()
jitcode = assembler.assemble(ssarepr)
assert jitcode.code == ("\x00\xFF"
"\x00\xFE")
assert assembler.insns == {'float_return/f': 0}
assert jitcode.constants_f == [r_longlong(-18000000000000000),
r_longlong(-8546744073709551616)]
def test_struct_fields_longlong(self):
POINT = lltype.Struct('POINT', ('x', rffi.LONGLONG),
('y', rffi.ULONGLONG))
y_ofs = 8
p = lltype.malloc(POINT, flavor='raw')
p.x = r_longlong(123)
p.y = r_ulonglong(456)
addr = rffi.cast(rffi.VOIDP, p)
assert struct_getfield_longlong(types.slonglong, addr, 0) == 123
assert struct_getfield_longlong(types.ulonglong, addr, y_ofs) == 456
#
v = rffi.cast(lltype.SignedLongLong, r_ulonglong(9223372036854775808))
struct_setfield_longlong(types.slonglong, addr, 0, v)
struct_setfield_longlong(types.ulonglong, addr, y_ofs, r_longlong(-1))
assert p.x == -9223372036854775808
assert rffi.cast(lltype.UnsignedLongLong, p.y) == 18446744073709551615
#
lltype.free(p, flavor='raw')
def test_interp2app_unwrap_spec_c_int(self):
from pypy.rlib.rarithmetic import r_longlong
space = self.space
w = space.wrap
def g(space, x):
return space.wrap(x + 6)
app_g = gateway.interp2app(g, unwrap_spec=[gateway.ObjSpace,
'c_int'])
app_ug = gateway.interp2app(g, unwrap_spec=[gateway.ObjSpace,
'c_uint'])
app_ng = gateway.interp2app(g, unwrap_spec=[gateway.ObjSpace,
'c_nonnegint'])
assert app_ug is not app_g
w_app_g = space.wrap(app_g)
w_app_ug = space.wrap(app_ug)
w_app_ng = space.wrap(app_ng)
#
assert self.space.eq_w(space.call_function(w_app_g, space.wrap(7)),
space.wrap(13))
space.raises_w(space.w_OverflowError,
space.call_function, w_app_g,
space.wrap(r_longlong(0x80000000)))
space.raises_w(space.w_OverflowError,
space.call_function, w_app_g,
space.wrap(r_longlong(-0x80000001)))
#
assert self.space.eq_w(space.call_function(w_app_ug, space.wrap(7)),
space.wrap(13))
assert self.space.eq_w(space.call_function(w_app_ug,
space.wrap(0x7FFFFFFF)),
space.wrap(r_longlong(0x7FFFFFFF+6)))
space.raises_w(space.w_ValueError,
space.call_function, w_app_ug, space.wrap(-1))
space.raises_w(space.w_OverflowError,
space.call_function, w_app_ug,
space.wrap(r_longlong(0x100000000)))
#
assert self.space.eq_w(space.call_function(w_app_ng, space.wrap(7)),
space.wrap(13))
space.raises_w(space.w_OverflowError,
space.call_function, w_app_ng,
space.wrap(r_longlong(0x80000000)))
space.raises_w(space.w_ValueError,
space.call_function, w_app_ng, space.wrap(-1))
def test_assemble_llong_consts():
if sys.maxint > 2147483647:
py.test.skip("only for 32-bit platforms")
from pypy.rlib.rarithmetic import r_longlong, r_ulonglong
ssarepr = SSARepr("test")
ssarepr.insns = [
('float_return',
Constant(r_longlong(-18000000000000000), lltype.SignedLongLong)),
('float_return',
Constant(r_ulonglong(9900000000000000000), lltype.UnsignedLongLong)),
]
assembler = Assembler()
jitcode = assembler.assemble(ssarepr)
assert jitcode.code == ("\x00\xFF" "\x00\xFE")
assert assembler.insns == {'float_return/f': 0}
assert jitcode.constants_f == [
r_longlong(-18000000000000000),
r_longlong(-8546744073709551616)
]
def __init__(self, space, stream, buffering):
self.space = space
self.stream = stream
self.decompressor = W_BZ2Decompressor(space)
self.readlength = r_longlong(0)
self.buffer = ""
self.finished = False
if buffering < 1024:
buffering = 1024 # minimum amount of compressed data read at once
self.buffering = buffering
def __init__(self, space, stream, buffering):
self.space = space
self.stream = stream
self.decompressor = W_BZ2Decompressor(space)
self.readlength = r_longlong(0)
self.buffer = ""
self.finished = False
if buffering < 1024:
buffering = 1024 # minimum amount of compressed data read at once
self.buffering = buffering
def __init__(self):
self.top = frame.null_state
self.restart_substate = -1
self.retval_long = 0
self.retval_longlong = rarithmetic.r_longlong(0)
self.retval_float = 0.0
self.retval_addr = llmemory.NULL
self.retval_ref = frame.null_saved_ref
self.exception = None
self.masterarray = lltype.malloc(frame.FRAME_INFO_ARRAY, 0,
immortal=True)
def entry_point(argv):
assert str(r4800000000 + r_longlong(len(argv))) == '4800000003'
fd = os.open(filename, os.O_RDWR | os.O_CREAT, 0644)
os.lseek(fd, r4800000000, 0)
newpos = os.lseek(fd, 0, 1)
if newpos == r4800000000:
print "OK"
else:
print "BAD POS"
os.close(fd)
return 0
def f(n):
a = A()
a.as_int = n
a.as_char = chr(n)
a.as_unichar = unichr(n)
a.as_double = n + 0.5
a.as_bool = bool(n)
a.as_void = None
a.as_longlong = r_longlong(n)
a.as_reference = A()
return a