def register_time_sleep(self):
if sys.platform == 'win32':
MAX = maxint32
Sleep = self.llexternal('Sleep', [rffi.ULONG], lltype.Void)
def time_sleep_llimpl(secs):
millisecs = secs * 1000.0
while millisecs > MAX:
Sleep(MAX)
millisecs -= MAX
Sleep(rffi.cast(rffi.ULONG, int(millisecs)))
else:
c_select = self.llexternal('select', [rffi.INT, rffi.VOIDP,
rffi.VOIDP, rffi.VOIDP,
self.TIMEVALP], rffi.INT)
def time_sleep_llimpl(secs):
void = lltype.nullptr(rffi.VOIDP.TO)
t = lltype.malloc(self.TIMEVAL, flavor='raw')
try:
frac = math.fmod(secs, 1.0)
rffi.setintfield(t, 'c_tv_sec', int(secs))
rffi.setintfield(t, 'c_tv_usec', int(frac*1000000.0))
if rffi.cast(rffi.LONG, c_select(0, void, void, void, t)) != 0:
errno = rposix.get_errno()
if errno != EINTR:
raise OSError(rposix.get_errno(), "Select failed")
finally:
lltype.free(t, flavor='raw')
return extdef([float], None, llimpl=time_sleep_llimpl,
export_name='ll_time.ll_time_sleep')
def register_time_clock(self):
c_clock = self.llexternal('clock', [], self.CLOCK_T,
threadsafe=False)
if sys.platform == 'win32':
# hacking to avoid LARGE_INTEGER which is a union...
A = lltype.FixedSizeArray(lltype.SignedLongLong, 1)
QueryPerformanceCounter = self.llexternal(
'QueryPerformanceCounter', [lltype.Ptr(A)], lltype.Void,
threadsafe=False)
QueryPerformanceFrequency = self.llexternal(
'QueryPerformanceFrequency', [lltype.Ptr(A)], rffi.INT,
threadsafe=False)
class State(object):
pass
state = State()
state.divisor = 0.0
def time_clock_llimpl():
a = lltype.malloc(A, flavor='raw')
if state.divisor == 0.0:
QueryPerformanceCounter(a)
state.counter_start = a[0]
QueryPerformanceFrequency(a)
state.divisor = float(a[0])
QueryPerformanceCounter(a)
diff = a[0] - state.counter_start
lltype.free(a, flavor='raw')
return float(diff) / state.divisor
else:
def time_clock_llimpl():
result = c_clock()
return float(result) / self.CLOCKS_PER_SEC
return extdef([], float, llimpl=time_clock_llimpl,
export_name='ll_time.ll_time_clock')
def register_os_read(self):
os_read = self.llexternal(underscore_on_windows+'read',
[rffi.INT, rffi.VOIDP, rffi.SIZE_T],
rffi.SIZE_T)
def os_read_llimpl(fd, count):
if count < 0:
raise OSError(errno.EINVAL, None)
inbuf = lltype.malloc(rffi.CCHARP.TO, count, flavor='raw')
try:
got = rffi.cast(lltype.Signed, os_read(rffi.cast(rffi.INT, fd),
inbuf, rffi.cast(rffi.SIZE_T, count)))
if got < 0:
raise OSError(rposix.get_errno(), "os_read failed")
# XXX too many copies of the data!
l = [inbuf[i] for i in range(got)]
finally:
lltype.free(inbuf, flavor='raw')
return ''.join(l)
def os_read_oofakeimpl(fd, count):
return OOSupport.to_rstr(os.read(fd, count))
return extdef([int, int], str, "ll_os.ll_os_read",
llimpl=os_read_llimpl, oofakeimpl=os_read_oofakeimpl)
def register_os_execve(self):
os_execve = self.llexternal(
'execve', [rffi.CCHARP, rffi.CCHARPP, rffi.CCHARPP], rffi.INT)
def execve_llimpl(path, args, env):
# XXX Check path, args, env for \0 and raise TypeErrors as
# appropriate
envstrs = []
for item in env.iteritems():
envstrs.append("%s=%s" % item)
l_args = rffi.liststr2charpp(args)
l_env = rffi.liststr2charpp(envstrs)
os_execve(path, l_args, l_env)
# XXX untested
rffi.free_charpp(l_env)
rffi.free_charpp(l_args)
raise OSError(rposix.get_errno(), "execve failed")
return extdef(
[str, [str], {str: str}],
s_ImpossibleValue,
llimpl=execve_llimpl,
export_name="ll_os.ll_os_execve")
def register_os_getcwd(self):
os_getcwd = self.llexternal(underscore_on_windows + 'getcwd',
[rffi.CCHARP, rffi.SIZE_T],
rffi.CCHARP)
def os_getcwd_llimpl():
bufsize = 256
while True:
buf = lltype.malloc(rffi.CCHARP.TO, bufsize, flavor='raw')
res = os_getcwd(buf, rffi.cast(rffi.SIZE_T, bufsize))
if res:
break # ok
error = rposix.get_errno()
lltype.free(buf, flavor='raw')
if error != errno.ERANGE:
raise OSError(error, "getcwd failed")
# else try again with a larger buffer, up to some sane limit
bufsize *= 4
if bufsize > 1024*1024: # xxx hard-coded upper limit
raise OSError(error, "getcwd result too large")
result = rffi.charp2str(res)
lltype.free(buf, flavor='raw')
return result
def os_getcwd_oofakeimpl():
return OOSupport.to_rstr(os.getcwd())
return extdef([], str,
"ll_os.ll_os_getcwd", llimpl=os_getcwd_llimpl,
oofakeimpl=os_getcwd_oofakeimpl)
def register_os_write(self):
os_write = self.llexternal(underscore_on_windows+'write',
[rffi.INT, rffi.VOIDP, rffi.SIZE_T],
rffi.SIZE_T)
def os_write_llimpl(fd, data):
count = len(data)
outbuf = lltype.malloc(rffi.CCHARP.TO, count, flavor='raw')
try:
for i in range(count):
outbuf[i] = data[i]
written = rffi.cast(lltype.Signed, os_write(
rffi.cast(rffi.INT, fd),
outbuf, rffi.cast(rffi.SIZE_T, count)))
if written < 0:
raise OSError(rposix.get_errno(), "os_write failed")
finally:
lltype.free(outbuf, flavor='raw')
return written
def os_write_oofakeimpl(fd, data):
return os.write(fd, OOSupport.from_rstr(data))
return extdef([int, str], SomeInteger(nonneg=True),
"ll_os.ll_os_write", llimpl=os_write_llimpl,
oofakeimpl=os_write_oofakeimpl)
def register_os_readlink(self):
os_readlink = self.llexternal('readlink',
[rffi.CCHARP, rffi.CCHARP, rffi.SIZE_T],
rffi.INT)
# XXX SSIZE_T in POSIX.1-2001
def os_readlink_llimpl(path):
bufsize = 1023
while True:
l_path = rffi.str2charp(path)
buf = lltype.malloc(rffi.CCHARP.TO, bufsize,
flavor='raw')
res = rffi.cast(lltype.Signed, os_readlink(l_path, buf, bufsize))
lltype.free(l_path, flavor='raw')
if res < 0:
error = rposix.get_errno() # failed
lltype.free(buf, flavor='raw')
raise OSError(error, "readlink failed")
elif res < bufsize:
break # ok
else:
# buf too small, try again with a larger buffer
lltype.free(buf, flavor='raw')
bufsize *= 4
# convert the result to a string
l = [buf[i] for i in range(res)]
result = ''.join(l)
lltype.free(buf, flavor='raw')
return result
return extdef([str], str,
"ll_os.ll_os_readlink",
llimpl=os_readlink_llimpl)
def register_time_clock(self):
c_clock = self.llexternal('clock', [], self.CLOCK_T,
threadsafe=False)
if sys.platform == 'win32':
# hacking to avoid LARGE_INTEGER which is a union...
A = lltype.FixedSizeArray(lltype.SignedLongLong, 1)
QueryPerformanceCounter = self.llexternal(
'QueryPerformanceCounter', [lltype.Ptr(A)], lltype.Void,
threadsafe=False)
QueryPerformanceFrequency = self.llexternal(
'QueryPerformanceFrequency', [lltype.Ptr(A)], rffi.INT,
threadsafe=False)
class State(object):
pass
state = State()
state.divisor = 0.0
state.counter_start = 0
def time_clock_llimpl():
a = lltype.malloc(A, flavor='raw')
if state.divisor == 0.0:
QueryPerformanceCounter(a)
state.counter_start = a[0]
QueryPerformanceFrequency(a)
state.divisor = float(a[0])
QueryPerformanceCounter(a)
diff = a[0] - state.counter_start
lltype.free(a, flavor='raw')
return float(diff) / state.divisor
else:
def time_clock_llimpl():
result = c_clock()
return float(result) / self.CLOCKS_PER_SEC
return extdef([], float, llimpl=time_clock_llimpl,
export_name='ll_time.ll_time_clock')
def register_os_waitpid(self):
if sys.platform.startswith('win'):
# emulate waitpid() with the _cwait() of Microsoft's compiler
os__cwait = self.llexternal('_cwait',
[rffi.INTP, rffi.PID_T, rffi.INT],
rffi.PID_T)
def os_waitpid(pid, status_p, options):
result = os__cwait(status_p, pid, options)
# shift the status left a byte so this is more
# like the POSIX waitpid
status_p[0] <<= 8
return result
else:
# Posix
os_waitpid = self.llexternal('waitpid',
[rffi.PID_T, rffi.INTP, rffi.INT],
rffi.PID_T)
def os_waitpid_llimpl(pid, options):
status_p = lltype.malloc(rffi.INTP.TO, 1, flavor='raw')
status_p[0] = rffi.cast(rffi.INT, 0)
result = os_waitpid(rffi.cast(rffi.PID_T, pid),
status_p,
rffi.cast(rffi.INT, options))
result = rffi.cast(lltype.Signed, result)
status = status_p[0]
lltype.free(status_p, flavor='raw')
if result == -1:
raise OSError(rposix.get_errno(), "os_waitpid failed")
return (rffi.cast(lltype.Signed, result),
rffi.cast(lltype.Signed, status))
return extdef([int, int], (int, int),
"ll_os.ll_os_waitpid",
llimpl=os_waitpid_llimpl)
def register_time_sleep(self):
if sys.platform == 'win32':
MAX = sys.maxint
Sleep = self.llexternal('Sleep', [rffi.ULONG], lltype.Void)
def time_sleep_llimpl(secs):
millisecs = secs * 1000.0
while millisecs > MAX:
Sleep(MAX)
millisecs -= MAX
Sleep(rffi.cast(rffi.ULONG, int(millisecs)))
else:
c_select = self.llexternal('select', [rffi.INT, rffi.VOIDP,
rffi.VOIDP, rffi.VOIDP,
self.TIMEVALP], rffi.INT)
def time_sleep_llimpl(secs):
void = lltype.nullptr(rffi.VOIDP.TO)
t = lltype.malloc(self.TIMEVAL, flavor='raw')
try:
frac = math.fmod(secs, 1.0)
t.c_tv_sec = int(secs)
t.c_tv_usec = int(frac*1000000.0)
if rffi.cast(rffi.LONG, c_select(0, void, void, void, t)) != 0:
errno = rposix.get_errno()
if errno != EINTR:
raise OSError(rposix.get_errno(), "Select failed")
finally:
lltype.free(t, flavor='raw')
return extdef([float], None, llimpl=time_sleep_llimpl,
export_name='ll_time.ll_time_sleep')
def register_os_uname(self):
CHARARRAY = lltype.FixedSizeArray(lltype.Char, 1)
class CConfig:
_compilation_info_ = ExternalCompilationInfo(
includes = ['sys/utsname.h']
)
UTSNAME = platform.Struct('struct utsname', [
('sysname', CHARARRAY),
('nodename', CHARARRAY),
('release', CHARARRAY),
('version', CHARARRAY),
('machine', CHARARRAY)])
config = platform.configure(CConfig)
UTSNAMEP = lltype.Ptr(config['UTSNAME'])
os_uname = self.llexternal('uname', [UTSNAMEP], rffi.INT,
compilation_info=CConfig._compilation_info_)
def uname_llimpl():
l_utsbuf = lltype.malloc(UTSNAMEP.TO, flavor='raw')
result = os_uname(l_utsbuf)
if result == -1:
raise OSError(rposix.get_errno(), "os_uname failed")
retval = (
rffi.charp2str(rffi.cast(rffi.CCHARP, l_utsbuf.c_sysname)),
rffi.charp2str(rffi.cast(rffi.CCHARP, l_utsbuf.c_nodename)),
rffi.charp2str(rffi.cast(rffi.CCHARP, l_utsbuf.c_release)),
rffi.charp2str(rffi.cast(rffi.CCHARP, l_utsbuf.c_version)),
rffi.charp2str(rffi.cast(rffi.CCHARP, l_utsbuf.c_machine)),
)
lltype.free(l_utsbuf, flavor='raw')
return retval
return extdef([], (str, str, str, str, str),
"ll_os.ll_uname", llimpl=uname_llimpl)
def register_time_time(self):
# Note: time.time() is used by the framework GC during collect(),
# which means that we have to be very careful about not allocating
# GC memory here. This is the reason for the _nowrapper=True.
# AWFUL
if self.HAVE_GETTIMEOFDAY:
if self.GETTIMEOFDAY_NO_TZ:
c_gettimeofday = self.llexternal('gettimeofday',
[self.TIMEVALP], rffi.INT,
_nowrapper=True, threadsafe=False)
else:
c_gettimeofday = self.llexternal('gettimeofday',
[self.TIMEVALP, rffi.VOIDP], rffi.INT,
_nowrapper=True, threadsafe=False)
else:
c_gettimeofday = None
if self.HAVE_FTIME:
self.configure(CConfigForFTime)
c_ftime = self.llexternal(FTIME, [lltype.Ptr(self.TIMEB)],
lltype.Void,
_nowrapper=True, threadsafe=False)
else:
c_ftime = None # to not confuse the flow space
c_time = self.llexternal('time', [rffi.VOIDP], rffi.TIME_T,
_nowrapper=True, threadsafe=False)
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 = g_gettimeofday(t)
else:
errcode = c_gettimeofday(t, void)
if rffi.cast(rffi.LONG, errcode) == 0:
result = float(rffi.cast(lltype.Signed, t.c_tv_sec)) \
+ float(rffi.cast(lltype.Signed, t.c_tv_usec)) \
* 0.000001
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(int(t.c_time)) + float(int(t.c_millitm)) * 0.001
lltype.free(t, flavor='raw')
return result
return float(c_time(void))
return extdef([], float, llimpl=time_time_llimpl,
export_name='ll_time.ll_time_time')
def register_os__exit(self):
os__exit = self.llexternal('_exit', [rffi.INT], lltype.Void)
def _exit_llimpl(status):
os__exit(rffi.cast(rffi.INT, status))
return extdef([int], s_None, llimpl=_exit_llimpl,
export_name="ll_os.ll_os__exit")
def register_os_isatty(self):
os_isatty = self.llexternal(underscore_on_windows+'isatty', [rffi.INT], rffi.INT)
def isatty_llimpl(fd):
res = rffi.cast(rffi.LONG, os_isatty(rffi.cast(rffi.INT, fd)))
return res != 0
return extdef([int], bool, llimpl=isatty_llimpl,
export_name="ll_os.ll_os_isatty")
def register_os_umask(self):
os_umask = self.llexternal(underscore_on_windows+'umask', [rffi.MODE_T], rffi.MODE_T)
def umask_llimpl(fd):
res = os_umask(rffi.cast(rffi.MODE_T, fd))
return rffi.cast(lltype.Signed, res)
return extdef([int], int, llimpl=umask_llimpl,
export_name="ll_os.ll_os_umask")
def register_os_system(self):
os_system = self.llexternal('system', [rffi.CCHARP], rffi.INT)
def system_llimpl(command):
res = os_system(command)
return rffi.cast(lltype.Signed, res)
return extdef([str], int, llimpl=system_llimpl,
export_name="ll_os.ll_os_system")
def register_time_time(self):
# Note: time.time() is used by the framework GC during collect(),
# which means that we have to be very careful about not allocating
# GC memory here. This is the reason for the _nowrapper=True.
# AWFUL
if self.HAVE_GETTIMEOFDAY:
if self.GETTIMEOFDAY_NO_TZ:
c_gettimeofday = self.llexternal('gettimeofday',
[self.TIMEVALP], rffi.INT,
_nowrapper=True, threadsafe=False)
else:
c_gettimeofday = self.llexternal('gettimeofday',
[self.TIMEVALP, rffi.VOIDP], rffi.INT,
_nowrapper=True, threadsafe=False)
else:
c_gettimeofday = None
if self.HAVE_FTIME:
self.configure(CConfigForFTime)
c_ftime = self.llexternal('ftime', [lltype.Ptr(self.TIMEB)],
lltype.Void,
_nowrapper=True, threadsafe=False)
else:
c_ftime = None # to not confuse the flow space
c_time = self.llexternal('time', [rffi.VOIDP], self.TIME_T,
_nowrapper=True, threadsafe=False)
def time_time_llimpl():
void = lltype.nullptr(rffi.VOIDP.TO)
result = -1.0
if self.HAVE_GETTIMEOFDAY:
t = lltype.malloc(self.TIMEVAL, flavor='raw')
if self.GETTIMEOFDAY_NO_TZ:
if rffi.cast(rffi.LONG, c_gettimeofday(t)) == 0:
result = float(t.c_tv_sec) + \
float(t.c_tv_usec) * 0.000001
else:
if rffi.cast(rffi.LONG, c_gettimeofday(t, void)) == 0:
result = float(t.c_tv_sec) + \
float(t.c_tv_usec) * 0.000001
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(int(t.c_time)) + float(int(t.c_millitm)) * 0.001
lltype.free(t, flavor='raw')
return result
return float(c_time(void))
return extdef([], float, llimpl=time_time_llimpl,
export_name='ll_time.ll_time_time')
def register_os_unlink(self):
os_unlink = self.llexternal(underscore_on_windows+'unlink', [rffi.CCHARP], rffi.INT)
def unlink_llimpl(pathname):
res = rffi.cast(lltype.Signed, os_unlink(pathname))
if res < 0:
raise OSError(rposix.get_errno(), "os_unlink failed")
return extdef([str], s_None, llimpl=unlink_llimpl,
export_name="ll_os.ll_os_unlink")
def register_os_close(self):
os_close = self.llexternal(underscore_on_windows+'close', [rffi.INT], rffi.INT)
def close_llimpl(fd):
error = rffi.cast(lltype.Signed, os_close(rffi.cast(rffi.INT, fd)))
if error == -1:
raise OSError(rposix.get_errno(), "close failed")
return extdef([int], s_None, llimpl=close_llimpl,
export_name="ll_os.ll_os_close", oofakeimpl=os.close)
def register_os_chdir(self):
os_chdir = self.llexternal(underscore_on_windows+'chdir', [rffi.CCHARP], rffi.INT)
def chdir_llimpl(path):
res = rffi.cast(lltype.Signed, os_chdir(path))
if res < 0:
raise OSError(rposix.get_errno(), "os_chdir failed")
return extdef([str], s_None, llimpl=chdir_llimpl,
export_name="ll_os.ll_os_chdir")
def register_os_setsid(self):
os_setsid = self.llexternal('setsid', [], rffi.PID_T)
def setsid_llimpl():
result = rffi.cast(lltype.Signed, os_setsid())
if result == -1:
raise OSError(rposix.get_errno(), "os_setsid failed")
return result
return extdef([], int, export_name="ll_os.ll_os_setsid",
llimpl=setsid_llimpl)
def register_os_fork(self):
os_fork = self.llexternal('fork', [], rffi.PID_T)
def fork_llimpl():
childpid = rffi.cast(lltype.Signed, os_fork())
if childpid == -1:
raise OSError(rposix.get_errno(), "os_fork failed")
return rffi.cast(lltype.Signed, childpid)
return extdef([], int, llimpl=fork_llimpl,
export_name="ll_os.ll_os_fork")
def extdef_for_function_int_to_int(self, name, **kwds):
c_func = self.llexternal(name, [rffi.INT], rffi.INT, **kwds)
def c_func_llimpl(arg):
res = rffi.cast(rffi.LONG, c_func(arg))
if res == -1:
raise OSError(rposix.get_errno(), "%s failed" % name)
c_func_llimpl.func_name = name + '_llimpl'
return extdef([int], None, llimpl=c_func_llimpl,
export_name='ll_os.ll_os_' + name)
def register_os_ttyname(self):
os_ttyname = self.llexternal('ttyname', [lltype.Signed], rffi.CCHARP)
def ttyname_llimpl(fd):
l_name = os_ttyname(fd)
if not l_name:
raise OSError(rposix.get_errno(), "ttyname raised")
return rffi.charp2str(l_name)
return extdef([int], str, "ll_os.ttyname",
llimpl=ttyname_llimpl)
def register_os_dup(self):
os_dup = self.llexternal(underscore_on_windows+'dup', [rffi.INT], rffi.INT)
def dup_llimpl(fd):
newfd = rffi.cast(lltype.Signed, os_dup(rffi.cast(rffi.INT, fd)))
if newfd == -1:
raise OSError(rposix.get_errno(), "dup failed")
return newfd
return extdef([int], int, llimpl=dup_llimpl,
export_name="ll_os.ll_os_dup", oofakeimpl=os.dup)
def register_os_symlink(self):
os_symlink = self.llexternal('symlink', [rffi.CCHARP, rffi.CCHARP],
rffi.INT)
def symlink_llimpl(oldpath, newpath):
res = rffi.cast(lltype.Signed, os_symlink(oldpath, newpath))
if res < 0:
raise OSError(rposix.get_errno(), "os_symlink failed")
return extdef([str, str], s_None, llimpl=symlink_llimpl,
export_name="ll_os.ll_os_symlink")
def register_os_chmod(self):
os_chmod = self.llexternal(underscore_on_windows+'chmod', [rffi.CCHARP, rffi.MODE_T],
rffi.INT)
def chmod_llimpl(path, mode):
res = rffi.cast(lltype.Signed, os_chmod(path, rffi.cast(rffi.MODE_T, mode)))
if res < 0:
raise OSError(rposix.get_errno(), "os_chmod failed")
return extdef([str, int], s_None, llimpl=chmod_llimpl,
export_name="ll_os.ll_os_chmod")
def extdef_for_os_function_returning_int(self, name, **kwds):
c_func = self.llexternal(name, [], rffi.INT, **kwds)
def c_func_llimpl():
res = rffi.cast(rffi.LONG, c_func())
if res == -1:
raise OSError(rposix.get_errno(), "%s failed" % name)
return res
c_func_llimpl.func_name = name + '_llimpl'
return extdef([], int, llimpl=c_func_llimpl,
export_name='ll_os.ll_os_' + name)
def register_os_strerror(self):
os_strerror = self.llexternal('strerror', [rffi.INT], rffi.CCHARP)
def strerror_llimpl(errnum):
res = os_strerror(rffi.cast(rffi.INT, errnum))
if not res:
raise ValueError("os_strerror failed")
return rffi.charp2str(res)
return extdef([int], str, llimpl=strerror_llimpl,
export_name="ll_os.ll_os_strerror")
def register_os_dup2(self):
os_dup2 = self.llexternal(underscore_on_windows+'dup2',
[rffi.INT, rffi.INT], rffi.INT)
def dup2_llimpl(fd, newfd):
error = rffi.cast(lltype.Signed, os_dup2(rffi.cast(rffi.INT, fd),
rffi.cast(rffi.INT, newfd)))
if error == -1:
raise OSError(rposix.get_errno(), "dup2 failed")
return extdef([int, int], s_None, llimpl=dup2_llimpl,
export_name="ll_os.ll_os_dup2")
def register_os_execv(self):
os_execv = self.llexternal('execv', [rffi.CCHARP, rffi.CCHARPP],
rffi.INT)
def execv_llimpl(path, args):
l_args = rffi.liststr2charpp(args)
os_execv(path, l_args)
rffi.free_charpp(l_args)
raise OSError(rposix.get_errno(), "execv failed")
return extdef([str, [str]], s_ImpossibleValue, llimpl=execv_llimpl,
export_name="ll_os.ll_os_execv")
def register_os_kill(self):
os_kill = self.llexternal('kill', [rffi.PID_T, rffi.INT],
rffi.INT)
def kill_llimpl(pid, sig):
res = rffi.cast(lltype.Signed, os_kill(rffi.cast(rffi.PID_T, pid),
rffi.cast(rffi.INT, sig)))
if res < 0:
raise OSError(rposix.get_errno(), "os_kill failed")
return extdef([int, int], s_None, llimpl=kill_llimpl,
export_name="ll_os.ll_os_kill")
def register_time_clock(self):
if sys.platform == 'win32':
# hacking to avoid LARGE_INTEGER which is a union...
A = lltype.FixedSizeArray(lltype.SignedLongLong, 1)
QueryPerformanceCounter = self.llexternal(
'QueryPerformanceCounter', [lltype.Ptr(A)],
lltype.Void,
threadsafe=False)
QueryPerformanceFrequency = self.llexternal(
'QueryPerformanceFrequency', [lltype.Ptr(A)],
rffi.INT,
threadsafe=False)
class State(object):
pass
state = State()
state.divisor = 0.0
state.counter_start = 0
def time_clock_llimpl():
a = lltype.malloc(A, flavor='raw')
if state.divisor == 0.0:
QueryPerformanceCounter(a)
state.counter_start = a[0]
QueryPerformanceFrequency(a)
state.divisor = float(a[0])
QueryPerformanceCounter(a)
diff = a[0] - state.counter_start
lltype.free(a, flavor='raw')
return float(diff) / state.divisor
else:
RUSAGE = self.RUSAGE
RUSAGE_SELF = self.RUSAGE_SELF or 0
c_getrusage = self.llexternal(
'getrusage', [rffi.INT, lltype.Ptr(RUSAGE)],
lltype.Void,
threadsafe=False)
def time_clock_llimpl():
a = lltype.malloc(RUSAGE, flavor='raw')
c_getrusage(RUSAGE_SELF, a)
result = (decode_timeval(a.c_ru_utime) +
decode_timeval(a.c_ru_stime))
lltype.free(a, flavor='raw')
return result
return extdef([],
float,
llimpl=time_clock_llimpl,
export_name='ll_time.ll_time_clock')
def register_posix__getfullpathname(self):
# this nt function is not exposed via os, but needed
# to get a correct implementation of os.abspath
# XXX why do we ignore WINAPI conventions everywhere?
class CConfig:
_compilation_info_ = ExternalCompilationInfo(
includes = ['Windows.h']
)
MAX_PATH = platform.ConstantInteger('MAX_PATH')
DWORD = platform.SimpleType("DWORD", rffi.ULONG)
LPCTSTR = platform.SimpleType("LPCTSTR", rffi.CCHARP)
LPTSTR = platform.SimpleType("LPTSTR", rffi.CCHARP)
LPTSTRP = platform.SimpleType("LPTSTR*", rffi.CCHARPP)
config = platform.configure(CConfig)
MAX_PATH = config['MAX_PATH']
DWORD = config['DWORD']
LPCTSTR = config['LPCTSTR']
LPTSTR = config['LPTSTR']
LPTSTRP = config['LPTSTRP']
# XXX unicode?
GetFullPathName = self.llexternal('GetFullPathNameA',
[LPCTSTR, DWORD, LPTSTR, LPTSTRP], DWORD)
GetLastError = self.llexternal('GetLastError', [], DWORD)
##DWORD WINAPI GetFullPathName(
## __in LPCTSTR lpFileName,
## __in DWORD nBufferLength,
## __out LPTSTR lpBuffer,
## __out LPTSTR* lpFilePart
##);
def _getfullpathname_llimpl(lpFileName):
nBufferLength = MAX_PATH + 1
lpBuffer = lltype.malloc(LPTSTR.TO, nBufferLength, flavor='raw')
try:
res = GetFullPathName(
lpFileName, rffi.cast(DWORD, nBufferLength),
lpBuffer, lltype.nullptr(LPTSTRP.TO))
if res == 0:
error = GetLastError()
raise OSError(error, "_getfullpathname failed")
# XXX ntpath expects WindowsError :-(
result = rffi.charp2str(lpBuffer)
return result
finally:
lltype.free(lpBuffer, flavor='raw')
return extdef([str], # a single argument which is a str
str, # returns a string
"ll_os.posix__getfullpathname",
llimpl=_getfullpathname_llimpl)
