rhodes 3.1.1 → 3.2.0.beta.1

data/platform/shared/ruby/process.c

@@ -59,9 +59,7 @@ struct timeval rb_time_interval(VALUE);
 #undef HAVE_GETPGRP
 #endif
 
-/* RHO BEGIN */
-#include <common/stat.h>
-/* RHO END */
+#include <sys/stat.h>
 
 #ifdef HAVE_SYS_TIMES_H
 #include <sys/times.h>
@@ -141,7 +139,7 @@ static VALUE rb_cProcessTms;
 
 /*
  *  call-seq:
- *     Process.pid   => fixnum
+ *     Process.pid   -> fixnum
  *
  *  Returns the process id of this process. Not available on all
  *  platforms.
@@ -159,7 +157,7 @@ get_pid(void)
 
 /*
  *  call-seq:
- *     Process.ppid   => fixnum
+ *     Process.ppid   -> fixnum
  *
  *  Returns the process id of the parent of this process. Returns
  *  untrustworthy value on Win32/64. Not available on all platforms.
@@ -236,8 +234,8 @@ rb_last_status_clear(void)
 
 /*
  *  call-seq:
- *     stat.to_i     => fixnum
- *     stat.to_int   => fixnum
+ *     stat.to_i     -> fixnum
+ *     stat.to_int   -> fixnum
  *
  *  Returns the bits in _stat_ as a <code>Fixnum</code>. Poking
  *  around in these bits is platform dependent.
@@ -257,7 +255,7 @@ pst_to_i(VALUE st)
 
 /*
  *  call-seq:
- *     stat.pid   => fixnum
+ *     stat.pid   -> fixnum
  *
  *  Returns the process ID that this status object represents.
  *
@@ -309,7 +307,7 @@ pst_message(VALUE str, rb_pid_t pid, int status)
 
 /*
  *  call-seq:
- *     stat.to_s   => string
+ *     stat.to_s   -> string
  *
  *  Show pid and exit status as a string.
  */
@@ -321,7 +319,7 @@ pst_to_s(VALUE st)
     int status;
     VALUE str;
 
-    pid = NUM2LONG(pst_pid(st));
+    pid = NUM2PIDT(pst_pid(st));
     status = PST2INT(st);
 
     str = rb_str_buf_new(0);
@@ -332,7 +330,7 @@ pst_to_s(VALUE st)
 
 /*
  *  call-seq:
- *     stat.inspect   => string
+ *     stat.inspect   -> string
  *
  *  Override the inspection method.
  */
@@ -348,7 +346,7 @@ pst_inspect(VALUE st)
     if (NIL_P(vpid)) {
         return rb_sprintf("#<%s: uninitialized>", rb_class2name(CLASS_OF(st)));
     }
-    pid = NUM2LONG(vpid);
+    pid = NUM2PIDT(vpid);
     status = PST2INT(st);
 
     str = rb_sprintf("#<%s: ", rb_class2name(CLASS_OF(st)));
@@ -360,7 +358,7 @@ pst_inspect(VALUE st)
 
 /*
  *  call-seq:
- *     stat == other   => true or false
+ *     stat == other   -> true or false
  *
  *  Returns +true+ if the integer value of _stat_
  *  equals <em>other</em>.
@@ -376,7 +374,7 @@ pst_equal(VALUE st1, VALUE st2)
 
 /*
  *  call-seq:
- *     stat & num   => fixnum
+ *     stat & num   -> fixnum
  *
  *  Logical AND of the bits in _stat_ with <em>num</em>.
  *
@@ -397,7 +395,7 @@ pst_bitand(VALUE st1, VALUE st2)
 
 /*
  *  call-seq:
- *     stat >> num   => fixnum
+ *     stat >> num   -> fixnum
  *
  *  Shift the bits in _stat_ right <em>num</em> places.
  *
@@ -418,7 +416,7 @@ pst_rshift(VALUE st1, VALUE st2)
 
 /*
  *  call-seq:
- *     stat.stopped?   => true or false
+ *     stat.stopped?   -> true or false
  *
  *  Returns +true+ if this process is stopped. This is only
  *  returned if the corresponding <code>wait</code> call had the
@@ -439,7 +437,7 @@ pst_wifstopped(VALUE st)
 
 /*
  *  call-seq:
- *     stat.stopsig   => fixnum or nil
+ *     stat.stopsig   -> fixnum or nil
  *
  *  Returns the number of the signal that caused _stat_ to stop
  *  (or +nil+ if self is not stopped).
@@ -458,7 +456,7 @@ pst_wstopsig(VALUE st)
 
 /*
  *  call-seq:
- *     stat.signaled?   => true or false
+ *     stat.signaled?   -> true or false
  *
  *  Returns +true+ if _stat_ terminated because of
  *  an uncaught signal.
@@ -478,7 +476,7 @@ pst_wifsignaled(VALUE st)
 
 /*
  *  call-seq:
- *     stat.termsig   => fixnum or nil
+ *     stat.termsig   -> fixnum or nil
  *
  *  Returns the number of the signal that caused _stat_ to
  *  terminate (or +nil+ if self was not terminated by an
@@ -498,7 +496,7 @@ pst_wtermsig(VALUE st)
 
 /*
  *  call-seq:
- *     stat.exited?   => true or false
+ *     stat.exited?   -> true or false
  *
  *  Returns +true+ if _stat_ exited normally (for
  *  example using an <code>exit()</code> call or finishing the
@@ -519,7 +517,7 @@ pst_wifexited(VALUE st)
 
 /*
  *  call-seq:
- *     stat.exitstatus   => fixnum or nil
+ *     stat.exitstatus   -> fixnum or nil
  *
  *  Returns the least significant eight bits of the return code of
  *  _stat_. Only available if <code>exited?</code> is
@@ -549,7 +547,7 @@ pst_wexitstatus(VALUE st)
 
 /*
  *  call-seq:
- *     stat.success?   => true, false or nil
+ *     stat.success?   -> true, false or nil
  *
  *  Returns +true+ if _stat_ is successful, +false+ if not.
  *  Returns +nil+ if <code>exited?</code> is not +true+.
@@ -568,7 +566,7 @@ pst_success_p(VALUE st)
 
 /*
  *  call-seq:
- *     stat.coredump?   => true or false
+ *     stat.coredump?   -> true or false
  *
  *  Returns +true+ if _stat_ generated a coredump
  *  when it terminated. Not available on all platforms.
@@ -727,9 +725,9 @@ rb_waitpid(rb_pid_t pid, int *st, int flags)
 
 /*
  *  call-seq:
- *     Process.wait()                     => fixnum
- *     Process.wait(pid=-1, flags=0)      => fixnum
- *     Process.waitpid(pid=-1, flags=0)   => fixnum
+ *     Process.wait()                     -> fixnum
+ *     Process.wait(pid=-1, flags=0)      -> fixnum
+ *     Process.waitpid(pid=-1, flags=0)   -> fixnum
  *
  *  Waits for a child process to exit, returns its process id, and
  *  sets <code>$?</code> to a <code>Process::Status</code> object
@@ -800,8 +798,8 @@ proc_wait(int argc, VALUE *argv)
 
 /*
  *  call-seq:
- *     Process.wait2(pid=-1, flags=0)      => [pid, status]
- *     Process.waitpid2(pid=-1, flags=0)   => [pid, status]
+ *     Process.wait2(pid=-1, flags=0)      -> [pid, status]
+ *     Process.waitpid2(pid=-1, flags=0)   -> [pid, status]
  *
  *  Waits for a child process to exit (see Process::waitpid for exact
  *  semantics) and returns an array containing the process id and the
@@ -826,7 +824,7 @@ proc_wait2(int argc, VALUE *argv)
 
 /*
  *  call-seq:
- *     Process.waitall   => [ [pid1,status1], ...]
+ *     Process.waitall   -> [ [pid1,status1], ...]
  *
  *  Waits for all children, returning an array of
  *  _pid_/_status_ pairs (where _status_ is a
@@ -924,7 +922,7 @@ rb_detach_process(rb_pid_t pid)
 
 /*
  *  call-seq:
- *     Process.detach(pid)   => thread
+ *     Process.detach(pid)   -> thread
  *
  *  Some operating systems retain the status of terminated child
  *  processes until the parent collects that status (normally using
@@ -941,6 +939,8 @@ rb_detach_process(rb_pid_t pid)
  *  know the result.  If specified _pid_ is not a valid child process
  *  ID, the thread returns +nil+ immediately.
  *
+ *  The waiting thread has <code>pid</code> method which returns the pid.
+ *
  *  In this first example, we don't reap the first child process, so
  *  it appears as a zombie in the process status display.
  *
@@ -1229,6 +1229,7 @@ enum {
     EXEC_OPTION_DUP2,
     EXEC_OPTION_CLOSE,
     EXEC_OPTION_OPEN,
+    EXEC_OPTION_DUP2_CHILD,
     EXEC_OPTION_CLOSE_OTHERS
 };
 
@@ -1240,6 +1241,17 @@ check_exec_redirect_fd(VALUE v)
     if (FIXNUM_P(v)) {
         fd = FIX2INT(v);
     }
+    else if (SYMBOL_P(v)) {
+        ID id = SYM2ID(v);
+        if (id == rb_intern("in"))
+            fd = 0;
+        else if (id == rb_intern("out"))
+            fd = 1;
+        else if (id == rb_intern("err"))
+            fd = 2;
+        else
+            goto wrong;
+    }
     else if (!NIL_P(tmp = rb_check_convert_type(v, T_FILE, "IO", "to_io"))) {
         rb_io_t *fptr;
         GetOpenFile(tmp, fptr);
@@ -1251,6 +1263,7 @@ check_exec_redirect_fd(VALUE v)
         rb_raise(rb_eArgError, "wrong exec redirect");
     }
     if (fd < 0) {
+      wrong:
         rb_raise(rb_eArgError, "negative file descriptor");
     }
     return INT2FIX(fd);
@@ -1271,6 +1284,18 @@ check_exec_redirect(VALUE key, VALUE val, VALUE options)
             index = EXEC_OPTION_CLOSE;
             param = Qnil;
         }
+        else if (id == rb_intern("in")) {
+            index = EXEC_OPTION_DUP2;
+            param = INT2FIX(0);
+        }
+        else if (id == rb_intern("out")) {
+            index = EXEC_OPTION_DUP2;
+            param = INT2FIX(1);
+        }
+        else if (id == rb_intern("err")) {
+            index = EXEC_OPTION_DUP2;
+            param = INT2FIX(2);
+        }
         else {
             rb_raise(rb_eArgError, "wrong exec redirect symbol: %s",
                                    rb_id2name(id));
@@ -1286,20 +1311,27 @@ check_exec_redirect(VALUE key, VALUE val, VALUE options)
         break;
 
       case T_ARRAY:
-        index = EXEC_OPTION_OPEN;
         path = rb_ary_entry(val, 0);
-        FilePathValue(path);
-        flags = rb_ary_entry(val, 1);
-        if (NIL_P(flags))
-            flags = INT2NUM(O_RDONLY);
-        else if (TYPE(flags) == T_STRING)
-            flags = INT2NUM(rb_io_modestr_oflags(StringValueCStr(flags)));
-        else
-            flags = rb_to_int(flags);
-        perm = rb_ary_entry(val, 2);
-        perm = NIL_P(perm) ? INT2FIX(0644) : rb_to_int(perm);
-        param = hide_obj(rb_ary_new3(3, hide_obj(rb_str_dup(path)),
-                                        flags, perm));
+        if (RARRAY_LEN(val) == 2 && SYMBOL_P(path) &&
+            SYM2ID(path) == rb_intern("child")) {
+            index = EXEC_OPTION_DUP2_CHILD;
+            param = check_exec_redirect_fd(rb_ary_entry(val, 1));
+        }
+        else {
+            index = EXEC_OPTION_OPEN;
+            FilePathValue(path);
+            flags = rb_ary_entry(val, 1);
+            if (NIL_P(flags))
+                flags = INT2NUM(O_RDONLY);
+            else if (TYPE(flags) == T_STRING)
+                flags = INT2NUM(rb_io_modestr_oflags(StringValueCStr(flags)));
+            else
+                flags = rb_to_int(flags);
+            perm = rb_ary_entry(val, 2);
+            perm = NIL_P(perm) ? INT2FIX(0644) : rb_to_int(perm);
+            param = hide_obj(rb_ary_new3(3, hide_obj(rb_str_dup(path)),
+                                            flags, perm));
+        }
         break;
 
       case T_STRING:
@@ -1486,7 +1518,7 @@ check_exec_fds(VALUE options)
     int index, i;
     int maxhint = -1;
 
-    for (index = EXEC_OPTION_DUP2; index <= EXEC_OPTION_OPEN; index++) {
+    for (index = EXEC_OPTION_DUP2; index <= EXEC_OPTION_DUP2_CHILD; index++) {
         ary = rb_ary_entry(options, index);
         if (NIL_P(ary))
             continue;
@@ -1496,16 +1528,53 @@ check_exec_fds(VALUE options)
             if (RTEST(rb_hash_lookup(h, INT2FIX(fd)))) {
                 rb_raise(rb_eArgError, "fd %d specified twice", fd);
             }
-            rb_hash_aset(h, INT2FIX(fd), Qtrue);
+            if (index == EXEC_OPTION_OPEN || index == EXEC_OPTION_DUP2)
+                rb_hash_aset(h, INT2FIX(fd), Qtrue);
+            else if (index == EXEC_OPTION_DUP2_CHILD)
+                rb_hash_aset(h, INT2FIX(fd), RARRAY_PTR(elt)[1]);
+            else /* index == EXEC_OPTION_CLOSE */
+                rb_hash_aset(h, INT2FIX(fd), INT2FIX(-1));
             if (maxhint < fd)
                 maxhint = fd;
-            if (index == EXEC_OPTION_DUP2) {
+            if (index == EXEC_OPTION_DUP2 || index == EXEC_OPTION_DUP2_CHILD) {
                 fd = FIX2INT(RARRAY_PTR(elt)[1]);
                 if (maxhint < fd)
                     maxhint = fd;
             }
         }
     }
+
+    ary = rb_ary_entry(options, EXEC_OPTION_DUP2_CHILD);
+    if (!NIL_P(ary)) {
+        for (i = 0; i < RARRAY_LEN(ary); i++) {
+            VALUE elt = RARRAY_PTR(ary)[i];
+            int newfd = FIX2INT(RARRAY_PTR(elt)[0]);
+            int oldfd = FIX2INT(RARRAY_PTR(elt)[1]);
+            int lastfd = oldfd;
+            VALUE val = rb_hash_lookup(h, INT2FIX(lastfd));
+            long depth = 0;
+            while (FIXNUM_P(val) && 0 <= FIX2INT(val)) {
+                lastfd = FIX2INT(val);
+                val = rb_hash_lookup(h, val);
+                if (RARRAY_LEN(ary) < depth)
+                    rb_raise(rb_eArgError, "cyclic child fd redirection from %d", oldfd);
+                depth++;
+            }
+            if (val != Qtrue)
+                rb_raise(rb_eArgError, "child fd %d is not redirected", oldfd);
+            if (oldfd != lastfd) {
+                VALUE val2;
+                rb_ary_store(elt, 1, INT2FIX(lastfd));
+                rb_hash_aset(h, INT2FIX(newfd), INT2FIX(lastfd));
+                val = INT2FIX(oldfd);
+                while (FIXNUM_P(val2 = rb_hash_lookup(h, val))) {
+                    rb_hash_aset(h, val, INT2FIX(lastfd));
+                    val = val2;
+                }
+            }
+        }
+    }
+
     if (rb_ary_entry(options, EXEC_OPTION_CLOSE_OTHERS) != Qfalse) {
         rb_ary_store(options, EXEC_OPTION_CLOSE_OTHERS, INT2FIX(maxhint));
     }
@@ -1655,25 +1724,38 @@ rb_exec_arg_fixup(struct rb_exec_arg *e)
 
 /*
  *  call-seq:
- *     exec([env,] command [, arg, ...] [,options])
+ *     exec([env,] command... [,options])
  *
  *  Replaces the current process by running the given external _command_.
- *  If optional arguments, sequence of +arg+, are not given, that argument is
- *  taken as a line that is subject to shell expansion before being
- *  executed. If one or more +arg+ given, they
- *  are passed as parameters to _command_ with no shell
- *  expansion. If +command+ is a two-element array, the first
- *  element is the command to be executed, and the second argument is
- *  used as the <code>argv[0]</code> value, which may show up in process
- *  listings. In order to execute the command, one of the <code>exec(2)</code> 
- *  system calls is used, so the running command may inherit some of the environment 
- *  of the original program (including open file descriptors).
+ *  _command..._ is one of following forms.
  *
- *  The hash arguments, env and options, are same as
- *  <code>system</code> and <code>spawn</code>.
+ *    commandline                 : command line string which is passed to the standard shell
+ *    cmdname, arg1, ...          : command name and one or more arguments (no shell)
+ *    [cmdname, argv0], arg1, ... : command name, argv[0] and zero or more arguments (no shell)
+ *
+ *  If single string is given as the command,
+ *  it is taken as a command line that is subject to shell expansion before being executed.
+ *
+ *  The standard shell means always <code>"/bin/sh"</code> on Unix-like systems,
+ *  <code>ENV["RUBYSHELL"]</code> or <code>ENV["COMSPEC"]</code> on Windows NT series, and
+ *  similar.
+ *
+ *  If two or more +string+ given,
+ *  the first is taken as a command name and
+ *  the rest are passed as parameters to command with no shell expansion.
+ *
+ *  If a two-element array at the beginning of the command,
+ *  the first element is the command to be executed,
+ *  and the second argument is used as the <code>argv[0]</code> value,
+ *  which may show up in process listings.
+ *
+ *  In order to execute the command, one of the <code>exec(2)</code>
+ *  system calls is used, so the running command may inherit some of the environment
+ *  of the original program (including open file descriptors).
+ *  This behavior is modified by env and options.
  *  See <code>spawn</code> for details.
  *
- *  Raises SystemCallError if the _command_ couldn't execute (typically
+ *  Raises SystemCallError if the command couldn't execute (typically
  *  <code>Errno::ENOENT</code> when it was not found).
  *
  *     exec "echo *"       # echoes list of files in current directory
@@ -1688,17 +1770,23 @@ VALUE
 rb_f_exec(int argc, VALUE *argv)
 {
     struct rb_exec_arg earg;
+#define CHILD_ERRMSG_BUFLEN 80
+    char errmsg[CHILD_ERRMSG_BUFLEN] = { '\0' };
 
-    rb_exec_arg_init(argc, argv, Qtrue, &earg);
+    rb_exec_arg_init(argc, argv, TRUE, &earg);
     if (NIL_P(rb_ary_entry(earg.options, EXEC_OPTION_CLOSE_OTHERS)))
         rb_exec_arg_addopt(&earg, ID2SYM(rb_intern("close_others")), Qfalse);
     rb_exec_arg_fixup(&earg);
 
-    rb_exec(&earg);
+    rb_exec_err(&earg, errmsg, sizeof(errmsg));
+    if (errmsg[0])
+        rb_sys_fail(errmsg);
     rb_sys_fail(earg.prog);
     return Qnil;		/* dummy */
 }
 
+#define ERRMSG(str) do { if (errmsg && 0 < errmsg_buflen) strlcpy(errmsg, (str), errmsg_buflen); } while (0)
+
 /*#define DEBUG_REDIRECT*/
 #if defined(DEBUG_REDIRECT)
 
@@ -1710,7 +1798,11 @@ ttyprintf(const char *fmt, ...)
     va_list ap;
     FILE *tty;
     int save = errno;
+#ifdef _WIN32
+    tty = fopen("con", "w");
+#else
     tty = fopen("/dev/tty", "w");
+#endif
     if (!tty)
         return;
 
@@ -1765,12 +1857,17 @@ redirect_open(const char *pathname, int flags, mode_t perm)
 #endif
 
 static int
-save_redirect_fd(int fd, VALUE save)
+save_redirect_fd(int fd, VALUE save, char *errmsg, size_t errmsg_buflen)
 {
     if (!NIL_P(save)) {
         VALUE newary;
         int save_fd = redirect_dup(fd);
-        if (save_fd == -1) return -1;
+        if (save_fd == -1) {
+            if (errno == EBADF)
+                return 0;
+            ERRMSG("dup");
+            return -1;
+        }
         newary = rb_ary_entry(save, EXEC_OPTION_DUP2);
         if (NIL_P(newary)) {
             newary = hide_obj(rb_ary_new());
@@ -1819,20 +1916,30 @@ intcmp(const void *a, const void *b)
 }
 
 static int
-run_exec_dup2(VALUE ary, VALUE save)
+intrcmp(const void *a, const void *b)
+{
+    return *(int*)b - *(int*)a;
+}
+
+static int
+run_exec_dup2(VALUE ary, VALUE save, char *errmsg, size_t errmsg_buflen)
 {
-    int n, i;
+    long n, i;
     int ret;
     int extra_fd = -1;
     struct fd_pair {
         int oldfd;
         int newfd;
-        int older_index;
-        int num_newer;
+        long older_index;
+        long num_newer;
     } *pairs = 0;
 
     n = RARRAY_LEN(ary);
-    pairs = ALLOC_N(struct fd_pair, n);
+    pairs = (struct fd_pair *)malloc(sizeof(struct fd_pair) * n);
+    if (pairs == NULL) {
+        ERRMSG("malloc");
+        return -1;
+    }
 
     /* initialize oldfd and newfd: O(n) */
     for (i = 0; i < n; i++) {
@@ -1843,7 +1950,10 @@ run_exec_dup2(VALUE ary, VALUE save)
     }
 
     /* sort the table by oldfd: O(n log n) */
-    qsort(pairs, n, sizeof(struct fd_pair), intcmp);
+    if (!RTEST(save))
+        qsort(pairs, n, sizeof(struct fd_pair), intcmp);
+    else
+        qsort(pairs, n, sizeof(struct fd_pair), intrcmp);
 
     /* initialize older_index and num_newer: O(n log n) */
     for (i = 0; i < n; i++) {
@@ -1865,13 +1975,15 @@ run_exec_dup2(VALUE ary, VALUE save)
 
     /* non-cyclic redirection: O(n) */
     for (i = 0; i < n; i++) {
-        int j = i;
+        long j = i;
         while (j != -1 && pairs[j].oldfd != -1 && pairs[j].num_newer == 0) {
-            if (save_redirect_fd(pairs[j].newfd, save) < 0)
+            if (save_redirect_fd(pairs[j].newfd, save, errmsg, errmsg_buflen) < 0)
                 goto fail;
             ret = redirect_dup2(pairs[j].oldfd, pairs[j].newfd);
-            if (ret == -1)
+            if (ret == -1) {
+                ERRMSG("dup2");
                 goto fail;
+            }
             pairs[j].oldfd = -1;
             j = pairs[j].older_index;
             if (j != -1)
@@ -1881,20 +1993,24 @@ run_exec_dup2(VALUE ary, VALUE save)
 
     /* cyclic redirection: O(n) */
     for (i = 0; i < n; i++) {
-        int j;
+        long j;
         if (pairs[i].oldfd == -1)
             continue;
         if (pairs[i].oldfd == pairs[i].newfd) { /* self cycle */
 #ifdef F_GETFD
             int fd = pairs[i].oldfd;
             ret = fcntl(fd, F_GETFD);
-            if (ret == -1)
+            if (ret == -1) {
+                ERRMSG("fcntl(F_GETFD)");
                 goto fail;
+            }
             if (ret & FD_CLOEXEC) {
                 ret &= ~FD_CLOEXEC;
                 ret = fcntl(fd, F_SETFD, ret);
-                if (ret == -1)
+                if (ret == -1) {
+                    ERRMSG("fcntl(F_SETFD)");
                     goto fail;
+                }
             }
 #endif
             pairs[i].oldfd = -1;
@@ -1902,29 +2018,37 @@ run_exec_dup2(VALUE ary, VALUE save)
         }
         if (extra_fd == -1) {
             extra_fd = redirect_dup(pairs[i].oldfd);
-            if (extra_fd == -1)
+            if (extra_fd == -1) {
+                ERRMSG("dup");
                 goto fail;
+            }
         }
         else {
             ret = redirect_dup2(pairs[i].oldfd, extra_fd);
-            if (ret == -1)
+            if (ret == -1) {
+                ERRMSG("dup2");
                 goto fail;
+            }
         }
         pairs[i].oldfd = extra_fd;
         j = pairs[i].older_index;
         pairs[i].older_index = -1;
         while (j != -1) {
             ret = redirect_dup2(pairs[j].oldfd, pairs[j].newfd);
-            if (ret == -1)
+            if (ret == -1) {
+                ERRMSG("dup2");
                 goto fail;
+            }
             pairs[j].oldfd = -1;
             j = pairs[j].older_index;
         }
     }
     if (extra_fd != -1) {
         ret = redirect_close(extra_fd);
-        if (ret == -1)
+        if (ret == -1) {
+            ERRMSG("close");
             goto fail;
+        }
     }
 
     xfree(pairs);
@@ -1936,7 +2060,7 @@ run_exec_dup2(VALUE ary, VALUE save)
 }
 
 static int
-run_exec_close(VALUE ary)
+run_exec_close(VALUE ary, char *errmsg, size_t errmsg_buflen)
 {
     int i, ret;
 
@@ -1944,14 +2068,16 @@ run_exec_close(VALUE ary)
         VALUE elt = RARRAY_PTR(ary)[i];
         int fd = FIX2INT(RARRAY_PTR(elt)[0]);
         ret = redirect_close(fd);
-        if (ret == -1)
+        if (ret == -1) {
+            ERRMSG("close");
             return -1;
+        }
     }
     return 0;
 }
 
 static int
-run_exec_open(VALUE ary, VALUE save)
+run_exec_open(VALUE ary, VALUE save, char *errmsg, size_t errmsg_buflen)
 {
     int i, ret;
 
@@ -1964,7 +2090,10 @@ run_exec_open(VALUE ary, VALUE save)
         int perm = NUM2INT(RARRAY_PTR(param)[2]);
         int need_close = 1;
         int fd2 = redirect_open(path, flags, perm);
-        if (fd2 == -1) return -1;
+        if (fd2 == -1) {
+            ERRMSG("open");
+            return -1;
+        }
         while (i < RARRAY_LEN(ary) &&
                (elt = RARRAY_PTR(ary)[i], RARRAY_PTR(elt)[1] == param)) {
             fd = FIX2INT(RARRAY_PTR(elt)[0]);
@@ -1972,16 +2101,42 @@ run_exec_open(VALUE ary, VALUE save)
                 need_close = 0;
             }
             else {
-                if (save_redirect_fd(fd, save) < 0)
+                if (save_redirect_fd(fd, save, errmsg, errmsg_buflen) < 0)
                     return -1;
                 ret = redirect_dup2(fd2, fd);
-                if (ret == -1) return -1;
+                if (ret == -1) {
+                    ERRMSG("dup2");
+                    return -1;
+                }
             }
             i++;
         }
         if (need_close) {
             ret = redirect_close(fd2);
-            if (ret == -1) return -1;
+            if (ret == -1) {
+                ERRMSG("close");
+                return -1;
+            }
+        }
+    }
+    return 0;
+}
+
+static int
+run_exec_dup2_child(VALUE ary, VALUE save, char *errmsg, size_t errmsg_buflen)
+{
+    int i, ret;
+    for (i = 0; i < RARRAY_LEN(ary); i++) {
+        VALUE elt = RARRAY_PTR(ary)[i];
+        int newfd = FIX2INT(RARRAY_PTR(elt)[0]);
+        int oldfd = FIX2INT(RARRAY_PTR(elt)[1]);
+
+        if (save_redirect_fd(newfd, save, errmsg, errmsg_buflen) < 0)
+            return -1;
+        ret = redirect_dup2(oldfd, newfd);
+        if (ret == -1) {
+            ERRMSG("dup2");
+            return -1;
         }
     }
     return 0;
@@ -1989,7 +2144,7 @@ run_exec_open(VALUE ary, VALUE save)
 
 #ifdef HAVE_SETPGID
 static int
-run_exec_pgroup(VALUE obj, VALUE save)
+run_exec_pgroup(VALUE obj, VALUE save, char *errmsg, size_t errmsg_buflen)
 {
     /*
      * If FD_CLOEXEC is available, rb_fork waits the child's execve.
@@ -1997,6 +2152,7 @@ run_exec_pgroup(VALUE obj, VALUE save)
      * No race condition, even without setpgid from the parent.
      * (Is there an environment which has setpgid but FD_CLOEXEC?)
      */
+    int ret;
     pid_t pgroup;
     if (!NIL_P(save)) {
         /* maybe meaningless with no fork environment... */
@@ -2006,13 +2162,15 @@ run_exec_pgroup(VALUE obj, VALUE save)
     if (pgroup == 0) {
         pgroup = getpid();
     }
-    return setpgid(getpid(), pgroup);
+    ret = setpgid(getpid(), pgroup);
+    if (ret == -1) ERRMSG("setpgid");
+    return ret;
 }
 #endif
 
 #ifdef RLIM2NUM
 static int
-run_exec_rlimit(VALUE ary, VALUE save)
+run_exec_rlimit(VALUE ary, VALUE save, char *errmsg, size_t errmsg_buflen)
 {
     int i;
     for (i = 0; i < RARRAY_LEN(ary); i++) {
@@ -2021,8 +2179,10 @@ run_exec_rlimit(VALUE ary, VALUE save)
         struct rlimit rlim;
         if (!NIL_P(save)) {
             VALUE tmp, newary;
-            if (getrlimit(rtype, &rlim) == -1)
+            if (getrlimit(rtype, &rlim) == -1) {
+                ERRMSG("getrlimit");
                 return -1;
+            }
             tmp = hide_obj(rb_ary_new3(3, RARRAY_PTR(elt)[0],
                                        RLIM2NUM(rlim.rlim_cur),
                                        RLIM2NUM(rlim.rlim_max)));
@@ -2035,15 +2195,17 @@ run_exec_rlimit(VALUE ary, VALUE save)
         }
         rlim.rlim_cur = NUM2RLIM(RARRAY_PTR(elt)[1]);
         rlim.rlim_max = NUM2RLIM(RARRAY_PTR(elt)[2]);
-        if (setrlimit(rtype, &rlim) == -1)
+        if (setrlimit(rtype, &rlim) == -1) {
+            ERRMSG("setrlimit");
             return -1;
+        }
     }
     return 0;
 }
 #endif
 
 int
-rb_run_exec_options(const struct rb_exec_arg *e, struct rb_exec_arg *s)
+rb_run_exec_options_err(const struct rb_exec_arg *e, struct rb_exec_arg *s, char *errmsg, size_t errmsg_buflen)
 {
     VALUE options = e->options;
     VALUE soptions = Qnil;
@@ -2063,7 +2225,7 @@ rb_run_exec_options(const struct rb_exec_arg *e, struct rb_exec_arg *s)
 #ifdef HAVE_SETPGID
     obj = rb_ary_entry(options, EXEC_OPTION_PGROUP);
     if (RTEST(obj)) {
-        if (run_exec_pgroup(obj, soptions) == -1)
+        if (run_exec_pgroup(obj, soptions, errmsg, errmsg_buflen) == -1)
             return -1;
     }
 #endif
@@ -2071,7 +2233,7 @@ rb_run_exec_options(const struct rb_exec_arg *e, struct rb_exec_arg *s)
 #ifdef RLIM2NUM
     obj = rb_ary_entry(options, EXEC_OPTION_RLIMIT);
     if (!NIL_P(obj)) {
-        if (run_exec_rlimit(obj, soptions) == -1)
+        if (run_exec_rlimit(obj, soptions, errmsg, errmsg_buflen) == -1)
             return -1;
     }
 #endif
@@ -2105,8 +2267,10 @@ rb_run_exec_options(const struct rb_exec_arg *e, struct rb_exec_arg *s)
                          hide_obj(rb_str_new2(cwd)));
             xfree(cwd);
         }
-        if (chdir(RSTRING_PTR(obj)) == -1)
+        if (chdir(RSTRING_PTR(obj)) == -1) {
+            ERRMSG("chdir");
             return -1;
+        }
     }
 
     obj = rb_ary_entry(options, EXEC_OPTION_UMASK);
@@ -2119,7 +2283,7 @@ rb_run_exec_options(const struct rb_exec_arg *e, struct rb_exec_arg *s)
 
     obj = rb_ary_entry(options, EXEC_OPTION_DUP2);
     if (!NIL_P(obj)) {
-        if (run_exec_dup2(obj, soptions) == -1)
+        if (run_exec_dup2(obj, soptions, errmsg, errmsg_buflen) == -1)
             return -1;
     }
 
@@ -2128,7 +2292,7 @@ rb_run_exec_options(const struct rb_exec_arg *e, struct rb_exec_arg *s)
         if (!NIL_P(soptions))
             rb_warn("cannot close fd before spawn");
         else {
-            if (run_exec_close(obj) == -1)
+            if (run_exec_close(obj, errmsg, errmsg_buflen) == -1)
                 return -1;
         }
     }
@@ -2136,13 +2300,19 @@ rb_run_exec_options(const struct rb_exec_arg *e, struct rb_exec_arg *s)
 #ifdef HAVE_FORK
     obj = rb_ary_entry(options, EXEC_OPTION_CLOSE_OTHERS);
     if (obj != Qfalse) {
-        rb_close_before_exec(3, FIX2LONG(obj), e->redirect_fds);
+        rb_close_before_exec(3, FIX2INT(obj), e->redirect_fds);
     }
 #endif
 
     obj = rb_ary_entry(options, EXEC_OPTION_OPEN);
     if (!NIL_P(obj)) {
-        if (run_exec_open(obj, soptions) == -1)
+        if (run_exec_open(obj, soptions, errmsg, errmsg_buflen) == -1)
+            return -1;
+    }
+
+    obj = rb_ary_entry(options, EXEC_OPTION_DUP2_CHILD);
+    if (!NIL_P(obj)) {
+        if (run_exec_dup2_child(obj, soptions, errmsg, errmsg_buflen) == -1)
             return -1;
     }
 
@@ -2150,13 +2320,19 @@ rb_run_exec_options(const struct rb_exec_arg *e, struct rb_exec_arg *s)
 }
 
 int
-rb_exec(const struct rb_exec_arg *e)
+rb_run_exec_options(const struct rb_exec_arg *e, struct rb_exec_arg *s)
+{
+    return rb_run_exec_options_err(e, s, NULL, 0);
+}
+
+int
+rb_exec_err(const struct rb_exec_arg *e, char *errmsg, size_t errmsg_buflen)
 {
     int argc = e->argc;
     VALUE *argv = e->argv;
     const char *prog = e->prog;
 
-    if (rb_run_exec_options(e, NULL) < 0) {
+    if (rb_run_exec_options_err(e, NULL, errmsg, errmsg_buflen) < 0) {
         return -1;
     }
 
@@ -2166,21 +2342,36 @@ rb_exec(const struct rb_exec_arg *e)
     else {
 	rb_proc_exec_n(argc, argv, prog);
     }
-#ifndef FD_CLOEXEC
-    preserving_errno({
-	fprintf(stderr, "%s:%d: command not found: %s\n",
-		rb_sourcefile(), rb_sourceline(), prog);
-    });
-#endif
     return -1;
 }
 
+int
+rb_exec(const struct rb_exec_arg *e)
+{
+#if !defined FD_CLOEXEC && !defined HAVE_SPAWNV
+    char errmsg[80] = { '\0' };
+    int ret = rb_exec_err(e, errmsg, sizeof(errmsg));
+    preserving_errno(
+	if (errmsg[0]) {
+	    fprintf(stderr, "%s\n", errmsg);
+	}
+	else {
+	    fprintf(stderr, "%s:%d: command not found: %s\n",
+		    rb_sourcefile(), rb_sourceline(), e->prog);
+	}
+    );
+    return ret;
+#else
+    return rb_exec_err(e, NULL, 0);
+#endif
+}
+
 #ifdef HAVE_FORK
 static int
-rb_exec_atfork(void* arg)
+rb_exec_atfork(void* arg, char *errmsg, size_t errmsg_buflen)
 {
     rb_thread_atfork_before_exec();
-    return rb_exec(arg);
+    return rb_exec_err(arg, errmsg, errmsg_buflen);
 }
 #endif
 
@@ -2263,7 +2454,8 @@ pipe_nocrash(int filedes[2], VALUE fds)
  * +chfunc+ must not raise any exceptions.
  */
 rb_pid_t
-rb_fork(int *status, int (*chfunc)(void*), void *charg, VALUE fds)
+rb_fork_err(int *status, int (*chfunc)(void*, char *, size_t), void *charg, VALUE fds,
+        char *errmsg, size_t errmsg_buflen)
 {
     rb_pid_t pid;
     int err, state = 0;
@@ -2318,10 +2510,14 @@ rb_fork(int *status, int (*chfunc)(void*), void *charg, VALUE fds)
 #ifdef FD_CLOEXEC
 	    close(ep[0]);
 #endif
-	    if (!(*chfunc)(charg)) _exit(EXIT_SUCCESS);
+	    if (!(*chfunc)(charg, errmsg, errmsg_buflen)) _exit(EXIT_SUCCESS);
 #ifdef FD_CLOEXEC
 	    err = errno;
-	    write(ep[1], &err, sizeof(err));
+	    (void)write(ep[1], &err, sizeof(err));
+            if (errmsg && 0 < errmsg_buflen) {
+                errmsg[errmsg_buflen-1] = '\0';
+                (void)write(ep[1], errmsg, strlen(errmsg));
+            }
 #endif
 #if EXIT_SUCCESS == 127
 	    _exit(EXIT_FAILURE);
@@ -2333,12 +2529,21 @@ rb_fork(int *status, int (*chfunc)(void*), void *charg, VALUE fds)
     after_fork();
 #ifdef FD_CLOEXEC
     if (pid && chfunc) {
+	ssize_t size;
 	close(ep[1]);
-	if ((state = read(ep[0], &err, sizeof(err))) < 0) {
+	if ((size = read(ep[0], &err, sizeof(err))) < 0) {
 	    err = errno;
 	}
+        if (size == sizeof(err) &&
+            errmsg && 0 < errmsg_buflen) {
+            ssize_t ret;
+            ret = read(ep[0], errmsg, errmsg_buflen-1);
+            if (0 <= ret) {
+                errmsg[ret] = '\0';
+            }
+        }
 	close(ep[0]);
-	if (state) {
+	if (size) {
 	    if (status) {
 		rb_protect(proc_syswait, (VALUE)pid, status);
 	    }
@@ -2352,12 +2557,41 @@ rb_fork(int *status, int (*chfunc)(void*), void *charg, VALUE fds)
 #endif
     return pid;
 }
+
+struct chfunc_wrapper_t {
+    int (*chfunc)(void*);
+    void *arg;
+};
+
+static int
+chfunc_wrapper(void *arg_, char *errmsg, size_t errmsg_buflen)
+{
+    struct chfunc_wrapper_t *arg = arg_;
+    return arg->chfunc(arg->arg);
+}
+
+rb_pid_t
+rb_fork(int *status, int (*chfunc)(void*), void *charg, VALUE fds)
+{
+    if (chfunc) {
+        struct chfunc_wrapper_t warg;
+        warg.chfunc = chfunc;
+        warg.arg = charg;
+        return rb_fork_err(status, chfunc_wrapper, &warg, fds, NULL, 0);
+    }
+    else {
+        return rb_fork_err(status, NULL, NULL, fds, NULL, 0);
+    }
+
+}
+
 #endif
 
+#if defined(HAVE_FORK) && !defined(CANNOT_FORK_WITH_PTHREAD)
 /*
  *  call-seq:
- *     Kernel.fork  [{ block }]   => fixnum or nil
- *     Process.fork [{ block }]   => fixnum or nil
+ *     Kernel.fork  [{ block }]   -> fixnum or nil
+ *     Process.fork [{ block }]   -> fixnum or nil
  *
  *  Creates a subprocess. If a block is specified, that block is run
  *  in the subprocess, and the subprocess terminates with a status of
@@ -2373,21 +2607,19 @@ rb_fork(int *status, int (*chfunc)(void*), void *charg, VALUE fds)
  *
  *  The thread calling fork is the only thread in the created child process.
  *  fork doesn't copy other threads.
+ *
+ *  If fork is not usable, Process.respond_to?(:fork) returns false.
  */
 
 static VALUE
 rb_f_fork(VALUE obj)
 {
-#if defined(HAVE_FORK) && !defined(CANNOT_FORK_WITH_PTHREAD)
     rb_pid_t pid;
 
     rb_secure(2);
 
     switch (pid = rb_fork(0, 0, 0, Qnil)) {
       case 0:
-#ifdef linux
-	after_exec();
-#endif
 	rb_thread_atfork();
 	if (rb_block_given_p()) {
 	    int status;
@@ -2404,21 +2636,20 @@ rb_f_fork(VALUE obj)
       default:
 	return PIDT2NUM(pid);
     }
+}
 #else
-    rb_notimplement();
+#define rb_f_fork rb_f_notimplement
 #endif
-}
-
 
 /*
  *  call-seq:
- *     Process.exit!(fixnum=-1)
+ *     Process.exit!(status=false)
  *
  *  Exits the process immediately. No exit handlers are
- *  run. <em>fixnum</em> is returned to the underlying system as the
+ *  run. <em>status</em> is returned to the underlying system as the
  *  exit status.
  *
- *     Process.exit!(0)
+ *     Process.exit!(true)
  */
 
 static VALUE
@@ -2466,15 +2697,18 @@ rb_exit(int status)
 
 /*
  *  call-seq:
- *     exit(integer=0)
- *     Kernel::exit(integer=0)
- *     Process::exit(integer=0)
- *  
+ *     exit(status=true)
+ *     Kernel::exit(status=true)
+ *     Process::exit(status=true)
+ *
  *  Initiates the termination of the Ruby script by raising the
  *  <code>SystemExit</code> exception. This exception may be caught. The
  *  optional parameter is used to return a status code to the invoking
  *  environment.
- *     
+ *  +true+ and +FALSE+ of _status_ means success and failure
+ *  respectively.  The interpretation of other integer values are
+ *  system dependent.
+ *
  *     begin
  *       exit
  *       puts "never get here"
@@ -2482,22 +2716,22 @@ rb_exit(int status)
  *       puts "rescued a SystemExit exception"
  *     end
  *     puts "after begin block"
- *     
+ *
  *  <em>produces:</em>
- *     
+ *
  *     rescued a SystemExit exception
  *     after begin block
- *     
+ *
  *  Just prior to termination, Ruby executes any <code>at_exit</code> functions
  *  (see Kernel::at_exit) and runs any object finalizers (see
  *  ObjectSpace::define_finalizer).
- *     
+ *
  *     at_exit { puts "at_exit function" }
  *     ObjectSpace.define_finalizer("string",  proc { puts "in finalizer" })
  *     exit
- *     
+ *
  *  <em>produces:</em>
- *     
+ *
  *     at_exit function
  *     in finalizer
  */
@@ -2537,11 +2771,11 @@ rb_f_exit(int argc, VALUE *argv)
 /*
  *  call-seq:
  *     abort
- *     Kernel::abort
- *     Process::abort
- *  
+ *     Kernel::abort([msg])
+ *     Process::abort([msg])
+ *
  *  Terminate execution immediately, effectively by calling
- *  <code>Kernel.exit(1)</code>. If _msg_ is given, it is written
+ *  <code>Kernel.exit(false)</code>. If _msg_ is given, it is written
  *  to STDERR prior to terminating.
  */
 
@@ -2586,7 +2820,7 @@ rb_syswait(rb_pid_t pid)
 #endif
     RETSIGTYPE (*ifunc)(int) = 0;
     int status;
-    int i, hooked = Qfalse;
+    int i, hooked = FALSE;
 
     if (!overriding) {
 #ifdef SIGHUP
@@ -2596,8 +2830,8 @@ rb_syswait(rb_pid_t pid)
 	qfunc = signal(SIGQUIT, SIG_IGN);
 #endif
 	ifunc = signal(SIGINT, SIG_IGN);
-	overriding = Qtrue;
-	hooked = Qtrue;
+	overriding = TRUE;
+	hooked = TRUE;
     }
 
     do {
@@ -2612,47 +2846,54 @@ rb_syswait(rb_pid_t pid)
 	signal(SIGQUIT, qfunc);
 #endif
 	signal(SIGINT, ifunc);
-	overriding = Qfalse;
+	overriding = FALSE;
     }
 }
 
+static VALUE
+rb_exec_arg_prepare(struct rb_exec_arg *earg, int argc, VALUE *argv, int default_close_others)
+{
+    VALUE prog = rb_exec_arg_init(argc, argv, TRUE, earg);
+    if (NIL_P(rb_ary_entry(earg->options, EXEC_OPTION_CLOSE_OTHERS))) {
+        VALUE v = default_close_others ? Qtrue : Qfalse;
+        rb_exec_arg_addopt(earg, ID2SYM(rb_intern("close_others")), v);
+    }
+    rb_exec_arg_fixup(earg);
+    return prog;
+}
+
 static rb_pid_t
-rb_spawn_internal(int argc, VALUE *argv, int default_close_others)
+rb_spawn_process(struct rb_exec_arg *earg, VALUE prog, char *errmsg, size_t errmsg_buflen)
 {
-    rb_pid_t status;
-    VALUE prog;
-    struct rb_exec_arg earg;
+    rb_pid_t pid;
+#if defined HAVE_FORK || !defined HAVE_SPAWNV
+    int status;
+#endif
 #if !defined HAVE_FORK
     struct rb_exec_arg sarg;
+    int argc;
+    VALUE *argv;
 #endif
 
-    prog = rb_exec_arg_init(argc, argv, Qtrue, &earg);
-    if (NIL_P(rb_ary_entry(earg.options, EXEC_OPTION_CLOSE_OTHERS))) {
-        VALUE v = default_close_others ? Qtrue : Qfalse;
-        rb_exec_arg_addopt(&earg, ID2SYM(rb_intern("close_others")), v);
-    }
-    rb_exec_arg_fixup(&earg);
-
 #if defined HAVE_FORK
-    status = rb_fork(&status, rb_exec_atfork, &earg, earg.redirect_fds);
-    if (prog && earg.argc) earg.argv[0] = prog;
+    pid = rb_fork_err(&status, rb_exec_atfork, earg, earg->redirect_fds, errmsg, errmsg_buflen);
 #else
-    if (rb_run_exec_options(&earg, &sarg) < 0) {
+    if (rb_run_exec_options_err(earg, &sarg, errmsg, errmsg_buflen) < 0) {
         return -1;
     }
 
-    argc = earg.argc;
-    argv = earg.argv;
+    argc = earg->argc;
+    argv = earg->argv;
     if (prog && argc) argv[0] = prog;
 # if defined HAVE_SPAWNV
     if (!argc) {
-	status = proc_spawn(RSTRING_PTR(prog));
+	pid = proc_spawn(RSTRING_PTR(prog));
     }
     else {
-	status = proc_spawn_n(argc, argv, prog);
+	pid = proc_spawn_n(argc, argv, prog);
     }
 #  if defined(_WIN32)
-    if (status == -1)
+    if (pid == -1)
 	rb_last_status_set(0x7f << 8, 0);
 #  endif
 # else
@@ -2661,30 +2902,53 @@ rb_spawn_internal(int argc, VALUE *argv, int default_close_others)
     rb_last_status_set((status & 0xff) << 8, 0);
 # endif
 
-    rb_run_exec_options(&sarg, NULL);
+    rb_run_exec_options_err(&sarg, NULL, errmsg, errmsg_buflen);
 #endif
-    return status;
+    return pid;
+}
+
+static rb_pid_t
+rb_spawn_internal(int argc, VALUE *argv, int default_close_others,
+                  char *errmsg, size_t errmsg_buflen)
+{
+    struct rb_exec_arg earg;
+    VALUE prog = rb_exec_arg_prepare(&earg, argc, argv, default_close_others);
+    return rb_spawn_process(&earg, prog, errmsg, errmsg_buflen);
+}
+
+rb_pid_t
+rb_spawn_err(int argc, VALUE *argv, char *errmsg, size_t errmsg_buflen)
+{
+    return rb_spawn_internal(argc, argv, TRUE, errmsg, errmsg_buflen);
 }
 
 rb_pid_t
 rb_spawn(int argc, VALUE *argv)
 {
-    return rb_spawn_internal(argc, argv, Qtrue);
+    return rb_spawn_internal(argc, argv, TRUE, NULL, 0);
 }
 
 /*
  *  call-seq:
- *     system([env,] cmd [, arg, ...] [,options])    => true, false or nil
+ *     system([env,] command... [,options])    -> true, false or nil
  *
- *  Executes _cmd_ in a subshell, returning +true+ if the command
- *  gives zero exit status, +false+ for non zero exit status. Returns
- *  +nil+ if command execution fails.  An error status is available in
- *  <code>$?</code>. The arguments are processed in the same way as
- *  for <code>Kernel::exec</code>.
+ *  Executes _command..._ in a subshell.
+ *  _command..._ is one of following forms.
+ *
+ *    commandline                 : command line string which is passed to the standard shell
+ *    cmdname, arg1, ...          : command name and one or more arguments (no shell)
+ *    [cmdname, argv0], arg1, ... : command name, argv[0] and zero or more arguments (no shell)
+ *
+ *  system returns +true+ if the command gives zero exit status,
+ *  +false+ for non zero exit status.
+ *  Returns +nil+ if command execution fails.
+ *  An error status is available in <code>$?</code>.
+ *  The arguments are processed in the same way as
+ *  for <code>Kernel.spawn</code>.
  *
  *  The hash arguments, env and options, are same as
  *  <code>exec</code> and <code>spawn</code>.
- *  See <code>spawn</code> for details.
+ *  See <code>Kernel.spawn</code> for details.
  *
  *     system("echo *")
  *     system("echo", "*")
@@ -2693,11 +2957,14 @@ rb_spawn(int argc, VALUE *argv)
  *
  *     config.h main.rb
  *     *
+ *
+ *  See <code>Kernel.exec</code> for the standard shell.
  */
 
 static VALUE
 rb_f_system(int argc, VALUE *argv)
 {
+    rb_pid_t pid;
     int status;
 
 #if defined(SIGCLD) && !defined(SIGCHLD)
@@ -2709,16 +2976,16 @@ rb_f_system(int argc, VALUE *argv)
 
     chfunc = signal(SIGCHLD, SIG_DFL);
 #endif
-    status = rb_spawn_internal(argc, argv, Qfalse);
+    pid = rb_spawn_internal(argc, argv, FALSE, NULL, 0);
 #if defined(HAVE_FORK) || defined(HAVE_SPAWNV)
-    if (status > 0) {
-	rb_syswait(status);
+    if (pid > 0) {
+	rb_syswait(pid);
     }
 #endif
 #ifdef SIGCHLD
     signal(SIGCHLD, chfunc);
 #endif
-    if (status < 0) {
+    if (pid < 0) {
 	return Qnil;
     }
     status = PST2INT(rb_last_status_get());
@@ -2728,10 +2995,64 @@ rb_f_system(int argc, VALUE *argv)
 
 /*
  *  call-seq:
- *     spawn([env,] cmd [, arg, ...] [,options])     => pid
- *
- *  Similar to <code>Kernel::system</code> except for not waiting for
- *  end of _cmd_, but returns its <i>pid</i>.
+ *     spawn([env,] command... [,options])     -> pid
+ *     Process.spawn([env,] command... [,options])     -> pid
+ *
+ *  spawn executes specified command and return its pid.
+ *
+ *  This method doesn't wait for end of the command.
+ *  The parent process should
+ *  use <code>Process.wait</code> to collect
+ *  the termination status of its child or
+ *  use <code>Process.detach</code> to register
+ *  disinterest in their status;
+ *  otherwise, the operating system may accumulate zombie processes.
+ *
+ *  spawn has bunch of options to specify process attributes:
+ *
+ *    env: hash
+ *      name => val : set the environment variable
+ *      name => nil : unset the environment variable
+ *    command...:
+ *      commandline                 : command line string which is passed to the standard shell
+ *      cmdname, arg1, ...          : command name and one or more arguments (no shell)
+ *      [cmdname, argv0], arg1, ... : command name, argv[0] and zero or more arguments (no shell)
+ *    options: hash
+ *      clearing environment variables:
+ *        :unsetenv_others => true   : clear environment variables except specified by env
+ *        :unsetenv_others => false  : don't clear (default)
+ *      process group:
+ *        :pgroup => true or 0 : make a new process group
+ *        :pgroup => pgid      : join to specified process group
+ *        :pgroup => nil       : don't change the process group (default)
+ *      resource limit: resourcename is core, cpu, data, etc.  See Process.setrlimit.
+ *        :rlimit_resourcename => limit
+ *        :rlimit_resourcename => [cur_limit, max_limit]
+ *      current directory:
+ *        :chdir => str
+ *      umask:
+ *        :umask => int
+ *      redirection:
+ *        key:
+ *          FD              : single file descriptor in child process
+ *          [FD, FD, ...]   : multiple file descriptor in child process
+ *        value:
+ *          FD                        : redirect to the file descriptor in parent process
+ *          string                    : redirect to file with open(string, "r" or "w")
+ *          [string]                  : redirect to file with open(string, File::RDONLY)
+ *          [string, open_mode]       : redirect to file with open(string, open_mode, 0644)
+ *          [string, open_mode, perm] : redirect to file with open(string, open_mode, perm)
+ *          [:child, FD]              : redirect to the redirected file descriptor
+ *          :close                    : close the file descriptor in child process
+ *        FD is one of follows
+ *          :in     : the file descriptor 0 which is the standard input
+ *          :out    : the file descriptor 1 which is the standard output
+ *          :err    : the file descriptor 2 which is the standard error
+ *          integer : the file descriptor of specified the integer
+ *          io      : the file descriptor specified as io.fileno
+ *      file descriptor inheritance: close non-redirected non-standard fds (3, 4, 5, ...) or not
+ *        :close_others => false : inherit fds (default for system and exec)
+ *        :close_others => true  : don't inherit (default for spawn and IO.popen)
  *
  *  If a hash is given as +env+, the environment is
  *  updated by +env+ before <code>exec(2)</code> in the child process.
@@ -2743,7 +3064,7 @@ rb_f_system(int argc, VALUE *argv)
  *  If a hash is given as +options+,
  *  it specifies
  *  process group,
- *  resource limit, 
+ *  resource limit,
  *  current directory,
  *  umask and
  *  redirects for the child process.
@@ -2757,22 +3078,23 @@ rb_f_system(int argc, VALUE *argv)
  *
  *  The <code>:pgroup</code> key in +options+ specifies a process group.
  *  The corresponding value should be true, zero or positive integer.
- *  true and zero means the process should be a process leader.
+ *  true and zero means the process should be a process leader of a new
+ *  process group.
  *  Other values specifies a process group to be belongs.
  *
  *    pid = spawn(command, :pgroup=>true) # process leader
  *    pid = spawn(command, :pgroup=>10) # belongs to the process group 10
  *
  *  The <code>:rlimit_</code><em>foo</em> key specifies a resource limit.
- *  <em>foo</em> should be one of resource types such as <code>core</code>
+ *  <em>foo</em> should be one of resource types such as <code>core</code>.
  *  The corresponding value should be an integer or an array which have one or
  *  two integers: same as cur_limit and max_limit arguments for
  *  Process.setrlimit.
  *
- *    pid = spawn(command, :rlimit_core=>0) # never dump core.
  *    cur, max = Process.getrlimit(:CORE)
  *    pid = spawn(command, :rlimit_core=>[0,max]) # disable core temporary.
  *    pid = spawn(command, :rlimit_core=>max) # enable core dump
+ *    pid = spawn(command, :rlimit_core=>0) # never dump core.
  *
  *  The <code>:chdir</code> key in +options+ specifies the current directory.
  *
@@ -2782,59 +3104,80 @@ rb_f_system(int argc, VALUE *argv)
  *
  *    pid = spawn(command, :umask=>077)
  *
- *  The :in, :out, :err, a fixnum, an IO and an array key specifies a redirect.
+ *  The :in, :out, :err, a fixnum, an IO and an array key specifies a redirection.
  *  The redirection maps a file descriptor in the child process.
  *
- *  For example, stderr can be merged into stdout:
+ *  For example, stderr can be merged into stdout as follows:
  *
  *    pid = spawn(command, :err=>:out)
- *    pid = spawn(command, STDERR=>STDOUT)
  *    pid = spawn(command, 2=>1)
+ *    pid = spawn(command, STDERR=>:out)
+ *    pid = spawn(command, STDERR=>STDOUT)
  *
  *  The hash keys specifies a file descriptor
  *  in the child process started by <code>spawn</code>.
- *  :err, STDERR and 2 specifies the standard error stream.
+ *  :err, 2 and STDERR specifies the standard error stream (stderr).
  *
  *  The hash values specifies a file descriptor
  *  in the parent process which invokes <code>spawn</code>.
- *  :out, STDOUT and 1 specifies the standard output stream.
+ *  :out, 1 and STDOUT specifies the standard output stream (stdout).
  *
- *  The standard output in the child process is not specified.
+ *  In the above example,
+ *  the standard output in the child process is not specified.
  *  So it is inherited from the parent process.
  *
- *  The standard input stream can be specifed by :in, STDIN and 0.
- *  
+ *  The standard input stream (stdin) can be specified by :in, 0 and STDIN.
+ *
  *  A filename can be specified as a hash value.
  *
- *    pid = spawn(command, STDIN=>"/dev/null") # read mode
- *    pid = spawn(command, STDOUT=>"/dev/null") # write mode
- *    pid = spawn(command, STDERR=>"log") # write mode
+ *    pid = spawn(command, :in=>"/dev/null") # read mode
+ *    pid = spawn(command, :out=>"/dev/null") # write mode
+ *    pid = spawn(command, :err=>"log") # write mode
  *    pid = spawn(command, 3=>"/dev/null") # read mode
  *
- *  For standard output and standard error,
+ *  For stdout and stderr,
  *  it is opened in write mode.
  *  Otherwise read mode is used.
  *
  *  For specifying flags and permission of file creation explicitly,
  *  an array is used instead.
  *
- *    pid = spawn(command, STDIN=>["file"]) # read mode is assumed
- *    pid = spawn(command, STDIN=>["file", "r"])
- *    pid = spawn(command, STDOUT=>["log", "w"]) # 0644 assumed
- *    pid = spawn(command, STDOUT=>["log", "w", 0600])
- *    pid = spawn(command, STDOUT=>["log", File::WRONLY|File::EXCL|File::CREAT, 0600])
+ *    pid = spawn(command, :in=>["file"]) # read mode is assumed
+ *    pid = spawn(command, :in=>["file", "r"])
+ *    pid = spawn(command, :out=>["log", "w"]) # 0644 assumed
+ *    pid = spawn(command, :out=>["log", "w", 0600])
+ *    pid = spawn(command, :out=>["log", File::WRONLY|File::EXCL|File::CREAT, 0600])
  *
  *  The array specifies a filename, flags and permission.
  *  The flags can be a string or an integer.
- *  If the flags is ommitted or nil, File::RDONLY is assumed.
+ *  If the flags is omitted or nil, File::RDONLY is assumed.
  *  The permission should be an integer.
- *  If the permission is ommitted or nil, 0644 is assumed.
+ *  If the permission is omitted or nil, 0644 is assumed.
  *
  *  If an array of IOs and integers are specified as a hash key,
- *  all the elemetns are redirected.
+ *  all the elements are redirected.
+ *
+ *    # stdout and stderr is redirected to log file.
+ *    # The file "log" is opened just once.
+ *    pid = spawn(command, [:out, :err]=>["log", "w"])
+ *
+ *  Another way to merge multiple file descriptors is [:child, fd].
+ *  \[:child, fd] means the file descriptor in the child process.
+ *  This is different from fd.
+ *  For example, :err=>:out means redirecting child stderr to parent stdout.
+ *  But :err=>[:child, :out] means redirecting child stderr to child stdout.
+ *  They differs if stdout is redirected in the child process as follows.
+ *
+ *    # stdout and stderr is redirected to log file.
+ *    # The file "log" is opened just once.
+ *    pid = spawn(command, :out=>["log", "w"], :err=>[:child, :out])
+ *
+ *  \[:child, :out] can be used to merge stderr into stdout in IO.popen.
+ *  In this case, IO.popen redirects stdout to a pipe in the child process
+ *  and [:child, :out] refers the redirected stdout.
  *
- *    # standard output and standard error is redirected to log file.
- *    pid = spawn(command, [STDOUT, STDERR]=>["log", "w"])
+ *    io = IO.popen(["sh", "-c", "echo out; echo err >&2", :err=>[:child, :out]])
+ *    p io.read #=> "out\nerr\n"
  *
  *  spawn closes all non-standard unspecified descriptors by default.
  *  The "standard" descriptors are 0, 1 and 2.
@@ -2851,33 +3194,52 @@ rb_f_system(int argc, VALUE *argv)
  *
  *    # similar to r = IO.popen(command)
  *    r, w = IO.pipe
- *    pid = spawn(command, STDOUT=>w)   # r, w is closed in the child process.
+ *    pid = spawn(command, :out=>w)   # r, w is closed in the child process.
  *    w.close
  *
- *  :close is specified as a hash value to close a fd individualy.
+ *  :close is specified as a hash value to close a fd individually.
  *
  *    f = open(foo)
  *    system(command, f=>:close)        # don't inherit f.
  *
+ *  If a file descriptor need to be inherited,
+ *  io=>io can be used.
+ *
+ *    # valgrind has --log-fd option for log destination.
+ *    # log_w=>log_w indicates log_w.fileno inherits to child process.
+ *    log_r, log_w = IO.pipe
+ *    pid = spawn("valgrind", "--log-fd=#{log_w.fileno}", "echo", "a", log_w=>log_w)
+ *    log_w.close
+ *    p log_r.read
+ *
  *  It is also possible to exchange file descriptors.
  *
- *    pid = spawn(command, STDOUT=>STDERR, STDERR=>STDOUT)
+ *    pid = spawn(command, :out=>:err, :err=>:out)
  *
  *  The hash keys specify file descriptors in the child process.
  *  The hash values specifies file descriptors in the parent process.
- *  So the above specifies exchanging STDOUT and STDERR.
+ *  So the above specifies exchanging stdout and stderr.
  *  Internally, +spawn+ uses an extra file descriptor to resolve such cyclic
  *  file descriptor mapping.
  *
+ *  See <code>Kernel.exec</code> for the standard shell.
  */
 
 static VALUE
 rb_f_spawn(int argc, VALUE *argv)
 {
     rb_pid_t pid;
+    char errmsg[CHILD_ERRMSG_BUFLEN] = { '\0' };
+    struct rb_exec_arg earg;
 
-    pid = rb_spawn(argc, argv);
-    if (pid == -1) rb_sys_fail(RSTRING_PTR(argv[0]));
+    pid = rb_spawn_process(&earg, rb_exec_arg_prepare(&earg, argc, argv, TRUE), errmsg, sizeof(errmsg));
+    if (pid == -1) {
+	const char *prog = errmsg;
+	if (!prog[0] && !(prog = earg.prog) && earg.argc) {
+	    prog = RSTRING_PTR(earg.argv[0]);
+	}
+	rb_sys_fail(prog);
+    }
 #if defined(HAVE_FORK) || defined(HAVE_SPAWNV)
     return PIDT2NUM(pid);
 #else
@@ -2887,13 +3249,13 @@ rb_f_spawn(int argc, VALUE *argv)
 
 /*
  *  call-seq:
- *     sleep([duration])    => fixnum
+ *     sleep([duration])    -> fixnum
  *
  *  Suspends the current thread for _duration_ seconds (which may be any number,
  *  including a +Float+ with fractional seconds). Returns the actual number of
  *  seconds slept (rounded), which may be less than that asked for if another
- *  thread calls <code>Thread#run</code>. Zero arguments causes +sleep+ to sleep
- *  forever.
+ *  thread calls <code>Thread#run</code>. Called without an argument, sleep()
+ *  will sleep forever.
  *
  *     Time.new    #=> 2008-03-08 19:56:19 +0900
  *     sleep 1.2   #=> 1
@@ -2915,7 +3277,7 @@ rb_f_sleep(int argc, VALUE *argv)
 	rb_thread_wait_for(rb_time_interval(argv[0]));
     }
     else {
-	rb_raise(rb_eArgError, "wrong number of arguments");
+	rb_raise(rb_eArgError, "wrong number of arguments (%d for 0..1)", argc);
     }
 
     end = time(0) - beg;
@@ -2924,9 +3286,10 @@ rb_f_sleep(int argc, VALUE *argv)
 }
 
 
+#if (defined(HAVE_GETPGRP) && defined(GETPGRP_VOID)) || defined(HAVE_GETPGID)
 /*
  *  call-seq:
- *     Process.getpgrp   => integer
+ *     Process.getpgrp   -> integer
  *
  *  Returns the process group ID for this process. Not available on
  *  all platforms.
@@ -2938,30 +3301,28 @@ rb_f_sleep(int argc, VALUE *argv)
 static VALUE
 proc_getpgrp(void)
 {
-#if defined(HAVE_GETPGRP) && defined(GETPGRP_VOID) || defined(HAVE_GETPGID)
     rb_pid_t pgrp;
-#endif
 
     rb_secure(2);
 #if defined(HAVE_GETPGRP) && defined(GETPGRP_VOID)
     pgrp = getpgrp();
     if (pgrp < 0) rb_sys_fail(0);
     return PIDT2NUM(pgrp);
-#else
-# ifdef HAVE_GETPGID
+#else /* defined(HAVE_GETPGID) */
     pgrp = getpgid(0);
     if (pgrp < 0) rb_sys_fail(0);
     return PIDT2NUM(pgrp);
-# else
-    rb_notimplement();
-# endif
 #endif
 }
+#else
+#define proc_getpgrp rb_f_notimplement
+#endif
 
 
+#if defined(HAVE_SETPGID) || (defined(HAVE_SETPGRP) && defined(SETPGRP_VOID))
 /*
  *  call-seq:
- *     Process.setpgrp   => 0
+ *     Process.setpgrp   -> 0
  *
  *  Equivalent to <code>setpgid(0,0)</code>. Not available on all
  *  platforms.
@@ -2979,16 +3340,18 @@ proc_setpgrp(void)
     if (setpgid(0,0) < 0) rb_sys_fail(0);
 #elif defined(HAVE_SETPGRP) && defined(SETPGRP_VOID)
     if (setpgrp() < 0) rb_sys_fail(0);
-#else
-    rb_notimplement();
 #endif
     return INT2FIX(0);
 }
+#else
+#define proc_setpgrp rb_f_notimplement
+#endif
 
 
+#if defined(HAVE_GETPGID)
 /*
  *  call-seq:
- *     Process.getpgid(pid)   => integer
+ *     Process.getpgid(pid)   -> integer
  *
  *  Returns the process group ID for the given process id. Not
  *  available on all platforms.
@@ -2999,22 +3362,22 @@ proc_setpgrp(void)
 static VALUE
 proc_getpgid(VALUE obj, VALUE pid)
 {
-#if defined(HAVE_GETPGID) && !defined(__CHECKER__)
     rb_pid_t i;
 
     rb_secure(2);
     i = getpgid(NUM2PIDT(pid));
     if (i < 0) rb_sys_fail(0);
     return PIDT2NUM(i);
+}
 #else
-    rb_notimplement();
+#define proc_getpgid rb_f_notimplement
 #endif
-}
 
 
+#ifdef HAVE_SETPGID
 /*
  *  call-seq:
- *     Process.setpgid(pid, integer)   => 0
+ *     Process.setpgid(pid, integer)   -> 0
  *
  *  Sets the process group ID of _pid_ (0 indicates this
  *  process) to <em>integer</em>. Not available on all platforms.
@@ -3023,7 +3386,6 @@ proc_getpgid(VALUE obj, VALUE pid)
 static VALUE
 proc_setpgid(VALUE obj, VALUE pid, VALUE pgrp)
 {
-#ifdef HAVE_SETPGID
     rb_pid_t ipid, ipgrp;
 
     rb_secure(2);
@@ -3032,15 +3394,20 @@ proc_setpgid(VALUE obj, VALUE pid, VALUE pgrp)
 
     if (setpgid(ipid, ipgrp) < 0) rb_sys_fail(0);
     return INT2FIX(0);
+}
 #else
-    rb_notimplement();
+#define proc_setpgid rb_f_notimplement
 #endif
-}
 
 
+#if defined(HAVE_SETSID) || (defined(HAVE_SETPGRP) && defined(TIOCNOTTY))
+#if !defined(HAVE_SETSID)
+static rb_pid_t ruby_setsid(void);
+#define setsid() ruby_setsid()
+#endif
 /*
  *  call-seq:
- *     Process.setsid   => fixnum
+ *     Process.setsid   -> fixnum
  *
  *  Establishes this process as a new session and process group
  *  leader, with no controlling tty. Returns the session id. Not
@@ -3052,18 +3419,22 @@ proc_setpgid(VALUE obj, VALUE pid, VALUE pgrp)
 static VALUE
 proc_setsid(void)
 {
-#if defined(HAVE_SETSID)
     rb_pid_t pid;
 
     rb_secure(2);
     pid = setsid();
     if (pid < 0) rb_sys_fail(0);
     return PIDT2NUM(pid);
-#elif defined(HAVE_SETPGRP) && defined(TIOCNOTTY)
+}
+
+#if !defined(HAVE_SETSID)
+#define HAVE_SETSID 1
+static rb_pid_t
+ruby_setsid(void)
+{
     rb_pid_t pid;
     int ret;
 
-    rb_secure(2);
     pid = getpid();
 #if defined(SETPGRP_VOID)
     ret = setpgrp();
@@ -3073,22 +3444,24 @@ proc_setsid(void)
 #else
     ret = setpgrp(0, pid);
 #endif
-    if (ret == -1) rb_sys_fail(0);
+    if (ret == -1) return -1;
 
     if ((fd = open("/dev/tty", O_RDWR)) >= 0) {
 	ioctl(fd, TIOCNOTTY, NULL);
 	close(fd);
     }
-    return PIDT2NUM(pid);
+    return pid;
+}
+#endif
 #else
-    rb_notimplement();
+#define proc_setsid rb_f_notimplement
 #endif
-}
 
 
+#ifdef HAVE_GETPRIORITY
 /*
  *  call-seq:
- *     Process.getpriority(kind, integer)   => fixnum
+ *     Process.getpriority(kind, integer)   -> fixnum
  *
  *  Gets the scheduling priority for specified process, process group,
  *  or user. <em>kind</em> indicates the kind of entity to find: one
@@ -3106,7 +3479,6 @@ proc_setsid(void)
 static VALUE
 proc_getpriority(VALUE obj, VALUE which, VALUE who)
 {
-#ifdef HAVE_GETPRIORITY
     int prio, iwhich, iwho;
 
     rb_secure(2);
@@ -3117,15 +3489,16 @@ proc_getpriority(VALUE obj, VALUE which, VALUE who)
     prio = getpriority(iwhich, iwho);
     if (errno) rb_sys_fail(0);
     return INT2FIX(prio);
+}
 #else
-    rb_notimplement();
+#define proc_getpriority rb_f_notimplement
 #endif
-}
 
 
+#ifdef HAVE_GETPRIORITY
 /*
  *  call-seq:
- *     Process.setpriority(kind, integer, priority)   => 0
+ *     Process.setpriority(kind, integer, priority)   -> 0
  *
  *  See <code>Process#getpriority</code>.
  *
@@ -3138,7 +3511,6 @@ proc_getpriority(VALUE obj, VALUE which, VALUE who)
 static VALUE
 proc_setpriority(VALUE obj, VALUE which, VALUE who, VALUE prio)
 {
-#ifdef HAVE_GETPRIORITY
     int iwhich, iwho, iprio;
 
     rb_secure(2);
@@ -3149,10 +3521,10 @@ proc_setpriority(VALUE obj, VALUE which, VALUE who, VALUE prio)
     if (setpriority(iwhich, iwho, iprio) < 0)
 	rb_sys_fail(0);
     return INT2FIX(0);
+}
 #else
-    rb_notimplement();
+#define proc_setpriority rb_f_notimplement
 #endif
-}
 
 #if defined(RLIM2NUM)
 static int
@@ -3161,7 +3533,7 @@ rlimit_resource_name2int(const char *name, int casetype)
     size_t len = strlen(name);
     if (16 < len) return -1;
     if (casetype == 1) {
-        int i;
+        size_t i;
         char *name2 = ALLOCA_N(char, len+1);
         for (i = 0; i < len; i++) {
             if (!ISLOWER(name[i]))
@@ -3318,9 +3690,10 @@ rlimit_resource_value(VALUE rval)
 }
 #endif
 
+#if defined(HAVE_GETRLIMIT) && defined(RLIM2NUM)
 /*
  *  call-seq:
- *     Process.getrlimit(resource)   => [cur_limit, max_limit]
+ *     Process.getrlimit(resource)   -> [cur_limit, max_limit]
  *
  *  Gets the resource limit of the process.
  *  _cur_limit_ means current (soft) limit and
@@ -3341,7 +3714,6 @@ rlimit_resource_value(VALUE rval)
 static VALUE
 proc_getrlimit(VALUE obj, VALUE resource)
 {
-#if defined(HAVE_GETRLIMIT) && defined(RLIM2NUM)
     struct rlimit rlim;
 
     rb_secure(2);
@@ -3350,15 +3722,16 @@ proc_getrlimit(VALUE obj, VALUE resource)
 	rb_sys_fail("getrlimit");
     }
     return rb_assoc_new(RLIM2NUM(rlim.rlim_cur), RLIM2NUM(rlim.rlim_max));
+}
 #else
-    rb_notimplement();
+#define proc_getrlimit rb_f_notimplement
 #endif
-}
 
+#if defined(HAVE_SETRLIMIT) && defined(NUM2RLIM)
 /*
  *  call-seq:
- *     Process.setrlimit(resource, cur_limit, max_limit)        => nil
- *     Process.setrlimit(resource, cur_limit)                   => nil
+ *     Process.setrlimit(resource, cur_limit, max_limit)        -> nil
+ *     Process.setrlimit(resource, cur_limit)                   -> nil
  *
  *  Sets the resource limit of the process.
  *  _cur_limit_ means current (soft) limit and
@@ -3404,7 +3777,6 @@ proc_getrlimit(VALUE obj, VALUE resource)
 static VALUE
 proc_setrlimit(int argc, VALUE *argv, VALUE obj)
 {
-#if defined(HAVE_SETRLIMIT) && defined(NUM2RLIM)
     VALUE resource, rlim_cur, rlim_max;
     struct rlimit rlim;
 
@@ -3421,10 +3793,10 @@ proc_setrlimit(int argc, VALUE *argv, VALUE obj)
 	rb_sys_fail("setrlimit");
     }
     return Qnil;
+}
 #else
-    rb_notimplement();
+#define proc_setrlimit rb_f_notimplement
 #endif
-}
 
 static int under_uid_switch = 0;
 static void
@@ -3458,9 +3830,10 @@ check_gid_switch(void)
  */
 
 
+#if defined HAVE_SETUID
 /*
  *  call-seq:
- *     Process::Sys.setuid(integer)   => nil
+ *     Process::Sys.setuid(integer)   -> nil
  *
  *  Set the user ID of the current process to _integer_. Not
  *  available on all platforms.
@@ -3470,20 +3843,19 @@ check_gid_switch(void)
 static VALUE
 p_sys_setuid(VALUE obj, VALUE id)
 {
-#if defined HAVE_SETUID
     check_uid_switch();
     if (setuid(NUM2UIDT(id)) != 0) rb_sys_fail(0);
-#else
-    rb_notimplement();
-#endif
     return Qnil;
 }
+#else
+#define p_sys_setuid rb_f_notimplement
+#endif
 
 
-
+#if defined HAVE_SETRUID
 /*
  *  call-seq:
- *     Process::Sys.setruid(integer)   => nil
+ *     Process::Sys.setruid(integer)   -> nil
  *
  *  Set the real user ID of the calling process to _integer_.
  *  Not available on all platforms.
@@ -3493,19 +3865,19 @@ p_sys_setuid(VALUE obj, VALUE id)
 static VALUE
 p_sys_setruid(VALUE obj, VALUE id)
 {
-#if defined HAVE_SETRUID
     check_uid_switch();
     if (setruid(NUM2UIDT(id)) != 0) rb_sys_fail(0);
-#else
-    rb_notimplement();
-#endif
     return Qnil;
 }
+#else
+#define p_sys_setruid rb_f_notimplement
+#endif
 
 
+#if defined HAVE_SETEUID
 /*
  *  call-seq:
- *     Process::Sys.seteuid(integer)   => nil
+ *     Process::Sys.seteuid(integer)   -> nil
  *
  *  Set the effective user ID of the calling process to
  *  _integer_.  Not available on all platforms.
@@ -3515,19 +3887,19 @@ p_sys_setruid(VALUE obj, VALUE id)
 static VALUE
 p_sys_seteuid(VALUE obj, VALUE id)
 {
-#if defined HAVE_SETEUID
     check_uid_switch();
     if (seteuid(NUM2UIDT(id)) != 0) rb_sys_fail(0);
-#else
-    rb_notimplement();
-#endif
     return Qnil;
 }
+#else
+#define p_sys_seteuid rb_f_notimplement
+#endif
 
 
+#if defined HAVE_SETREUID
 /*
  *  call-seq:
- *     Process::Sys.setreuid(rid, eid)   => nil
+ *     Process::Sys.setreuid(rid, eid)   -> nil
  *
  *  Sets the (integer) real and/or effective user IDs of the current
  *  process to _rid_ and _eid_, respectively. A value of
@@ -3539,19 +3911,19 @@ p_sys_seteuid(VALUE obj, VALUE id)
 static VALUE
 p_sys_setreuid(VALUE obj, VALUE rid, VALUE eid)
 {
-#if defined HAVE_SETREUID
     check_uid_switch();
     if (setreuid(NUM2UIDT(rid),NUM2UIDT(eid)) != 0) rb_sys_fail(0);
-#else
-    rb_notimplement();
-#endif
     return Qnil;
 }
+#else
+#define p_sys_setreuid rb_f_notimplement
+#endif
 
 
+#if defined HAVE_SETRESUID
 /*
  *  call-seq:
- *     Process::Sys.setresuid(rid, eid, sid)   => nil
+ *     Process::Sys.setresuid(rid, eid, sid)   -> nil
  *
  *  Sets the (integer) real, effective, and saved user IDs of the
  *  current process to _rid_, _eid_, and _sid_ respectively. A
@@ -3563,21 +3935,20 @@ p_sys_setreuid(VALUE obj, VALUE rid, VALUE eid)
 static VALUE
 p_sys_setresuid(VALUE obj, VALUE rid, VALUE eid, VALUE sid)
 {
-#if defined HAVE_SETRESUID
     check_uid_switch();
     if (setresuid(NUM2UIDT(rid),NUM2UIDT(eid),NUM2UIDT(sid)) != 0) rb_sys_fail(0);
-#else
-    rb_notimplement();
-#endif
     return Qnil;
 }
+#else
+#define p_sys_setresuid rb_f_notimplement
+#endif
 
 
 /*
  *  call-seq:
- *     Process.uid           => fixnum
- *     Process::UID.rid      => fixnum
- *     Process::Sys.getuid   => fixnum
+ *     Process.uid           -> fixnum
+ *     Process::UID.rid      -> fixnum
+ *     Process::Sys.getuid   -> fixnum
  *
  *  Returns the (real) user ID of this process.
  *
@@ -3592,9 +3963,10 @@ proc_getuid(VALUE obj)
 }
 
 
+#if defined(HAVE_SETRESUID) || defined(HAVE_SETREUID) || defined(HAVE_SETRUID) || defined(HAVE_SETUID)
 /*
  *  call-seq:
- *     Process.uid= integer   => numeric
+ *     Process.uid= integer   -> numeric
  *
  *  Sets the (integer) user ID for this process. Not available on all
  *  platforms.
@@ -3608,7 +3980,7 @@ proc_setuid(VALUE obj, VALUE id)
     check_uid_switch();
 
     uid = NUM2UIDT(id);
-#if defined(HAVE_SETRESUID) &&  !defined(__CHECKER__)
+#if defined(HAVE_SETRESUID)
     if (setresuid(uid, -1, -1) < 0) rb_sys_fail(0);
 #elif defined HAVE_SETREUID
     if (setreuid(uid, -1) < 0) rb_sys_fail(0);
@@ -3623,11 +3995,12 @@ proc_setuid(VALUE obj, VALUE id)
 	    rb_notimplement();
 	}
     }
-#else
-    rb_notimplement();
 #endif
     return id;
 }
+#else
+#define proc_setuid rb_f_notimplement
+#endif
 
 
 /********************************************************************
@@ -3659,7 +4032,7 @@ setreuid(rb_uid_t ruid, rb_uid_t euid)
 
 /*
  *  call-seq:
- *     Process::UID.change_privilege(integer)   => fixnum
+ *     Process::UID.change_privilege(integer)   -> fixnum
  *
  *  Change the current process's real and effective user ID to that
  *  specified by _integer_. Returns the new user ID. Not
@@ -3810,9 +4183,10 @@ p_uid_change_privilege(VALUE obj, VALUE id)
 
 
 
+#if defined HAVE_SETGID
 /*
  *  call-seq:
- *     Process::Sys.setgid(integer)   => nil
+ *     Process::Sys.setgid(integer)   -> nil
  *
  *  Set the group ID of the current process to _integer_. Not
  *  available on all platforms.
@@ -3822,19 +4196,19 @@ p_uid_change_privilege(VALUE obj, VALUE id)
 static VALUE
 p_sys_setgid(VALUE obj, VALUE id)
 {
-#if defined HAVE_SETGID
     check_gid_switch();
     if (setgid(NUM2GIDT(id)) != 0) rb_sys_fail(0);
-#else
-    rb_notimplement();
-#endif
     return Qnil;
 }
+#else
+#define p_sys_setgid rb_f_notimplement
+#endif
 
 
+#if defined HAVE_SETRGID
 /*
  *  call-seq:
- *     Process::Sys.setrgid(integer)   => nil
+ *     Process::Sys.setrgid(integer)   -> nil
  *
  *  Set the real group ID of the calling process to _integer_.
  *  Not available on all platforms.
@@ -3844,20 +4218,19 @@ p_sys_setgid(VALUE obj, VALUE id)
 static VALUE
 p_sys_setrgid(VALUE obj, VALUE id)
 {
-#if defined HAVE_SETRGID
     check_gid_switch();
     if (setrgid(NUM2GIDT(id)) != 0) rb_sys_fail(0);
-#else
-    rb_notimplement();
-#endif
     return Qnil;
 }
+#else
+#define p_sys_setrgid rb_f_notimplement
+#endif
 
 
-
+#if defined HAVE_SETEGID
 /*
  *  call-seq:
- *     Process::Sys.setegid(integer)   => nil
+ *     Process::Sys.setegid(integer)   -> nil
  *
  *  Set the effective group ID of the calling process to
  *  _integer_.  Not available on all platforms.
@@ -3867,19 +4240,19 @@ p_sys_setrgid(VALUE obj, VALUE id)
 static VALUE
 p_sys_setegid(VALUE obj, VALUE id)
 {
-#if defined HAVE_SETEGID
     check_gid_switch();
     if (setegid(NUM2GIDT(id)) != 0) rb_sys_fail(0);
-#else
-    rb_notimplement();
-#endif
     return Qnil;
 }
+#else
+#define p_sys_setegid rb_f_notimplement
+#endif
 
 
+#if defined HAVE_SETREGID
 /*
  *  call-seq:
- *     Process::Sys.setregid(rid, eid)   => nil
+ *     Process::Sys.setregid(rid, eid)   -> nil
  *
  *  Sets the (integer) real and/or effective group IDs of the current
  *  process to <em>rid</em> and <em>eid</em>, respectively. A value of
@@ -3891,18 +4264,18 @@ p_sys_setegid(VALUE obj, VALUE id)
 static VALUE
 p_sys_setregid(VALUE obj, VALUE rid, VALUE eid)
 {
-#if defined HAVE_SETREGID
     check_gid_switch();
     if (setregid(NUM2GIDT(rid),NUM2GIDT(eid)) != 0) rb_sys_fail(0);
-#else
-    rb_notimplement();
-#endif
     return Qnil;
 }
+#else
+#define p_sys_setregid rb_f_notimplement
+#endif
 
+#if defined HAVE_SETRESGID
 /*
  *  call-seq:
- *     Process::Sys.setresgid(rid, eid, sid)   => nil
+ *     Process::Sys.setresgid(rid, eid, sid)   -> nil
  *
  *  Sets the (integer) real, effective, and saved user IDs of the
  *  current process to <em>rid</em>, <em>eid</em>, and <em>sid</em>
@@ -3914,19 +4287,19 @@ p_sys_setregid(VALUE obj, VALUE rid, VALUE eid)
 static VALUE
 p_sys_setresgid(VALUE obj, VALUE rid, VALUE eid, VALUE sid)
 {
-#if defined HAVE_SETRESGID
     check_gid_switch();
     if (setresgid(NUM2GIDT(rid),NUM2GIDT(eid),NUM2GIDT(sid)) != 0) rb_sys_fail(0);
-#else
-    rb_notimplement();
-#endif
     return Qnil;
 }
+#else
+#define p_sys_setresgid rb_f_notimplement
+#endif
 
 
+#if defined HAVE_ISSETUGID
 /*
  *  call-seq:
- *     Process::Sys.issetugid   => true or false
+ *     Process::Sys.issetugid   -> true or false
  *
  *  Returns +true+ if the process was created as a result
  *  of an execve(2) system call which had either of the setuid or
@@ -3939,25 +4312,23 @@ p_sys_setresgid(VALUE obj, VALUE rid, VALUE eid, VALUE sid)
 static VALUE
 p_sys_issetugid(VALUE obj)
 {
-#if defined HAVE_ISSETUGID
     rb_secure(2);
     if (issetugid()) {
 	return Qtrue;
     } else {
 	return Qfalse;
     }
+}
 #else
-    rb_notimplement();
-    return Qnil;		/* not reached */
+#define p_sys_issetugid rb_f_notimplement
 #endif
-}
 
 
 /*
  *  call-seq:
- *     Process.gid           => fixnum
- *     Process::GID.rid      => fixnum
- *     Process::Sys.getgid   => fixnum
+ *     Process.gid           -> fixnum
+ *     Process::GID.rid      -> fixnum
+ *     Process::Sys.getgid   -> fixnum
  *
  *  Returns the (real) group ID for this process.
  *
@@ -3972,9 +4343,10 @@ proc_getgid(VALUE obj)
 }
 
 
+#if defined(HAVE_SETRESGID) || defined(HAVE_SETREGID) || defined(HAVE_SETRGID) || defined(HAVE_SETGID)
 /*
  *  call-seq:
- *     Process.gid= fixnum   => fixnum
+ *     Process.gid= fixnum   -> fixnum
  *
  *  Sets the group ID for this process.
  */
@@ -3987,7 +4359,7 @@ proc_setgid(VALUE obj, VALUE id)
     check_gid_switch();
 
     gid = NUM2GIDT(id);
-#if defined(HAVE_SETRESGID) && !defined(__CHECKER__)
+#if defined(HAVE_SETRESGID)
     if (setresgid(gid, -1, -1) < 0) rb_sys_fail(0);
 #elif defined HAVE_SETREGID
     if (setregid(gid, -1) < 0) rb_sys_fail(0);
@@ -4002,19 +4374,21 @@ proc_setgid(VALUE obj, VALUE id)
 	    rb_notimplement();
 	}
     }
-#else
-    rb_notimplement();
 #endif
     return GIDT2NUM(gid);
 }
+#else
+#define proc_setgid rb_f_notimplement
+#endif
 
 
-static size_t maxgroups = 32;
+static int maxgroups = 32;
 
 
+#ifdef HAVE_GETGROUPS
 /*
  *  call-seq:
- *     Process.groups   => array
+ *     Process.groups   -> array
  *
  *  Get an <code>Array</code> of the gids of groups in the
  *  supplemental group access list for this process.
@@ -4026,11 +4400,9 @@ static size_t maxgroups = 32;
 static VALUE
 proc_getgroups(VALUE obj)
 {
-#ifdef HAVE_GETGROUPS
     VALUE ary;
-    size_t ngroups;
+    int i, ngroups;
     rb_gid_t *groups;
-    int i;
 
     groups = ALLOCA_N(rb_gid_t, maxgroups);
 
@@ -4043,16 +4415,16 @@ proc_getgroups(VALUE obj)
 	rb_ary_push(ary, GIDT2NUM(groups[i]));
 
     return ary;
+}
 #else
-    rb_notimplement();
-    return Qnil;
+#define proc_getgroups rb_f_notimplement
 #endif
-}
 
 
+#ifdef HAVE_SETGROUPS
 /*
  *  call-seq:
- *     Process.groups= array   => array
+ *     Process.groups= array   -> array
  *
  *  Set the supplemental group access list to the given
  *  <code>Array</code> of group IDs.
@@ -4066,21 +4438,19 @@ proc_getgroups(VALUE obj)
 static VALUE
 proc_setgroups(VALUE obj, VALUE ary)
 {
-#ifdef HAVE_SETGROUPS
-    size_t ngroups;
+    size_t ngroups, i;
     rb_gid_t *groups;
-    int i;
     struct group *gr;
 
     Check_Type(ary, T_ARRAY);
 
     ngroups = RARRAY_LEN(ary);
-    if (ngroups > maxgroups)
-	rb_raise(rb_eArgError, "too many groups, %lu max", (unsigned long)maxgroups);
+    if (ngroups > (size_t)maxgroups)
+	rb_raise(rb_eArgError, "too many groups, %u max", maxgroups);
 
     groups = ALLOCA_N(rb_gid_t, ngroups);
 
-    for (i = 0; i < ngroups && i < RARRAY_LEN(ary); i++) {
+    for (i = 0; i < ngroups && i < (size_t)RARRAY_LEN(ary); i++) {
 	VALUE g = RARRAY_PTR(ary)[i];
 
 	if (FIXNUM_P(g)) {
@@ -4094,29 +4464,30 @@ proc_setgroups(VALUE obj, VALUE ary)
 	    }
 	    else {
 		gr = getgrnam(RSTRING_PTR(tmp));
-		if (gr == NULL)
+		if (gr == NULL) {
+		    RB_GC_GUARD(tmp);
 		    rb_raise(rb_eArgError,
 			     "can't find group for %s", RSTRING_PTR(tmp));
+		}
 		groups[i] = gr->gr_gid;
 	    }
 	}
     }
 
-    i = setgroups(ngroups, groups);
-    if (i == -1)
+    if (setgroups((int)ngroups, groups) == -1) /* ngroups <= maxgroups */
 	rb_sys_fail(0);
 
     return proc_getgroups(obj);
+}
 #else
-    rb_notimplement();
-    return Qnil;
+#define proc_setgroups rb_f_notimplement
 #endif
-}
 
 
+#ifdef HAVE_INITGROUPS
 /*
  *  call-seq:
- *     Process.initgroups(username, gid)   => array
+ *     Process.initgroups(username, gid)   -> array
  *
  *  Initializes the supplemental group access list by reading the
  *  system group database and using all groups of which the given user
@@ -4134,21 +4505,19 @@ proc_setgroups(VALUE obj, VALUE ary)
 static VALUE
 proc_initgroups(VALUE obj, VALUE uname, VALUE base_grp)
 {
-#ifdef HAVE_INITGROUPS
     if (initgroups(StringValuePtr(uname), NUM2GIDT(base_grp)) != 0) {
 	rb_sys_fail(0);
     }
     return proc_getgroups(obj);
+}
 #else
-    rb_notimplement();
-    return Qnil;
+#define proc_initgroups rb_f_notimplement
 #endif
-}
 
 
 /*
  *  call-seq:
- *     Process.maxgroups   => fixnum
+ *     Process.maxgroups   -> fixnum
  *
  *  Returns the maximum number of gids allowed in the supplemental
  *  group access list.
@@ -4165,7 +4534,7 @@ proc_getmaxgroups(VALUE obj)
 
 /*
  *  call-seq:
- *     Process.maxgroups= fixnum   => fixnum
+ *     Process.maxgroups= fixnum   -> fixnum
  *
  *  Sets the maximum number of gids allowed in the supplemental group
  *  access list.
@@ -4174,7 +4543,7 @@ proc_getmaxgroups(VALUE obj)
 static VALUE
 proc_setmaxgroups(VALUE obj, VALUE val)
 {
-    size_t  ngroups = FIX2INT(val);
+    int ngroups = FIX2UINT(val);
 
     if (ngroups > 4096)
 	ngroups = 4096;
@@ -4184,10 +4553,11 @@ proc_setmaxgroups(VALUE obj, VALUE val)
     return INT2FIX(maxgroups);
 }
 
+#if defined(HAVE_DAEMON) || (defined(HAVE_FORK) && defined(HAVE_SETSID))
 /*
  *  call-seq:
- *     Process.daemon()                        => fixnum
- *     Process.daemon(nochdir=nil,noclose=nil) => fixnum
+ *     Process.daemon()                        -> 0
+ *     Process.daemon(nochdir=nil,noclose=nil) -> 0
  *
  *  Detach the process from controlling terminal and run in
  *  the background as system daemon.  Unless the argument
@@ -4195,15 +4565,14 @@ proc_setmaxgroups(VALUE obj, VALUE val)
  *  working directory to the root ("/"). Unless the argument
  *  noclose is true, daemon() will redirect standard input,
  *  standard output and standard error to /dev/null.
+ *  Return zero on success, or raise one of Errno::*.
  */
 
 static VALUE
 proc_daemon(int argc, VALUE *argv)
 {
     VALUE nochdir, noclose;
-#if defined(HAVE_DAEMON) || defined(HAVE_FORK)
     int n;
-#endif
 
     rb_secure(2);
     rb_scan_args(argc, argv, "02", &nochdir, &noclose);
@@ -4218,11 +4587,11 @@ proc_daemon(int argc, VALUE *argv)
 #elif defined(HAVE_FORK)
     switch (rb_fork(0, 0, 0, Qnil)) {
       case -1:
-	return INT2FIX(-1);
+	rb_sys_fail("daemon");
       case 0:
 	break;
       default:
-	_exit(0);
+	_exit(EXIT_SUCCESS);
     }
 
     proc_setsid();
@@ -4230,11 +4599,11 @@ proc_daemon(int argc, VALUE *argv)
     /* must not be process-leader */
     switch (rb_fork(0, 0, 0, Qnil)) {
       case -1:
-	return INT2FIX(-1);
+	rb_sys_fail("daemon");
       case 0:
 	break;
       default:
-	_exit(0);
+	_exit(EXIT_SUCCESS);
     }
 
     if (!RTEST(nochdir))
@@ -4248,10 +4617,11 @@ proc_daemon(int argc, VALUE *argv)
 	    (void)close (n);
     }
     return INT2FIX(0);
-#else
-    rb_notimplement();
 #endif
 }
+#else
+#define proc_daemon rb_f_notimplement
+#endif
 
 /********************************************************************
  *
@@ -4263,7 +4633,7 @@ proc_daemon(int argc, VALUE *argv)
  *
  */
 
-static int SAVED_GROUP_ID = -1;
+static rb_gid_t SAVED_GROUP_ID = -1;
 
 #ifdef BROKEN_SETREGID
 int
@@ -4282,7 +4652,7 @@ setregid(rb_gid_t rgid, rb_gid_t egid)
 
 /*
  *  call-seq:
- *     Process::GID.change_privilege(integer)   => fixnum
+ *     Process::GID.change_privilege(integer)   -> fixnum
  *
  *  Change the current process's real and effective group ID to that
  *  specified by _integer_. Returns the new group ID. Not
@@ -4435,9 +4805,9 @@ p_gid_change_privilege(VALUE obj, VALUE id)
 
 /*
  *  call-seq:
- *     Process.euid           => fixnum
- *     Process::UID.eid       => fixnum
- *     Process::Sys.geteuid   => fixnum
+ *     Process.euid           -> fixnum
+ *     Process::UID.eid       -> fixnum
+ *     Process::Sys.geteuid   -> fixnum
  *
  *  Returns the effective user ID for this process.
  *
@@ -4451,7 +4821,7 @@ proc_geteuid(VALUE obj)
     return UIDT2NUM(euid);
 }
 
-
+#if defined(HAVE_SETRESUID) || defined(HAVE_SETREUID) || defined(HAVE_SETEUID) || defined(HAVE_SETUID) || defined(_POSIX_SAVED_IDS)
 /*
  *  call-seq:
  *     Process.euid= integer
@@ -4468,7 +4838,7 @@ proc_seteuid(VALUE obj, VALUE euid)
     check_uid_switch();
 
     uid = NUM2UIDT(euid);
-#if defined(HAVE_SETRESUID) && !defined(__CHECKER__)
+#if defined(HAVE_SETRESUID)
     if (setresuid(-1, uid, -1) < 0) rb_sys_fail(0);
 #elif defined HAVE_SETREUID
     if (setreuid(-1, uid) < 0) rb_sys_fail(0);
@@ -4486,6 +4856,13 @@ proc_seteuid(VALUE obj, VALUE euid)
 #endif
     return euid;
 }
+#endif
+
+#if defined(HAVE_SETRESUID) || defined(HAVE_SETREUID) || defined(HAVE_SETEUID) || defined(HAVE_SETUID)
+#define proc_seteuid_m proc_seteuid
+#else
+#define proc_seteuid_m rb_f_notimplement
+#endif
 
 static rb_uid_t
 rb_seteuid_core(rb_uid_t euid)
@@ -4496,7 +4873,7 @@ rb_seteuid_core(rb_uid_t euid)
 
     uid = getuid();
 
-#if defined(HAVE_SETRESUID) && !defined(__CHECKER__)
+#if defined(HAVE_SETRESUID)
     if (uid != euid) {
 	if (setresuid(-1,euid,euid) < 0) rb_sys_fail(0);
 	SAVED_USER_ID = euid;
@@ -4524,8 +4901,8 @@ rb_seteuid_core(rb_uid_t euid)
 
 /*
  *  call-seq:
- *     Process::UID.grant_privilege(integer)   => fixnum
- *     Process::UID.eid= integer               => fixnum
+ *     Process::UID.grant_privilege(integer)   -> fixnum
+ *     Process::UID.eid= integer               -> fixnum
  *
  *  Set the effective user ID, and if possible, the saved user ID of
  *  the process to the given _integer_. Returns the new
@@ -4546,9 +4923,9 @@ p_uid_grant_privilege(VALUE obj, VALUE id)
 
 /*
  *  call-seq:
- *     Process.egid          => fixnum
- *     Process::GID.eid      => fixnum
- *     Process::Sys.geteid   => fixnum
+ *     Process.egid          -> fixnum
+ *     Process::GID.eid      -> fixnum
+ *     Process::Sys.geteid   -> fixnum
  *
  *  Returns the effective group ID for this process. Not available on
  *  all platforms.
@@ -4564,10 +4941,10 @@ proc_getegid(VALUE obj)
     return GIDT2NUM(egid);
 }
 
-
+#if defined(HAVE_SETRESGID) || defined(HAVE_SETREGID) || defined(HAVE_SETEGID) || defined(HAVE_SETGID) || defined(_POSIX_SAVED_IDS)
 /*
  *  call-seq:
- *     Process.egid = fixnum   => fixnum
+ *     Process.egid = fixnum   -> fixnum
  *
  *  Sets the effective group ID for this process. Not available on all
  *  platforms.
@@ -4581,7 +4958,7 @@ proc_setegid(VALUE obj, VALUE egid)
     check_gid_switch();
 
     gid = NUM2GIDT(egid);
-#if defined(HAVE_SETRESGID) && !defined(__CHECKER__)
+#if defined(HAVE_SETRESGID)
     if (setresgid(-1, gid, -1) < 0) rb_sys_fail(0);
 #elif defined HAVE_SETREGID
     if (setregid(-1, gid) < 0) rb_sys_fail(0);
@@ -4599,6 +4976,13 @@ proc_setegid(VALUE obj, VALUE egid)
 #endif
     return egid;
 }
+#endif
+
+#if defined(HAVE_SETRESGID) || defined(HAVE_SETREGID) || defined(HAVE_SETEGID) || defined(HAVE_SETGID)
+#define proc_setegid_m proc_setegid
+#else
+#define proc_setegid_m rb_f_notimplement
+#endif
 
 static rb_gid_t
 rb_setegid_core(rb_gid_t egid)
@@ -4609,7 +4993,7 @@ rb_setegid_core(rb_gid_t egid)
 
     gid = getgid();
 
-#if defined(HAVE_SETRESGID) && !defined(__CHECKER__)
+#if defined(HAVE_SETRESGID)
     if (gid != egid) {
 	if (setresgid(-1,egid,egid) < 0) rb_sys_fail(0);
 	SAVED_GROUP_ID = egid;
@@ -4637,8 +5021,8 @@ rb_setegid_core(rb_gid_t egid)
 
 /*
  *  call-seq:
- *     Process::GID.grant_privilege(integer)    => fixnum
- *     Process::GID.eid = integer               => fixnum
+ *     Process::GID.grant_privilege(integer)    -> fixnum
+ *     Process::GID.eid = integer               -> fixnum
  *
  *  Set the effective group ID, and if possible, the saved group ID of
  *  the process to the given _integer_. Returns the new
@@ -4659,7 +5043,7 @@ p_gid_grant_privilege(VALUE obj, VALUE id)
 
 /*
  *  call-seq:
- *     Process::UID.re_exchangeable?   => true or false
+ *     Process::UID.re_exchangeable?   -> true or false
  *
  *  Returns +true+ if the real and effective user IDs of a
  *  process may be exchanged on the current platform.
@@ -4669,7 +5053,7 @@ p_gid_grant_privilege(VALUE obj, VALUE id)
 static VALUE
 p_uid_exchangeable(void)
 {
-#if defined(HAVE_SETRESUID) &&  !defined(__CHECKER__)
+#if defined(HAVE_SETRESUID)
     return Qtrue;
 #elif defined(HAVE_SETREUID) && !defined(OBSOLETE_SETREUID)
     return Qtrue;
@@ -4681,7 +5065,7 @@ p_uid_exchangeable(void)
 
 /*
  *  call-seq:
- *     Process::UID.re_exchange   => fixnum
+ *     Process::UID.re_exchange   -> fixnum
  *
  *  Exchange real and effective user IDs and return the new effective
  *  user ID. Not available on all platforms.
@@ -4701,7 +5085,7 @@ p_uid_exchange(VALUE obj)
     uid = getuid();
     euid = geteuid();
 
-#if defined(HAVE_SETRESUID) &&  !defined(__CHECKER__)
+#if defined(HAVE_SETRESUID)
     if (setresuid(euid, uid, uid) < 0) rb_sys_fail(0);
     SAVED_USER_ID = uid;
 #elif defined(HAVE_SETREUID) && !defined(OBSOLETE_SETREUID)
@@ -4716,7 +5100,7 @@ p_uid_exchange(VALUE obj)
 
 /*
  *  call-seq:
- *     Process::GID.re_exchangeable?   => true or false
+ *     Process::GID.re_exchangeable?   -> true or false
  *
  *  Returns +true+ if the real and effective group IDs of a
  *  process may be exchanged on the current platform.
@@ -4726,7 +5110,7 @@ p_uid_exchange(VALUE obj)
 static VALUE
 p_gid_exchangeable(void)
 {
-#if defined(HAVE_SETRESGID) &&  !defined(__CHECKER__)
+#if defined(HAVE_SETRESGID)
     return Qtrue;
 #elif defined(HAVE_SETREGID) && !defined(OBSOLETE_SETREGID)
     return Qtrue;
@@ -4738,7 +5122,7 @@ p_gid_exchangeable(void)
 
 /*
  *  call-seq:
- *     Process::GID.re_exchange   => fixnum
+ *     Process::GID.re_exchange   -> fixnum
  *
  *  Exchange real and effective group IDs and return the new effective
  *  group ID. Not available on all platforms.
@@ -4758,7 +5142,7 @@ p_gid_exchange(VALUE obj)
     gid = getgid();
     egid = getegid();
 
-#if defined(HAVE_SETRESGID) &&  !defined(__CHECKER__)
+#if defined(HAVE_SETRESGID)
     if (setresgid(egid, gid, gid) < 0) rb_sys_fail(0);
     SAVED_GROUP_ID = gid;
 #elif defined(HAVE_SETREGID) && !defined(OBSOLETE_SETREGID)
@@ -4774,7 +5158,7 @@ p_gid_exchange(VALUE obj)
 
 /*
  *  call-seq:
- *     Process::UID.sid_available?   => true or false
+ *     Process::UID.sid_available?   -> true or false
  *
  *  Returns +true+ if the current platform has saved user
  *  ID functionality.
@@ -4804,8 +5188,8 @@ p_uid_sw_ensure(rb_uid_t id)
 
 /*
  *  call-seq:
- *     Process::UID.switch              => fixnum
- *     Process::UID.switch {|| block}   => object
+ *     Process::UID.switch              -> fixnum
+ *     Process::UID.switch {|| block}   -> object
  *
  *  Switch the effective and real user IDs of the current process. If
  *  a <em>block</em> is given, the user IDs will be switched back
@@ -4883,7 +5267,7 @@ p_uid_switch(VALUE obj)
 
 /*
  *  call-seq:
- *     Process::GID.sid_available?   => true or false
+ *     Process::GID.sid_available?   -> true or false
  *
  *  Returns +true+ if the current platform has saved group
  *  ID functionality.
@@ -4912,8 +5296,8 @@ p_gid_sw_ensure(rb_gid_t id)
 
 /*
  *  call-seq:
- *     Process::GID.switch              => fixnum
- *     Process::GID.switch {|| block}   => object
+ *     Process::GID.switch              -> fixnum
+ *     Process::GID.switch {|| block}   -> object
  *
  *  Switch the effective and real group IDs of the current process. If
  *  a <em>block</em> is given, the group IDs will be switched back
@@ -4926,7 +5310,7 @@ p_gid_sw_ensure(rb_gid_t id)
 static VALUE
 p_gid_switch(VALUE obj)
 {
-    int gid, egid;
+    rb_gid_t gid, egid;
 
     check_gid_switch();
 
@@ -4941,7 +5325,8 @@ p_gid_switch(VALUE obj)
 	} else {
 	    return GIDT2NUM(egid);
 	}
-    } else if (egid != SAVED_GROUP_ID) {
+    }
+    else if (egid != SAVED_GROUP_ID) {
 	proc_setegid(obj, GIDT2NUM(SAVED_GROUP_ID));
 	if (rb_block_given_p()) {
 	    under_gid_switch = 1;
@@ -4949,7 +5334,8 @@ p_gid_switch(VALUE obj)
 	} else {
 	    return GIDT2NUM(gid);
 	}
-    } else {
+    }
+    else {
 	errno = EPERM;
 	rb_sys_fail(0);
     }
@@ -4987,9 +5373,10 @@ p_gid_switch(VALUE obj)
 #endif
 
 
+#if defined(HAVE_TIMES)
 /*
  *  call-seq:
- *     Process.times   => aStructTms
+ *     Process.times   -> aStructTms
  *
  *  Returns a <code>Tms</code> structure (see <code>Struct::Tms</code>
  *  on page 388) that contains user and system CPU times for this
@@ -5002,7 +5389,6 @@ p_gid_switch(VALUE obj)
 VALUE
 rb_proc_times(VALUE obj)
 {
-#if defined(HAVE_TIMES) && !defined(__CHECKER__)
     const double hertz =
 #ifdef HAVE__SC_CLK_TCK
 	(double)sysconf(_SC_CLK_TCK);
@@ -5025,10 +5411,10 @@ rb_proc_times(VALUE obj)
 			 stime = DBL2NUM(buf.tms_stime / hertz),
 			 cutime = DBL2NUM(buf.tms_cutime / hertz),
 			 sctime = DBL2NUM(buf.tms_cstime / hertz));
+}
 #else
-    rb_notimplement();
+#define rb_proc_times rb_f_notimplement
 #endif
-}
 
 VALUE rb_mProcess;
 VALUE rb_mProcUID;
@@ -5129,13 +5515,17 @@ Init_process(void)
     {
         VALUE inf = RLIM2NUM(RLIM_INFINITY);
 #ifdef RLIM_SAVED_MAX
-	VALUE v = RLIM_INFINITY == RLIM_SAVED_MAX ? inf : RLIM2NUM(RLIM_SAVED_MAX);
-        rb_define_const(rb_mProcess, "RLIM_SAVED_MAX", v);
+	{
+	    VALUE v = RLIM_INFINITY == RLIM_SAVED_MAX ? inf : RLIM2NUM(RLIM_SAVED_MAX);
+	    rb_define_const(rb_mProcess, "RLIM_SAVED_MAX", v);
+	}
 #endif
         rb_define_const(rb_mProcess, "RLIM_INFINITY", inf);
 #ifdef RLIM_SAVED_CUR
-        v = RLIM_INFINITY == RLIM_SAVED_CUR ? inf : RLIM2NUM(RLIM_SAVED_CUR);
-        rb_define_const(rb_mProcess, "RLIM_SAVED_CUR", v);
+	{
+	    VALUE v = RLIM_INFINITY == RLIM_SAVED_CUR ? inf : RLIM2NUM(RLIM_SAVED_CUR);
+	    rb_define_const(rb_mProcess, "RLIM_SAVED_CUR", v);
+	}
 #endif
     }
 #ifdef RLIMIT_CORE
@@ -5178,9 +5568,9 @@ Init_process(void)
     rb_define_module_function(rb_mProcess, "gid", proc_getgid, 0);
     rb_define_module_function(rb_mProcess, "gid=", proc_setgid, 1);
     rb_define_module_function(rb_mProcess, "euid", proc_geteuid, 0);
-    rb_define_module_function(rb_mProcess, "euid=", proc_seteuid, 1);
+    rb_define_module_function(rb_mProcess, "euid=", proc_seteuid_m, 1);
     rb_define_module_function(rb_mProcess, "egid", proc_getegid, 0);
-    rb_define_module_function(rb_mProcess, "egid=", proc_setegid, 1);
+    rb_define_module_function(rb_mProcess, "egid=", proc_setegid_m, 1);
     rb_define_module_function(rb_mProcess, "initgroups", proc_initgroups, 2);
     rb_define_module_function(rb_mProcess, "groups", proc_getgroups, 0);
     rb_define_module_function(rb_mProcess, "groups=", proc_setgroups, 1);