[libinline-java-perl] 133/398: *** empty log message ***

Jonas Smedegaard dr at jones.dk
Thu Feb 26 11:42:57 UTC 2015


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 1cc565b0102822cdd17a517706b1577a892fceb4
Author: Patrick LeBoutillier <patl at cpan.org>
Date:   Wed Jan 9 16:08:26 2002 +0000

    *** empty log message ***
---
 Java/Array.pm     |  32 +++---
 Java/Callback.pm  |  33 ++++--
 Java/Class.pm     |   6 +-
 Java/Init.pm      |  27 +----
 Java/JNI.pm       |  26 +----
 Java/JVM.pm       | 130 ++++++++++++++--------
 Java/Makefile.PL  | 316 ++++++++++++++++++++++++++++++++++--------------------
 Java/Object.pm    |  95 +++++++++-------
 Java/Protocol.pm  |  37 ++++---
 Makefile.PL       |  33 ++----
 t/01_init.t       |   6 +-
 t/02_primitives.t |   4 +-
 t/05_arrays.t     |  41 +++++--
 t/07_polymorph.t  |  17 ++-
 t/13_callbacks.t  |  38 +++++--
 15 files changed, 502 insertions(+), 339 deletions(-)

diff --git a/Java/Array.pm b/Java/Array.pm
index 47c9c2b..fe299c9 100644
--- a/Java/Array.pm
+++ b/Java/Array.pm
@@ -4,7 +4,7 @@ package Inline::Java::Array ;
 
 use strict ;
 
-$Inline::Java::Array::VERSION = '0.20' ;
+$Inline::Java::Array::VERSION = '0.31' ;
 
 use Carp ;
 
@@ -23,8 +23,8 @@ sub new {
 
 	$OBJECTS->{$knot} = $object ;
 
-	Inline::Java::debug("this = $this") ; 
-	Inline::Java::debug("knot = $knot") ; 
+	Inline::Java::debug("this = '$this'") ; 
+	Inline::Java::debug("knot = '$knot'") ; 
 
 	return $this ;
 }
@@ -37,7 +37,7 @@ sub __get_object {
 
 	my $ref = $OBJECTS->{$knot} ;
 	if (! defined($ref)){
-		croak "Unknown Java array reference $knot" ;
+		croak "Unknown Java array reference '$knot'" ;
 	}
 	
 	return $ref ;
@@ -59,7 +59,15 @@ sub length {
 
 	my $ret = undef ;
 	eval {
-		$ret = $obj->__get_private()->{proto}->CallJavaMethod('getLength', [], []) ;
+		# Check the cached value
+		$ret = $obj->__get_private()->{array_length} ;
+		if (! defined($ret)){
+			$ret = $obj->__get_private()->{proto}->CallJavaMethod('getLength', [], []) ;
+			$obj->__get_private()->{array_length} = $ret ;
+		}
+		else{
+			Inline::Java::debug("Using cached array length $ret") ;
+		}
 	} ;
 	croak $@ if $@ ;
 
@@ -104,7 +112,7 @@ sub __set_element {
 	# the array.
 	my $java_class = $obj->__get_private()->{java_class} ;
 	my $elem_class = $java_class ;
-	my $an = new Inline::Java::ArrayNorm($java_class) ;
+	my $an = Inline::Java::Array::Normalizer->new($java_class) ;
 	if ($an->{req_nb_dim} > 1){
 		$elem_class =~ s/^\[// ;
 	}
@@ -133,9 +141,7 @@ sub AUTOLOAD {
 	# method.
 	$func_name =~ s/^(.*)::// ;
 
-	Inline::Java::debug("$func_name") ;
-
-	croak "Can't call method $func_name on Java arrays" ;
+	croak "Can't call method '$func_name' on Java arrays" ;
 }
 
 
@@ -296,7 +302,7 @@ sub new {
 	my $ref = shift ;
 
 	if (! Inline::Java::Class::ClassIsArray($java_class)){
-		croak "Can't create Java array of non-array class $java_class" ;
+		croak "Can't create Java array of non-array class '$java_class'" ;
 	}
 
 	my $this = {} ;
@@ -369,7 +375,7 @@ sub InitFromFlat {
 
 			my @dims = @{$dims} ;
 			shift @dims ;
-			my $obj = new Inline::Java::Array::Normalizer($java_class) ;
+			my $obj = Inline::Java::Array::Normalizer->new($java_class) ;
 			$obj->InitFromFlat(\@dims, \@sub, $level + 1) ;
 			$elem = $obj->{array} ;
 		}
@@ -408,7 +414,7 @@ sub AnalyzeArrayClass {
 
 	my $pclass = $map{$type} ;
 	if (! $pclass){
-		croak "Can't determine array type for $java_class" ;
+		croak "Can't determine array type for '$java_class'" ;
 	}
 
 	$this->{req_element_class} = $pclass ;
@@ -430,7 +436,7 @@ sub ValidateArray {
 
 	if (! UNIVERSAL::isa($ref, "ARRAY")){
 		# We must start with an array of some kind...
-		croak "$ref is not an array reference" ;
+		croak "'$ref' is not an array reference" ;
 	}
 
 	$this->ValidateElements($ref, $array, $level) ;
diff --git a/Java/Callback.pm b/Java/Callback.pm
index 40c7003..4d8c9e7 100644
--- a/Java/Callback.pm
+++ b/Java/Callback.pm
@@ -19,11 +19,12 @@ sub InterceptCallback {
 		$inline = $Inline::Java::JNI::INLINE_HOOK ;
 	}
 
-	if ($resp =~ s/^callback (.*?) (\w+)//){
+	if ($resp =~ s/^callback ([^ ]+) (\w+) ([^ ]+)//){
 		my $module = $1 ;
 		my $function = $2 ;
+		my $cast_return = $3 ;
 		my @args = split(' ', $resp) ;
-		return Inline::Java::Callback::ProcessCallback($inline, $module, $function, @args) ;
+		return Inline::Java::Callback::ProcessCallback($inline, $module, $function, $cast_return, @args) ;
 	}
 
 	croak "Malformed callback request from server: $resp" ;
@@ -34,13 +35,17 @@ sub ProcessCallback {
 	my $inline = shift ;
 	my $module = shift ;
 	my $function = shift ;
+	my $cast_return = shift ;
 	my @sargs = @_ ;
 
 	my $pc = new Inline::Java::Protocol(undef, $inline) ;
 	my $thrown = 'false' ;
 	my $ret = undef ;
 	eval {
-		my @args = map {$pc->DeserializeObject(0, $_)} @sargs ;
+		my @args = map {
+			my $a = $pc->DeserializeObject(0, $_) ;
+			$a ;
+		} @sargs ;
 
 		Inline::Java::debug(" processing callback $module" . "::" . "$function(" . 
 			join(", ", @args) . ")") ;
@@ -58,9 +63,20 @@ sub ProcessCallback {
 		}
 	}
 
-	($ret) = $pc->ValidateArgs([$ret]) ;
+	my $proto = 'java.lang.Object' ;
+	if ($cast_return ne "null"){
+		$ret = Inline::Java::cast($proto, $ret, $cast_return) ;
+	}
+
+	($ret) = Inline::Java::Class::CastArgument($ret, $proto, $inline->get_api('modfname')) ;
+	
+	# Here we must keep a reference to $ret or else it gets deleted 
+	# before the id is returned to Java...
+	my $ref = $ret ;
+
+	($ret) = $pc->ValidateArgs([$ret], 1) ;
 
-	return "callback $thrown $ret" ;
+	return ("callback $thrown $ret", $ref) ;
 }
 
 
@@ -101,6 +117,11 @@ public class InlineJavaPerlCaller {
 
 
 	public Object CallPerl(String pkg, String method, Object args[]) throws InlineJavaException, PerlException {
+		return CallPerl(pkg, method, args, null) ;
+	}
+
+
+	public Object CallPerl(String pkg, String method, Object args[], String cast) throws InlineJavaException, PerlException {
 		if (InlineJavaServer.instance == null){
 			System.err.println("Can't use InlineJavaPerlCaller outside of an Inline::Java context") ;
 			System.err.flush() ;
@@ -108,7 +129,7 @@ public class InlineJavaPerlCaller {
 		}
 
 		try {
-			return InlineJavaServer.instance.Callback(pkg, method, args) ;
+			return InlineJavaServer.instance.Callback(pkg, method, args, cast) ;
 		}
 		catch (InlineJavaServer.InlineJavaException e){
 			throw new InlineJavaException(e) ;
diff --git a/Java/Class.pm b/Java/Class.pm
index b083fb6..d6c69cc 100644
--- a/Java/Class.pm
+++ b/Java/Class.pm
@@ -3,7 +3,7 @@ package Inline::Java::Class ;
 
 use strict ;
 
-$Inline::Java::Class::VERSION = '0.30' ;
+$Inline::Java::Class::VERSION = '0.31' ;
 
 $Inline::Java::Class::MAX_SCORE = 10 ;
 
@@ -146,14 +146,14 @@ sub CastArgument {
 			# They will wrapped on the Java side.
 			if (UNIVERSAL::isa($arg, "ARRAY")){
 				if (! UNIVERSAL::isa($arg, "Inline::Java::Array")){
-					my $an = new Inline::Java::Array::Normalizer($array_type || $proto, $arg) ;
+					my $an = Inline::Java::Array::Normalizer->new($array_type || $proto, $arg) ;
 					$array_score = $an->{score} ;
 					my $flat = $an->FlattenArray() ; 
 					my $inline = Inline::Java::get_INLINE($module) ;
-					my $obj = Inline::Java::Object->__new($array_type || $proto, $inline, -1, $flat->[0], $flat->[1]) ;
 
 					# We need to create the array on the Java side, and then grab 
 					# the returned object.
+					my $obj = Inline::Java::Object->__new($array_type || $proto, $inline, -1, $flat->[0], $flat->[1]) ;
 					$arg = new Inline::Java::Array($obj) ;
 				}
 				else{
diff --git a/Java/Init.pm b/Java/Init.pm
index 90e4eac..ab1b232 100644
--- a/Java/Init.pm
+++ b/Java/Init.pm
@@ -3,7 +3,7 @@ package Inline::Java::Init ;
 
 use strict ;
 
-$Inline::Java::Init::VERSION = '0.30' ;
+$Inline::Java::Init::VERSION = '0.31' ;
 
 my $DATA = join('', <DATA>) ;
 my $OBJECT_DATA = join('', <Inline::Java::Object::DATA>) ;
@@ -36,9 +36,6 @@ 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 ;
 }
 
@@ -254,13 +251,13 @@ public class InlineJavaServer {
 	}
 
 
-	public Object Callback(String pkg, String method, Object args[]) throws InlineJavaException, InlineJavaPerlException {
+	public Object Callback(String pkg, String method, Object args[], String cast) throws InlineJavaException, InlineJavaPerlException {
 		Object ret = null ;
 
 		try {
 			InlineJavaProtocol ijp = new InlineJavaProtocol(this, null) ;
 			InlineJavaClass ijc = new InlineJavaClass(this, ijp) ;
-			StringBuffer cmdb = new StringBuffer("callback " + pkg + " " + method) ;
+			StringBuffer cmdb = new StringBuffer("callback " + pkg + " " + method + " " + cast) ;
 			if (args != null){
 				for (int i = 0 ; i < args.length ; i++){
 					 cmdb.append(" " + ijp.SerializeObject(args[i])) ;
@@ -358,24 +355,6 @@ 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 3476a8b..200c62e 100644
--- a/Java/JNI.pm
+++ b/Java/JNI.pm
@@ -6,6 +6,7 @@ use strict ;
 
 $Inline::Java::JNI::VERSION = '0.31' ;
 
+use DynaLoader ;
 use Carp ;
 use File::Basename ;
 
@@ -13,38 +14,13 @@ 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 = Inline::Java::portable("RE_FILE", Cwd::abs_path($dir) . $sep . $f) ;
-	$Inline::Java::JNI::SO = Inline::Java::portable("RE_FILE_JAVA", $Inline::Java::JNI::SO) ;
-
-	return DynaLoader::dl_load_flags() ;
-}
-
-
-
 1 ;
diff --git a/Java/JVM.pm b/Java/JVM.pm
index 77f5b50..2bc0b09 100644
--- a/Java/JVM.pm
+++ b/Java/JVM.pm
@@ -3,7 +3,7 @@ package Inline::Java::JVM ;
 
 use strict ;
 
-$Inline::Java::JVM::VERSION = '0.30' ;
+$Inline::Java::JVM::VERSION = '0.31' ;
 
 use Carp ;
 use IPC::Open3 ;
@@ -20,6 +20,8 @@ sub new {
 	$this->{JNI} = undef ;
 	$this->{owner} = 1 ;
 
+	$this->{destroyed} = 0 ;
+
 	Inline::Java::debug("Starting JVM...") ;
 
 	if ($o->get_java_config('JNI')){
@@ -55,10 +57,10 @@ sub new {
 			}
 		}
 
-		my $java = $o->get_java_config('BIN') . "/java" . Inline::Java::portable("EXE_EXTENSION") ;
-		my $pjava = Inline::Java::portable("RE_FILE", $java) ;
+		my $java = File::Spec->catfile($o->get_java_config('BIN'), 
+			"java" . Inline::Java::portable("EXE_EXTENSION")) ;
 
-		my $cmd = "\"$pjava\" InlineJavaServer $debug $this->{port} $shared_jvm" ;
+		my $cmd = "\"$java\" InlineJavaServer $debug $this->{port} $shared_jvm" ;
 		Inline::Java::debug($cmd) ;
 
 		if ($o->get_config('UNTAINT')){
@@ -90,46 +92,59 @@ sub new {
 sub DESTROY {
 	my $this = shift ;
 
-	if ($this->{owner}){
-		Inline::Java::debug("JVM owner exiting...") ;
+	$this->shutdown() ;	
+}
 
-		if ($this->{socket}){
-			# This asks the Java server to stop and die.
-			my $sock = $this->{socket} ;
-			if ($sock->connected()){
-				Inline::Java::debug("Sending 'die' message to JVM...") ;
-				print $sock "die\n" ;
-			}
-			else{
-				carp "Lost connection with Java virtual machine" ;
+
+sub shutdown {
+	my $this = shift ;
+
+	if (! $this->{destroyed}){
+		if ($this->am_owner()){
+			Inline::Java::debug("JVM owner exiting...") ;
+
+			if ($this->{socket}){
+				# This asks the Java server to stop and die.
+				my $sock = $this->{socket} ;
+				if ($sock->connected()){
+					Inline::Java::debug("Sending 'die' message to JVM...") ;
+					print $sock "die\n" ;
+				}
+				else{
+					carp "Lost connection with Java virtual machine" ;
+				}
+				close($sock) ;
+		
+				if ($this->{pid}){
+					# Here we go ahead and send the signals anyway to be very 
+					# sure it's dead...
+					# Always be polite first, and then insist.
+					Inline::Java::debug("Sending 15 signal to JVM...") ;
+					kill(15, $this->{pid}) ;
+					Inline::Java::debug("Sending 9 signal to JVM...") ;
+					kill(9, $this->{pid}) ;
+		
+					# Reap the child...
+					waitpid($this->{pid}, 0) ;
+				}
 			}
-			close($sock) ;
-	
-			if ($this->{pid}){
-				# Here we go ahead and send the signals anyway to be very 
-				# sure it's dead...
-				# Always be polite first, and then insist.
-				Inline::Java::debug("Sending 15 signal to JVM...") ;
-				kill(15, $this->{pid}) ;
-				Inline::Java::debug("Sending 9 signal to JVM...") ;
-				kill(9, $this->{pid}) ;
-	
-				# Reap the child...
-				waitpid($this->{pid}, 0) ;
+			if ($this->{JNI}){
+				$this->{JNI}->shutdown() ;
 			}
 		}
-	}
-	else{
-		# We are not the JVM owner, so we simply politely disconnect
-		if ($this->{socket}){
-			Inline::Java::debug("JVM non-owner exiting...") ;
-			close($this->{socket}) ;
-			$this->{socket} = undef ;
+		else{
+			# We are not the JVM owner, so we simply politely disconnect
+			if ($this->{socket}){
+				Inline::Java::debug("JVM non-owner exiting...") ;
+				close($this->{socket}) ;
+				$this->{socket} = undef ;
+			}
+
+			# This should never happen in JNI mode
 		}
-	}
 
-	# For JNI we need to do nothing because the garbage collector will call
-	# the JNI destructor
+        $this->{destroyed} = 1 ;
+	}
 }
 
 
@@ -194,13 +209,6 @@ sub setup_socket {
 }
 
 
-sub release {
-	my $this = shift ;
-
-	$this->{owner} = 0 ;
-}
-
-
 sub reconnect {
 	my $this = shift ;
 
@@ -227,11 +235,41 @@ sub reconnect {
 }
 
 
+sub capture {
+	my $this = shift ;
+
+	if ($this->{JNI}){
+		return ;
+	}
+
+	$this->{owner} = 1 ;
+}
+
+
+sub am_owner {
+	my $this = shift ;
+
+	return $this->{owner} ;
+}
+
+
+sub release {
+	my $this = shift ;
+
+	if ($this->{JNI}){
+		return ;
+	}
+
+	$this->{owner} = 0 ;
+}
+
+
 sub process_command {
 	my $this = shift ;
 	my $inline = shift ;
 	my $data = shift ;
 
+	my $ref = undef ;
 	my $resp = undef ;
 	while (1){
 		Inline::Java::debug("  packet sent is $data") ;
@@ -255,7 +293,7 @@ sub process_command {
 
 		# We got an answer from the server. Is it a callback?
 		if ($resp =~ /^callback/){
-			$data = Inline::Java::Callback::InterceptCallback($inline, $resp) ;
+			($data, $ref) = Inline::Java::Callback::InterceptCallback($inline, $resp) ;
 			next ;
 		}
 		else{
diff --git a/Java/Makefile.PL b/Java/Makefile.PL
index d7d83be..a15a881 100644
--- a/Java/Makefile.PL
+++ b/Java/Makefile.PL
@@ -2,159 +2,211 @@ use ExtUtils::MakeMaker ;
 use File::Find ;
 
 use strict ;
+use File::Spec ;
 
+require "Portable.pm" ;
+Inline::Java::Portable::use_alone() ;
 
-# Inherited from the parent Makefile.PL
-if (! defined($main::JNI_BUILD)){
-	$main::JNI_BUILD = 0 ;
-}
-if (! defined($main::JNI_VM)){
-	$main::JNI_VM = "classic" ;
-}
+# Some shortcuts while developing
+my $jdk_dir = undef ;
+my $build_jni = ($jdk_dir ? 1 : 0) ;
+
+my $jvm_lib = Inline::Java::Portable::portable('JVM_LIB') ;
+my $jvm_so = Inline::Java::Portable::portable('JVM_SO') ;
 
+my @files = (
+	'jni.h',
+	'jni_md.h',
+	$jvm_lib,
+) ;
+if ($jvm_so ne $jvm_lib){
+	push @files, $jvm_so ;
+}
 
-my $JNI_BUILD = $main::JNI_BUILD ;
-my $JNI_VM = $main::JNI_VM ;
+my $files = {
+	'jni.h'		=> {
+		discard		=> qr/include-old/,
+	},
+	'jni_md.h'	=> {
+		discard		=> qr/include-old/,
+	},
+	$jvm_lib	=> {
+		discard		=> qr/green_threads/,
+	},
+	$jvm_so		=> {
+		discard		=> qr/green_threads/,
+	},
+} ;
+
+foreach my $f (@files){
+	$files->{$f}->{selected} = undef ;
+	$files->{$f}->{choices} = [] ;
+}
 
 
-# Define these variables with the correct values to bypass the
-# rest of the code that looks for them.
-my $java_include = 		undef ;
-my $java_include_os = 	undef ;
-my $java_lib = 			undef ;
-my $java_so = 			undef ;
+print "\n" ;
+print
+	"Inline::Java can use a JNI extension that allows the Java Virtual Machine\n" .
+	"(JVM) to be dynamically linked with Perl instead of running as a separate\n" .
+	"process. The use of this extension is optional, and building it still\n" .
+	"allows Inline::Java to run the JVM in the default (separate process)\n" .
+	"fashion.\n\n" ;
 
+if (($build_jni || AskYN("Do you wish to build the JNI extension?"))){
+	print "\nBuilding JNI extension.\n\n" ;
 
-my $jvm_lib = 
-	((($^O eq "MSWin32")||($^O eq "cygwin")) ? "jvm.lib" : "libjvm.so") ;
-my $jvm_so = 
-	((($^O eq "MSWin32")||($^O eq "cygwin")) ? "jvm.dll" : "libjvm.so") ;
+	rename("JNI.xs_", "JNI.xs") ;
 
+	$jdk_dir = ($jdk_dir || AskSub("Enter the path to your Java 2 SDK installation",
+		sub {((-d $_[0]) ? 1 : (print("Directory '$_[0]' does not exist.\n") && 0))})) ;
+	print "\n" ;
 
-if ($JNI_BUILD){
-	if ((! defined($java_include))&&
-		(! defined($java_include_os))&&
-		(! defined($java_lib))&&
-		(! defined($java_so))){
-		print "\nBuilding JNI extension, $JNI_VM VM.\n" ;
+	my $type = FindDefaultVMType() ;
 
-		# We need to find the files in order to be able to build
-		my $q = "\nEnter the path to your Java 2 SDK installation" ;
-		my $jh = Ask($q) ;
-		chomp($jh) ;
-		if (! -d $jh){
-			die("Directory $jh does not exist.") ;
-		}
-		print "\n" ;
-		find(\&wanted, $jh) ;
+	find(\&search, $jdk_dir) ;
 
-		if (! defined($java_include)){
-			die("Couldn't find jni.h.") ;
-		}
-		if (! defined($java_include_os)){
-			die("Couldn't find jni_md.h.") ;
+	my $done = 0 ;
+	foreach my $f (@files){
+		my $cnt = scalar(@{$files->{$f}->{choices}}) ;
+		if ($cnt == 0){
+			print "Can't locate file '$f' anywhere under '$jdk_dir'\n" ;
+			$done = 1 ;
+			last ;
 		}
-		if (! defined($java_lib)){
-			die("Couldn't find $jvm_lib.") ;
+		elsif ($cnt == 1){
+			$files->{$f}->{selected} = $files->{$f}->{choices}->[0] ;
 		}
-		if (! defined($java_so)){
-			die("Couldn't find $jvm_so.") ;
+		else{
+			Choose($f, $type) ;
 		}
 	}
+	if (! $done){
+		# We have all the required files selected.
 
-	my $l = join(" or ", @{$java_so}) ;
-	if ($^O eq "MSWin32"){
-		print "\nNote: You will need to add $l to your PATH environment " .
-			"variable in order to be able to use the JNI mode.\n" ;
-	}
-	else{
-		print "\nNote: You will need to add $l (and maybe other Java " .
-			"directories) to your LD_LIBRARY_PATH environment variable in " .
-			"order to be able to use the JNI mode. See README.JNI for more " .
-			"information.\n" ;
-	}
-
-	print "\nNote: In order for Inline::Java to use the JNI extension, you " .
-		"will need to use the JNI configuration option or set the " .
-		"PERL_INLINE_JAVA_JNI environment variable to a true value. " .
-		"See README.JNI for more information.\n" ;
+		print "Building with:\n" ;
+		foreach my $f (@files){
+			print File::Spec->catfile($files->{$f}->{selected}, $f) . "\n" ;
+		}
+		print "\n" ;
 
-	print "\n" ;
+		$done = WriteBSFile() ;
+		if (! $done){
+			WriteMakefile(
+				NAME => 'Inline::Java::JNI',
+				VERSION_FROM => 'JNI.pm',
+				INC => "-I" . $files->{'jni.h'}->{selected} . " -I" . $files->{'jni_md.h'}->{selected},
+				LIBS => ["-L" . $files->{$jvm_lib}->{selected} . " -ljvm"],
+			) ;
+
+			print
+				"\nNote: In order for Inline::Java to use the JNI extension, you\n" .
+				"will need to use the JNI configuration option or set the\n" .
+				"PERL_INLINE_JAVA_JNI environment variable to a true value.\n" .
+				"See README.JNI for more information.\n" ;
+
+			print "\n" ;
+		}
+	}
 }
 else{
-	rename("JNI.xs", "JNI.xs_") ;
-}
-
+	print "\n" ;
 
-WriteMakefile(
-	NAME => 'Inline::Java::JNI',
-	VERSION_FROM => 'JNI.pm',
-	INC => (! $JNI_BUILD ? undef :
-		join(" ", 
-			"-I$java_include",
-			"-I$java_include_os"
-		)),
-	LIBS => (! $JNI_BUILD ? undef :
-		[
-			"-L$java_lib -ljvm"
-		]),
-) ;
+	rename("JNI.xs", "JNI.xs_") ;
 
+	WriteMakefile(
+		NAME => 'Inline::Java::JNI',
+		VERSION_FROM => 'JNI.pm') ;
+}
 
 
 #################################################
 
 
-sub wanted {
+sub search {
 	my $file = $_ ;
 
-	if ($file eq "jni.h"){
-		print "Found jni.h in $File::Find::dir...\n" ;
-		$java_include = $File::Find::dir ;
-	}
-	if ($file eq "jni_md.h"){
-		print "Found jni_md.h in $File::Find::dir...\n" ;
-		$java_include_os = $File::Find::dir ;
-	}
-	if ($file eq $jvm_lib){
-		print "Found $jvm_lib in $File::Find::dir...\n" ;
-		$java_lib = $File::Find::dir ;
-	}
-	if ($file eq $jvm_so){
-		print "Found $jvm_so in $File::Find::dir...\n" ;
-		if (! defined($java_so)){
-			$java_so = [] ;
+	foreach my $f (@files){
+		if ($file eq $f){
+			my $re = $files->{$f}->{discard} ;
+			if ((! $re)||($File::Find::dir !~ /$re/)){
+				push @{$files->{$f}->{choices}}, File::Spec->canonpath($File::Find::dir) ;
+			}
+			last ;
 		}
-		push @{$java_so}, $File::Find::dir ;
 	}
 }
 
 
-# Gets yes/no from stdin
-sub AskYN {
-	my $ques = shift ;
+sub WriteBSFile {
+	if (! open(BS, '>JNI_BS')){
+		return 1 ;
+	}
 
-	my $str = $ques . " [yn]: " ;
-	print($str) ;
+	my $so = File::Spec->catfile($files->{$jvm_so}->{selected}, $jvm_so) ;
+	print BS <<BS_CODE;
+my \$so = '$so' ;
+push(\@dl_resolve_using, \$so) ;
 
-	my $ans = '' ;
-	while (<STDIN>){
-		$ans = $_ ;
-		chomp($ans) ;
-		if ($ans =~ /^(y|n)$/i){
-			last ;
-		}
-		else{
-			print($str) ;
+\$bscode = <<CODE ;
+dl_load_file('\$so', Inline::Java::JNI->dl_load_flags) or
+croak("Can't load '\$so' for module Inline::Java::JNI: " . dl_error()) ;
+CODE
+
+BS_CODE
+
+	close(BS) ;
+	return 0 ;
+}
+
+
+sub FindDefaultVMType {
+	my $type = undef ;
+	my $cfg = File::Spec->catfile($jdk_dir, "jre", "lib", "jvm.cfg") ;
+	if (open(CFG, "<$cfg")){
+		while (<CFG>){
+			my $line = $_ ;
+			chomp($line) ;
+			$line =~ s/^\s+// ;
+			$line =~ s/\s+$// ;
+
+			if (! $line){
+				next ;
+			}
+			elsif ($line =~ /^#/){
+				next ;
+			}
+			else{
+				$type = $line ;
+				$type =~ s/^-// ;
+				last ;
+			}
 		}
+		close(CFG) ;
 	}
 
-	if ($ans eq "y"){
-		return 1 ;
-	}
-	else{
-		return 0 ;
+	return $type ;
+}
+
+
+sub Choose {
+	my $f = shift ;
+	my $type = shift ;
+
+	my $o = $files->{$f} ;
+	my $cnt = 0 ;
+	foreach my $f (@{$o->{choices}}){
+		$cnt++ ;
+		my $hint = '' ;
+		if ($f =~ /$type/){
+			$hint = "[your system default]" ;
+		}
+		print "[$cnt] $f $hint\n" ;
 	}
+	my $idx = AskSub("Please select from the above list which '$f' to use $type [1-$cnt]",
+		sub {(($_[0] >= 1)&&($_[0] <= $cnt))}) ;
+
+	$o->{selected} = $o->{choices}->[int($idx) - 1] ;
+	print "\n" ;
 }
 
 
@@ -162,11 +214,39 @@ sub AskYN {
 sub Ask {
 	my $ques = shift ;
 
-	my $str = $ques . " : " ;
-	print($str) ;
-	my $ans = '' ;
-	$ans = <STDIN> ;
+	return AskSub($ques, undef) ;
+}
 
-	return $ans ;
+
+# Gets yes/no from stdin
+sub AskYN {
+	my $ques = shift ;
+
+	$ques .= " [yn]" ;
+
+	my $ans = AskSub($ques, sub {$_[0] =~ /^(y|n)$/i}) ;
+
+	return (($ans eq "y") ? 1 : 0) ;
 }
 
+
+sub AskSub {
+	my $ques = shift ;
+	my $sub = shift ;
+
+	my $str = $ques . ": " ;
+	print $str ;
+
+	while (<STDIN>){
+		my $ans = $_ ;
+		chomp($ans) ;
+		if (! $sub){
+			return $ans ;
+		}
+		elsif ($sub->($ans)){
+			return $ans ;
+		}
+
+		print $str ;
+	}
+}
diff --git a/Java/Object.pm b/Java/Object.pm
index 60dd7a1..e3c6c96 100644
--- a/Java/Object.pm
+++ b/Java/Object.pm
@@ -3,7 +3,7 @@ package Inline::Java::Object ;
 
 use strict ;
 
-$Inline::Java::Object::VERSION = '0.22' ;
+$Inline::Java::Object::VERSION = '0.31' ;
 
 use Inline::Java::Protocol ;
 use Carp ;
@@ -234,16 +234,23 @@ sub __get_member {
 	my $key = shift ;
 
 	if ($this->__get_private()->{class} eq "Inline::Java::Object"){
-		croak "Can't get member $key for an object that is not bound to Perl" ;
+		croak "Can't get member '$key' for an object that is not bound to Perl" ;
 	}
 
-	Inline::Java::debug("fetching member variable $key") ;
+	Inline::Java::debug("fetching member variable '$key'") ;
 
 	my $inline = Inline::Java::get_INLINE($this->__get_private()->{module}) ;
 	my $fields = $inline->get_fields($this->__get_private()->{class}) ;
 
-	if ($fields->{$key}){
-		my $proto = $fields->{$key}->{TYPE} ;
+	my $types = $fields->{$key} ;
+	if ($types){
+		my @typesk = keys %{$types} ;
+
+		# We take the last one, which is more specific. Eventually
+		# we should use a scoring method just like for the methods
+		my $sign = $types->{$typesk[-1]} ;
+
+		my $proto = $sign->{TYPE} ;
 
 		my $ret = $this->__get_private()->{proto}->GetJavaMember($key, [$proto], [undef]) ;
 		Inline::Java::debug("returning member (" . ($ret || '') . ")") ;
@@ -252,7 +259,7 @@ sub __get_member {
 	}
 	else{
 		my $name = $this->__get_private()->{class} ;
-		croak "No public member variable $key defined for class $name" ;
+		croak "No public member variable '$key' defined for class '$name'" ;
 	}
 }
 
@@ -263,14 +270,21 @@ sub __set_member {
 	my $value = shift ;
 
 	if ($this->__get_private()->{class} eq "Inline::Java::Object"){
-		croak "Can't set member $key for an object that is not bound to Perl" ;
+		croak "Can't set member '$key' for an object that is not bound to Perl" ;
 	}
 
 	my $inline = Inline::Java::get_INLINE($this->__get_private()->{module}) ;
 	my $fields = $inline->get_fields($this->__get_private()->{class}) ;
 
-	if ($fields->{$key}){
-		my $proto = $fields->{$key}->{TYPE} ;
+	my $types = $fields->{$key} ;
+	if ($types){
+		my @typesk = keys %{$types} ;
+
+		# We take the last one, which is more specific. Eventually
+		# we should use a scoring method just like for the methods
+		my $sign = $types->{$typesk[-1]} ;
+
+		my $proto = $sign->{TYPE} ;
 		my $new_args = undef ;
 		my $score = undef ;
 
@@ -279,7 +293,7 @@ sub __set_member {
 	}
 	else{
 		my $name = $this->__get_private()->{class} ;
-		croak "No public member variable $key defined for class $name" ;
+		croak "No public member variable '$key' defined for class '$name'" ;
 	}
 }
 
@@ -298,10 +312,10 @@ sub AUTOLOAD {
 
 	my $name = (ref($this) ? $this->__get_private()->{class} : $this) ;
 	if ($name eq "Inline::Java::Object"){
-		croak "Can't call method $func_name on an object ($name) that is not bound to Perl" ;
+		croak "Can't call method '$func_name' on an object ($name) that is not bound to Perl" ;
 	}
 
-	croak "No public method $func_name defined for class $name" ;
+	croak "No public method '$func_name' defined for class '$name'" ;
 }
 
 
@@ -313,36 +327,41 @@ sub DESTROY {
 		Inline::Java::debug("Destroying Inline::Java::Object::Tie") ;
 		
 		if (! Inline::Java::get_DONE()){
-			# This one is very tricky:
-			# Here we want to be carefull since this can be called
-			# at scope end, but the scope end might be triggered
-			# by another croak, so we need to record and propagate 
-			# the current $@
-			my $prev_dollar_at = $@ ;
-			eval {
-				$this->__get_private()->{proto}->DeleteJavaObject($this) ;
-			} ;
-			if ($@){
-				# We croaked here. Was there already a pending $@?
-				my $name = $this->__get_private()->{class} ;
-				my $msg = "In method DESTROY of class $name: $@" ;
-				if ($prev_dollar_at){
-					$msg = "$prev_dollar_at\n$msg" ;
+			if (! $this->__get_private()->{weak_ref}){
+				# This one is very tricky:
+				# Here we want to be carefull since this can be called
+				# at scope end, but the scope end might be triggered
+				# by another croak, so we need to record and propagate 
+				# the current $@
+				my $prev_dollar_at = $@ ;
+				eval {
+					$this->__get_private()->{proto}->DeleteJavaObject($this) ;
+				} ;
+				if ($@){
+					# We croaked here. Was there already a pending $@?
+					my $name = $this->__get_private()->{class} ;
+					my $msg = "In method DESTROY of class $name: $@" ;
+					if ($prev_dollar_at){
+						$msg = "$prev_dollar_at\n$msg" ;
+					}
+					croak $msg ;
+				}
+				else{
+					# Put back the previous $@
+					$@ = $prev_dollar_at ;
 				}
-				croak $msg ;
+
+				# Here we have a circular reference so we need to break it
+				# so that the memory is collected.
+				my $priv = $this->__get_private() ;
+				my $proto = $priv->{proto} ;
+				$priv->{proto} = undef ;
+				$proto->{obj_priv} = undef ;
+				$PRIVATES->{$this} = undef ;
 			}
 			else{
-				# Put back the previous $@
-				$@ = $prev_dollar_at ;
+				Inline::Java::debug(" Object marked a weak reference, object destruction not propagated to Java") ;
 			}
-
-			# Here we have a circular reference so we need to break it
-			# so that the memory is collected.
-			my $priv = $this->__get_private() ;
-			my $proto = $priv->{proto} ;
-			$priv->{proto} = undef ;
-			$proto->{obj_priv} = undef ;
-			$PRIVATES->{$this} = undef ;
 		}
 		else{
 			Inline::Java::debug(" Script marked as DONE, object destruction not propagated to Java") ;
diff --git a/Java/Protocol.pm b/Java/Protocol.pm
index bc6f006..758aa55 100644
--- a/Java/Protocol.pm
+++ b/Java/Protocol.pm
@@ -266,7 +266,7 @@ sub Send {
 	my $const = shift ;
 
 	my $inline = Inline::Java::get_INLINE($this->{module}) ;
-	my $resp = Inline::Java::get_JVM()->process_command($inline, $data) ;
+	my $resp = Inline::Java::__get_JVM()->process_command($inline, $data) ;
 
 	if ($resp =~ /^error scalar:([\d.]*)$/){
 		my $msg = pack("C*", split(/\./, $1)) ;
@@ -323,16 +323,23 @@ sub DeserializeObject {
 				$elem_class = $d[2] ;
 			}
 
-			my $perl_class = Inline::Java::java2perl($pkg, $elem_class) ;
-			if (Inline::Java::Class::ClassIsReference($elem_class)){
-				if (! Inline::Java::known_to_perl($pkg, $elem_class)){
-					if (($thrown)||($inline->get_java_config('AUTOSTUDY'))){
-						$inline->_study([$elem_class]) ;
-					}
-					else{
-						$perl_class = "Inline::Java::Object" ;
-					}
-			 	}
+
+			my $perl_class = "Inline::Java::Object" ;
+			if ($elem_class){
+				# We have a real class or an array of real classes
+				$perl_class = Inline::Java::java2perl($pkg, $elem_class) ;
+				if (Inline::Java::Class::ClassIsReference($elem_class)){
+					if (! Inline::Java::known_to_perl($pkg, $elem_class)){
+						if (($thrown)||($inline->get_java_config('AUTOSTUDY'))){
+							$inline->_study([$elem_class]) ;
+						}
+						else{	
+							# Object is not known to Perl, it lives as a 
+							# Inline::Java::Object
+							$perl_class = "Inline::Java::Object" ;
+						}
+				 	}
+				}
 			}
 			else{
 				# We should only get here if an array of primitives types
@@ -899,7 +906,6 @@ class InlineJavaProtocol {
 				if (type.equals(t)){
 					ijs.debug("  has matching type " + t) ;
 					fl.add(fl.size(), f) ;
-					break ;
 				}
 			}
 		}
@@ -911,10 +917,13 @@ class InlineJavaProtocol {
 				"Member " + name + " of type " + type + " for class " + c.getName() +
 					" not found") ;
 		}
-		else if (fl.size() == 1){
+		else {
 			// Now we need to force the arguments received to match
 			// the methods signature.
-			Field f = (Field)fl.get(0) ;
+
+			// If we have more that one, we use tha last one, which is the most
+			// specialized
+			Field f = (Field)fl.get(fl.size() - 1) ;
 			param = f.getType() ;
 
 			String msg = "For member " + name + " of class " + c.getName() + ": " ;
diff --git a/Makefile.PL b/Makefile.PL
index fd8a7bf..77aad23 100644
--- a/Makefile.PL
+++ b/Makefile.PL
@@ -1,32 +1,11 @@
-use ExtUtils::MakeMaker;
+use ExtUtils::MakeMaker ;
 
+use strict ;
 
-# 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
-rename("Java/JNI.xs_", "Java/JNI.xs") ;
-
-
-my $fix_makefile = 0 ;
-foreach my $arg (@ARGV){
-	my $a = $arg ;
-	$a =~ s/^\s+// ;
-	$a =~ s/\s+$// ;
-
-	if ($a =~ /^JNI(:(\w+))?$/i){
-		$JNI_BUILD = 1 ;
-		if ($2){
-			$main::JNI_VM = $2 ;			
-		}
-	}
-	elsif ($a =~ /^FIX$/i){
-		$fix_makefile = 1 ;
-	}
-}
+require "Java/Portable.pm" ;
+Inline::Java::Portable::use_alone() ;
 
+print "\nWelcome to the Inline::Java installation procedure.\n\n" ;
 
 WriteMakefile(
 	NAME => 'Inline::Java',
@@ -38,7 +17,7 @@ WriteMakefile(
 ) ;
 
 
-if ($fix_makefile){
+if (Inline::Java::Portable::portable('COMMAND_COM')){
 	print "\nFixing Makefile for Win32...\n" ;
 	open(MAKEFILE, "<Makefile") or die "Can't open Makefile for reading" ;
 	my @lines = <MAKEFILE> ;
diff --git a/t/01_init.t b/t/01_init.t
index c14cdbe..df86a68 100644
--- a/t/01_init.t
+++ b/t/01_init.t
@@ -1,10 +1,10 @@
-use strict;
-use Test;
+use strict ;
+use Test ;
 
 BEGIN {
 	plan(tests => 1) ;
 }
 
-mkdir('./_Inline_test', 0777) unless -e './_Inline_test';
+mkdir('./_Inline_test', 0777) unless -e './_Inline_test' ;
 
 ok(1) ;
diff --git a/t/02_primitives.t b/t/02_primitives.t
index c2d4040..faff73f 100644
--- a/t/02_primitives.t
+++ b/t/02_primitives.t
@@ -2,9 +2,9 @@ use strict ;
 use Test ;
 
 use Inline Config => 
-           DIRECTORY => './_Inline_test';
+           DIRECTORY => './_Inline_test' ;
 
-use Inline(
+use Inline (
 	Java => 'DATA'
 ) ;
 
diff --git a/t/05_arrays.t b/t/05_arrays.t
index 87c9103..ee3ace7 100644
--- a/t/05_arrays.t
+++ b/t/05_arrays.t
@@ -9,48 +9,62 @@ use Inline(
 ) ;
 
 BEGIN {
-	plan(tests => 42) ;
+	plan(tests => 50) ;
 }
 
 
 my $t = new types5() ;
 
 {
-	ok($t->_byte([12, 34, 56])->[0] == 123) ;
+	ok(++($t->_byte([12, 34, 56])->[0]) == 124) ;
 	ok(eq_array($t->_Byte([12, 34, 56]), [12, 34, 56])) ;
-	ok($t->_short([12, 34, 56])->[0] == 123) ;
+	ok(++($t->_short([12, 34, 56])->[0]) == 124) ;
 	ok(eq_array($t->_Short([12, 34, 56]), [12, 34, 56])) ;
-	ok($t->_int([12, 34, 56])->[0] == 123) ;
+	ok(++($t->_int([12, 34, 56])->[0]) == 124) ;
 	ok(eq_array($t->_Integer([12, 34, 56]), [12, 34, 56])) ;
-	ok($t->_long([12, 34, 56])->[0] == 123) ;
+	ok(++($t->_long([12, 34, 56])->[0]) == 124) ;
 	ok(eq_array($t->_Long([12, 34, 56]), [12, 34, 56])) ;
-	ok($t->_float([12.34, 5.6, 7])->[0] == 123.456) ;
+	ok(++($t->_float([12.34, 5.6, 7])->[0]) == 124.456) ;
 	ok(eq_array($t->_Float([12.34, 5.6, 7]), [12.34, 5.6, 7])) ;
-	ok($t->_double([12.34, 5.6, 7])->[0] == 123.456) ;
+	ok(++($t->_double([12.34, 5.6, 7])->[0]) == 124.456) ;
 	ok(eq_array($t->_Double([12.34, 5.6, 7]), [12.34, 5.6, 7])) ;
 	ok($t->_boolean([1, 0, "tree"])->[0]) ;
 	ok($t->_Boolean([1, 0])->[0]) ;
 	ok(! $t->_Boolean([1, 0])->[1]) ;
 	ok($t->_char(['a', 'b', 'c'])->[0], "A") ;
 	ok(eq_array($t->_Character(['a', 'b', 'c']), ['a', 'b', 'c'], 1)) ;
-	ok($t->_String(["bla", "ble", "bli"])->[0], "STRING") ;
+	my $a = $t->_String(["bla", "ble", "bli"]) ;
+	ok($a->[0], "STRING") ;
+	$a->[1] = "wazoo" ;
+	ok($a->[1], "wazoo") ;
 	ok($t->_StringBuffer(["bla", "ble", "bli"])->[0], "STRINGBUFFER") ;
 	
 	ok($t->_Object(undef), undef) ;
-	my $a = $t->_Object([1, "two", $t]) ;
+	$a = $t->_Object([1, "two", $t]) ;
 	ok($a->[0], "1") ;
 	ok($a->[1], "two") ;
 	ok(UNIVERSAL::isa($a->[2], "main::types5")) ;
 	ok($a->[2]->{data}->[1], "a") ;
 	$a->[2]->{data} = ["1", "2"] ;
 	ok($a->[2]->{data}->[1], 2) ;
+
+	$a->[0]++ ;
+	ok($a->[0], "2") ;
+
+	$a->[1] = "three" ;
+	ok($a->[1], "three") ;
+
+	$a->[2] = "string" ;
+	ok($a->[2], "string") ;
+
+	$a->[0] = $t ;
+	ok(UNIVERSAL::isa($a->[0], "main::types5")) ;
 	
 	# Try some multidimensional arrays.
 	$a = $t->_StringString([
 		["00", "01"],
 		["10", "11"]
 	]) ;
-	ok($a->[1]->[0], "10") ;
 	
 	# Try some incomplete multidimensional arrays.
 	$a = $t->_StringString([
@@ -98,6 +112,13 @@ my $t = new types5() ;
 	eval {pop @{$b}} ; ok($@, qr/Operation POP/) ;
 	eval {shift @{$b}} ; ok($@, qr/Operation SHIFT/) ;
 	eval {splice(@{$b}, 0, 1)} ; ok($@, qr/Operation SPLICE/) ;
+
+	# Cool stuff on arrays
+	$a = $t->_byte([12, 34, 56]) ;
+	ok(scalar(@{$a}), 3) ;
+	foreach my $e (@{$a}){
+		ok($e =~ /^(123|34|56)$/) ;
+	}
 }
 
 ok($t->__get_private()->{proto}->ObjectCount(), 1) ;
diff --git a/t/07_polymorph.t b/t/07_polymorph.t
index c306f59..f42adfc 100644
--- a/t/07_polymorph.t
+++ b/t/07_polymorph.t
@@ -12,7 +12,7 @@ use Inline::Java qw(cast) ;
 
 
 BEGIN {
-	plan(tests => 18) ;
+	plan(tests => 22) ;
 }
 
 
@@ -44,6 +44,15 @@ my $t = new types7() ;
 	ok($t2->f($t1), "t2") ;
 	ok($t2->f(cast("t17", $t2)), "t2") ;
 
+	ok($t2->f($t1), "t2") ;
+
+	# Here we should always get the more specific stuff
+	ok($t2->{i}, 7) ;
+	ok($t2->{j}, 3.1416) ;
+
+	# So this should fail
+	eval {$t2->{j} = "string"} ; ok($@, qr/Can't convert/) ;
+
 	# Interfaces
 	my $al = $t1->get_al() ;
 	ok(0, $t1->count($al)) ;
@@ -60,6 +69,9 @@ __Java__
 import java.util.* ;
 
 class t17 {
+	public int i = 5 ;
+	public String j = "toto" ;
+
 	public t17(){
 	}
 
@@ -78,6 +90,9 @@ class t17 {
 
 
 class t27 extends t17 {
+	public int i = 7 ;
+	public double j = 3.1416 ;
+
 	public t27(){
 	}
 
diff --git a/t/13_callbacks.t b/t/13_callbacks.t
index 1cbee7e..7e26893 100644
--- a/t/13_callbacks.t
+++ b/t/13_callbacks.t
@@ -14,15 +14,17 @@ use Inline::Java qw(caught) ;
 
 
 BEGIN {
-	plan(tests => 19) ;
+	plan(tests => 20) ;
 }
 
-my $t = new t10() ;
+my $t = new t15() ;
 
 {
 	eval {
 		ok($t->add(5, 6), 11) ;
 		ok($t->add_via_perl(5, 6), 11) ;
+		my $a = $t->incr_via_perl([7, 6, 5]) ;
+		ok($a->[1], 7) ;
 		ok($t->mul(5, 6), 30) ;
 		ok($t->mul_via_perl(5, 6), 30) ;
 		ok($t->silly_mul(3, 2), 6) ;
@@ -33,7 +35,7 @@ my $t = new t10() ;
 		ok($t->add_via_perl_via_java(3, 4), 7) ;
 		ok($t->silly_mul_via_perl_via_java(10, 9), 90) ;
 
-		ok(t10->add_via_perl_via_java_t($t, 6, 9), 15) ;
+		ok(t15->add_via_perl_via_java_t($t, 6, 9), 15) ;
 
 		ok($t->cat_via_perl("Inline", "Java"), "InlineJava") ;
 
@@ -45,7 +47,7 @@ my $t = new t10() ;
 		my $msg = '' ;
 		eval {$t->twister(20, 0, 1)} ;
 		if ($@) {
-			if (caught('t10$OwnException')){
+			if (caught('t15$OwnException')){
 				$msg = $@->getMessage() ;
 			}
 			else{
@@ -82,6 +84,17 @@ sub add {
 }
 
 
+sub incr {
+	my $ija = shift ;
+	
+	for (my $i = 0 ; $i < $ija->length() ; $i++){
+		$ija->[$i]++ ;
+	}
+
+	return $ija ;
+}
+
+
 sub mul {
 	my $i = shift ;
 	my $j = shift ;
@@ -144,6 +157,7 @@ sub dummy {
 }
 
 
+
 __END__
 
 __Java__
@@ -151,7 +165,7 @@ __Java__
 
 import java.io.* ;
 
-class t10 extends InlineJavaPerlCaller {
+class t15 extends InlineJavaPerlCaller {
 	class OwnException extends Exception {
 		OwnException(String msg){
 			super(msg) ;
@@ -159,7 +173,7 @@ class t10 extends InlineJavaPerlCaller {
 	}
 
 
-	public t10() {
+	public t15() {
 	}
 
 	public int add(int a, int b){
@@ -186,7 +200,6 @@ class t10 extends InlineJavaPerlCaller {
 		return ret ;
 	}
 
-
 	public int add_via_perl(int a, int b) throws InlineJavaException, PerlException {
 		String val = (String)CallPerl("main", "add", 
 			new Object [] {new Integer(a), new Integer(b)}) ;
@@ -194,12 +207,19 @@ class t10 extends InlineJavaPerlCaller {
 		return new Integer(val).intValue() ;
 	}
 
+	public int [] incr_via_perl(int a[]) throws InlineJavaException, PerlException {
+		int [] r = (int [])CallPerl("main", "incr", 
+			new Object [] {a}, "[I") ;
+
+		return r ;
+	}
+
 	public void death_via_perl() throws InlineJavaException, PerlException {
 		InlineJavaPerlCaller c = new InlineJavaPerlCaller() ;
 		c.CallPerl("main", "death", null) ;
 	}
 
-	public void except() throws InlineJavaException, PerlException {		
+	public void except() throws InlineJavaException, PerlException {
 		throw new PerlException("test") ;
 	}
 
@@ -217,7 +237,7 @@ class t10 extends InlineJavaPerlCaller {
 		return new Integer(val).intValue() ;
 	}
 
-	static public int add_via_perl_via_java_t(t10 t, int a, int b) throws InlineJavaException, PerlException {
+	static public int add_via_perl_via_java_t(t15 t, int a, int b) throws InlineJavaException, PerlException {
 		InlineJavaPerlCaller c = new InlineJavaPerlCaller() ;
 		String val = (String)c.CallPerl("main", "add_via_java_t", 
 			new Object [] {t, new Integer(a), new Integer(b)}) ;

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



More information about the Pkg-perl-cvs-commits mailing list