def method_kill(self, space, w_signal, args_w):
if not args_w:
raise space.error(space.w_ArgumentError,
"wrong number of arguments (%d for at least 2)" % (len(args_w) + 1)
)
if space.is_kind_of(w_signal, space.w_fixnum):
sig = space.int_w(w_signal)
else:
s = Coerce.str(space, w_signal)
if s.startswith("SIG"):
s = s[len("SIG"):]
try:
sig = SIGNALS[s]
except KeyError:
raise space.error(space.w_ArgumentError,
"unsupported name `SIG%s'" % s
)
if sig < 0:
for w_arg in args_w:
pid = Coerce.int(space, w_arg)
try:
killpg(pid, -sig)
except OSError as e:
raise error_for_oserror(space, e)
else:
for w_arg in args_w:
pid = Coerce.int(space, w_arg)
try:
kill(pid, sig)
except OSError as e:
raise error_for_oserror(space, e)
return space.newint(len(args_w))
def method_exec(self, space, args_w):
if len(args_w) > 1 and space.respond_to(args_w[0], "to_hash"):
raise space.error(space.w_NotImplementedError, "exec with environment")
if len(args_w) > 1 and space.respond_to(args_w[-1], "to_hash"):
raise space.error(space.w_NotImplementedError, "exec with options")
if space.respond_to(args_w[0], "to_ary"):
w_cmd = space.convert_type(args_w[0], space.w_array, "to_ary")
cmd_w = space.listview(w_cmd)
if len(cmd_w) != 2:
raise space.error(space.w_ArgumentError, "wrong first argument")
cmd, argv0 = [
space.str0_w(space.convert_type(
w_e, space.w_string, "to_str"
)) for w_e in cmd_w
]
else:
w_cmd = space.convert_type(args_w[0], space.w_string, "to_str")
cmd = space.str0_w(w_cmd)
argv0 = None
if len(args_w) > 1 or argv0 is not None:
if argv0 is None:
sepidx = cmd.rfind(os.sep) + 1
if sepidx > 0:
argv0 = cmd[sepidx:]
else:
argv0 = cmd
args = [argv0]
args += [
space.str0_w(space.convert_type(
w_arg, space.w_string, "to_str"
)) for w_arg in args_w[1:]
]
try:
os.execv(cmd, args)
except OSError as e:
raise error_for_oserror(space, e)
else:
if not cmd:
raise error_for_errno(space, errno.ENOENT)
shell = os.environ.get("RUBYSHELL") or os.environ.get("COMSPEC") or "/bin/sh"
sepidx = shell.rfind(os.sep) + 1
if sepidx > 0:
argv0 = shell[sepidx:]
else:
argv0 = shell
try:
os.execv(shell, [argv0, "-c", cmd])
except OSError as e:
raise error_for_oserror(space, e)
def method_read(self, space, w_length=None, w_str=None):
self.ensure_not_closed(space)
if w_length:
length = space.int_w(w_length)
if length < 0:
raise space.error(space.w_ArgumentError,
"negative length %d given" % length
)
else:
length = -1
read_bytes = 0
read_chunks = []
while length < 0 or read_bytes < length:
if length > 0:
max_read = int(length - read_bytes)
else:
max_read = 8192
try:
current_read = os.read(self.fd, max_read)
except OSError as e:
raise error_for_oserror(space, e)
if len(current_read) == 0:
break
read_bytes += len(current_read)
read_chunks += current_read
# Return nil on EOF if length is given
if read_bytes == 0:
return space.w_nil
w_read_str = space.newstr_fromchars(read_chunks)
if w_str is not None:
w_str.clear(space)
w_str.extend(space, w_read_str)
return w_str
else:
return w_read_str
def method_initialize(self, space, path):
self.path = path
try:
self.dirp = opendir(path)
except OSError as e:
raise error_for_oserror(space, e)
self.open = True
def method_truncate(self, space, length):
self.ensure_not_closed(space)
try:
ftruncate(self.fd, length)
except OSError as e:
raise error_for_oserror(space, e)
return space.newint(0)
def method_write(self, space, w_str):
self.ensure_not_closed(space)
string = space.str_w(space.send(w_str, "to_s"))
try:
bytes_written = os.write(self.fd, string)
except OSError as e:
raise error_for_oserror(space, e)
return space.newint(bytes_written)
def method_stat(self, space):
try:
stat_val = os.fstat(self.fd)
except OSError as e:
raise error_for_oserror(space, e)
stat_obj = W_FileStatObject(space)
stat_obj.set_stat(stat_val)
return stat_obj
def singleton_method_chmod(self, space, mode, args_w):
for arg_w in args_w:
path = Coerce.path(space, arg_w)
try:
os.chmod(path, mode)
except OSError as e:
raise error_for_oserror(space, e)
return space.newint(len(args_w))
def singleton_method_lstat(self, space, filename):
try:
stat_val = os.lstat(filename)
except OSError as e:
raise error_for_oserror(space, e)
stat_obj = W_FileStatObject(space)
stat_obj.set_stat(stat_val)
return stat_obj
def singleton_method_delete(self, space, args_w):
for w_path in args_w:
path = Coerce.path(space, w_path)
try:
os.unlink(path)
except OSError as e:
raise error_for_oserror(space, e)
return space.newint(len(args_w))
def method_getc(self, space):
self.ensure_not_closed(space)
try:
c = os.read(self.fd, 1)
except OSError as e:
raise error_for_oserror(space, e)
if not c:
return space.w_nil
return space.newstr_fromstr(c)
def method_chdir(self, space, path=None, block=None):
if path is None:
path = os.environ["HOME"]
current_dir = os.getcwd()
try:
os.chdir(path)
except OSError as e:
raise error_for_oserror(space, e)
if block is not None:
try:
return space.invoke_block(block, [space.newstr_fromstr(path)])
finally:
try:
os.chdir(current_dir)
except OSError as e:
raise error_for_oserror(space, e)
else:
return space.newint(0)
def method_clock_gettime(self, space, clockid, args_w):
if len(args_w) > 1:
raise space.error(space.w_ArgumentError,
"wrong number of arguments (given %d, expected 1..2)"
)
if len(args_w) == 1:
unit = Coerce.symbol(space, args_w[0])
else:
unit = "float_second"
if rtime.HAS_CLOCK_GETTIME:
with lltype.scoped_alloc(rtime.TIMESPEC) as a:
if rtime.c_clock_gettime(clockid, a) == 0:
sec = rffi.getintfield(a, 'c_tv_sec')
nsec = rffi.getintfield(a, 'c_tv_nsec')
else:
raise error_for_oserror(space, OSError(
errno.EINVAL, "clock_gettime")
)
elif clockid == CLOCK_PROCESS_CPUTIME_ID:
r = rtime.clock()
sec = int(r)
nsec = r * 1000000000
else:
raise error_for_oserror(space, OSError(
errno.EINVAL, "clock_gettime")
)
if unit == "float_second":
return space.newfloat(sec + nsec * 0.000000001)
elif unit == "float_millisecond":
return space.newfloat(sec * 1000 + nsec * 0.000001)
elif unit == "float_microsecond":
return space.newfloat(sec * 1000000 + nsec * 0.001)
elif unit == "second":
return space.newint(int(sec))
elif unit == "millisecond":
return space.newint(int(sec) * 1000)
elif unit == "microsecond":
return space.newint(sec * 1000000)
elif unit == "nanosecond":
return space.newint(sec * 1000000000 + int(nsec))
else:
raise space.error(space.w_ArgumentError,
"unexpected unit: %s" % unit
)
def method_read(self, space, args_w):
self.ensure_open(space)
try:
filename = readdir(self.dirp)
except OSError as e:
raise error_for_oserror(space, e)
if filename is None:
return space.w_nil
else:
return space.newstr_fromstr(filename)
def method_waitpid(self, space, pid=-1):
try:
pid, status = os.waitpid(pid, 0)
except OSError as e:
raise error_for_oserror(space, e)
status = WEXITSTATUS(status)
w_status = space.send(
space.find_const(self, "Status"),
"new",
[space.newint(pid), space.newint(status)]
)
space.globals.set(space, "$?", w_status)
return space.newint(pid)
def load_feature(space, path, orig_path):
if not os.path.exists(path):
raise space.error(space.w_LoadError, orig_path)
try:
f = open_file_as_stream(path, buffering=0)
try:
contents = f.readall()
finally:
f.close()
except OSError as e:
raise error_for_oserror(space, e)
space.execute(contents, filepath=path)
def method_sysopen(self, space, w_path, w_mode_str_or_int=None, w_perm=None):
perm = 0666
mode = os.O_RDONLY
if w_mode_str_or_int is not None:
mode = map_filemode(space, w_mode_str_or_int)
if w_perm is not None and w_perm is not space.w_nil:
perm = space.int_w(w_perm)
path = Coerce.path(space, w_path)
try:
fd = os.open(path, mode, perm)
except OSError as e:
raise error_for_oserror(space, e)
else:
return space.newint(fd)
def method_tcgetattr(self, space, fd):
try:
mode = tcgetattr(fd)
except OSError as e:
raise error_for_oserror(space, e)
mode_w = [
space.newint(mode[0]), # iflag
space.newint(mode[1]), # oflag
space.newint(mode[2]), # cflag
space.newint(mode[3]), # lflag
space.newint(mode[4]), # ispeed
space.newint(mode[5]), # ospeed
space.newarray([space.newstr_fromstr(cc) for cc in mode[6]])
]
return space.newarray(mode_w)
def method_tcsetattr(self, space, fd, when, mode_w):
cc = [space.str_w(w_char) for w_char in space.listview(mode_w[6])]
mode = (
space.int_w(mode_w[0]), # iflag
space.int_w(mode_w[1]), # oflag
space.int_w(mode_w[2]), # cflag
space.int_w(mode_w[3]), # lflag
space.int_w(mode_w[4]), # ispeed
space.int_w(mode_w[5]), # ospeed
cc
)
try:
tcsetattr(fd, when, mode)
except OSError as e:
raise error_for_oserror(space, e)
return self
def load_feature(space, path, orig_path, wrap=False):
if not os.path.exists(path):
raise space.error(space.w_LoadError, orig_path)
try:
f = open_file_as_stream(path, buffering=0)
try:
contents = f.readall()
finally:
f.close()
except OSError as e:
raise error_for_oserror(space, e)
if wrap:
lexical_scope = StaticScope(space.newmodule("Anonymous"), None)
else:
lexical_scope = None
space.execute(contents, filepath=path, lexical_scope=lexical_scope)
def method_initialize(self, space, filename, w_mode=None, w_perm_or_opt=None, w_opt=None):
if w_mode is None:
w_mode = space.w_nil
if w_perm_or_opt is None:
w_perm_or_opt = space.w_nil
if w_opt is None:
w_opt = space.w_nil
if isinstance(w_perm_or_opt, W_HashObject):
assert w_opt is space.w_nil
perm = 0665
w_opt = w_perm_or_opt
elif w_opt is not space.w_nil:
perm = space.int_w(w_perm_or_opt)
else:
perm = 0665
mode = map_filemode(space, w_mode)
if w_perm_or_opt is not space.w_nil or w_opt is not space.w_nil:
raise space.error(space.w_NotImplementedError, "options hash or permissions for File.new")
try:
self.fd = os.open(filename, mode, perm)
except OSError as e:
raise error_for_oserror(space, e)
return self
def method_delete(self, space, path):
try:
os.rmdir(path if path else "")
except OSError as e:
raise error_for_oserror(space, e)
return space.newint(0)
def method_ctime(self, space):
try:
stat_val = os.stat(self.filename)
except OSError as e:
raise error_for_oserror(space, e)
return self._time_at(space, stat_val.st_ctime)
def method_chmod(self, space, mode):
try:
fchmod(self.fd, mode)
except OSError as e:
raise error_for_oserror(space, e)
return space.newint(0)
def method_ctime(self, space):
try:
stat_val = os.stat(self.filename)
except OSError as e:
raise error_for_oserror(space, e)
return self._time_at(space, stat_val.st_ctime)
def method_chmod(self, space, mode):
try:
fchmod(self.fd, mode)
except OSError as e:
raise error_for_oserror(space, e)
return space.newint(0)
def method_entries(self, space, dirname):
try:
return space.newarray([space.newstr_fromstr(d) for d in os.listdir(dirname)])
except OSError as e:
raise error_for_oserror(space, e)
def method_entries(self, space, dirname):
try:
return space.newarray([space.newstr_fromstr(d) for d in os.listdir(dirname)])
except OSError as e:
raise error_for_oserror(space, e)
def method_initialize(self, space, filename):
try:
self.set_stat(os.stat(filename))
except OSError as e:
raise error_for_oserror(space, e)
def method_initialize(self, space, filename, w_mode=None, w_perm_or_opt=None, w_opt=None):
if w_mode is None:
w_mode = space.w_nil
if w_perm_or_opt is None:
w_perm_or_opt = space.w_nil
if w_opt is None:
w_opt = space.w_nil
if isinstance(w_perm_or_opt, W_HashObject):
assert w_opt is space.w_nil
perm = 0665
w_opt = w_perm_or_opt
elif w_opt is not space.w_nil:
perm = space.int_w(w_perm_or_opt)
else:
perm = 0665
if w_mode is space.w_nil:
mode = os.O_RDONLY
elif isinstance(w_mode, W_StringObject):
mode_str = space.str_w(w_mode)
mode = 0
invalid_error = space.error(space.w_ArgumentError,
"invalid access mode %s" % mode_str
)
major_mode_seen = False
readable = writeable = append = False
for ch in mode_str:
if ch == "b":
mode |= O_BINARY
elif ch == "+":
readable = writeable = True
elif ch == "r":
if major_mode_seen:
raise invalid_error
major_mode_seen = True
readable = True
elif ch == "a":
if major_mode_seen:
raise invalid_error
major_mode_seen = True
mode |= os.O_CREAT
append = writeable = True
elif ch == "w":
if major_mode_seen:
raise invalid_error
major_mode_seen = True
mode |= os.O_TRUNC | os.O_CREAT
writeable = True
else:
raise invalid_error
if readable and writeable:
mode |= os.O_RDWR
elif readable:
mode |= os.O_RDONLY
elif writeable:
mode |= os.O_WRONLY
if append:
mode |= os.O_APPEND
else:
mode = space.int_w(w_mode)
if w_perm_or_opt is not space.w_nil or w_opt is not space.w_nil:
raise NotImplementedError("options hash or permissions for File.new")
try:
self.fd = os.open(filename, mode, perm)
except OSError as e:
raise error_for_oserror(space, e)
return self
def method_mkdir(self, space, path, mode=0777):
try:
os.mkdir(path, mode)
except OSError as e:
raise error_for_oserror(space, e)
return space.newint(0)
def singleton_method_link(self, space, old_name, new_name):
try:
os.link(old_name, new_name)
except OSError as e:
raise error_for_oserror(space, e)
return space.newint(0)
def method_initialize(self, space, filename):
try:
self.set_stat(os.stat(filename))
except OSError as e:
raise error_for_oserror(space, e)
def method_delete(self, space, path):
try:
os.rmdir(path if path else "")
except OSError as e:
raise error_for_oserror(space, e)
return space.newint(0)
def singleton_method_link(self, space, old_name, new_name):
try:
os.link(old_name, new_name)
except OSError as e:
raise error_for_oserror(space, e)
return space.newint(0)
def method_mkdir(self, space, path, mode=0777):
try:
os.mkdir(path, mode)
except OSError as e:
raise error_for_oserror(space, e)
return space.newint(0)
