Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   /*
    **** BEGIN LICENSE BLOCK *****
    * Version: CPL 1.0/GPL 2.0/LGPL 2.1
    *
    * The contents of this file are subject to the Common Public
    * License Version 1.0 (the "License"); you may not use this file
    * except in compliance with the License. You may obtain a copy of
    * the License at http://www.eclipse.org/legal/cpl-v10.html
    *
   * Software distributed under the License is distributed on an "AS
   * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
   * implied. See the License for the specific language governing
   * rights and limitations under the License.
   *
   * Copyright (C) 2004 Thomas E Enebo <enebo@acm.org>
   * Copyright (C) 2004 Jan Arne Petersen <jpetersen@uni-bonn.de>
   * 
   * Alternatively, the contents of this file may be used under the terms of
   * either of the GNU General Public License Version 2 or later (the "GPL"),
   * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
   * in which case the provisions of the GPL or the LGPL are applicable instead
   * of those above. If you wish to allow use of your version of this file only
   * under the terms of either the GPL or the LGPL, and not to allow others to
   * use your version of this file under the terms of the CPL, indicate your
   * decision by deleting the provisions above and replace them with the notice
   * and other provisions required by the GPL or the LGPL. If you do not delete
   * the provisions above, a recipient may use your version of this file under
   * the terms of any one of the CPL, the GPL or the LGPL.
   ***** END LICENSE BLOCK *****/
  package org.jruby;
  
  import jnr.ffi.*;
  import jnr.posix.Times;
  import jnr.posix.POSIX;
  import static org.jruby.runtime.Visibility.*;
  import static org.jruby.CompatVersion.*;
  
  import static org.jruby.javasupport.util.RuntimeHelpers.invokedynamic;
  import static org.jruby.runtime.invokedynamic.MethodNames.OP_EQUAL;


  
  
  @JRubyModule(name="Process")
  public class RubyProcess {
  
      public static RubyModule createProcessModule(Ruby runtime) {
          RubyModule process = runtime.defineModule("Process");
          runtime.setProcess(process);
          
          // TODO: NOT_ALLOCATABLE_ALLOCATOR is probably ok here. Confirm. JRUBY-415
          RubyClass process_status = process.defineClassUnder("Status"runtime.getObject(), .);
          runtime.setProcStatus(process_status);
          
          RubyModule process_uid = process.defineModuleUnder("UID");
          runtime.setProcUID(process_uid);
          
          RubyModule process_gid = process.defineModuleUnder("GID");
          runtime.setProcGID(process_gid);
          
          RubyModule process_sys = process.defineModuleUnder("Sys");
          runtime.setProcSys(process_sys);
          
          process.defineAnnotatedMethods(RubyProcess.class);
          process_status.defineAnnotatedMethods(RubyStatus.class);
          process_uid.defineAnnotatedMethods(UserID.class);
          process_gid.defineAnnotatedMethods(GroupID.class);
          process_sys.defineAnnotatedMethods(Sys.class);
  
          runtime.loadConstantSet(processjnr.constants.platform.PRIO.class);
          runtime.loadConstantSet(processjnr.constants.platform.RLIM.class);
          runtime.loadConstantSet(processjnr.constants.platform.RLIMIT.class);
          
          process.defineConstant("WNOHANG"runtime.newFixnum(1));
          process.defineConstant("WUNTRACED"runtime.newFixnum(2));
          
          return process;
      }
      
      @JRubyClass(name="Process::Status")
      public static class RubyStatus extends RubyObject {
          private final long status;
          private final long pid;
          
         private static final long EXIT_SUCCESS = 0L;
         public RubyStatus(Ruby runtimeRubyClass metaClasslong statuslong pid) {
             super(runtimemetaClass);
             this. = status;
             this. = pid;
         }
         
         public static RubyStatus newProcessStatus(Ruby runtimelong statuslong pid) {
             return new RubyStatus(runtimeruntime.getProcStatus(), statuspid);
         }
         
         // Bunch of methods still not implemented
         @JRubyMethod(name = "to_int")
         public IRubyObject not_implemented() {
             String error = "Process::Status#to_int not implemented";
             throw getRuntime().newNotImplementedError(error);
         }
 
         @JRubyMethod(name = "stopped?")
         public IRubyObject not_implemented0() {
             String error = "Process::Status#stopped? not implemented";
             throw getRuntime().newNotImplementedError(error);
         }
         
         @JRubyMethod(name = {"&"})
         public IRubyObject not_implemented1(IRubyObject arg) {
             String error = "Process::Status#& not implemented";
             throw getRuntime().newNotImplementedError(error);
         }
         
         @JRubyMethod
         public IRubyObject exitstatus() {
             return getRuntime().newFixnum();
         }
 
         @JRubyMethod(name = {"exited?"})
         public IRubyObject exited() {
             return RubyBoolean.newBoolean(getRuntime(), ( == 0));
         }
 
         @JRubyMethod(name = {"signaled?"})
         public IRubyObject signaled() {
             return RubyBoolean.newBoolean(getRuntime(), ( > 0));
         }
 
         @JRubyMethod(name = {"termsig"})
         public IRubyObject termsig() {
             return RubyFixnum.newFixnum(getRuntime(),  & 0x7f);
         }
 
         @JRubyMethod(name = {"stopsig"})
         public IRubyObject stopsig() {
             return RubyFixnum.newFixnum(getRuntime(), );
         }
 
         @Deprecated
         public IRubyObject op_rshift(IRubyObject other) {
             return op_rshift(getRuntime(), other);
         }
         @JRubyMethod(name = ">>")
         public IRubyObject op_rshift(ThreadContext contextIRubyObject other) {
             return op_rshift(context.runtimeother);
         }
         public IRubyObject op_rshift(Ruby runtimeIRubyObject other) {
             long shiftValue = other.convertToInteger().getLongValue();
             return runtime.newFixnum( >> shiftValue);
         }
 
         @Override
         @JRubyMethod(name = "==")
         public IRubyObject op_equal(ThreadContext contextIRubyObject other) {
             return invokedynamic(contextotherthis.to_i(context.runtime));
         }
         
         @Deprecated
         public IRubyObject to_i() {
             return to_i(getRuntime());
         }
         @JRubyMethod
         public IRubyObject to_i(ThreadContext context) {
             return to_i(context.runtime);
         }
         public IRubyObject to_i(Ruby runtime) {
             return runtime.newFixnum(shiftedValue());
         }
         
         @Override
         public IRubyObject to_s() {
             return to_s(getRuntime());
         }
         @JRubyMethod
         public IRubyObject to_s(ThreadContext context) {
             return to_s(context.runtime);
         }
         public IRubyObject to_s(Ruby runtime) {
             return runtime.newString(String.valueOf(shiftedValue()));
         }
         
         @Override
         public IRubyObject inspect() {
             return inspect(getRuntime());
         }
         @JRubyMethod
         public IRubyObject inspect(ThreadContext context) {
             return inspect(context.runtime);
         }
         public IRubyObject inspect(Ruby runtime) {
             return runtime.newString("#<Process::Status: pid=" +  + ",exited(" + String.valueOf() + ")>");
         }
         
         @JRubyMethod(name = "success?")
         public IRubyObject success_p(ThreadContext context) {
             return context.runtime.newBoolean( == );
         }
 
         @JRubyMethod(name = "coredump?")
         public IRubyObject coredump_p(ThreadContext context) {
             // Temporarily return false until a backend can be implemented
             // to copy the CRuby behavior (checking WCOREDUMP)
             return context.runtime.getFalse();
         }
         
         @JRubyMethod
         public IRubyObject pid(ThreadContext context) {
             return context.runtime.newFixnum();
         }
         
         private long shiftedValue() {
             return  << 8;
         }
     }
 
     @JRubyModule(name="Process::UID")
     public static class UserID {
         @JRubyMethod(name = "change_privilege", module = true)
         public static IRubyObject change_privilege(IRubyObject selfIRubyObject arg) {
             throw self.getRuntime().newNotImplementedError("Process::UID::change_privilege not implemented yet");
         }
         
         @Deprecated
         public static IRubyObject eid(IRubyObject self) {
             return euid(self.getRuntime());
         }
         @JRubyMethod(name = "eid", module = true)
         public static IRubyObject eid(ThreadContext contextIRubyObject self) {
             return euid(context.runtime);
         }
 
         @Deprecated
         public static IRubyObject eid(IRubyObject selfIRubyObject arg) {
             return eid(self.getRuntime(), arg);
         }
         @JRubyMethod(name = "eid=", module = true)
         public static IRubyObject eid(ThreadContext contextIRubyObject selfIRubyObject arg) {
             return eid(context.runtimearg);
         }
         public static IRubyObject eid(Ruby runtimeIRubyObject arg) {
             return euid_set(runtimearg);
         }
         
         @JRubyMethod(name = "grant_privilege", module = true)
         public static IRubyObject grant_privilege(IRubyObject selfIRubyObject arg) {
             throw self.getRuntime().newNotImplementedError("Process::UID::grant_privilege not implemented yet");
         }
         
         @JRubyMethod(name = "re_exchange", module = true)
         public static IRubyObject re_exchange(ThreadContext contextIRubyObject self) {
             return switch_rb(contextself.);
         }
         
         @JRubyMethod(name = "re_exchangeable?", module = true)
         public static IRubyObject re_exchangeable_p(IRubyObject self) {
             throw self.getRuntime().newNotImplementedError("Process::UID::re_exchangeable? not implemented yet");
         }
 
         @Deprecated
         public static IRubyObject rid(IRubyObject self) {
             return rid(self.getRuntime());
         }
         @JRubyMethod(name = "rid", module = true)
         public static IRubyObject rid(ThreadContext contextIRubyObject self) {
             return rid(context.runtime);
         }
         public static IRubyObject rid(Ruby runtime) {
             return uid(runtime);
         }
         
         @JRubyMethod(name = "sid_available?", module = true)
         public static IRubyObject sid_available_p(IRubyObject self) {
             throw self.getRuntime().newNotImplementedError("Process::UID::sid_available not implemented yet");
         }
         
         @JRubyMethod(name = "switch", module = true, visibility = )
         public static IRubyObject switch_rb(ThreadContext contextIRubyObject selfBlock block) {
             Ruby runtime = context.runtime;
             int uid = checkErrno(runtimeruntime.getPosix().getuid());
             int euid = checkErrno(runtimeruntime.getPosix().geteuid());
             
             if (block.isGiven()) {
                 try {
                     checkErrno(runtimeruntime.getPosix().seteuid(uid));
                     checkErrno(runtimeruntime.getPosix().setuid(euid));
                     
                     return block.yield(contextruntime.getNil());
                 } finally {
                     checkErrno(runtimeruntime.getPosix().seteuid(euid));
                     checkErrno(runtimeruntime.getPosix().setuid(uid));
                 }
             } else {
                 checkErrno(runtimeruntime.getPosix().seteuid(uid));
                 checkErrno(runtimeruntime.getPosix().setuid(euid));
                 
                 return RubyFixnum.zero(runtime);
             }
         }
     }
     
     @JRubyModule(name="Process::GID")
     public static class GroupID {
         @JRubyMethod(name = "change_privilege", module = true)
         public static IRubyObject change_privilege(IRubyObject selfIRubyObject arg) {
             throw self.getRuntime().newNotImplementedError("Process::GID::change_privilege not implemented yet");
         }
 
         @Deprecated
         public static IRubyObject eid(IRubyObject self) {
             return eid(self.getRuntime());
         }
         @JRubyMethod(name = "eid", module = true)
         public static IRubyObject eid(ThreadContext contextIRubyObject self) {
             return eid(context.runtime);
         }
         public static IRubyObject eid(Ruby runtime) {
             return egid(runtime);
         }
 
         @Deprecated
         public static IRubyObject eid(IRubyObject selfIRubyObject arg) {
             return eid(self.getRuntime(), arg);
         }
         @JRubyMethod(name = "eid=", module = true)
         public static IRubyObject eid(ThreadContext contextIRubyObject selfIRubyObject arg) {
             return eid(context.runtimearg);
         }
         public static IRubyObject eid(Ruby runtimeIRubyObject arg) {
             return RubyProcess.egid_set(runtimearg);
         }
         
         @JRubyMethod(name = "grant_privilege", module = true)
         public static IRubyObject grant_privilege(IRubyObject selfIRubyObject arg) {
             throw self.getRuntime().newNotImplementedError("Process::GID::grant_privilege not implemented yet");
         }
         
         @JRubyMethod(name = "re_exchange", module = true)
         public static IRubyObject re_exchange(ThreadContext contextIRubyObject self) {
             return switch_rb(contextself.);
         }
         
         @JRubyMethod(name = "re_exchangeable?", module = true)
         public static IRubyObject re_exchangeable_p(IRubyObject self) {
             throw self.getRuntime().newNotImplementedError("Process::GID::re_exchangeable? not implemented yet");
         }
 
         @Deprecated
         public static IRubyObject rid(IRubyObject self) {
             return rid(self.getRuntime());
         }
         @JRubyMethod(name = "rid", module = true)
         public static IRubyObject rid(ThreadContext contextIRubyObject self) {
             return rid(context.runtime);
         }
         public static IRubyObject rid(Ruby runtime) {
             return gid(runtime);
         }
         
         @JRubyMethod(name = "sid_available?", module = true)
         public static IRubyObject sid_available_p(IRubyObject self) {
             throw self.getRuntime().newNotImplementedError("Process::GID::sid_available not implemented yet");
         }
         
         @JRubyMethod(name = "switch", module = true, visibility = )
         public static IRubyObject switch_rb(ThreadContext contextIRubyObject selfBlock block) {
             Ruby runtime = context.runtime;
             int gid = checkErrno(runtimeruntime.getPosix().getgid());
             int egid = checkErrno(runtimeruntime.getPosix().getegid());
             
             if (block.isGiven()) {
                 try {
                     checkErrno(runtimeruntime.getPosix().setegid(gid));
                     checkErrno(runtimeruntime.getPosix().setgid(egid));
                     
                     return block.yield(contextruntime.getNil());
                 } finally {
                     checkErrno(runtimeruntime.getPosix().setegid(egid));
                     checkErrno(runtimeruntime.getPosix().setgid(gid));
                 }
             } else {
                 checkErrno(runtimeruntime.getPosix().setegid(gid));
                 checkErrno(runtimeruntime.getPosix().setgid(egid));
                 
                 return RubyFixnum.zero(runtime);
             }
         }
     }
     
     @JRubyModule(name="Process::Sys")
     public static class Sys {
         @Deprecated
         public static IRubyObject getegid(IRubyObject self) {
             return egid(self.getRuntime());
         }
         @JRubyMethod(name = "getegid", module = true, visibility = )
         public static IRubyObject getegid(ThreadContext contextIRubyObject self) {
             return egid(context.runtime);
         }
         
         @Deprecated
         public static IRubyObject geteuid(IRubyObject self) {
             return euid(self.getRuntime());
         }
         @JRubyMethod(name = "geteuid", module = true, visibility = )
         public static IRubyObject geteuid(ThreadContext contextIRubyObject self) {
             return euid(context.runtime);
         }
 
         @Deprecated
         public static IRubyObject getgid(IRubyObject self) {
             return gid(self.getRuntime());
         }
         @JRubyMethod(name = "getgid", module = true, visibility = )
         public static IRubyObject getgid(ThreadContext contextIRubyObject self) {
             return gid(context.runtime);
         }
 
         @Deprecated
         public static IRubyObject getuid(IRubyObject self) {
             return uid(self.getRuntime());
         }
         @JRubyMethod(name = "getuid", module = true, visibility = )
         public static IRubyObject getuid(ThreadContext contextIRubyObject self) {
             return uid(context.runtime);
         }
 
         @Deprecated
         public static IRubyObject setegid(IRubyObject recvIRubyObject arg) {
             return egid_set(recv.getRuntime(), arg);
         }
         @JRubyMethod(name = "setegid", module = true, visibility = )
         public static IRubyObject setegid(ThreadContext contextIRubyObject recvIRubyObject arg) {
             return egid_set(context.runtimearg);
         }
 
         @Deprecated
         public static IRubyObject seteuid(IRubyObject recvIRubyObject arg) {
             return euid_set(recv.getRuntime(), arg);
         }
         @JRubyMethod(name = "seteuid", module = true, visibility = )
         public static IRubyObject seteuid(ThreadContext contextIRubyObject recvIRubyObject arg) {
             return euid_set(context.runtimearg);
         }
 
         @Deprecated
         public static IRubyObject setgid(IRubyObject recvIRubyObject arg) {
             return gid_set(recv.getRuntime(), arg);
         }
         @JRubyMethod(name = "setgid", module = true, visibility = )
         public static IRubyObject setgid(ThreadContext contextIRubyObject recvIRubyObject arg) {
             return gid_set(context.runtimearg);
         }
 
         @Deprecated
         public static IRubyObject setuid(IRubyObject recvIRubyObject arg) {
             return uid_set(recv.getRuntime(), arg);
         }
         @JRubyMethod(name = "setuid", module = true, visibility = )
         public static IRubyObject setuid(ThreadContext contextIRubyObject recvIRubyObject arg) {
             return uid_set(context.runtimearg);
         }
     }
 
     @JRubyMethod(name = "abort", optional = 1, module = true, visibility = )
     public static IRubyObject abort(ThreadContext contextIRubyObject recvIRubyObject[] args) {
         return RubyKernel.abort(contextrecvargs);
     }
 
     @JRubyMethod(name = "exit!", optional = 1, module = true, visibility = )
     public static IRubyObject exit_bang(IRubyObject recvIRubyObject[] args) {
         return RubyKernel.exit_bang(recvargs);
     }
 
     @JRubyMethod(name = "groups", module = true, visibility = )
     public static IRubyObject groups(IRubyObject recv) {
         throw recv.getRuntime().newNotImplementedError("Process#groups not yet implemented");
     }
 
     @JRubyMethod(name = "setrlimit", rest = true, module = true, visibility = )
     public static IRubyObject setrlimit(IRubyObject recvIRubyObject[] args) {
         throw recv.getRuntime().newNotImplementedError("Process#setrlimit not yet implemented");
     }
 
     @Deprecated
     public static IRubyObject getpgrp(IRubyObject recv) {
         return getpgrp(recv.getRuntime());
     }
     @JRubyMethod(name = "getpgrp", module = true, visibility = )
     public static IRubyObject getpgrp(ThreadContext contextIRubyObject recv) {
         return getpgrp(context.runtime);
     }
     public static IRubyObject getpgrp(Ruby runtime) {
         return runtime.newFixnum(runtime.getPosix().getpgrp());
     }
 
     @JRubyMethod(name = "groups=", required = 1, module = true, visibility = )
     public static IRubyObject groups_set(IRubyObject recvIRubyObject arg) {
         throw recv.getRuntime().newNotImplementedError("Process#groups not yet implemented");
     }
 
     @Deprecated
     public static IRubyObject waitpid(IRubyObject recvIRubyObject[] args) {
         return waitpid(recv.getRuntime(), args);
     }
     @JRubyMethod(name = "waitpid", rest = true, module = true, visibility = )
     public static IRubyObject waitpid(ThreadContext contextIRubyObject recvIRubyObject[] args) {
         return waitpid(context.runtimeargs);
     }
     public static IRubyObject waitpid(Ruby runtimeIRubyObject[] args) {
         int pid = -1;
         int flags = 0;
         if (args.length > 0) {
             pid = (int)args[0].convertToInteger().getLongValue();
         }
         if (args.length > 1) {
             flags = (int)args[1].convertToInteger().getLongValue();
         }
         
         int[] status = new int[1];
         runtime.getPosix().errno(0);
         pid = runtime.getPosix().waitpid(pidstatusflags);
         raiseErrnoIfSet(runtime);
         
         runtime.getCurrentContext().setLastExitStatus(RubyProcess.RubyStatus.newProcessStatus(runtime, (status[0] >> 8) & 0xff, pid));
         return runtime.newFixnum(pid);
     }
 
     private interface NonNativeErrno {
         public int handle(Ruby runtimeint result);
     }
 
     private static final NonNativeErrno ECHILD = new NonNativeErrno() {
         public int handle(Ruby runtimeint result) {
             throw runtime.newErrnoECHILDError();
         }
     };
 
     @Deprecated
     public static IRubyObject wait(IRubyObject recvIRubyObject[] args) {
         return wait(recv.getRuntime(), args);
     }
     @JRubyMethod(name = "wait", rest = true, module = true, visibility = )
     public static IRubyObject wait(ThreadContext contextIRubyObject recvIRubyObject[] args) {
         return wait(context.runtimeargs);
     }
     public static IRubyObject wait(Ruby runtimeIRubyObject[] args) {
         
         if (args.length > 0) {
             return waitpid(runtimeargs);
         }
         
         int[] status = new int[1];
         runtime.getPosix().errno(0);
         int pid = runtime.getPosix().wait(status);
         raiseErrnoIfSet(runtime);
         
         runtime.getCurrentContext().setLastExitStatus(RubyProcess.RubyStatus.newProcessStatus(runtime, (status[0] >> 8) & 0xff, pid));
         return runtime.newFixnum(pid);
     }
 
 
     @Deprecated
     public static IRubyObject waitall(IRubyObject recv) {
         return waitall(recv.getRuntime());
     }
     @JRubyMethod(name = "waitall", module = true, visibility = )
     public static IRubyObject waitall(ThreadContext contextIRubyObject recv) {
         return waitall(context.runtime);
     }
     public static IRubyObject waitall(Ruby runtime) {
         POSIX posix = runtime.getPosix();
         RubyArray results = runtime.newArray();
         
         int[] status = new int[1];
         int result = posix.wait(status);
         while (result != -1) {
             results.append(runtime.newArray(runtime.newFixnum(result), RubyProcess.RubyStatus.newProcessStatus(runtime, (status[0] >> 8) & 0xff, result)));
             result = posix.wait(status);
         }
         
         return results;
     }
 
     @Deprecated
     public static IRubyObject setsid(IRubyObject recv) {
         return setsid(recv.getRuntime());
     }
     @JRubyMethod(name = "setsid", module = true, visibility = )
     public static IRubyObject setsid(ThreadContext contextIRubyObject recv) {
         return setsid(context.runtime);
     }
     public static IRubyObject setsid(Ruby runtime) {
         return runtime.newFixnum(checkErrno(runtimeruntime.getPosix().setsid()));
     }
 
     @Deprecated
     public static IRubyObject setpgrp(IRubyObject recv) {
         return setpgrp(recv.getRuntime());
     }
     @JRubyMethod(name = "setpgrp", module = true, visibility = )
     public static IRubyObject setpgrp(ThreadContext contextIRubyObject recv) {
         return setpgrp(context.runtime);
     }
     public static IRubyObject setpgrp(Ruby runtime) {
         return runtime.newFixnum(checkErrno(runtimeruntime.getPosix().setpgid(0, 0)));
     }
 
     @Deprecated
     public static IRubyObject egid_set(IRubyObject recvIRubyObject arg) {
         return egid_set(recv.getRuntime(), arg);
     }
     @JRubyMethod(name = "egid=", required = 1, module = true, visibility = )
     public static IRubyObject egid_set(ThreadContext contextIRubyObject recvIRubyObject arg) {
         return egid_set(context.runtimearg);
     }
     public static IRubyObject egid_set(Ruby runtimeIRubyObject arg) {
         checkErrno(runtimeruntime.getPosix().setegid((int)arg.convertToInteger().getLongValue()));
         return RubyFixnum.zero(runtime);
     }
 
     @Deprecated
     public static IRubyObject euid(IRubyObject recv) {
         return euid(recv.getRuntime());
     }
     @JRubyMethod(name = "euid", module = true, visibility = )
     public static IRubyObject euid(ThreadContext contextIRubyObject recv) {
         return euid(context.runtime);
     }
     public static IRubyObject euid(Ruby runtime) {
         return runtime.newFixnum(checkErrno(runtimeruntime.getPosix().geteuid()));
     }
 
     @Deprecated
     public static IRubyObject uid_set(IRubyObject recvIRubyObject arg) {
         return uid_set(recv.getRuntime(), arg);
     }
     @JRubyMethod(name = "uid=", required = 1, module = true, visibility = )
     public static IRubyObject uid_set(ThreadContext contextIRubyObject recvIRubyObject arg) {
         return uid_set(context.runtimearg);
     }
     public static IRubyObject uid_set(Ruby runtimeIRubyObject arg) {
         checkErrno(runtimeruntime.getPosix().setuid((int)arg.convertToInteger().getLongValue()));
         return RubyFixnum.zero(runtime);
     }
 
     @Deprecated
     public static IRubyObject gid(IRubyObject recv) {
         return gid(recv.getRuntime());
     }
     @JRubyMethod(name = "gid", module = true, visibility = )
     public static IRubyObject gid(ThreadContext contextIRubyObject recv) {
         return gid(context.runtime);
     }
     public static IRubyObject gid(Ruby runtime) {
         if (.) {
             // MRI behavior on Windows
             return RubyFixnum.zero(runtime);
         }
         return runtime.newFixnum(checkErrno(runtimeruntime.getPosix().getgid()));
     }
 
     @JRubyMethod(name = "maxgroups", module = true, visibility = )
     public static IRubyObject maxgroups(IRubyObject recv) {
         throw recv.getRuntime().newNotImplementedError("Process#maxgroups not yet implemented");
     }
 
     @Deprecated
     public static IRubyObject getpriority(IRubyObject recvIRubyObject arg1IRubyObject arg2) {
         return getpriority(recv.getRuntime(), arg1arg2);
     }
     @JRubyMethod(name = "getpriority", required = 2, module = true, visibility = )
     public static IRubyObject getpriority(ThreadContext contextIRubyObject recvIRubyObject arg1IRubyObject arg2) {
         return getpriority(context.runtimearg1arg2);
     }
     public static IRubyObject getpriority(Ruby runtimeIRubyObject arg1IRubyObject arg2) {
         int which = (int)arg1.convertToInteger().getLongValue();
         int who = (int)arg2.convertToInteger().getLongValue();
         int result = checkErrno(runtimeruntime.getPosix().getpriority(whichwho));
         
         return runtime.newFixnum(result);
     }
 
     @Deprecated
     public static IRubyObject uid(IRubyObject recv) {
         return uid(recv.getRuntime());
     }
     @JRubyMethod(name = "uid", module = true, visibility = )
     public static IRubyObject uid(ThreadContext contextIRubyObject recv) {
         return uid(context.runtime);
     }
     public static IRubyObject uid(Ruby runtime) {
         return runtime.newFixnum(checkErrno(runtimeruntime.getPosix().getuid()));
     }
 
     @Deprecated
     public static IRubyObject waitpid2(IRubyObject recvIRubyObject[] args) {
         return waitpid2(recv.getRuntime(), args);
     }
     @JRubyMethod(name = "waitpid2", rest = true, module = true, visibility = )
     public static IRubyObject waitpid2(ThreadContext contextIRubyObject recvIRubyObject[] args) {
         return waitpid2(context.runtimeargs);
     }
     public static IRubyObject waitpid2(Ruby runtimeIRubyObject[] args) {
         int pid = -1;
         int flags = 0;
         if (args.length > 0) {
             pid = (int)args[0].convertToInteger().getLongValue();
         }
         if (args.length > 1) {
             flags = (int)args[1].convertToInteger().getLongValue();
         }
         
         int[] status = new int[1];
         pid = checkErrno(runtimeruntime.getPosix().waitpid(pidstatusflags), );
         
         return runtime.newArray(runtime.newFixnum(pid), RubyProcess.RubyStatus.newProcessStatus(runtime, (status[0] >> 8) & 0xff, pid));
     }
 
     @JRubyMethod(name = "initgroups", required = 2, module = true, visibility = )
     public static IRubyObject initgroups(IRubyObject recvIRubyObject arg1IRubyObject arg2) {
         throw recv.getRuntime().newNotImplementedError("Process#initgroups not yet implemented");
     }
 
     @JRubyMethod(name = "maxgroups=", required = 1, module = true, visibility = )
     public static IRubyObject maxgroups_set(IRubyObject recvIRubyObject arg) {
         throw recv.getRuntime().newNotImplementedError("Process#maxgroups_set not yet implemented");
     }
 
     @Deprecated
     public static IRubyObject ppid(IRubyObject recv) {
         return ppid(recv.getRuntime());
     }
     @JRubyMethod(name = "ppid", module = true, visibility = )
     public static IRubyObject ppid(ThreadContext contextIRubyObject recv) {
         return ppid(context.runtime);
     }
     public static IRubyObject ppid(Ruby runtime) {
         int result = checkErrno(runtimeruntime.getPosix().getppid());
 
         return runtime.newFixnum(result);
     }
 
     @Deprecated
     public static IRubyObject gid_set(IRubyObject recvIRubyObject arg) {
         return gid_set(recv.getRuntime(), arg);
     }
     @JRubyMethod(name = "gid=", required = 1, module = true, visibility = )
     public static IRubyObject gid_set(ThreadContext contextIRubyObject recvIRubyObject arg) {
         return gid_set(context.runtimearg);
     }
     public static IRubyObject gid_set(Ruby runtimeIRubyObject arg) {
         int result = checkErrno(runtimeruntime.getPosix().setgid((int)arg.convertToInteger().getLongValue()));
 
         return runtime.newFixnum(result);
     }
 
     @Deprecated
     public static IRubyObject wait2(IRubyObject recvIRubyObject[] args) {
         return waitpid2(recv.getRuntime(), args);
     }
     @JRubyMethod(name = "wait2", rest = true, module = true, visibility = )
     public static IRubyObject wait2(ThreadContext contextIRubyObject recvIRubyObject[] args) {
         return waitpid2(context.runtimeargs);
     }
 
     @Deprecated
     public static IRubyObject euid_set(IRubyObject recvIRubyObject arg) {
         return euid_set(recv.getRuntime(), arg);
     }
     @JRubyMethod(name = "euid=", required = 1, module = true, visibility = )
     public static IRubyObject euid_set(ThreadContext contextIRubyObject recvIRubyObject arg) {
         return euid_set(context.runtimearg);
     }
     public static IRubyObject euid_set(Ruby runtimeIRubyObject arg) {
         checkErrno(runtimeruntime.getPosix().seteuid((int)arg.convertToInteger().getLongValue()));
         return RubyFixnum.zero(runtime);
     }
 
     @Deprecated
     public static IRubyObject setpriority(IRubyObject recvIRubyObject arg1IRubyObject arg2IRubyObject arg3) {
         return setpriority(recv.getRuntime(), arg1arg2arg3);
     }
     @JRubyMethod(name = "setpriority", required = 3, module = true, visibility = )
     public static IRubyObject setpriority(ThreadContext contextIRubyObject recvIRubyObject arg1IRubyObject arg2IRubyObject arg3) {
         return setpriority(context.runtimearg1arg2arg3);
     }
     public static IRubyObject setpriority(Ruby runtimeIRubyObject arg1IRubyObject arg2IRubyObject arg3) {
         int which = (int)arg1.convertToInteger().getLongValue();
         int who = (int)arg2.convertToInteger().getLongValue();
         int prio = (int)arg3.convertToInteger().getLongValue();
         runtime.getPosix().errno(0);
         int result = checkErrno(runtimeruntime.getPosix().setpriority(whichwhoprio));
         
         return runtime.newFixnum(result);
     }
 
     @Deprecated
     public static IRubyObject setpgid(IRubyObject recvIRubyObject arg1IRubyObject arg2) {
         return setpgid(recv.getRuntime(), arg1arg2);
     }
     @JRubyMethod(name = "setpgid", required = 2, module = true, visibility = )
     public static IRubyObject setpgid(ThreadContext contextIRubyObject recvIRubyObject arg1IRubyObject arg2) {
         return setpgid(context.runtimearg1arg2);
     }
     public static IRubyObject setpgid(Ruby runtimeIRubyObject arg1IRubyObject arg2) {
         int pid = (int)arg1.convertToInteger().getLongValue();
         int gid = (int)arg2.convertToInteger().getLongValue();
         return runtime.newFixnum(checkErrno(runtimeruntime.getPosix().setpgid(pidgid)));
     }
 
     @Deprecated
     public static IRubyObject getpgid(IRubyObject recvIRubyObject arg) {
         return getpgid(recv.getRuntime(), arg);
     }
     @JRubyMethod(name = "getpgid", required = 1, module = true, visibility = )
     public static IRubyObject getpgid(ThreadContext contextIRubyObject recvIRubyObject arg) {
         return getpgid(context.runtimearg);
     }
     public static IRubyObject getpgid(Ruby runtimeIRubyObject arg) {
         return runtime.newFixnum(checkErrno(runtimeruntime.getPosix().getpgid((int)arg.convertToInteger().getLongValue())));
     }
 
     @Deprecated
     public static IRubyObject getrlimit(IRubyObject recvIRubyObject arg) {
         return getrlimit(recv.getRuntime(), arg);
     }
     @JRubyMethod(name = "getrlimit", required = 1, module = true, visibility = )
     public static IRubyObject getrlimit(ThreadContext contextIRubyObject recvIRubyObject arg) {
         return getrlimit(context.runtimearg);
     }
     public static IRubyObject getrlimit(Ruby runtimeIRubyObject arg) {
         throw runtime.newNotImplementedError("Process#getrlimit not yet implemented");
     }
 
     @Deprecated
     public static IRubyObject egid(IRubyObject recv) {
         return egid(recv.getRuntime());
     }
     @JRubyMethod(name = "egid", module = true, visibility = )
     public static IRubyObject egid(ThreadContext contextIRubyObject recv) {
         return egid(context.runtime);
     }
     public static IRubyObject egid(Ruby runtime) {
         if (.) {
             // MRI behavior on Windows
             return RubyFixnum.zero(runtime);
         }
         return runtime.newFixnum(checkErrno(runtimeruntime.getPosix().getegid()));
     }
     
     private static int parseSignalString(Ruby runtimeString value) {
         boolean negative = value.startsWith("-");
 
         // Gets rid of the - if there is one present.
         if (negativevalue = value.substring(1);
 
         // We need the SIG for sure.
         String signalName = value.startsWith("SIG") ? value : "SIG" + value;
 
         try {
             int signalValue = Signal.valueOf(signalName).intValue();
             return negative ? -signalValue : signalValue;
 
         } catch (IllegalArgumentException ex) {
             throw runtime.newArgumentError("unsupported name `" + signalName + "'");
         }
     }
 	
     public static interface Kernel32  {
         jnr.ffi.Pointer OpenProcess(int dwDesiredAccessint bInheritHandleint dwProcessId);
 		int CloseHandle(jnr.ffi.Pointer handle);
 		int GetLastError();
 		int