@JRubyMethod(required = 1) 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 = obj; } return backtrace(); }
static String exceptionMessage(final RaiseException e) { if (e != null) { StringBuilder st = new StringBuilder(); st.append(e.getException().toString()).append('\n'); ByteArrayOutputStream b = new ByteArrayOutputStream(); e.getException().printBacktrace(new PrintStream(b)); st.append(b.toString()); return st.toString(); } else { return null; } }
protected static String printBacktraceJRuby(RubyException exception, boolean console) { final Ruby runtime = exception.getRuntime(); final ThreadContext context = runtime.getCurrentContext(); boolean color = console && runtime.getInstanceConfig().getBacktraceColor(); // exception line String message; try { message = exception.callMethod(context, "message").toString(); } catch (org.jruby.exceptions.Exception unused) { message = exception.message(context).toString(); } if (exception.getMetaClass() == runtime.getRuntimeError() && message.length() == 0) { message = "No current exception"; } String type = exception.getMetaClass().getName(); return printBacktraceJRuby(exception.getRuntime(), exception.getBacktraceElements(), type, message, color); }
public IRubyObject allocate(Ruby runtime, RubyClass klass) { RubyException instance = new RubyException(runtime, klass); // for future compatibility as constructors move toward not accepting metaclass? instance.setMetaClass(klass); return instance; } };
public static RaiseException from(Ruby runtime, RubyClass excptnClass, String msg) { return RubyException.newException(runtime, excptnClass, msg).toThrowable(); }
@JRubyMethod(required = 1) public IRubyObject set_backtrace(IRubyObject obj) { setBacktrace(obj); return backtrace(); }
protected static String printBacktraceMRI(RubyException exception, boolean console) { Ruby runtime = exception.getRuntime(); ThreadContext context = runtime.getCurrentContext(); IRubyObject backtrace = exception.callMethod(context, "backtrace"); RubyClass type = exception.getMetaClass(); String info = exception.toString(); exception.printBacktrace(errorStream, 1);
@Override public String getMessage() { if (providedMessage == null) { providedMessage = '(' + exception.getMetaClass().getBaseName() + ") " + exception.message(exception.getRuntime().getCurrentContext()).asJavaString(); } return providedMessage; }
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 void exceptionRaised(RaiseException exception) { assert isCurrent(); RubyException rubyException = exception.getException(); Ruby runtime = rubyException.getRuntime(); if (runtime.getSystemExit().isInstance(rubyException)) { runtime.getThreadService().getMainThread().raise(new IRubyObject[] {rubyException}, Block.NULL_BLOCK); } else if (abortOnException(runtime)) { RubyException systemExit; if (!runtime.is1_9()) { runtime.printError(rubyException); String message = rubyException.message.convertToString().toString(); systemExit = RubySystemExit.newInstance(runtime, 1, message); systemExit.set_backtrace(rubyException.backtrace()); } else { systemExit = rubyException; } runtime.getThreadService().getMainThread().raise(new IRubyObject[] {systemExit}, Block.NULL_BLOCK); return; } else if (runtime.getDebug().isTrue()) { runtime.printError(exception.getException()); } exitingException = exception; }
@Override @JRubyMethod(name = "==") public RubyBoolean op_equal(ThreadContext context, IRubyObject other) { if (this == other) return context.tru; boolean equal = context.runtime.getException().isInstance(other) && getMetaClass().getRealClass() == other.getMetaClass().getRealClass() && callMethod(context, "message").equals(other.callMethod(context, "message")) && callMethod(context, "backtrace").equals(other.callMethod(context, "backtrace")); return context.runtime.newBoolean(equal); }
private static void dumpThread(Ruby ruby, RubyThread th, Gather gather, PrintWriter pw) { pw.println("Thread: " + th.getNativeThread().getName()); pw.println("Stack:"); ThreadContext tc = th.getContext(); if (tc != null) { RubyException exc = new RubyException(ruby, ruby.getRuntimeError(), "thread dump"); exc.setBacktraceData(gather.getBacktraceData(tc, th.getNativeThread().getStackTrace())); pw.println(Format.MRI.printBacktrace(exc, false)); } else { pw.println(" [no longer alive]"); } pw.println(); }
static RaiseException newGzipFileError(Ruby runtime, String klass, String message) { RubyClass errorClass = runtime.getModule("Zlib").getClass("GzipFile").getClass(klass); RubyException excn = RubyException.newException(runtime, errorClass, message); // TODO: not yet supported. rewrite GzipReader/Writer with Inflate/Deflate? excn.setInstanceVariable("@input", runtime.getNil()); return excn.toThrowable(); }
private static void printExceptionSummary(ThreadContext context, Ruby runtime, RubyException rEx) { RubyStackTraceElement[] elements = rEx.getBacktraceElements(); RubyStackTraceElement firstElement = elements.length > 0 ? elements[0] : new RubyStackTraceElement("", "", "(empty)", 0, false); String msg = String.format("Exception `%s' at %s:%s - %s\n", rEx.getMetaClass(), firstElement.getFileName(), firstElement.getLineNumber(), runtime.is1_9() ? TypeConverter.convertToType(rEx, runtime.getString(), "to_s") : rEx.convertToString().toString()); runtime.getErrorStream().print(msg); }
/** * Attempts to interpret the given exception in a Ruby context. * * @param inE an <code>Exception</code> * @return a <code>String</code> describing the exception's contents */ static String exceptionAsString(Exception inE) { RaiseException raiseException = null; if(inE instanceof RaiseException) { raiseException = (RaiseException)inE; } else if(inE instanceof BSFException && ((BSFException)inE).getTargetException() instanceof RaiseException) { raiseException = (RaiseException)((BSFException)inE).getTargetException(); } if(raiseException != null) { return String.format("%s %s", //$NON-NLS-1$ raiseException.getException().toString(), raiseException.getException().backtrace().toString()); } return inE.toString(); } /* (non-Javadoc)
/** * Print the Ruby exception's backtrace to the given PrintStream. This * version accepts a number of lines to skip and is primarily used * internally for exception printing where the first line is treated specially. * * @param errorStream the PrintStream to which backtrace should be printed */ public void printBacktrace(PrintStream errorStream, int skip) { IRubyObject backtrace = callMethod(getRuntime().getCurrentContext(), "backtrace"); if (!backtrace.isNil() && backtrace instanceof RubyArray) { IRubyObject[] elements = backtrace.convertToArray().toJavaArray(); for (int i = skip; i < elements.length; i++) { IRubyObject stackTraceLine = elements[i]; if (stackTraceLine instanceof RubyString) { printStackTraceLine(errorStream, stackTraceLine); } } } }
} else { raise = ((RubyException) lastException).toThrowable(); raise = ((RubyException) runtime.getRuntimeError().newInstance(context, args, block)).toThrowable(); } else { raise = convertToException(context, args[0], null).toThrowable(); raise = convertToException(context, args[0], args[1]).toThrowable(); break; default: RubyException exception = convertToException(context, args[0], args[1]); exception.forceBacktrace(args[2]); raise = exception.toThrowable(); break; if (forceCause || argc > 0 && raise.getException().getCause() == null && cause != raise.getException()) { raise.getException().setCause(cause);
@JRubyMethod(name = "to_s", compat = CompatVersion.RUBY1_8) public IRubyObject to_s(ThreadContext context) { if (message.isNil()) { return context.runtime.newString(getMetaClass().getRealClass().getName()); } message.setTaint(isTaint()); return message; }
public IRubyObject backtrace() { IRubyObject rubyTrace = super.backtrace(); if (rubyTrace.isNil()) { return rubyTrace; } RubyArray array = (RubyArray) rubyTrace.dup(); StackTraceElement[] stackTrace = cause.getStackTrace(); for (int i = stackTrace.length - 1; i >= 0; i--) { StackTraceElement element = stackTrace[i]; String className = element.getClassName(); String line = null; if (element.getFileName() == null) { line = className + ":" + element.getLineNumber() + ":in `" + element.getMethodName() + "'"; } else { int index = className.lastIndexOf("."); String packageName = null; if (index == -1) { packageName = ""; } else { packageName = className.substring(0, index) + "/"; } line = packageName.replace(".", "/") + element.getFileName() + ":" + element.getLineNumber() + ":in `" + element.getMethodName() + "'"; } RubyString string = runtime.newString(line); array.unshift(string); } return array; }
private static RaiseException newMemcachedError(Ruby ruby, String klass, String message) { RubyClass errorClass = ruby.getModule("Memcached").getClass(klass); return new RaiseException(RubyException.newException(ruby, errorClass, message), true); } }