Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.jruby;
  
  import java.util.List;
  import java.util.Map;
  import java.util.HashMap;
  
 import static org.jruby.runtime.Visibility.*;
 
 
 @JRubyClass(name="SystemCallError", parent="StandardError")
 public class RubySystemCallError extends RubyException {
     private IRubyObject errno = getRuntime().getNil();
 
     private final static Map<StringStringdefaultMessages = new HashMap<StringString>();
     static {
         // FIXME: these descriptions should probably be moved out,
         // to Constantine project which deals with all platform-dependent constants.
         .put("Errno::EPERM""Operation not permitted");
         .put("Errno::ENOENT""No such file or directory");
         .put("Errno::ESRCH""No such process");
         .put("Errno::EINTR""Interrupted system call");
         .put("Errno::EIO""Input/output error");
         .put("Errno::ENXIO""Device not configured");
         .put("Errno::E2BIG""Argument list too long");
         .put("Errno::ENOEXEC""Exec format error");
         .put("Errno::EBADF""Bad file descriptor");
         .put("Errno::ECHILD""No child processes");
         .put("Errno::EDEADLK""Resource deadlock avoided");
         .put("Errno::ENOMEM""Cannot allocate memory");
         .put("Errno::EACCES""Permission denied");
         .put("Errno::EFAULT""Bad address");
         .put("Errno::ENOTBLK""Block device required");
         .put("Errno::EBUSY""Resource busy");
         .put("Errno::EEXIST""File exists");
         .put("Errno::EXDEV""Cross-device link");
         .put("Errno::ENODEV""Operation not supported by device");
         .put("Errno::ENOTDIR""Not a directory");
         .put("Errno::EISDIR""Is a directory");
         .put("Errno::EINVAL""Invalid argument");
         .put("Errno::ENFILE""Too many open files in system");
         .put("Errno::EMFILE""Too many open files");
         .put("Errno::ENOTTY""Inappropriate ioctl for device");
         .put("Errno::ETXTBSY""Text file busy");
         .put("Errno::EFBIG""File too large");
         .put("Errno::ENOSPC""No space left on device");
         .put("Errno::ESPIPE""Illegal seek");
         .put("Errno::EROFS""Read-only file system");
         .put("Errno::EMLINK""Too many links");
         .put("Errno::EPIPE""Broken pipe");
         .put("Errno::EDOM""Numerical argument out of domain");
         .put("Errno::ERANGE""Result too large");
         .put("Errno::EAGAIN""Resource temporarily unavailable");
         .put("Errno::EWOULDBLOCK""Resource temporarily unavailable");
         .put("Errno::EINPROGRESS""Operation now in progress");
         .put("Errno::EALREADY""Operation already in progress");
         .put("Errno::ENOTSOCK""Socket operation on non-socket");
         .put("Errno::EDESTADDRREQ""Destination address required");
         .put("Errno::EMSGSIZE""Message too long");
         .put("Errno::EPROTOTYPE""Protocol wrong type for socket");
         .put("Errno::ENOPROTOOPT""Protocol not available");
         .put("Errno::EPROTONOSUPPORT""Protocol not supported");
         .put("Errno::ESOCKTNOSUPPORT""Socket type not supported");
         .put("Errno::EPFNOSUPPORT""Protocol family not supported");
         .put("Errno::EAFNOSUPPORT""Address family not supported by protocol family");
         .put("Errno::EADDRINUSE""Address already in use");
         .put("Errno::EADDRNOTAVAIL""Can't assign requested address");
         .put("Errno::ENETDOWN""Network is down");
         .put("Errno::ENETUNREACH""Network is unreachable");
         .put("Errno::ENETRESET""Network dropped connection on reset");
         .put("Errno::ECONNABORTED""Software caused connection abort");
         .put("Errno::ECONNRESET""Connection reset by peer");
         .put("Errno::ENOBUFS""No buffer space available");
         .put("Errno::EISCONN""Socket is already connected");
         .put("Errno::ENOTCONN""Socket is not connected");
         .put("Errno::ESHUTDOWN""Can't send after socket shutdown");
         .put("Errno::ETOOMANYREFS""Too many references: can't splice");
         .put("Errno::ETIMEDOUT""Operation timed out");
         .put("Errno::ECONNREFUSED""Connection refused");
         .put("Errno::ELOOP""Too many levels of symbolic links");
         .put("Errno::ENAMETOOLONG""File name too long");
         .put("Errno::EHOSTDOWN""Host is down");
         .put("Errno::EHOSTUNREACH""No route to host");
         .put("Errno::ENOTEMPTY""Directory not empty");
         .put("Errno::EUSERS""Too many users");
         .put("Errno::EDQUOT""Disc quota exceeded");
        .put("Errno::ESTALE""Stale NFS file handle");
        .put("Errno::EREMOTE""Too many levels of remote in path");
        .put("Errno::ENOLCK""No locks available");
        .put("Errno::ENOSYS""Function not implemented");
        .put("Errno::EOVERFLOW""Value too large to be stored in data type");
        .put("Errno::EIDRM""Identifier removed");
        .put("Errno::ENOMSG""No message of desired type");
        .put("Errno::EILSEQ""Illegal byte sequence");
        .put("Errno::EBADMSG""Bad message");
        .put("Errno::EMULTIHOP""EMULTIHOP (Reserved)");
        .put("Errno::ENODATA""No message available on STREAM");
        .put("Errno::ENOLINK""ENOLINK (Reserved)");
        .put("Errno::ENOSR""No STREAM resources");
        .put("Errno::ENOSTR""Not a STREAM");
        .put("Errno::EPROTO""Protocol error");
        .put("Errno::ETIME""STREAM ioctl timeout");
        .put("Errno::EOPNOTSUPP""Operation not supported");
        .put("Errno::EOPNOTSUPP_DARWIN""Operation not supported");
    }
    protected RubySystemCallError(Ruby runtimeRubyClass rubyClass) {
        super(runtimerubyClassnull);
    }
    public RubySystemCallError(Ruby runtimeRubyClass rubyClassString messageint errno) {
        super(runtimerubyClassmessage);
        this. = runtime.newFixnum(errno);
    }
    private static ObjectAllocator SYSTEM_CALL_ERROR_ALLOCATOR = new ObjectAllocator() {
        public IRubyObject allocate(Ruby runtimeRubyClass klass) {
            RubyException instance = new RubySystemCallError(runtimeklass);
            
            instance.setMetaClass(klass);
            
            return instance;
        }
    };
    
    private static final ObjectMarshal SYSTEM_CALL_ERROR_MARSHAL = new ObjectMarshal() {
        public void marshalTo(Ruby runtimeObject objRubyClass type,
                              MarshalStream marshalStreamthrows IOException {
            RubySystemCallError exc = (RubySystemCallErrorobj;
            marshalStream.registerLinkTarget(exc);
            
            List<Variable<Object>> attrs = exc.getVariableList();
            attrs.add(new VariableEntry<Object>(
                    "mesg"exc.message == null ? runtime.getNil() : exc.message));
            attrs.add(new VariableEntry<Object>("errno"exc.errno));
            attrs.add(new VariableEntry<Object>("bt"exc.getBacktrace()));
            marshalStream.dumpVariables(attrs);
        }
        public Object unmarshalFrom(Ruby runtimeRubyClass type,
            UnmarshalStream unmarshalStreamthrows IOException {
            RubySystemCallError exc = (RubySystemCallErrortype.allocate();
            
            unmarshalStream.registerLinkTarget(exc);
            // FIXME: Can't just pull these off the wire directly? Or maybe we should
            // just use real vars all the time for these?
            unmarshalStream.defaultVariablesUnmarshal(exc);
            
            exc.message = (IRubyObject)exc.removeInternalVariable("mesg");
            exc.errno = (IRubyObject)exc.removeInternalVariable("errno");
            exc.set_backtrace((IRubyObject)exc.removeInternalVariable("bt"));
            
            return exc;
        }
    };
    public static RubyClass createSystemCallErrorClass(Ruby runtimeRubyClass standardError) {
        RubyClass exceptionClass = runtime.defineClass("SystemCallError"standardError);
        exceptionClass.setMarshal();
        
        runtime.callbackFactory(RubyClass.class);
        exceptionClass.defineAnnotatedMethods(RubySystemCallError.class);
        return exceptionClass;
    }
    
    @JRubyMethod(optional = 2, required=0, visibility = )
    public IRubyObject initialize(IRubyObject[] argsBlock block) {
        Ruby runtime = getRuntime();
        RubyClass sCallErorrClass = runtime.getSystemCallError();
        RubyClass klass = getMetaClass().getRealClass();
        IRubyObject msg = runtime.getNil();
        IRubyObject err = runtime.getNil();
        boolean isErrnoClass = !klass.equals(sCallErorrClass);
        if (!isErrnoClass) {
            // one optional, one required args
            Arity.checkArgumentCount(runtimeargs, 1, 2);
            msg = args[0];
            if (args.length == 2) {
                err = args[1];
            }
            if (args.length == 1 && (msg instanceof RubyFixnum)) {
                err = msg;
                msg = runtime.getNil();
            }
        } else {
            // one optional and no required args
            Arity.checkArgumentCount(runtimeargs, 0, 1);
            if (args.length == 1) {
                msg = args[0];
            }
            // try to get errno value out of the class
            err = klass.getConstant("Errno");
        }
        String val = null;
        if (!err.isNil()) {
             = err.convertToInteger();
            int errnoVal = RubyNumeric.num2int();
            if (Errno.valueOf(errnoVal) != .) {
                // we got a valid errno value
                isErrnoClass = true;
                // set the metaclass to an Errno, if something other than SystemCallError or Errno wasn't provided
                if ( == runtime.getSystemCallError() ||
                         == runtime.getErrno()) {
                    setMetaClass(runtime.getErrno(errnoVal));
                }
                
                klass = getMetaClass().getRealClass();
                // FIXME: Errno descriptions from Constantine
                // on Windows are not useful at the moment.
                if (!.) {
                  val = Errno.valueOf(errnoVal).description();
                }
            }
        }
        if (val == null) {
            val = .get(klass.getName());
            if (val == null) {
                val = "Unknown error";
            }
        }
        // MRI behavior: we don't print errno for actual Errno errors
        if (!.isNil() && !isErrnoClass) {
            val += " " + .toString();
        }
        if (!msg.isNil()) {
            val += " - " + msg.convertToString();
        }
         = runtime.newString(val);
        return this;
    }
    public IRubyObject errno() {
        return ;
    }
New to GrepCode? Check out our FAQ X