class SystemCallError
SystemCallError ist die Basisklasse für alle plattformabhängigen Low-Level-Fehler.
Die auf der aktuellen Plattform verfügbaren Fehler sind Unterklassen von SystemCallError und werden im Errno-Modul definiert.
File.open("does/not/exist")
löst die Ausnahme aus
Errno::ENOENT: No such file or directory - does/not/exist
Öffentliche Klassenmethoden
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));
}
Gibt true zurück, wenn der Empfänger eine generische SystemCallError ist oder wenn die Fehlercodes von self und other identisch sind.
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;
}
Wenn errno einem bekannten Systemfehlercode entspricht, wird die entsprechende Errno-Klasse für diesen Fehler konstruiert, andernfalls wird ein generisches SystemCallError-Objekt konstruiert. Die Fehlernummer ist anschließend über die Methode errno verfügbar.
Wenn nur ein numerisches Objekt angegeben wird, wird es als Integer errno behandelt und msg weggelassen. Andernfalls wird das erste Argument msg als zusätzliche Fehlermeldung verwendet.
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>
Wenn func nicht nil ist, wird es mit “ @ ” an die Meldung angehängt.
SystemCallError.new("foo", Errno::EPIPE::Errno, "here") #=> #<Errno::EPIPE: Broken pipe @ here - foo>
Eine Unterklasse von SystemCallError kann auch über die new-Methode der Unterklasse instanziiert werden. Siehe Errno.
Öffentliche Instanzmethoden
Source
static VALUE
syserr_errno(VALUE self)
{
return rb_attr_get(self, id_errno);
}
Gibt die Fehlernummer dieses SystemCallError zurück.