a start of native<->Ruby error handling.

Jan Arne Petersen · Jan Arne Petersen · commit dee977db2a9a · 2002-07-14T23:00:31.000Z
git-svn-id: http://svn.codehaus.org/jruby/trunk/jruby@498 961051c9-f516-0410-bf72-c9f7e237a7b7
diff --git a/org/jruby/RubyJava.java b/org/jruby/RubyJava.java
@@ -8,6 +8,7 @@ public static RubyModule createJavaModule(Ruby ruby) {
 
         javaModule.defineModuleFunction("import", CallbackFactory.getSingletonMethod(RubyJava.class, "rbImport", RubyString.class));
         javaModule.defineModuleFunction("name", CallbackFactory.getSingletonMethod(RubyJava.class, "name", RubyString.class, RubyString.class));
+        javaModule.defineModuleFunction("define_exception_handler", CallbackFactory.getOptSingletonMethod(RubyJava.class, "define_exception_handler"));
 
         return javaModule;
     }
@@ -22,4 +23,17 @@ public static RubyObject name(Ruby ruby, RubyObject recv, RubyString javaName, R
 		ruby.getJavaSupport().rename(rubyName.getValue(), javaName.getValue());
         return recv;
     }
+
+    public static RubyObject define_exception_handler(Ruby ruby, RubyObject recv, RubyObject[] args) {
+        String name = args[0].toString();
+        RubyProc handler = null;
+        if (args.length > 1) {
+            handler = (RubyProc)args[1];
+        } else {
+            handler = RubyProc.newProc(ruby, ruby.getClasses().getProcClass());
+        }
+        ruby.getJavaSupport().defineExceptionHandler(name, handler);
+
+        return recv;
+    }
 }
diff --git a/org/jruby/javasupport/JavaMethod.java b/org/jruby/javasupport/JavaMethod.java
@@ -37,6 +37,7 @@
 import org.jruby.*;
 import org.jruby.exceptions.*;
 import org.jruby.runtime.*;
+import org.jruby.util.Asserts;
 
 /**
  *
@@ -83,27 +84,23 @@ public RubyObject execute(RubyObject recv, RubyObject[] args, Ruby ruby) {
             Object receiver = !singleton ? ((RubyJavaObject)recv).getValue() : null;
 
             return JavaUtil.convertJavaToRuby(ruby, method.invoke(receiver, newArgs));
-        } catch (Exception e) {
-            throw convertException(ruby, e);
+        } catch (InvocationTargetException itExcptn) {
+            convertException(ruby, (Exception)itExcptn.getTargetException());
+
+            return ruby.getNil();
+        } catch (Exception excptn) {
+            Asserts.assertNotReached();
+            return null;
         }
     }
 
-    private static RuntimeException convertException(Ruby ruby, Exception e) {
+    private static void convertException(Ruby ruby, Exception e) {
         if (e instanceof RaiseException) {
-            return (RaiseException) e;
+            throw (RaiseException) e;
         } else if (e instanceof IOException) {
-            return IOError.fromException(ruby, (IOException) e);
+            throw IOError.fromException(ruby, (IOException) e);
         } else {
-            StringWriter stackTrace = new StringWriter();
-            e.printStackTrace(new PrintWriter(stackTrace));
-
-            StringBuffer sb = new StringBuffer();
-            sb.append("Native Exception: '");
-            sb.append(e.getClass()).append("\'; Message: ");
-            sb.append(e.getMessage());
-            sb.append("; StackTrace: ");
-            sb.append(stackTrace.getBuffer().toString());
-            throw new RaiseException(ruby, "RuntimeError", sb.toString());
+            ruby.getJavaSupport().handleNativeException(e);
         }
     }
 
diff --git a/org/jruby/javasupport/JavaSupport.java b/org/jruby/javasupport/JavaSupport.java
@@ -1,17 +1,21 @@
 package org.jruby.javasupport;
 
+import java.io.PrintWriter;
+import java.io.StringWriter;
 import java.lang.reflect.*;
 import java.util.*;
 
 import org.jruby.*;
 import org.jruby.exceptions.NameError;
+import org.jruby.exceptions.RaiseException;
 
 public class JavaSupport {
     private Ruby ruby;
 
     private Map loadedJavaClasses = new HashMap();
     private List importedPackages = new ArrayList();
     private Map renamedJavaClasses = new HashMap();
+    private Map exceptionHandlers = new HashMap();
 
     private ClassLoader javaClassLoader = new ClassLoader() {};
 
@@ -282,4 +286,31 @@ public Class getJavaClass(RubyClass type) {
         }
         return null;
     }
+
+    public void defineExceptionHandler(String exceptionClass, RubyProc handler) {
+        exceptionHandlers.put(exceptionClass, handler);
+    }
+
+    public void handleNativeException(Exception excptn) {
+        Class excptnClass = excptn.getClass();
+        RubyProc handler = (RubyProc)exceptionHandlers.get(excptnClass.getName());
+        while (handler == null &&
+               excptnClass != Exception.class) {
+            excptnClass = excptnClass.getSuperclass();
+        }
+        if (handler != null) {
+            handler.call(new RubyObject[]{JavaUtil.convertJavaToRuby(ruby, excptn)});
+        } else {
+            StringWriter stackTrace = new StringWriter();
+            excptn.printStackTrace(new PrintWriter(stackTrace));
+
+            StringBuffer sb = new StringBuffer();
+            sb.append("Native Exception: '");
+            sb.append(excptn.getClass()).append("\'; Message: ");
+            sb.append(excptn.getMessage());
+            sb.append("; StackTrace: ");
+            sb.append(stackTrace.getBuffer().toString());
+            throw new RaiseException(ruby, "RuntimeError", sb.toString());
+        }
+    }
 }
diff --git a/org/jruby/runtime/ReflectionCallbackMethod.java b/org/jruby/runtime/ReflectionCallbackMethod.java
@@ -128,13 +128,10 @@ protected final RubyObject invokeMethod(
         } catch (InvocationTargetException itExcptn) {
             if (itExcptn.getTargetException() instanceof RaiseException) {
                 throw (RaiseException) itExcptn.getTargetException();
-            } else if (
-                itExcptn.getTargetException() instanceof RuntimeException) {
-                throw (RuntimeException) itExcptn.getTargetException();
+            } else if (itExcptn.getTargetException() instanceof JumpException) {
+                throw (JumpException) itExcptn.getTargetException();
             } else {
-                System.err.println(
-                    "[ERROR] Calling method: " + klass + "#" + method);
-                itExcptn.getTargetException().printStackTrace();
+                ruby.getJavaSupport().handleNativeException((Exception)itExcptn.getTargetException());
                 return ruby.getNil();
             }
         } catch (final IllegalAccessException iaExcptn) {
diff --git a/samples/error.rb b/samples/error.rb
@@ -0,0 +1,6 @@
+Java::define_exception_handler "java.lang.NumberFormatException" do |e|
+  puts e.type
+  puts e.message
+end
+
+Java::Lang::Integer.parseInt "23aa"
