/** * * Prints out an error message. * * @param exception An Exception thrown by JRuby */ private static void printException(Ruby runtime, Exception exception) { assert exception != null; if (exception instanceof RaiseException) runtime.printError(((RaiseException)exception).getException()); }
/** * @param exceptionClass * @param message * @return */ public RaiseException newRaiseException(RubyClass exceptionClass, String message) { return new RaiseException(this, exceptionClass, message, true); }
/** * Method still in use by jruby-openssl <= 0.5.2 */ public static RaiseException createNativeRaiseException(Ruby runtime, Throwable cause) { return createNativeRaiseException(runtime, cause, null); }
public static IRubyObject rewriteStackTraceAndThrow(Throwable t, Ruby runtime) { RaiseException rewriteStackTrace = RaiseException.createNativeRaiseException(runtime, t); t.setStackTrace(rewriteStackTrace.getStackTrace()); throwException(t); // not reached return null; } }
public RaiseException(Throwable cause, NativeException nativeException) { super(buildMessage(cause), cause); providedMessage = buildMessage(cause); setException(nativeException, true); preRaise(nativeException.getRuntime().getCurrentContext(), nativeException.getCause().getStackTrace()); setStackTrace(javaTraceFromRubyTrace(exception.getBacktraceElements())); }
private void preRaise(ThreadContext context, StackTraceElement[] javaTrace) { context.runtime.incrementExceptionCount(); doSetLastError(context); doCallEventHook(context); if (RubyInstanceConfig.LOG_EXCEPTIONS) TraceType.logException(exception); if (requiresBacktrace(context)) { exception.prepareIntegratedBacktrace(context, javaTrace); } }
private void preRaise(ThreadContext context, IRubyObject backtrace) { context.runtime.incrementExceptionCount(); doSetLastError(context); doCallEventHook(context); if (RubyInstanceConfig.LOG_EXCEPTIONS) TraceType.logException(exception); // We can only omit backtraces of descendents of Standard error for 'foo rescue nil' if (requiresBacktrace(context)) { if (backtrace == null) { exception.prepareBacktrace(context); } else { exception.forceBacktrace(backtrace); if ( backtrace.isNil() ) return; } setStackTrace(RaiseException.javaTraceFromRubyTrace(exception.getBacktraceElements())); } }
public static RubyRegexp newRegexp(Ruby runtime, ByteList pattern, RegexpOptions options) { try { return new RubyRegexp(runtime, pattern, options.clone()); } catch (RaiseException re) { throw runtime.newSyntaxError(re.getMessage()); } }
public IRubyObject call() throws Exception { ThreadContext context = runtime.getCurrentContext(); try { return body.call(context); } catch (RaiseException re) { RubyKernel.puts(context, body.getBinding().getSelf(), new IRubyObject[] { RubyString.newString(runtime, "joroutine terminated with error: " + re.getMessage())}); RubyKernel.puts(context, body.getBinding().getSelf(), new IRubyObject[] {re.getException().backtrace()}); throw re; } }
protected RaiseException(String message, RubyException exception) { super(message); setException(exception); preRaise(exception.getRuntime().getCurrentContext()); }
protected void warnCircularRequire(String requireName) { runtime.getWarnings().warn("loading in progress, circular require considered harmful - " + requireName); // it's a hack for c:rb_backtrace impl. // We should introduce new method to Ruby.TraceType when rb_backtrace is widely used not only for this purpose. RaiseException ex = new RaiseException(runtime, runtime.getRuntimeError(), null, false); String trace = runtime.getInstanceConfig().getTraceType().printBacktrace(ex.getException(), runtime.getPosix().isatty(FileDescriptor.err)); // rb_backtrace dumps to stderr directly. System.err.print(trace.replaceFirst("[^\n]*\n", "")); }
private static RaiseException initCause(final RaiseException ex, final Throwable cause) { ex.initCause(cause); return ex; }
private void preRaise(ThreadContext context, StackTraceElement[] javaTrace) { context.runtime.incrementExceptionCount(); doSetLastError(context); doCallEventHook(context); exception.prepareIntegratedBacktrace(context, javaTrace); if (RubyInstanceConfig.LOG_EXCEPTIONS) TraceType.dumpException(exception); }
private void preRaise(ThreadContext context) { preRaise(context, (IRubyObject) null); }
@Deprecated // un-used public static void rewriteStackTrace(final Ruby runtime, final Throwable e) { final StackTraceElement[] javaTrace = e.getStackTrace(); BacktraceData backtraceData = runtime.getInstanceConfig().getTraceType().getIntegratedBacktrace(runtime.getCurrentContext(), javaTrace); e.setStackTrace(RaiseException.javaTraceFromRubyTrace(backtraceData.getBacktrace(runtime))); }
public RaiseException(Throwable cause, NativeException nativeException) { super(buildMessage(cause), cause); providedMessage = buildMessage(cause); setException(nativeException, true); preRaise(nativeException.getRuntime().getCurrentContext(), nativeException.getCause().getStackTrace()); setStackTrace(javaTraceFromRubyTrace(exception.getBacktraceElements())); }
private void preRaise(ThreadContext context, IRubyObject backtrace) { context.runtime.incrementExceptionCount(); doSetLastError(context); doCallEventHook(context); if (RubyInstanceConfig.LOG_EXCEPTIONS) TraceType.logException(exception); // We can only omit backtraces of descendents of Standard error for 'foo rescue nil' if (requiresBacktrace(context)) { if (backtrace == null) { exception.prepareBacktrace(context); } else { exception.forceBacktrace(backtrace); if ( backtrace.isNil() ) return; } setStackTrace(RaiseException.javaTraceFromRubyTrace(exception.getBacktraceElements())); } }
public static RubyRegexp newRegexp(Ruby runtime, ByteList pattern, RegexpOptions options) { try { return new RubyRegexp(runtime, pattern, (RegexpOptions)options.clone()); } catch (RaiseException re) { throw runtime.newSyntaxError(re.getMessage()); } }
protected RaiseException(String message, RubyException exception) { super(message); setException(exception); preRaise(exception.getRuntime().getCurrentContext()); }
protected void warnCircularRequire(String requireName) { runtime.getWarnings().warn("loading in progress, circular require considered harmful - " + requireName); // it's a hack for c:rb_backtrace impl. // We should introduce new method to Ruby.TraceType when rb_backtrace is widely used not only for this purpose. RaiseException ex = new RaiseException(runtime, runtime.getRuntimeError(), null, false); String trace = runtime.getInstanceConfig().getTraceType().printBacktrace(ex.getException(), runtime.getPosix().isatty(FileDescriptor.err)); // rb_backtrace dumps to stderr directly. System.err.print(trace.replaceFirst("[^\n]*\n", "")); }