class SystemCallError - Documentation for Ruby 4.0
Description: class SystemCallError: SystemCallError is the base class for all low-level platform-dependent errors. The errors available on the current platform are subclasses of SystemCa
Keywords: ruby,class,SystemCallError

🔍

No recent searches

# class SystemCallError

`SystemCallError` is the base class for all low-level platform-dependent errors.

The errors available on the current platform are subclasses of `SystemCallError` and are defined in the `Errno` module.

    File.open("does/not/exist")

raises the exception:

    Errno::ENOENT: No such file or directory - does/not/exist

### Public Class Methods

system_call_error === other → true or false
Source

    static VALUE
    syserr_eqq(VALUE self, VALUE exc)
    {
        VALUE num, e;

        if (!rb_obj_is_kind_of(exc, rb_eSystemCallError)) {
            if (!rb_respond_to(exc, id_errno)) return Qfalse;
        }
        else if (self == rb_eSystemCallError) return Qtrue;

        num = rb_attr_get(exc, id_errno);
        if (NIL_P(num)) {
            num = rb_funcallv(exc, id_errno, 0, 0);
        }
        e = rb_const_get(self, id_Errno);
        return RBOOL(FIXNUM_P(num) ? num == e : rb_equal(num, e));
    }

Return `true` if the receiver is a generic `SystemCallError`, or if the error numbers `self` and other are the same.

new(msg, errno = nil, func = nil) → system_call_error_subclass
Source

    static VALUE
    syserr_initialize(int argc, VALUE *argv, VALUE self)
    {
        const char *err;
        VALUE mesg, error, func, errmsg;
        VALUE klass = rb_obj_class(self);

        if (klass == rb_eSystemCallError) {
            st_data_t data = (st_data_t)klass;
            rb_scan_args(argc, argv, "12", &mesg, &error, &func);
            if (argc == 1 && FIXNUM_P(mesg)) {
                error = mesg; mesg = Qnil;
            }
            if (!NIL_P(error) && st_lookup(syserr_tbl, NUM2LONG(error), &data)) {
                klass = (VALUE)data;
                /* change class */
                if (!RB_TYPE_P(self, T_OBJECT)) { /* insurance to avoid type crash */
                    rb_raise(rb_eTypeError, "invalid instance type");
                }
                RBASIC_SET_CLASS(self, klass);
            }
        }
        else {
            rb_scan_args(argc, argv, "02", &mesg, &func);
            error = rb_const_get(klass, id_Errno);
        }
        if (!NIL_P(error)) err = strerror(NUM2INT(error));
        else err = "unknown error";

        errmsg = rb_enc_str_new_cstr(err, rb_locale_encoding());
        if (!NIL_P(mesg)) {
            VALUE str = StringValue(mesg);

            if (!NIL_P(func)) rb_str_catf(errmsg, " @ %"PRIsVALUE, func);
            rb_str_catf(errmsg, " - %"PRIsVALUE, str);
        }
        mesg = errmsg;

        rb_call_super(1, &mesg);
        rb_ivar_set(self, id_errno, error);
        return self;
    }

If errno corresponds to a known system error code, constructs the appropriate `Errno` class for that error, otherwise constructs a generic `SystemCallError` object. The error number is subsequently available via the `errno` method.

If only numeric object is given, it is treated as an `Integer` errno, and msg is omitted, otherwise the first argument msg is used as the additional error message.

    SystemCallError.new(Errno::EPIPE::Errno)
    #=> #<Errno::EPIPE: Broken pipe>

    SystemCallError.new("foo")
    #=> #<SystemCallError: unknown error - foo>

    SystemCallError.new("foo", Errno::EPIPE::Errno)
    #=> #<Errno::EPIPE: Broken pipe - foo>

If func is not `nil`, it is appended to the message with “`@` ”.

    SystemCallError.new("foo", Errno::EPIPE::Errno, "here")
    #=> #<Errno::EPIPE: Broken pipe @ here - foo>

A subclass of `SystemCallError` can also be instantiated via the `new` method of the subclass. See `Errno`.

### Public Instance Methods

errno → integer
Source

    static VALUE
    syserr_errno(VALUE self)
    {
        return rb_attr_get(self, id_errno);
    }

Return this SystemCallError’s error number.