Descendents of class Exceptionare used to communicate between raisemethods and rescuestatements in begin/endblocks. Exceptionobjects carry information about the exception—its type (the exception's class name), an optional descriptive string, and optional traceback information. Programs may subclass Exceptionto add additional information.

Methods
B
E
I
M
N
S
T
Y
Class Public methods
exc.exception(string) → an_exception or exc

With no argument, or if the argument is the same as the receiver, return the receiver. Otherwise, create a new exception object of the same class as the receiver, but with a message equal to string.to_str.

Exception.new(msg = nil) => exception

Construct a new Exception object, optionally passing in a message.

static VALUE
exc_initialize(argc, argv, exc)
    int argc;
    VALUE *argv;
    VALUE exc;
{
    VALUE arg;
    rb_scan_args(argc, argv, "01", &arg);
    rb_iv_set(exc, "mesg", arg);
    rb_iv_set(exc, "bt", Qnil);
    return exc;
}
yaml_new( klass, tag, val )
# File lib/yaml/rubytypes.rb, line 119
def Exception.yaml_new( klass, tag, val )
    o = YAML.object_maker( klass, { 'mesg' => val.delete( 'message' ) } )
    val.each_pair do |k,v|
        o.instance_variable_set("@#{k}", v)
    end
    o
end
Instance Public methods
exception.backtrace => array

Returns any backtrace associated with the exception. The backtrace is an array of strings, each containing either “filename:lineNo: in `method''' or “filename:lineNo.''

def a
  raise "boom"
end
def b
  a()
end
begin
  b()
rescue => detail
  print detail.backtrace.join("\n")
end

produces:

prog.rb:2:in `a'
prog.rb:6:in `b'
prog.rb:10
static VALUE
exc_backtrace(exc)
    VALUE exc;
{
    static ID bt;
    if (!bt) bt = rb_intern("bt");
    return rb_attr_get(exc, bt);
}
exc.exception(string) → an_exception or exc

With no argument, or if the argument is the same as the receiver, return the receiver. Otherwise, create a new exception object of the same class as the receiver, but with a message equal to string.to_str.

static VALUE
exc_exception(argc, argv, self)
    int argc;
    VALUE *argv;
    VALUE self;
{
    VALUE exc;
    if (argc == 0) return self;
    if (argc == 1 && self == argv[0]) return self;
    exc = rb_obj_clone(self);
    exc_initialize(argc, argv, exc);
    return exc;
}
exception.inspect => string

Return this exception's class name an message

static VALUE
exc_inspect(exc)
    VALUE exc;
{
    VALUE str, klass;
    klass = CLASS_OF(exc);
    exc = rb_obj_as_string(exc);
    if (RSTRING(exc)->len == 0) {
        return rb_str_dup(rb_class_name(klass));
    }
    str = rb_str_buf_new2("#<");
    klass = rb_class_name(klass);
    rb_str_buf_append(str, klass);
    rb_str_buf_cat(str, ": ", 2);
    rb_str_buf_append(str, exc);
    rb_str_buf_cat(str, ">", 1);
    return str;
}
exception.message => string exception.to_str => string

Returns the result of invoking exception.to_s. Normally this returns the exception's message or name. By supplying a #to_str method, exceptions are agreeing to be used where Strings are expected.

static VALUE
exc_to_str(exc)
    VALUE exc;
{
    return rb_funcall(exc, rb_intern("to_s"), 0, 0);
}
exc.set_backtrace(array) => array

Sets the backtrace information associated with exc. The argument must be an array of Stringobjects in the format described in Exception#backtrace.

static VALUE
exc_set_backtrace(exc, bt)
    VALUE exc;
    VALUE bt;
{
    return rb_iv_set(exc, "bt", rb_check_backtrace(bt));
}
exception.to_s => string

Returns exception's message (or the name of the exception if no message is set).

static VALUE
exc_to_s(exc)
    VALUE exc;
{
    VALUE mesg = rb_attr_get(exc, rb_intern("mesg"));
    if (NIL_P(mesg)) return rb_class_name(CLASS_OF(exc));
    return mesg;
}
exception.message => string exception.to_str => string

Returns the result of invoking exception.to_s. Normally this returns the exception's message or name. By supplying a #to_str method, exceptions are agreeing to be used where Strings are expected.

static VALUE
exc_to_str(exc)
    VALUE exc;
{
    return rb_funcall(exc, rb_intern("to_s"), 0, 0);
}
to_yaml( opts = {} )
# File lib/yaml/rubytypes.rb, line 126
def to_yaml( opts = {} )
        YAML::quick_emit( self, opts ) do |out|
    out.map( taguri, to_yaml_style ) do |map|
        map.add( 'message', message )
                        to_yaml_properties.each do |m|
            map.add( m[1..-1], instance_variable_get( m ) )
        end
    end
end
end