public RaiseException(RubyException actException) 
{
       
        this(actException, false);
}

 public RaiseException(RubyException exception,
    boolean isNativeException) 
{
        super();
        if (DEBUG) {
            Thread.dumpStack();
        }
        setException(exception, isNativeException);
}

 public RaiseException(Throwable cause,
    NativeException nativeException) 
{
        super(buildMessage(cause), cause);
        setException(nativeException, false);
}

 public RaiseException(Ruby runtime,
    RubyClass excptnClass,
    String msg,
    boolean nativeException) 
{
        super(msg);
        if (msg == null) {
            msg = "No message available";
        }
        if (DEBUG) {
            Thread.dumpStack();
        }
        setException((RubyException)RuntimeHelpers.invoke(
                runtime.getCurrentContext(),
                excptnClass,
                "new",
                RubyString.newUnicodeString(excptnClass.getRuntime(), msg)),
                nativeException);
}

 public static RaiseException createNativeRaiseException(Ruby runtime,
    Throwable cause) 
{
        NativeException nativeException = new NativeException(runtime, runtime.getClass(NativeException.CLASS_NAME), cause);
        return new RaiseException(cause, nativeException);
}

 public RubyException getException() 
{
        return exception;
}

Gets the exception

 public  void printStackTrace() 
{
        printStackTrace(System.err);
}

 public  void printStackTrace(PrintStream ps) 
{
        StackTraceElement[] trace = getStackTrace();
        int externalIndex = 0;
        for (int i = trace.length - 1; i  > 0; i--) {
            if (trace[i].getClassName().indexOf("org.jruby.evaluator")  >= 0) {
                break;
            }
            externalIndex = i;
        }
        IRubyObject backtrace = exception.backtrace();
        Ruby runtime = backtrace.getRuntime();
        if (runtime.getNil() != backtrace) {
            String firstLine = backtrace.callMethod(runtime.getCurrentContext(), "first").convertToString().toString();
            ps.print(firstLine + ": ");
        }
        ps.println(exception.message.convertToString() + " (" + exception.getMetaClass().toString() + ")");
        exception.printBacktrace(ps);
        ps.println("\t...internal jruby stack elided...");
        for (int i = externalIndex; i <  trace.length; i++) {
            ps.println("\tfrom " + trace[i].toString());
        }
}

 public  void printStackTrace(PrintWriter pw) 
{
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        printStackTrace(new PrintStream(baos));
        pw.print(baos.toString());
}

 protected  void setException(RubyException newException,
    boolean nativeException) 
{
        Ruby runtime = newException.getRuntime();
        ThreadContext context = runtime.getCurrentContext();
        if (!context.isWithinDefined()) {
            runtime.getGlobalVariables().set("$!", newException);
        }
        if (runtime.hasEventHooks()) {
            runtime.callEventHooks(
                    context,
                    RubyEvent.RAISE,
                    context.getFile(),
                    context.getLine(),
                    context.getFrameName(),
                    context.getFrameKlazz());
        }
        this.exception = newException;
        if (runtime.getStackTraces()  > 5) {
            return;
        }
        runtime.setStackTraces(runtime.getStackTraces() + 1);
        StackTraceElement[] stackTrace = context.createBacktrace2(0, nativeException);
        newException.setBacktraceFrames(stackTrace);
        // JRUBY-2673: if wrapping a NativeException, use the actual Java exception's trace as our Java trace
        if (newException instanceof NativeException) {
            setStackTrace(((NativeException)newException).getCause().getStackTrace());
        } else {
            setStackTrace(stackTrace);
        }
        runtime.setStackTraces(runtime.getStackTraces() - 1);
}

Sets the exception