This is an automated email from the git hooks/post-receive script.

js pushed a commit to tag 0.55
in repository libinline-java-perl.

commit 94f1f544ee43c32aafd9136bba13cf7c6a261a10
Author: Patrick LeBoutillier <p...@cpan.org>
Date:   Fri Dec 14 13:17:36 2001 +0000

    *** empty log message ***
---
 Java.pm           |  12 +++++--
 Java/Array.pm     |   4 +--
 Java/Callback.pm  |  51 ++++++++++++++++++++++++++--
 Java/Class.pm     |  38 +++++++++++++++------
 Java/Init.pm      | 100 ++++++++++++++++++++++++++++++++++++++++++------------
 Java/JNI.pm       |  30 +++++++++++++++-
 Java/JNI.xs       |  59 ++++++++++++++++++++++++++++++++
 Java/JVM.pm       |  50 ++++++++++++++-------------
 MANIFEST          |   5 ++-
 Makefile.PL       |   6 +++-
 t/03_objects.t    |   6 +++-
 t/12_exceptions.t |   5 ++-
 t/13_callbacks.t  |  49 +++++++++++++++++++++++---
 13 files changed, 341 insertions(+), 74 deletions(-)

diff --git a/Java.pm b/Java.pm
index 1cb0b68..7fee281 100644
--- a/Java.pm
+++ b/Java.pm
@@ -242,6 +242,12 @@ sub _validate {
 
        $o->set_java_bin() ;
 
+       # Moved the require here so that $Inline::Java::JNI::SO will
+       # be set in time for the generation of the Init.pm Java code.
+       if ($o->{ILSM}->{JNI}){
+               require Inline::Java::JNI ;
+       }
+
        Inline::Java::debug("validate done.") ;
 }
 
@@ -1364,9 +1370,11 @@ sub caught {
        if (($e)&&(UNIVERSAL::isa($e, "Inline::Java::Object"))){
                my ($msg, $score) = $e->__isa($class) ;
                if ($msg){
-                       croak $msg ;
+                       $ret = 0 ;
+               }
+               else{
+                       $ret = 1 ;
                }
-               $ret = 1 ;
        }
        $@ = $e ;
 
diff --git a/Java/Array.pm b/Java/Array.pm
index a670932..47c9c2b 100644
--- a/Java/Array.pm
+++ b/Java/Array.pm
@@ -636,8 +636,8 @@ __DATA__
 
 
 class InlineJavaArray {
-       InlineJavaServer ijs ;
-       InlineJavaClass ijc ;
+       private InlineJavaServer ijs ;
+       private InlineJavaClass ijc ;
 
 
        InlineJavaArray(InlineJavaServer _ijs, InlineJavaClass _ijc){
diff --git a/Java/Callback.pm b/Java/Callback.pm
index b1911f6..1c23638 100644
--- a/Java/Callback.pm
+++ b/Java/Callback.pm
@@ -9,13 +9,60 @@ $Inline::Java::Callback::VERSION = '0.31' ;
 use Carp ;
 
 
+sub InterceptCallback {
+       my $inline = shift ;
+       my $resp = shift ;
+
+       # With JNI we need to store the object somewhere since we
+       # can't drag it along all the wat through Java land...
+       if (! defined($inline)){ 
+               $inline = $Inline::Java::JNI::INLINE_HOOK ;
+       }
+
+       if ($resp =~ s/^callback (.*?) (\w+)//){
+               my $module = $1 ;
+               my $function = $2 ;
+               my @args = split(' ', $resp) ;
+               return Inline::Java::Callback::ProcessCallback($inline, 
$module, $function, @args) ;
+       }
+
+       croak "Malformed callback request from server: $resp" ;
+}
+
+
+sub ProcessCallback {
+       my $inline = shift ;
+       my $module = shift ;
+       my $function = shift ;
+       my @sargs = @_ ;
+
+       my $pc = new Inline::Java::Protocol(undef, $inline) ;
+       my @args = map {$pc->DeserializeObject(0, $_)} @sargs ;
+
+       Inline::Java::debug(" processing callback $module" . "::" . 
"$function(" . 
+               join(", ", @args) . ")") ;
+
+       no strict 'refs' ;
+       my $sub = "$module" . "::" . $function ;
+       my $ret = $sub->(@args) ;
+
+       ($ret) = $pc->ValidateArgs([$ret]) ;
+
+       return "callback $ret" ;
+}
+
+
 __DATA__
 
 /*
        Callback to Perl...
 */
 public class InlineJavaPerlCaller {
-       protected InlineJavaPerlCaller(){
+       public InlineJavaPerlCaller(){
+               if (InlineJavaServer.instance == null){
+                       System.err.println("Can't use InlineJavaPerlCaller 
outside of an Inline::Java context") ;
+                       System.err.flush() ;
+               }
        }
 
 
@@ -26,7 +73,7 @@ public class InlineJavaPerlCaller {
        }
 
 
-       protected Object CallPerl(String pkg, String method, Object args[]) 
throws InlineJavaPerlCallerException {
+       public Object CallPerl(String pkg, String method, Object args[]) throws 
InlineJavaPerlCallerException {
                try {
                        return InlineJavaServer.instance.Callback(pkg, method, 
args) ;
                }
diff --git a/Java/Class.pm b/Java/Class.pm
index abf9c15..b083fb6 100644
--- a/Java/Class.pm
+++ b/Java/Class.pm
@@ -493,8 +493,8 @@ package Inline::Java::Class ;
 __DATA__
 
 class InlineJavaClass {
-       InlineJavaServer ijs ;
-       InlineJavaProtocol ijp ;
+       private InlineJavaServer ijs ;
+       private InlineJavaProtocol ijp ;
 
        InlineJavaClass(InlineJavaServer _ijs, InlineJavaProtocol _ijp){
                ijs = _ijs ;
@@ -685,16 +685,34 @@ class InlineJavaClass {
                Returns the number of levels that separate a from b
        */
        int DoesExtend(Class a, Class b){
-               // We need to check if a extends b
-               Class parent = a ;
-               int level = 0 ;
-               while (parent != null){
+               return DoesExtend(a, b, 0) ;
+       }
+
+
+       int DoesExtend(Class a, Class b, int level){
+               ijs.debug("   checking if " + a.getName() + " extends " + 
b.getName()) ;
+
+               if (a == b){
+                       return level ;
+               }
+
+               Class parent = a.getSuperclass() ;
+               if (parent != null){
                        ijs.debug("    parent is " + parent.getName()) ;
-                       if (parent == b){
-                               return level ;
+                       int ret = DoesExtend(parent, b, level + 1) ;
+                       if (ret != -1){
+                               return ret ;
+                       }
+               }
+
+               // Maybe b is an interface a implements it?
+               Class inter[] = a.getInterfaces() ;
+               for (int i = 0 ; i < inter.length ; i++){
+                       ijs.debug("    interface is " + inter[i].getName()) ;
+                       int ret = DoesExtend(inter[i], b, level + 1) ;
+                       if (ret != -1){
+                               return ret ;
                        }
-                       level++ ;
-                       parent = parent.getSuperclass() ;
                }
 
                return -1 ;
diff --git a/Java/Init.pm b/Java/Init.pm
index 5eb53ef..4d234ad 100644
--- a/Java/Init.pm
+++ b/Java/Init.pm
@@ -36,6 +36,9 @@ sub DumpServerJavaCode {
        $java =~ s/<INLINE_JAVA_CLASS>/$java_class/g ;
        $java =~ s/<INLINE_JAVA_PROTOCOL>/$java_proto/g ;
 
+       my $so = $Inline::Java::JNI::SO || '' ;
+       $java =~ s/<INLINE_JAVA_JNI_SO>/$so/g ;
+
        print $fh $java ;
 }
 
@@ -96,6 +99,7 @@ public class InlineJavaServer {
                }
                catch (IOException e){
                        System.err.println("Can't open server socket on port " 
+ String.valueOf(port)) ;
+                       System.err.flush() ;
                        System.exit(1) ;
                }
 
@@ -114,6 +118,7 @@ public class InlineJavaServer {
                        }
                        catch (IOException e){
                                System.err.println("IO error: " + 
e.getMessage()) ;
+                               System.err.flush() ;
                        }
                }
 
@@ -131,6 +136,10 @@ public class InlineJavaServer {
                it's best if it doesn't throw any exceptions.
        */
        private String ProcessCommand(String cmd) {
+               return ProcessCommand(cmd, true) ;
+       }
+
+       private String ProcessCommand(String cmd, boolean addlf) {
                debug("  packet recv is " + cmd) ;
 
                String resp = null ;
@@ -139,12 +148,12 @@ public class InlineJavaServer {
                        try {
                                ijp.Do() ;
                                debug("  packet sent is " + ijp.response) ;
-                               resp = ijp.response + "\n" ;
+                               resp = ijp.response ;
                        }
                        catch (InlineJavaException e){
                                String err = "error scalar:" + 
ijp.unpack(e.getMessage()) ;
                                debug("  packet sent is " + err) ;
-                               resp = err + "\n" ;
+                               resp = err ;
                        }
                }
                else{
@@ -159,6 +168,10 @@ public class InlineJavaServer {
                        }
                }
 
+               if (addlf){
+                       resp = resp + "\n" ;
+               }
+
                return resp ;
        }
 
@@ -242,40 +255,65 @@ public class InlineJavaServer {
 
 
        public Object Callback(String pkg, String method, Object args[]) throws 
InlineJavaException {
+               Object ret = null ;
+
                try {
-                       Thread t = Thread.currentThread() ;
-                       if (t instanceof InlineJavaThread){
-                               // Client-server mode
-                               InlineJavaProtocol ijp = new 
InlineJavaProtocol(this, null) ;
-                               StringBuffer cmd = new StringBuffer("callback " 
+ pkg + " " + method) ;
-                               if (args != null){
-                                       for (int i = 0 ; i < args.length ; i++){
-                                                cmd.append(" " + 
ijp.SerializeObject(args[i])) ;
-                                       }
+                       InlineJavaProtocol ijp = new InlineJavaProtocol(this, 
null) ;
+                       InlineJavaClass ijc = new InlineJavaClass(this, ijp) ;
+                       StringBuffer cmdb = new StringBuffer("callback " + pkg 
+ " " + method) ;
+                       if (args != null){
+                               for (int i = 0 ; i < args.length ; i++){
+                                        cmdb.append(" " + 
ijp.SerializeObject(args[i])) ;
                                }
-                               System.out.println("Callback command: " + 
cmd.toString()) ;
-                               debug("Callback command: " + cmd.toString()) ;
+                       }
+                       String cmd = cmdb.toString() ;
+                       debug(" callback command: " + cmd) ;
 
-                               InlineJavaThread ijt = (InlineJavaThread)t ;
-                               ijt.bw.write(cmd.toString() + "\n") ;
-                               ijt.bw.flush() ;                        
+                       Thread t = Thread.currentThread() ;
+                       String resp = null ;
+                       while (true) {                  
+                               debug("  packet sent (callback) is " + cmd) ;
+                               if (t instanceof InlineJavaThread){
+                                       // Client-server mode
+                                       InlineJavaThread ijt = 
(InlineJavaThread)t ;
+                                       ijt.bw.write(cmd + "\n") ;
+                                       ijt.bw.flush() ;
+
+                                       resp = ijt.br.readLine() ;
+                               }
+                               else{
+                                       // JNI mode
+                                       resp = jni_callback(cmd) ;
+                               }
+                               debug(" packet recv (callback) is " + resp) ;
 
-                               String resp = ijt.br.readLine() ;
+                               StringTokenizer st = new StringTokenizer(resp, 
" ") ;
+                               String c = st.nextToken() ;
+                               if (c.equals("callback")){
+                                       String arg = st.nextToken() ;
+                                       ret = 
ijc.CastArgument(java.lang.Object.class, arg) ;
+                                       break ;
+                               }       
+                               else{
+                                       // Pass it on through the regular 
channel...
+                                       debug(" packet is not callback 
response: " + resp) ;
+                                       cmd = ProcessCommand(resp, false) ;
 
-                               System.out.println("Callback response: " + 
resp) ;
-                       }
-                       else{
-                               // JNI mode
+                                       continue ;
+                               }
                        }
                }
                catch (IOException e){
                        throw new InlineJavaException("IO error: " + 
e.getMessage()) ;
                }
 
-               return null ;
+               return ret ;
        }
 
 
+       native private String jni_callback(String cmd) ;
+
+
        /*
                Creates a string representing a method signature
        */
@@ -314,6 +352,24 @@ public class InlineJavaServer {
 
 
        public static InlineJavaServer jni_main(boolean debug) {
+               String so = "<INLINE_JAVA_JNI_SO>" ;
+               if (! so.equals("")){
+                       try {
+                               System.load(so) ;
+                       }
+                       catch (UnsatisfiedLinkError e){
+                               System.err.println("Can't load shared object '" 
+ so + "' required for callbacks") ;
+                               System.err.flush() ;
+                               System.exit(1) ;
+                       }
+               }
+               else{
+                       System.err.println("JNI shared object not specified 
(required for callbacks)") ;
+                       System.err.println("Perhaps your Java code was not 
initially built in JNI mode") ;
+                       System.err.flush() ;
+                       System.exit(1) ;
+               }
+
                return new InlineJavaServer(debug) ;
        }
        
diff --git a/Java/JNI.pm b/Java/JNI.pm
index b4ae84c..653ab93 100644
--- a/Java/JNI.pm
+++ b/Java/JNI.pm
@@ -4,18 +4,46 @@ package Inline::Java::JNI ;
 
 use strict ;
 
-$Inline::Java::JNI::VERSION = '0.20' ;
+$Inline::Java::JNI::VERSION = '0.31' ;
 
 use Carp ;
+use File::Basename ;
+
+
+# A place to attach the Inline object that is currently in Java land
+$Inline::Java::JNI::INLINE_HOOK = undef ;
+
+# The full path to the shared object loaded by JNI
+$Inline::Java::JNI::SO = '' ;
 
 
 eval {
        Inline::Java::JNI->bootstrap($Inline::Java::JNI::VERSION) ;
+       
+       if (! $Inline::Java::JNI::SO){
+               croak "Can't find JNI shared object!" ;
+       }
+
+       Inline::Java::debug("JNI shared object is '$Inline::Java::JNI::SO'") ;
 } ;
 if ($@){
        croak "Can't load JNI module. Did you build it at install time?\nError: 
$@" ;
 }
 
 
+# This is a *NASTY* way to get the shared object file that was loaded 
+# by DynaLoader
+sub dl_load_flags {
+       my $so = $DynaLoader::file ;
+       my $dir = dirname($so) ;
+       my $f = basename($so) ;
+       my $sep = Inline::Java::portable("PATH_SEP") ;
+
+       $Inline::Java::JNI::SO = Cwd::abs_path($dir) . $sep . $f ;
+
+       return DynaLoader::dl_load_flags() ;
+}
+
+
 
 1 ;
diff --git a/Java/JNI.xs b/Java/JNI.xs
index 0c08db0..5a86231 100644
--- a/Java/JNI.xs
+++ b/Java/JNI.xs
@@ -22,6 +22,45 @@ void debug_ex(InlineJavaJNIVM *this){
 }
 
 
+JNIEXPORT jstring JNICALL Java_InlineJavaServer_jni_1callback(
+       JNIEnv *env, jobject obj, jstring cmd){
+
+       dSP ;
+       jstring resp = NULL ;
+       char *c = (char *)((*(env))->GetStringUTFChars(env, cmd, NULL)) ;
+       char *r = NULL ;
+       int count = 0 ;
+
+       ENTER ;
+       SAVETMPS ;
+
+       PUSHMARK(SP) ;
+       XPUSHs(&PL_sv_undef) ;
+       XPUSHs(sv_2mortal(newSVpv(c, 0))) ;
+       PUTBACK ;
+
+       count = perl_call_pv("Inline::Java::Callback::InterceptCallback", 
+               G_SCALAR) ;
+
+       SPAGAIN ;
+
+       if (count != 1){
+               croak("Invalid return value from 
Inline::Java::Callback::InterceptCallback: %d",
+                       count) ;
+       }
+
+       r = (char *)POPp ;
+       resp = (*(env))->NewStringUTF(env, r) ;
+
+       PUTBACK ;
+       FREETMPS ;
+       LEAVE ;
+
+       return resp ;
+}
+
+
+
 MODULE = Inline::Java::JNI   PACKAGE = Inline::Java::JNI
 
 
@@ -87,11 +126,19 @@ create_ijs(this)
 
        CODE:
        this->ijs_class = (*(this->env))->FindClass(this->env, 
"InlineJavaServer") ;
+       if ((*(this->env))->ExceptionOccurred(this->env)){
+               (*(this->env))->ExceptionDescribe(this->env) ;
+               croak("Exception occured") ;
+       }
        if (this->ijs_class == NULL){
                croak("Can't find class InlineJavaServer") ;
        }
 
        mid = (*(this->env))->GetStaticMethodID(this->env, this->ijs_class, 
"jni_main", "(Z)LInlineJavaServer;") ;
+       if ((*(this->env))->ExceptionOccurred(this->env)){
+               (*(this->env))->ExceptionDescribe(this->env) ;
+               croak("Exception occured") ;
+       }
        if (mid == NULL) {
                croak("Can't find method jni_main in class InlineJavaServer") ;
        }
@@ -115,6 +162,10 @@ process_command(this, data)
 
        CODE:
        mid = (*(this->env))->GetMethodID(this->env, this->ijs_class, 
"ProcessCommand", "(Ljava/lang/String;)Ljava/lang/String;") ;
+       if ((*(this->env))->ExceptionOccurred(this->env)){
+               (*(this->env))->ExceptionDescribe(this->env) ;
+               croak("Exception occured") ;
+       }
        if (mid == NULL) {
                croak("Can't find method ProcessCommand in class 
InlineJavaServer") ;
        }
@@ -157,11 +208,19 @@ report(this, module, classes, nb_classes)
 
        CODE:
        mid = (*(this->env))->GetMethodID(this->env, this->ijs_class, "Report", 
"([Ljava/lang/String;I)V") ;
+       if ((*(this->env))->ExceptionOccurred(this->env)){
+               (*(this->env))->ExceptionDescribe(this->env) ;
+               croak("Exception occured") ;
+       }
        if (mid == NULL) {
                croak("Can't find method Report in class InlineJavaServer") ;
        }
 
        class = (*(this->env))->FindClass(this->env, "java/lang/String") ;
+       if ((*(this->env))->ExceptionOccurred(this->env)){
+               (*(this->env))->ExceptionDescribe(this->env) ;
+               croak("Exception occured") ;
+       }
        if (class == NULL){
                croak("Can't find class java.lang.String") ;
        }
diff --git a/Java/JVM.pm b/Java/JVM.pm
index f153975..03e59b1 100644
--- a/Java/JVM.pm
+++ b/Java/JVM.pm
@@ -25,8 +25,6 @@ sub new {
        if ($o->get_java_config('JNI')){
                Inline::Java::debug("  JNI mode") ;
 
-               require Inline::Java::JNI ;
-
                my $jni = new Inline::Java::JNI(
                        $ENV{CLASSPATH} || "",
                        (Inline::Java::get_DEBUG() ? 1 : 0),
@@ -216,35 +214,39 @@ sub reconnect {
 
 sub process_command {
        my $this = shift ;
+       my $inline = shift ;
        my $data = shift ;
 
-       Inline::Java::debug("  packet sent is $data") ;
-
        my $resp = undef ;
-       if ($this->{socket}){
-               my $sock = $this->{socket} ;
-               print $sock $data . "\n" or
-                       croak "Can't send packet to JVM: $!" ;
-
-               $resp = <$sock> ;
-               if (! $resp){
-                       croak "Can't receive packet from JVM: $!" ;
-               }
-       }
-       if ($this->{JNI}){
-               $resp = $this->{JNI}->process_command($data) ;
-       }
-
-       # We got an answer from the server. Is it a callback?
-       if ($resp =~ s/^callback //){
-               print "Callback!!! ($resp)\n" ;
-       }
-
+       while (1){
+               Inline::Java::debug("  packet sent is $data") ;
 
+               if ($this->{socket}){
+                       my $sock = $this->{socket} ;
+                       print $sock $data . "\n" or
+                               croak "Can't send packet to JVM: $!" ;
 
+                       $resp = <$sock> ;
+                       if (! $resp){
+                               croak "Can't receive packet from JVM: $!" ;
+                       }
+               }
+               if ($this->{JNI}){
+                       $Inline::Java::JNI::INLINE_HOOK = $inline ;
+                       $resp = $this->{JNI}->process_command($data) ;
+               }
 
+               Inline::Java::debug("  packet recv is $resp") ;
 
-       Inline::Java::debug("  packet recv is $resp") ;
+               # We got an answer from the server. Is it a callback?
+               if ($resp =~ /^callback/){
+                       $data = 
Inline::Java::Callback::InterceptCallback($inline, $resp) ;
+                       next ;
+               }
+               else{
+                       last ;
+               }
+       }
 
        return $resp ;
 }
diff --git a/MANIFEST b/MANIFEST
index 7479755..2ebc7d4 100644
--- a/MANIFEST
+++ b/MANIFEST
@@ -6,6 +6,7 @@ TODO
 Makefile.PL
 shared_jvm_server.pl
 shared_jvm_test.pl
+swing_gui_test.pl
 Java.pm
 Java.pod
 Java/Init.pm
@@ -28,10 +29,8 @@ t/06_static.t
 t/07_polymorph.t
 t/08_study.t
 t/09_exceptions.t
-t/___pod.t
+t/10_callbacks.t
 t/types.java
 t/types.class
 t/no_const.java
 t/no_const.class
-
-
diff --git a/Makefile.PL b/Makefile.PL
index 1faeb64..fd8a7bf 100644
--- a/Makefile.PL
+++ b/Makefile.PL
@@ -3,6 +3,7 @@ use ExtUtils::MakeMaker;
 
 # So that the the sub dir Makefile.PL will see it...
 $main::JNI_BUILD = 0 ;
+$main::JNI_VM = "classic" ;
 
 
 # In case we had built differently a previous time
@@ -15,8 +16,11 @@ foreach my $arg (@ARGV){
        $a =~ s/^\s+// ;
        $a =~ s/\s+$// ;
 
-       if ($a =~ /^JNI$/i){
+       if ($a =~ /^JNI(:(\w+))?$/i){
                $JNI_BUILD = 1 ;
+               if ($2){
+                       $main::JNI_VM = $2 ;                    
+               }
        }
        elsif ($a =~ /^FIX$/i){
                $fix_makefile = 1 ;
diff --git a/t/03_objects.t b/t/03_objects.t
index d89af16..86e2fa1 100644
--- a/t/03_objects.t
+++ b/t/03_objects.t
@@ -10,7 +10,7 @@ use Inline(
 
 
 BEGIN {
-       plan(tests => 14) ;
+       plan(tests => 15) ;
 }
 
 
@@ -47,6 +47,10 @@ my $t = new types3() ;
        
        # Return a scalar hidden in an object.
        ok($t->_olong(), 12345) ;
+
+       # Pass a non-Java object.
+       my $d = bless({}, "Inline::Java::dummy") ;
+       eval {$t->_Object($d)} ; ok($@, qr/Can't convert/) ;
 }
 
 ok($t->__get_private()->{proto}->ObjectCount(), 1) ;
diff --git a/t/12_exceptions.t b/t/12_exceptions.t
index 774e96a..81186f8 100644
--- a/t/12_exceptions.t
+++ b/t/12_exceptions.t
@@ -110,7 +110,10 @@ my $t = new t9(0) ;
                $t2->len(undef) ;
        } ;
        if ($@){
-               if (caught("java.lang.Exception")){
+               if (caught("java.lang.IOException")){
+                       $msg = "io" ;
+               }
+               elsif (caught("java.lang.Exception")){
                        $msg = "null" ;
                }
                else{
diff --git a/t/13_callbacks.t b/t/13_callbacks.t
index 04c70d8..6a16f47 100644
--- a/t/13_callbacks.t
+++ b/t/13_callbacks.t
@@ -14,10 +14,7 @@ use Inline::Java qw(caught) ;
 
 
 BEGIN {
-       print STDERR "\nWARNING: Callbacks are still experimental and are 
possibly unstable!\n" ;
-       print STDERR "WARNING: Callback API can still change and might not be 
backwards compatible!\n" ;
-
-       plan(tests => 9) ;
+       plan(tests => 12) ;
 }
 
 my $t = new t10() ;
@@ -32,7 +29,24 @@ my $t = new t10() ;
                ok($t->silly_mul_via_perl(3, 2), 6) ;
 
                ok(add_via_java(3, 4), 7) ;
+
                ok($t->add_via_perl_via_java(3, 4), 7) ;
+               ok($t->silly_mul_via_perl_via_java(10, 9), 90) ;
+
+               eval {$t->death_via_perl()} ; ok($@, qr/death/) ;
+
+               my $msg = '' ;
+               eval {$t->except()} ; 
+               if ($@) {
+                       if 
(caught('InlineJavaPerlCaller$InlineJavaPerlCallerException')){
+                               $msg = $@->getMessage() ;
+                       }
+                       else{
+                               die $@ ;
+                       }
+               }
+               ok($msg, "test") ;
+       
        } ;
        if ($@){
                if (caught("java.lang.Throwable")){
@@ -71,6 +85,12 @@ sub add_via_java {
        return $t->add($i, $j) ;
 }
 
+
+sub death {
+       die("death") ;
+}
+
+
 __END__
 
 __Java__
@@ -103,7 +123,7 @@ class t10 extends InlineJavaPerlCaller {
                for (int i = 0 ; i < b ; i++){
                        ret = add_via_perl(ret, a) ;
                }
-               return a * b ;
+               return ret ;
        }
 
 
@@ -114,6 +134,15 @@ class t10 extends InlineJavaPerlCaller {
                return new Integer(val).intValue() ;
        }
 
+       public void death_via_perl() throws InlineJavaPerlCallerException {     
        
+               InlineJavaPerlCaller c = new InlineJavaPerlCaller() ;
+               c.CallPerl("main", "death", null) ;
+       }
+
+       public void except() throws InlineJavaPerlCallerException {             
+               throw new 
InlineJavaPerlCaller.InlineJavaPerlCallerException("test") ;
+       }
+
        public int mul_via_perl(int a, int b) throws 
InlineJavaPerlCallerException {
                String val = (String)CallPerl("main", "mul", 
                        new Object [] {new Integer(a), new Integer(b)}) ;
@@ -127,5 +156,15 @@ class t10 extends InlineJavaPerlCaller {
 
                return new Integer(val).intValue() ;
        }
+
+       public int silly_mul_via_perl_via_java(int a, int b) throws 
InlineJavaPerlCallerException {
+               int ret = 0 ;
+               for (int i = 0 ; i < b ; i++){
+                       String val = (String)CallPerl("main", "add_via_java", 
+                               new Object [] {new Integer(ret), new 
Integer(a)}) ;
+                       ret = new Integer(val).intValue() ;
+               }
+               return ret ;
+       }
 }
 

-- 
Alioth's /usr/local/bin/git-commit-notice on 
/srv/git.debian.org/git/pkg-perl/packages/libinline-java-perl.git

_______________________________________________
Pkg-perl-cvs-commits mailing list
Pkg-perl-cvs-commits@lists.alioth.debian.org
http://lists.alioth.debian.org/cgi-bin/mailman/listinfo/pkg-perl-cvs-commits

Reply via email to