protected RubyException(Ruby runtime,
    RubyClass rubyClass) 
{
         
        this(runtime, rubyClass, null);
}

 public RubyException(Ruby runtime,
    RubyClass rubyClass,
    String message) 
{
        super(runtime, rubyClass);
        this.message = message == null ? runtime.getNil() : runtime.newString(message);
}

 public IRubyObject backtrace() 
{
        return getBacktrace();
}

 public static RubyClass createExceptionClass(Ruby runtime) 
{
         
        RubyClass exceptionClass = runtime.defineClass("Exception", runtime.getObject(), EXCEPTION_ALLOCATOR);
        runtime.setException(exceptionClass);
        exceptionClass.setMarshal(EXCEPTION_MARSHAL);
        exceptionClass.defineAnnotatedMethods(RubyException.class);
        return exceptionClass;
}

 public RubyException exception(IRubyObject[] args) 
{
        switch (args.length) {
            case 0 :
                return this;
            case 1 :
                if(args[0] == this) {
                    return this;
                }
                RubyException ret = (RubyException)rbClone();
                ret.initialize(args, Block.NULL_BLOCK); // This looks wrong, but it's the way MRI does it.
                return ret;
            default :
                throw getRuntime().newArgumentError("Wrong argument count");
        }
}

 public static IRubyObject exception(ThreadContext context,
    IRubyObject recv,
    IRubyObject[] args,
    Block block) 
{
        return ((RubyClass) recv).newInstance(context, args, block);
}

 public IRubyObject getBacktrace() 
{
        if (backtrace == null) {
            backtrace = backtraceFrames == null ? getRuntime().getNil() : ThreadContext.createBacktraceFromFrames(getRuntime(), backtraceFrames);
        }
        return backtrace;
}

 public IRubyObject initialize(IRubyObject[] args,
    Block block) 
{
        if (args.length == 1) message = args[0];
        return this;
}

 public IRubyObject inspect(ThreadContext context) 
{
        RubyModule rubyClass = getMetaClass();
        RubyString exception = RubyString.objAsString(context, this);
        if (exception.getByteList().realSize == 0) return getRuntime().newString(rubyClass.getName());
        StringBuilder sb = new StringBuilder("#< ");
        sb.append(rubyClass.getName()).append(": ").append(exception.getByteList()).append(" >");
        return getRuntime().newString(sb.toString());
}

inspects an object and return a kind of debug information

 public static RubyException newException(Ruby runtime,
    RubyClass excptnClass,
    String msg) 
{
        return new RubyException(runtime, excptnClass, msg);
}

 public  void printBacktrace(PrintStream errorStream) 
{
        IRubyObject backtrace = callMethod(getRuntime().getCurrentContext(), "backtrace");
        if (!backtrace.isNil() && backtrace instanceof RubyArray) {
            IRubyObject[] elements = ((RubyArray)backtrace.convertToArray()).toJavaArray();
            for (int i = 1; i <  elements.length; i++) {
                IRubyObject stackTraceLine = elements[i];
                    if (stackTraceLine instanceof RubyString) {
                    printStackTraceLine(errorStream, stackTraceLine);
                }
                if (i == RubyException.TRACE_HEAD && elements.length  > RubyException.TRACE_MAX) {
                    int hiddenLevels = elements.length - RubyException.TRACE_HEAD - RubyException.TRACE_TAIL;
                            errorStream.print("\t ... " + hiddenLevels + " levels...\n");
                    i = elements.length - RubyException.TRACE_TAIL;
                }
            }
            }
}

 public  void setBacktraceFrames(Frame[] backtraceFrames) 
{
        this.backtraceFrames = backtraceFrames;
}

 public IRubyObject set_backtrace(IRubyObject obj) 
{
        if (obj.isNil()) {
            backtrace = null;
        } else if (!isArrayOfStrings(obj)) {
            throw getRuntime().newTypeError("backtrace must be Array of String");
        } else {
            backtrace = (RubyArray) obj;
        }
        return backtrace();
}

 public IRubyObject to_s() 
{
        if (message.isNil()) return getRuntime().newString(getMetaClass().getName());
        message.setTaint(isTaint());
        return message;
}

 public IRubyObject to_str(ThreadContext context) 
{
        return callMethod(context, MethodIndex.TO_S, "to_s");
}