def time_time_llimpl():
void = lltype.nullptr(rffi.VOIDP.TO)
result = -1.0
if self.HAVE_GETTIMEOFDAY:
t = lltype.malloc(self.TIMEVAL, flavor='raw')
errcode = -1
if self.GETTIMEOFDAY_NO_TZ:
errcode = c_gettimeofday(t)
else:
errcode = c_gettimeofday(t, void)
if rffi.cast(rffi.LONG, errcode) == 0:
result = decode_timeval(t)
lltype.free(t, flavor='raw')
if result != -1:
return result
if self.HAVE_FTIME:
t = lltype.malloc(self.TIMEB, flavor='raw')
c_ftime(t)
result = (float(intmask(t.c_time)) +
float(intmask(t.c_millitm)) * 0.001)
lltype.free(t, flavor='raw')
return result
return float(c_time(void))
def time_time_llimpl():
void = lltype.nullptr(rffi.VOIDP.TO)
result = -1.0
if self.HAVE_GETTIMEOFDAY:
t = lltype.malloc(self.TIMEVAL, flavor='raw')
errcode = -1
if self.GETTIMEOFDAY_NO_TZ:
errcode = c_gettimeofday(t)
else:
errcode = c_gettimeofday(t, void)
if rffi.cast(rffi.LONG, errcode) == 0:
result = decode_timeval(t)
lltype.free(t, flavor='raw')
if result != -1:
return result
if self.HAVE_FTIME:
t = lltype.malloc(self.TIMEB, flavor='raw')
c_ftime(t)
result = (float(intmask(t.c_time)) +
float(intmask(t.c_millitm)) * 0.001)
lltype.free(t, flavor='raw')
return result
return float(c_time(void))
def _int_binary_operations():
minint = -sys.maxint - 1
# Test cases. Note that for each operation there should be at least
# one case in which the two input arguments are equal.
for opnum, testcases in [
(rop.INT_ADD, [(10, -2, 8), (-60, -60, -120)]),
(rop.INT_SUB, [(10, -2, 12), (133, 133, 0)]),
(rop.INT_MUL, [(-6, -3, 18), (15, 15, 225)]),
(rop.INT_FLOORDIV, [(110, 3, 36), (-110, 3, -36), (110, -3, -36),
(-110, -3, 36), (-110, -1, 110),
(minint, 1, minint), (-87, -87, 1)]),
(rop.INT_MOD, [(11, 3, 2), (-11, 3, -2), (11, -3, 2), (-11, -3, -2),
(-87, -87, 0)]),
(rop.INT_AND, [(0xFF00, 0x0FF0, 0x0F00), (-111, -111, -111)]),
(rop.INT_OR, [(0xFF00, 0x0FF0, 0xFFF0), (-111, -111, -111)]),
(rop.INT_XOR, [(0xFF00, 0x0FF0, 0xF0F0), (-111, -111, 0)]),
(rop.INT_LSHIFT, [(10, 4, 10 << 4), (-5, 2, -20), (-5, 0, -5),
(3, 3, 24)]),
(rop.INT_RSHIFT, [(-17, 2, -5), (19, 1, 9), (3, 3, 0)]),
(rop.UINT_RSHIFT, [(-1, 4, intmask(r_uint(-1) >> r_uint(4))),
(1, 4, intmask(r_uint(1) >> r_uint(4))),
(3, 3, 0)]),
(rop.UINT_FLOORDIV, [(4, 3, intmask(r_uint(4) / r_uint(3))),
(1, -1, intmask(r_uint(1) / r_uint(-1))),
(110, 3, 36),
(-110, 3, intmask(r_uint(-110) / r_uint(3))),
(110, -3, intmask(r_uint(110) / r_uint(-3))),
(-110, -3, intmask(r_uint(-110) / r_uint(-3))),
(-110, -1, intmask(r_uint(-110) / r_uint(-1))),
(minint, 1, intmask(r_uint(minint) / r_uint(1))),
(-87, -87, intmask(r_uint(-87) / r_uint(-87)))])
]:
for x, y, z in testcases:
yield opnum, [x, y], z
def _PyLong_FromByteArray(space, bytes, n, little_endian, signed):
little_endian = rffi.cast(lltype.Signed, little_endian)
signed = rffi.cast(lltype.Signed, signed)
result = rbigint()
negative = False
for i in range(0, n):
if little_endian:
c = intmask(bytes[i])
else:
c = intmask(bytes[n - i - 1])
if i == 0 and signed and c & 0x80:
negative = True
if negative:
c = c ^ 0xFF
digit = rbigint.fromint(c)
result = result.lshift(8)
result = result.add(digit)
if negative:
result = result.neg()
return space.newlong_from_rbigint(result)
def test_id(self):
from pypy.rlib.objectmodel import compute_unique_id
from pypy.rlib.objectmodel import current_object_addr_as_int
class A:
pass
def fn():
a1 = A()
a2 = A()
return (compute_unique_id(a1), current_object_addr_as_int(a1),
compute_unique_id(a2), current_object_addr_as_int(a2))
res = self.interpret(fn, [])
x0, x1, x2, x3 = self.ll_unpack_tuple(res, 4)
assert isinstance(x0, (int, r_longlong))
assert isinstance(x1, int)
assert isinstance(x2, (int, r_longlong))
assert isinstance(x3, int)
assert x0 != x2
# the following checks are probably too precise, but work at
# least on top of llinterp
if type(self) is TestLLtype:
assert x1 == intmask(x0)
assert x3 == intmask(x2)
def _AsLong(v):
"""
Get an integer from a bigint object.
Raises OverflowError if overflow occurs.
"""
# This version by Tim Peters
i = len(v.digits) - 1
sign = v.sign
if not sign:
return 0
x = r_uint(0)
while i >= 0:
prev = x
x = (x << SHIFT) + v.digits[i]
if (x >> SHIFT) != prev:
raise OverflowError
i -= 1
# Haven't lost any bits, but if the sign bit is set we're in
# trouble *unless* this is the min negative number. So,
# trouble iff sign bit set && (positive || some bit set other
# than the sign bit).
if intmask(x) < 0 and (sign > 0 or (x << 1) != 0):
raise OverflowError
return intmask(x * sign)
def _AsLong(v):
"""
Get an integer from a bigint object.
Raises OverflowError if overflow occurs.
"""
# This version by Tim Peters
i = len(v.digits) - 1
sign = v.sign
if not sign:
return 0
x = r_uint(0)
while i >= 0:
prev = x
x = (x << SHIFT) + v.digits[i]
if (x >> SHIFT) != prev:
raise OverflowError
i -= 1
# Haven't lost any bits, but if the sign bit is set we're in
# trouble *unless* this is the min negative number. So,
# trouble iff sign bit set && (positive || some bit set other
# than the sign bit).
if intmask(x) < 0 and (sign > 0 or (x << 1) != 0):
raise OverflowError
return intmask(x * sign)
def _PyLong_FromByteArray(space, bytes, n, little_endian, signed):
little_endian = rffi.cast(lltype.Signed, little_endian)
signed = rffi.cast(lltype.Signed, signed)
result = rbigint()
negative = False
for i in range(0, n):
if little_endian:
c = intmask(bytes[i])
else:
c = intmask(bytes[n - i - 1])
if i == 0 and signed and c & 0x80:
negative = True
if negative:
c = c ^ 0xFF
digit = rbigint.fromint(c)
result = result.lshift(8)
result = result.add(digit)
if negative:
result = result.neg()
return space.newlong_from_rbigint(result)
def do_poll(self, space, timeout):
from pypy.module._multiprocessing.interp_win32 import (
_PeekNamedPipe, _GetTickCount, _Sleep)
from pypy.rlib import rwin32
from pypy.interpreter.error import wrap_windowserror
bytes_ptr = lltype.malloc(rffi.CArrayPtr(rwin32.DWORD).TO, 1,
flavor='raw')
try:
if not _PeekNamedPipe(self.handle, rffi.NULL, 0,
lltype.nullptr(rwin32.LPDWORD.TO),
bytes_ptr,
lltype.nullptr(rwin32.LPDWORD.TO)):
raise wrap_windowserror(space, rwin32.lastWindowsError())
bytes = bytes_ptr[0]
finally:
lltype.free(bytes_ptr, flavor='raw')
if timeout == 0.0:
return bytes > 0
block = timeout < 0
if not block:
# XXX does not check for overflow
deadline = intmask(_GetTickCount()) + int(1000 * timeout + 0.5)
else:
deadline = 0
_Sleep(0)
delay = 1
while True:
bytes_ptr = lltype.malloc(rffi.CArrayPtr(rwin32.DWORD).TO, 1,
flavor='raw')
try:
if not _PeekNamedPipe(self.handle, rffi.NULL, 0,
lltype.nullptr(rwin32.LPDWORD.TO),
bytes_ptr,
lltype.nullptr(rwin32.LPDWORD.TO)):
raise wrap_windowserror(space, rwin32.lastWindowsError())
bytes = bytes_ptr[0]
finally:
lltype.free(bytes_ptr, flavor='raw')
if bytes > 0:
return True
if not block:
now = intmask(_GetTickCount())
if now > deadline:
return False
diff = deadline - now
if delay > diff:
delay = diff
else:
delay += 1
if delay >= 20:
delay = 20
_Sleep(delay)
def func(no):
m = mmap.mmap(no, 6, access=mmap.ACCESS_WRITE)
f_size = os.fstat(no).st_size
assert intmask(m.file_size()) == f_size == 6
m.resize(10)
f_size = os.fstat(no).st_size
assert intmask(m.file_size()) == f_size == 10
m.close()
def func(no):
m = mmap.mmap(no, 6, access=mmap.ACCESS_WRITE)
f_size = os.fstat(no).st_size
assert intmask(m.file_size()) == f_size == 6
m.resize(10)
f_size = os.fstat(no).st_size
assert intmask(m.file_size()) == f_size == 10
m.close()
def test_truncate(self):
def f(n):
m = r_longlong(n) << 20
return r_uint(m)
res = self.interp_operations(f, [0x01234567])
assert res == 0x56700000
res = self.interp_operations(f, [0x56789ABC])
assert intmask(res) == intmask(0xABC00000)
def _ssl_thread_locking_function(mode, n, filename, line):
n = intmask(n)
if n < 0 or n >= len(_ssl_locks):
return
if intmask(mode) & CRYPTO_LOCK:
_ssl_locks[n].acquire(True)
else:
_ssl_locks[n].release()
def _ssl_thread_locking_function(mode, n, filename, line):
n = intmask(n)
if n < 0 or n >= len(_ssl_locks):
return
if intmask(mode) & CRYPTO_LOCK:
_ssl_locks[n].acquire(True)
else:
_ssl_locks[n].release()
def ll_hash(t):
retval = 0x345678
mult = 1000003
for i, hash_func in autounrolling_funclist:
attrname = 'item%d' % i
item = getattr(t, attrname)
retval = intmask((retval ^ hash_func(item)) * intmask(mult))
mult = mult + 82520 + 2*len(items_r)
return retval
def test_truncate(self):
def f(n):
m = r_longlong(n) << 20
return r_uint(m)
res = self.interp_operations(f, [0x01234567])
assert res == 0x56700000
res = self.interp_operations(f, [0x56789ABC])
assert intmask(res) == intmask(0xABC00000)
def test_args_from_long(self):
BASE = 1 << SHIFT
assert rbigint.fromlong(0).eq(bigint([0], 0))
assert rbigint.fromlong(17).eq(bigint([17], 1))
assert rbigint.fromlong(BASE-1).eq(bigint([intmask(BASE-1)], 1))
assert rbigint.fromlong(BASE).eq(bigint([0, 1], 1))
assert rbigint.fromlong(BASE**2).eq(bigint([0, 0, 1], 1))
assert rbigint.fromlong(-17).eq(bigint([17], -1))
assert rbigint.fromlong(-(BASE-1)).eq(bigint([intmask(BASE-1)], -1))
assert rbigint.fromlong(-BASE).eq(bigint([0, 1], -1))
assert rbigint.fromlong(-(BASE**2)).eq(bigint([0, 0, 1], -1))
def do_recv_string(self, space, buflength, maxlength):
from pypy.module._multiprocessing.interp_win32 import (
_ReadFile, _PeekNamedPipe, ERROR_BROKEN_PIPE, ERROR_MORE_DATA)
from pypy.rlib import rwin32
from pypy.interpreter.error import wrap_windowserror
read_ptr = lltype.malloc(rffi.CArrayPtr(rwin32.DWORD).TO,
1,
flavor='raw')
left_ptr = lltype.malloc(rffi.CArrayPtr(rwin32.DWORD).TO,
1,
flavor='raw')
try:
result = _ReadFile(self.handle, self.buffer,
min(self.BUFFER_SIZE, buflength), read_ptr,
rffi.NULL)
if result:
return intmask(read_ptr[0]), lltype.nullptr(rffi.CCHARP.TO)
err = rwin32.GetLastError()
if err == ERROR_BROKEN_PIPE:
raise OperationError(space.w_EOFError, space.w_None)
elif err != ERROR_MORE_DATA:
raise wrap_windowserror(space, WindowsError(err, "_ReadFile"))
# More data...
if not _PeekNamedPipe(self.handle, rffi.NULL, 0,
lltype.nullptr(rwin32.LPDWORD.TO),
lltype.nullptr(rwin32.LPDWORD.TO), left_ptr):
raise wrap_windowserror(space, rwin32.lastWindowsError())
length = intmask(read_ptr[0] + left_ptr[0])
if length > maxlength: # bad message, close connection
self.flags &= ~READABLE
if self.flags == 0:
self.close()
raise OperationError(space.w_IOError,
space.wrap("bad message length"))
newbuf = lltype.malloc(rffi.CCHARP.TO, length + 1, flavor='raw')
for i in range(read_ptr[0]):
newbuf[i] = self.buffer[i]
result = _ReadFile(self.handle, rffi.ptradd(newbuf, read_ptr[0]),
left_ptr[0], read_ptr, rffi.NULL)
if not result:
rffi.free_charp(newbuf)
raise wrap_windowserror(space, rwin32.lastWindowsError())
assert read_ptr[0] == left_ptr[0]
return length, newbuf
finally:
lltype.free(read_ptr, flavor='raw')
lltype.free(left_ptr, flavor='raw')
def do_recv_string(self, space, buflength, maxlength):
from pypy.module._multiprocessing.interp_win32 import (
_ReadFile, _PeekNamedPipe, ERROR_BROKEN_PIPE, ERROR_MORE_DATA)
from pypy.rlib import rwin32
from pypy.interpreter.error import wrap_windowserror
read_ptr = lltype.malloc(rffi.CArrayPtr(rwin32.DWORD).TO, 1,
flavor='raw')
left_ptr = lltype.malloc(rffi.CArrayPtr(rwin32.DWORD).TO, 1,
flavor='raw')
try:
result = _ReadFile(self.handle,
self.buffer, min(self.BUFFER_SIZE, buflength),
read_ptr, rffi.NULL)
if result:
return intmask(read_ptr[0]), lltype.nullptr(rffi.CCHARP.TO)
err = rwin32.GetLastError()
if err == ERROR_BROKEN_PIPE:
raise OperationError(space.w_EOFError, space.w_None)
elif err != ERROR_MORE_DATA:
raise wrap_windowserror(space, WindowsError(err, "_ReadFile"))
# More data...
if not _PeekNamedPipe(self.handle, rffi.NULL, 0,
lltype.nullptr(rwin32.LPDWORD.TO),
lltype.nullptr(rwin32.LPDWORD.TO),
left_ptr):
raise wrap_windowserror(space, rwin32.lastWindowsError())
length = intmask(read_ptr[0] + left_ptr[0])
if length > maxlength: # bad message, close connection
self.flags &= ~READABLE
if self.flags == 0:
self.close()
raise OperationError(space.w_IOError, space.wrap(
"bad message length"))
newbuf = lltype.malloc(rffi.CCHARP.TO, length + 1, flavor='raw')
for i in range(read_ptr[0]):
newbuf[i] = self.buffer[i]
result = _ReadFile(self.handle,
rffi.ptradd(newbuf, read_ptr[0]), left_ptr[0],
read_ptr, rffi.NULL)
if not result:
rffi.free_charp(newbuf)
raise wrap_windowserror(space, rwin32.lastWindowsError())
assert read_ptr[0] == left_ptr[0]
return length, newbuf
finally:
lltype.free(read_ptr, flavor='raw')
lltype.free(left_ptr, flavor='raw')
def test_args_from_int(self):
BASE = 1 << SHIFT
assert rbigint.fromrarith_int(0).eq(rbigint([0], 0))
assert rbigint.fromrarith_int(17).eq(rbigint([17], 1))
assert rbigint.fromrarith_int(BASE-1).eq(rbigint([intmask(BASE-1)], 1))
assert rbigint.fromrarith_int(BASE).eq(rbigint([0, 1], 1))
assert rbigint.fromrarith_int(BASE**2).eq(rbigint([0, 0, 1], 1))
assert rbigint.fromrarith_int(-17).eq(rbigint([17], -1))
assert rbigint.fromrarith_int(-(BASE-1)).eq(rbigint([intmask(BASE-1)], -1))
assert rbigint.fromrarith_int(-BASE).eq(rbigint([0, 1], -1))
assert rbigint.fromrarith_int(-(BASE**2)).eq(rbigint([0, 0, 1], -1))
def hash(self, storage):
storage = self.unerase(storage)
length = len(storage)
if length == 0:
return -1
x = ord(storage[0]) << 7
i = 0
while i < length:
x = intmask((1000003 * x) ^ ord(storage[i]))
i += 1
x ^= length
return intmask(x)
def hash(self, storage):
storage = self.unerase(storage)
length = len(storage)
if length == 0:
return -1
x = ord(storage[0]) << 7
i = 0
while i < length:
x = intmask((1000003 * x) ^ ord(storage[i]))
i += 1
x ^= length
return intmask(x)
def make_struct_passwd(space, pw):
w_passwd_struct = space.getattr(space.getbuiltinmodule('pwd'),
space.wrap('struct_passwd'))
w_tuple = space.newtuple([
space.wrap(rffi.charp2str(pw.c_pw_name)),
space.wrap(rffi.charp2str(pw.c_pw_passwd)),
space.wrap(intmask(pw.c_pw_uid)),
space.wrap(intmask(pw.c_pw_gid)),
space.wrap(rffi.charp2str(pw.c_pw_gecos)),
space.wrap(rffi.charp2str(pw.c_pw_dir)),
space.wrap(rffi.charp2str(pw.c_pw_shell)),
])
return space.call_function(w_passwd_struct, w_tuple)
def _hash_string(s):
"""The algorithm behind compute_hash() for a string or a unicode."""
from pypy.rlib.rarithmetic import intmask
length = len(s)
if length == 0:
return -1
x = ord(s[0]) << 7
i = 0
while i < length:
x = intmask((1000003*x) ^ ord(s[i]))
i += 1
x ^= length
return intmask(x)
def __init__(self, name, argtypes, restype, funcsym, flags=FUNCFLAG_CDECL, keepalive=None):
# initialize each one of pointers with null
AbstractFuncPtr.__init__(self, name, argtypes, restype, flags)
self.keepalive = keepalive
self.funcsym = funcsym
self.argnum = len(self.argtypes)
self.pushed_args = 0
self.ll_args = lltype.malloc(rffi.VOIDPP.TO, self.argnum, flavor="raw")
for i in range(self.argnum):
# space for each argument
self.ll_args[i] = lltype.malloc(rffi.VOIDP.TO, intmask(argtypes[i].c_size), flavor="raw")
if restype != ffi_type_void:
self.ll_result = lltype.malloc(rffi.VOIDP.TO, intmask(restype.c_size), flavor="raw")
def _hash_string(s):
"""The algorithm behind compute_hash() for a string or a unicode."""
from pypy.rlib.rarithmetic import intmask
length = len(s)
if length == 0:
return -1
x = ord(s[0]) << 7
i = 0
while i < length:
x = intmask((1000003*x) ^ ord(s[i]))
i += 1
x ^= length
return intmask(x)
def _int_binary_operations():
minint = -sys.maxint-1
# Test cases. Note that for each operation there should be at least
# one case in which the two input arguments are equal.
for opnum, testcases in [
(rop.INT_ADD, [(10, -2, 8),
(-60, -60, -120)]),
(rop.INT_SUB, [(10, -2, 12),
(133, 133, 0)]),
(rop.INT_MUL, [(-6, -3, 18),
(15, 15, 225)]),
(rop.INT_FLOORDIV, [(110, 3, 36),
(-110, 3, -36),
(110, -3, -36),
(-110, -3, 36),
(-110, -1, 110),
(minint, 1, minint),
(-87, -87, 1)]),
(rop.INT_MOD, [(11, 3, 2),
(-11, 3, -2),
(11, -3, 2),
(-11, -3, -2),
(-87, -87, 0)]),
(rop.INT_AND, [(0xFF00, 0x0FF0, 0x0F00),
(-111, -111, -111)]),
(rop.INT_OR, [(0xFF00, 0x0FF0, 0xFFF0),
(-111, -111, -111)]),
(rop.INT_XOR, [(0xFF00, 0x0FF0, 0xF0F0),
(-111, -111, 0)]),
(rop.INT_LSHIFT, [(10, 4, 10<<4),
(-5, 2, -20),
(-5, 0, -5),
(3, 3, 24)]),
(rop.INT_RSHIFT, [(-17, 2, -5),
(19, 1, 9),
(3, 3, 0)]),
(rop.UINT_RSHIFT, [(-1, 4, intmask(r_uint(-1) >> r_uint(4))),
( 1, 4, intmask(r_uint(1) >> r_uint(4))),
( 3, 3, 0)]),
(rop.UINT_FLOORDIV, [(4, 3, intmask(r_uint(4) / r_uint(3))),
(1, -1, intmask(r_uint(1) / r_uint(-1))),
(110, 3, 36),
(-110, 3, intmask(r_uint(-110) / r_uint(3))),
(110, -3, intmask(r_uint(110) / r_uint(-3))),
(-110, -3, intmask(r_uint(-110) / r_uint(-3))),
(-110, -1, intmask(r_uint(-110) / r_uint(-1))),
(minint, 1, intmask(r_uint(minint) / r_uint(1))),
(-87, -87, intmask(r_uint(-87) / r_uint(-87)))])
]:
for x, y, z in testcases:
yield opnum, [x, y], z
def digits_for_most_neg_long(l):
# This helper only works if 'l' is the most negative integer of its
# type, which in base 2 looks like: 1000000..0000
digits = []
while (intmask(l) & MASK) == 0:
digits.append(0)
l = l >> SHIFT
# now 'l' looks like: ...111100000
# turn it into: ...000100000
# to drop the extra unwanted 1's introduced by the signed right shift
l = -intmask(l)
assert l >= 0
digits.append(l)
return digits
def ll_stat_result(stat0, stat1, stat2, stat3, stat4,
stat5, stat6, stat7, stat8, stat9):
tup = lltype.malloc(STAT_RESULT)
tup.item0 = intmask(stat0)
tup.item1 = intmask(stat1)
tup.item2 = intmask(stat2)
tup.item3 = intmask(stat3)
tup.item4 = intmask(stat4)
tup.item5 = intmask(stat5)
tup.item6 = intmask(stat6)
tup.item7 = intmask(stat7)
tup.item8 = intmask(stat8)
tup.item9 = intmask(stat9)
return tup
def toint(self):
"""
Get an integer from a bigint object.
Raises OverflowError if overflow occurs.
"""
x = self._touint_helper()
# Haven't lost any bits, but if the sign bit is set we're in
# trouble *unless* this is the min negative number. So,
# trouble iff sign bit set && (positive || some bit set other
# than the sign bit).
sign = self.sign
if intmask(x) < 0 and (sign > 0 or (x << 1) != 0):
raise OverflowError
return intmask(x * sign)
def digits_for_most_neg_long(l):
# This helper only works if 'l' is the most negative integer of its
# type, which in base 2 looks like: 1000000..0000
digits = []
while (intmask(l) & MASK) == 0:
digits.append(0)
l = l >> SHIFT
# now 'l' looks like: ...111100000
# turn it into: ...000100000
# to drop the extra unwanted 1's introduced by the signed right shift
l = -intmask(l)
assert l >= 0
digits.append(l)
return digits
def compute_additional_info(self):
additional_info = GlobalRopeInfo()
charbitmask = 0
partial_hash = 0
for c in self.u:
ordc = ord(c)
charbitmask |= intmask(1 << (ordc & 0x1F))
partial_hash = (1000003*partial_hash) + ordc
partial_hash = intmask(partial_hash)
partial_hash |= HIGHEST_BIT_SET
additional_info.charbitmask = intmask(charbitmask)
additional_info.hash = partial_hash
self._additional_info = additional_info
return additional_info
def compute_additional_info(self):
additional_info = GlobalRopeInfo()
charbitmask = 0
partial_hash = 0
for c in self.u:
ordc = ord(c)
charbitmask |= intmask(1 << (ordc & 0x1F))
partial_hash = (1000003 * partial_hash) + ordc
partial_hash = intmask(partial_hash)
partial_hash |= HIGHEST_BIT_SET
additional_info.charbitmask = intmask(charbitmask)
additional_info.hash = partial_hash
self._additional_info = additional_info
return additional_info
def makeipaddr(name, result=None):
# Convert a string specifying a host name or one of a few symbolic
# names to an IPAddress instance. This usually calls getaddrinfo()
# to do the work; the names "" and "<broadcast>" are special.
# If 'result' is specified it must be a prebuilt INETAddress or
# INET6Address that is filled; otherwise a new INETXAddress is returned.
if result is None:
family = AF_UNSPEC
else:
family = result.family
if len(name) == 0:
info = getaddrinfo(None, "0",
family=family,
socktype=SOCK_DGRAM, # dummy
flags=AI_PASSIVE,
address_to_fill=result)
if len(info) > 1:
raise RSocketError("wildcard resolved to "
"multiple addresses")
return info[0][4]
# IPv4 also supports the special name "<broadcast>".
if name == '<broadcast>':
return makeipv4addr(intmask(INADDR_BROADCAST), result)
# "dd.dd.dd.dd" format.
digits = name.split('.')
if len(digits) == 4:
try:
d0 = int(digits[0])
d1 = int(digits[1])
d2 = int(digits[2])
d3 = int(digits[3])
except ValueError:
pass
else:
if (0 <= d0 <= 255 and
0 <= d1 <= 255 and
0 <= d2 <= 255 and
0 <= d3 <= 255):
return makeipv4addr(intmask(htonl(
(intmask(d0 << 24)) | (d1 << 16) | (d2 << 8) | (d3 << 0))),
result)
# generic host name to IP conversion
info = getaddrinfo(name, None, family=family, address_to_fill=result)
return info[0][4]
def makeipaddr(name, result=None):
# Convert a string specifying a host name or one of a few symbolic
# names to an IPAddress instance. This usually calls getaddrinfo()
# to do the work; the names "" and "<broadcast>" are special.
# If 'result' is specified it must be a prebuilt INETAddress or
# INET6Address that is filled; otherwise a new INETXAddress is returned.
if result is None:
family = AF_UNSPEC
else:
family = result.family
if len(name) == 0:
info = getaddrinfo(
None,
"0",
family=family,
socktype=SOCK_DGRAM, # dummy
flags=AI_PASSIVE,
address_to_fill=result)
if len(info) > 1:
raise RSocketError("wildcard resolved to " "multiple addresses")
return info[0][4]
# IPv4 also supports the special name "<broadcast>".
if name == '<broadcast>':
return makeipv4addr(intmask(INADDR_BROADCAST), result)
# "dd.dd.dd.dd" format.
digits = name.split('.')
if len(digits) == 4:
try:
d0 = int(digits[0])
d1 = int(digits[1])
d2 = int(digits[2])
d3 = int(digits[3])
except ValueError:
pass
else:
if (0 <= d0 <= 255 and 0 <= d1 <= 255 and 0 <= d2 <= 255
and 0 <= d3 <= 255):
return makeipv4addr(
intmask(
htonl((intmask(d0 << 24)) | (d1 << 16) | (d2 << 8)
| (d3 << 0))), result)
# generic host name to IP conversion
info = getaddrinfo(name, None, family=family, address_to_fill=result)
return info[0][4]
def get_len_of_range(lo, hi, step):
"""
Return number of items in range/xrange (lo, hi, step).
Raise ValueError if step == 0 and OverflowError if the true value is too
large to fit in a signed long.
"""
# If lo >= hi, the range is empty.
# Else if n values are in the range, the last one is
# lo + (n-1)*step, which must be <= hi-1. Rearranging,
# n <= (hi - lo - 1)/step + 1, so taking the floor of the RHS gives
# the proper value. Since lo < hi in this case, hi-lo-1 >= 0, so
# the RHS is non-negative and so truncation is the same as the
# floor. Letting M be the largest positive long, the worst case
# for the RHS numerator is hi=M, lo=-M-1, and then
# hi-lo-1 = M-(-M-1)-1 = 2*M. Therefore unsigned long has enough
# precision to compute the RHS exactly.
if step == 0:
raise ValueError
elif step < 0:
lo, hi, step = hi, lo, -step
if lo < hi:
uhi = r_uint(hi)
ulo = r_uint(lo)
diff = uhi - ulo - 1
n = intmask(diff // r_uint(step) + 1)
if n < 0:
raise OverflowError
else:
n = 0
return n
def lookup_where_with_method_cache(w_self, name):
space = w_self.space
assert space.config.objspace.std.withmethodcache
ec = space.getexecutioncontext()
version_tag = w_self.version_tag
if version_tag is None:
tup = w_self._lookup_where(name)
return tup
SHIFT = r_uint.BITS - space.config.objspace.std.methodcachesizeexp
method_hash = r_uint(intmask(id(version_tag) * hash(name))) >> SHIFT
cached_version_tag = ec.method_cache_versions[method_hash]
if cached_version_tag is version_tag:
cached_name = ec.method_cache_names[method_hash]
if cached_name is name:
tup = ec.method_cache_lookup_where[method_hash]
if space.config.objspace.std.withmethodcachecounter:
ec.method_cache_hits[name] = \
ec.method_cache_hits.get(name, 0) + 1
# print "hit", w_self, name
return tup
tup = w_self._lookup_where(name)
ec.method_cache_versions[method_hash] = version_tag
ec.method_cache_names[method_hash] = name
ec.method_cache_lookup_where[method_hash] = tup
if space.config.objspace.std.withmethodcachecounter:
ec.method_cache_misses[name] = \
ec.method_cache_misses.get(name, 0) + 1
# print "miss", w_self, name
return tup
def _do_call(self, funcsym, ll_args, RESULT):
# XXX: check len(args)?
ll_result = lltype.nullptr(rffi.CCHARP.TO)
if self.restype != types.void:
ll_result = lltype.malloc(rffi.CCHARP.TO,
intmask(self.restype.c_size),
flavor='raw')
ffires = c_ffi_call(self.ll_cif,
self.funcsym,
rffi.cast(rffi.VOIDP, ll_result),
rffi.cast(rffi.VOIDPP, ll_args))
if RESULT is not lltype.Void:
TP = lltype.Ptr(rffi.CArray(RESULT))
buf = rffi.cast(TP, ll_result)
if types.is_struct(self.restype):
assert RESULT == rffi.SIGNED
# for structs, we directly return the buffer and transfer the
# ownership
res = rffi.cast(RESULT, buf)
else:
res = buf[0]
else:
res = None
self._free_buffers(ll_result, ll_args)
clibffi.check_fficall_result(ffires, self.flags)
return res
def _index_cache(self, selector):
space = self.space
cache = space.fromcache(IndexCache)
SHIFT2 = r_uint.BITS - space.config.objspace.std.methodcachesizeexp
SHIFT1 = SHIFT2 - 5
attrs_as_int = objectmodel.current_object_addr_as_int(self)
# ^^^Note: see comment in typeobject.py for
# _pure_lookup_where_with_method_cache()
hash_selector = objectmodel.compute_hash(selector)
product = intmask(attrs_as_int * hash_selector)
index_hash = (r_uint(product) ^ (r_uint(product) << SHIFT1)) >> SHIFT2
# ^^^Note2: same comment too
cached_attr = cache.attrs[index_hash]
if cached_attr is self:
cached_selector = cache.selectors[index_hash]
if cached_selector == selector:
index = cache.indices[index_hash]
if space.config.objspace.std.withmethodcachecounter:
name = selector[0]
cache.hits[name] = cache.hits.get(name, 0) + 1
return index
index = self._index(selector)
cache.attrs[index_hash] = self
cache.selectors[index_hash] = selector
cache.indices[index_hash] = index
if space.config.objspace.std.withmethodcachecounter:
name = selector[0]
cache.misses[name] = cache.misses.get(name, 0) + 1
return index
def w_match(space, w_state, w_pattern_codes):
state = space.interp_w(W_State, w_state)
pattern_codes = [
intmask(space.uint_w(code))
for code in space.unpackiterable(w_pattern_codes)
]
return space.newbool(state.match(pattern_codes))
def _create_tuple_for_X509_NAME(space, xname):
entry_count = libssl_X509_NAME_entry_count(xname)
dn_w = []
rdn_w = []
rdn_level = -1
for index in range(entry_count):
entry = libssl_X509_NAME_get_entry(xname, index)
# check to see if we've gotten to a new RDN
entry_level = intmask(entry[0].c_set)
if rdn_level >= 0:
if rdn_level != entry_level:
# yes, new RDN
# add old RDN to DN
dn_w.append(space.newtuple(list(rdn_w)))
rdn_w = []
rdn_level = entry_level
# Now add this attribute to the current RDN
name = libssl_X509_NAME_ENTRY_get_object(entry)
value = libssl_X509_NAME_ENTRY_get_data(entry)
attr = _create_tuple_for_attribute(space, name, value)
rdn_w.append(attr)
# Now, there is typically a dangling RDN
if rdn_w:
dn_w.append(space.newtuple(list(rdn_w)))
return space.newtuple(list(dn_w))
def _pure_lookup_where_with_method_cache(w_self, name, version_tag):
space = w_self.space
SHIFT = r_uint.BITS - space.config.objspace.std.methodcachesizeexp
version_tag_as_int = current_object_addr_as_int(version_tag)
# ^^^Note: if the version_tag object is moved by a moving GC, the
# existing method cache entries won't be found any more; new
# entries will be created based on the new address. The
# assumption is that the version_tag object won't keep moving all
# the time - so using the fast current_object_addr_as_int() instead
# of a slower solution like hash() is still a good trade-off.
hash_name = compute_hash(name)
method_hash = r_uint(intmask(version_tag_as_int * hash_name)) >> SHIFT
cached_version_tag = space.method_cache_versions[method_hash]
if cached_version_tag is version_tag:
cached_name = space.method_cache_names[method_hash]
if cached_name is name:
tup = space.method_cache_lookup_where[method_hash]
if space.config.objspace.std.withmethodcachecounter:
space.method_cache_hits[name] = \
space.method_cache_hits.get(name, 0) + 1
# print "hit", w_self, name
return tup
tup = w_self._lookup_where_all_typeobjects(name)
space.method_cache_versions[method_hash] = version_tag
space.method_cache_names[method_hash] = name
space.method_cache_lookup_where[method_hash] = tup
if space.config.objspace.std.withmethodcachecounter:
space.method_cache_misses[name] = \
space.method_cache_misses.get(name, 0) + 1
# print "miss", w_self, name
return tup
def llimpl_FormatError(code):
"Return a message corresponding to the given Windows error code."
buf = lltype.malloc(rffi.VOIDPP.TO, 1, flavor='raw')
try:
msglen = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM,
None,
code,
DEFAULT_LANGUAGE,
rffi.cast(rffi.VOIDP, buf),
0, None)
if msglen <= 2 or msglen > sys.maxint:
return fake_FormatError(code)
# FormatMessage always appends \r\n.
buflen = intmask(msglen - 2)
assert buflen > 0
result = rffi.charpsize2str(buf[0], buflen)
LocalFree(buf[0])
finally:
lltype.free(buf, flavor='raw')
return result
def test_promote_index_in_virtualizable_list(self):
jitdriver = JitDriver(greens = [], reds = ['frame', 'n'],
virtualizables = ['frame'])
class Frame(object):
_virtualizable2_ = ['stackpos', 'stack[*]']
def f(n):
frame = Frame()
frame.stack = [42, 0, 0]
frame.stackpos = 1
while n > 0:
jitdriver.can_enter_jit(frame=frame, n=n)
jitdriver.jit_merge_point(frame=frame, n=n)
popped = frame.stack[frame.stackpos]
frame.stackpos -= 1
to_push = intmask(popped * 3)
frame.stack[frame.stackpos] = to_push
frame.stackpos += 1
n -= 1
return frame.stack[0]
res = self.meta_interp(f, [70], listops=True)
assert res == intmask(42 ** 70)
self.check_loops(int_add=0,
int_sub=1) # for 'n -= 1' only
def get_len_of_range(space, lo, hi, step):
"""
Return number of items in range/xrange (lo, hi, step).
Raise ValueError if step == 0 and OverflowError if the true value is too
large to fit in a signed long.
"""
# If lo >= hi, the range is empty.
# Else if n values are in the range, the last one is
# lo + (n-1)*step, which must be <= hi-1. Rearranging,
# n <= (hi - lo - 1)/step + 1, so taking the floor of the RHS gives
# the proper value. Since lo < hi in this case, hi-lo-1 >= 0, so
# the RHS is non-negative and so truncation is the same as the
# floor. Letting M be the largest positive long, the worst case
# for the RHS numerator is hi=M, lo=-M-1, and then
# hi-lo-1 = M-(-M-1)-1 = 2*M. Therefore unsigned long has enough
# precision to compute the RHS exactly.
if step == 0:
raise OperationError(space.w_ValueError,
space.wrap("step argument must not be zero"))
elif step < 0:
lo, hi, step = hi, lo, -step
if lo < hi:
uhi = r_uint(hi)
ulo = r_uint(lo)
diff = uhi - ulo - 1
n = intmask(diff // r_uint(step) + 1)
if n < 0:
raise OperationError(space.w_OverflowError,
space.wrap("result has too many items"))
else:
n = 0
return n
def __init__(self, name, argtypes, restype, flags=FUNCFLAG_CDECL):
self.name = name
self.argtypes = argtypes
self.restype = restype
self.flags = flags
argnum = len(argtypes)
self.ll_argtypes = lltype.malloc(
FFI_TYPE_PP.TO, argnum, flavor="raw", track_allocation=False
) # freed by the __del__
for i in range(argnum):
self.ll_argtypes[i] = argtypes[i]
self.ll_cif = lltype.malloc(FFI_CIFP.TO, flavor="raw", track_allocation=False) # freed by the __del__
if _MSVC:
# This little trick works correctly with MSVC.
# It returns small structures in registers
if intmask(restype.c_type) == FFI_TYPE_STRUCT:
if restype.c_size <= 4:
restype = ffi_type_sint32
elif restype.c_size <= 8:
restype = ffi_type_sint64
res = c_ffi_prep_cif(
self.ll_cif,
rffi.cast(rffi.USHORT, get_call_conv(flags, False)),
rffi.cast(rffi.UINT, argnum),
restype,
self.ll_argtypes,
)
if not res == FFI_OK:
raise OSError(-1, "Wrong typedef")
def read_struct(self, offset, fmt_str, read_null=False):
if offset == 0 and not read_null:
return []
size = calcsize(fmt_str)
os.lseek(self.os_file, intmask(offset), os.SEEK_SET)
struct_bin = os.read(self.os_file, size)
return unpack(fmt_str, struct_bin)
def default_identity_hash(space, w_obj):
fn = get_default_hash_function(w_obj.__class__)
if fn is None:
typename = space.type(w_obj).getname(space, '?')
msg = "%s objects have no default hash" % (typename, )
raise OperationError(space.w_TypeError, space.wrap(msg))
return space.wrap(intmask(fn(w_obj)))
def ll_dict_lookup(d, key, hash):
DICT = lltype.typeOf(d).TO
entries = d.entries
mask = len(entries) - 1
i = hash & mask
# do the first try before any looping
if entries.valid(i):
checkingkey = entries[i].key
if checkingkey == key:
return i # found the entry
if d.keyeq is not None and entries.hash(i) == hash:
# correct hash, maybe the key is e.g. a different pointer to
# an equal object
found = d.keyeq(checkingkey, key)
if DICT.paranoia:
if (entries != d.entries or not entries.valid(i)
or entries[i].key != checkingkey):
# the compare did major nasty stuff to the dict: start over
return ll_dict_lookup(d, key, hash)
if found:
return i # found the entry
freeslot = -1
elif entries.everused(i):
freeslot = i
else:
return i # pristine entry -- lookup failed
# In the loop, a deleted entry (everused and not valid) is by far
# (factor of 100s) the least likely outcome, so test for that last.
perturb = r_uint(hash)
while 1:
# compute the next index using unsigned arithmetic
i = r_uint(i)
i = (i << 2) + i + perturb + 1
i = intmask(i) & mask
# keep 'i' as a signed number here, to consistently pass signed
# arguments to the small helper methods.
if not entries.everused(i):
if freeslot == -1:
freeslot = i
return freeslot
elif entries.valid(i):
checkingkey = entries[i].key
if checkingkey == key:
return i
if d.keyeq is not None and entries.hash(i) == hash:
# correct hash, maybe the key is e.g. a different pointer to
# an equal object
found = d.keyeq(checkingkey, key)
if DICT.paranoia:
if (entries != d.entries or not entries.valid(i)
or entries[i].key != checkingkey):
# the compare did major nasty stuff to the dict:
# start over
return ll_dict_lookup(d, key, hash)
if found:
return i # found the entry
elif freeslot == -1:
freeslot = i
perturb >>= PERTURB_SHIFT
def __new__(cls, void_p):
if isinstance(void_p, (int, long)):
void_p = ctypes.c_void_p(void_p)
self = long.__new__(cls, void_p.value)
self.void_p = void_p
self.intval = intmask(void_p.value)
return self
def offset2int(offset):
intoffset = intmask(offset)
if intoffset != offset:
raise StreamError("seek() from a non-seekable source:"
" this would read and discard more"
" than sys.maxint bytes")
return intoffset
def _push_arg(self, value, ll_args, i):
# XXX: check the type is not translated?
argtype = self.argtypes[i]
c_size = intmask(argtype.c_size)
ll_buf = lltype.malloc(rffi.CCHARP.TO, c_size, flavor='raw')
push_arg_as_ffiptr(argtype, value, ll_buf)
ll_args[i] = ll_buf
def bound_reached(cell, *args):
# bound reached, but we do a last check: if it is the first
# time we reach the bound, or if another loop or bridge was
# compiled since the last time we reached it, then decrease
# the counter by a few percents instead. It should avoid
# sudden bursts of JIT-compilation, and also corner cases
# where we suddenly compile more than one loop because all
# counters reach the bound at the same time, but where
# compiling all but the first one is pointless.
curgen = warmrunnerdesc.memory_manager.current_generation
curgen = chr(intmask(curgen) & 0xFF) # only use 8 bits
if we_are_translated() and curgen != cell.extra_delay:
cell.counter = int(self.THRESHOLD_LIMIT * 0.98)
cell.extra_delay = curgen
return
#
if not confirm_enter_jit(*args):
cell.counter = 0
return
# start tracing
from pypy.jit.metainterp.pyjitpl import MetaInterp
metainterp = MetaInterp(metainterp_sd, jitdriver_sd)
# set counter to -2, to mean "tracing in effect"
cell.counter = -2
try:
metainterp.compile_and_run_once(jitdriver_sd, *args)
finally:
if cell.counter == -2:
cell.counter = 0
def jumpahead(self, space, w_n):
if space.is_true(space.isinstance(w_n, space.w_long)):
num = space.bigint_w(w_n)
n = intmask(num.uintmask())
else:
n = space.int_w(w_n)
self._rnd.jumpahead(n)
def int__SmallLong(space, w_value):
a = w_value.longlong
b = intmask(a)
if b == a:
return space.newint(b)
else:
return w_value