Merge branch 'andrey-starodubtsev-directorargout_and_java_typemaps'

* andrey-starodubtsev-directorargout_and_java_typemaps: WIP: #704 (java directorargout + java/typemaps.i fixes) WIP: #704 (java directorargout + java/typemaps.i fixes) WIP: #704 (java directorargout + java/typemaps.i fixes) WIP: #704 (java directorargout + java/typemaps.i fixes) WIP: #704 (java directorargout + java/typemaps.i fixes) a lot of memory leak (local refs) fixed java directorargout + java/typemaps.i fixes
2017-01-24 19:04:35 +00:00 · 2017-01-24 19:04:35 +00:00 · 2abdb50f60
commit 2abdb50f60
parent d6d7afb755 519f296579
6 changed files with 611 additions and 36 deletions
--- a/Examples/test-suite/java/Makefile.in
+++ b/Examples/test-suite/java/Makefile.in
@ -28,6 +28,7 @@ CPP_TEST_CASES = \
 	java_director_exception_feature \
 	java_director_exception_feature_nspace \
 	java_director_ptrclass \
+	java_director_typemaps \
 	java_enums \
 	java_jnitypes \
 	java_lib_arrays_dimensionless \
--- a/Examples/test-suite/java/java_director_typemaps_runme.java
+++ b/Examples/test-suite/java/java_director_typemaps_runme.java
@ -0,0 +1,151 @@
+// tests for java/typemaps.i used for directors
+
+import java_director_typemaps.*;
+import java.math.BigInteger;
+
+public class java_director_typemaps_runme {
+
+  static {
+    try {
+      System.loadLibrary("java_director_typemaps");
+    } catch (UnsatisfiedLinkError e) {
+      System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e);
+      System.exit(1);
+    }
+  }
+
+
+  public static void main(String argv[]) {
+    Quux quux = new java_director_MyQuux();
+    quux.etest();
+  }
+}
+
+class java_director_MyQuux extends Quux {
+  public java_director_MyQuux() {
+    super();
+  }
+
+  public void director_method_bool_output(
+      boolean[] bool_arg,
+
+      byte[] signed_char_arg,
+      short[] unsigned_char_arg,
+
+      short[] short_arg,
+      int[] unsigned_short_arg,
+
+      int[] int_arg,
+      long[] unsigned_int_arg,
+
+      int[] long_arg,
+      long[] unsigned_long_arg,
+
+      long[] long_long_arg,
+      // BigInteger[] unsigned_long_long_arg,
+
+      float[] float_arg,
+      double[] double_arg)
+  {
+    bool_arg[0] = true;
+    signed_char_arg[0] = 1;
+    unsigned_char_arg[0] = 2;
+    short_arg[0] = 3;
+    unsigned_short_arg[0] = 4;
+    int_arg[0] = 5;
+    unsigned_int_arg[0] = 6;
+    long_arg[0] = 7;
+    unsigned_long_arg[0] = 8;
+    long_long_arg[0] = 9;
+    // unsigned_long_long_arg[0] = 10;
+    float_arg[0] = 11;
+    double_arg[0] = 12;
+  }
+
+  public void director_method_bool_inout(
+      boolean[] bool_arg,
+
+      byte[] signed_char_arg,
+      short[] unsigned_char_arg,
+
+      short[] short_arg,
+      int[] unsigned_short_arg,
+
+      int[] int_arg,
+      long[] unsigned_int_arg,
+
+      int[] long_arg,
+      long[] unsigned_long_arg,
+
+      long[] long_long_arg,
+      // BigInteger[] unsigned_long_long_arg,
+
+      float[] float_arg,
+      double[] double_arg)
+  {
+    if (bool_arg[0]) throw new RuntimeException("unexpected value for bool_arg");
+
+    if (signed_char_arg[0] != 101)  throw new RuntimeException("unexpected value for signed_char_arg");
+    if (unsigned_char_arg[0] != 101)  throw new RuntimeException("unexpected value for unsigned_char_arg");
+    if (short_arg[0] != 101)  throw new RuntimeException("unexpected value for short_arg");
+    if (unsigned_short_arg[0] != 101)  throw new RuntimeException("unexpected value for unsigned_short_arg");
+    if (int_arg[0] != 101)  throw new RuntimeException("unexpected value for int_arg");
+    if (unsigned_int_arg[0] != 101)  throw new RuntimeException("unexpected value for unsigned_int_arg");
+    if (long_arg[0] != 101)  throw new RuntimeException("unexpected value for long_arg");
+    if (unsigned_long_arg[0] != 101)  throw new RuntimeException("unexpected value for unsigned_long_arg");
+    if (long_long_arg[0] != 101)  throw new RuntimeException("unexpected value for long_long_arg");
+    // if (unsigned_long_long_arg[0] != 101)  throw new RuntimeException("unexpected value for unsigned_long_long_arg");
+    if (float_arg[0] != 101)  throw new RuntimeException("unexpected value for float_arg");
+    if (double_arg[0] != 101)  throw new RuntimeException("unexpected value for double_arg");
+
+    bool_arg[0] = false;
+    signed_char_arg[0] = 11;
+    unsigned_char_arg[0] = 12;
+    short_arg[0] = 13;
+    unsigned_short_arg[0] = 14;
+    int_arg[0] = 15;
+    unsigned_int_arg[0] = 16;
+    long_arg[0] = 17;
+    unsigned_long_arg[0] = 18;
+    long_long_arg[0] = 19;
+    // unsigned_long_long_arg[0] = 110;
+    float_arg[0] = 111;
+    double_arg[0] = 112;
+  }
+
+  public void director_method_bool_nameless_args(
+      boolean[] bool_arg,
+
+      byte[] signed_char_arg,
+      short[] unsigned_char_arg,
+
+      short[] short_arg,
+      int[] unsigned_short_arg,
+
+      int[] int_arg,
+      long[] unsigned_int_arg,
+
+      int[] long_arg,
+      long[] unsigned_long_arg,
+
+      long[] long_long_arg,
+      // BigInteger[] unsigned_long_long_arg,
+
+      float[] float_arg,
+      double[] double_arg)
+  {
+    bool_arg[0] = true;
+    signed_char_arg[0] = 12;
+    unsigned_char_arg[0] = 13;
+    short_arg[0] = 14;
+    unsigned_short_arg[0] = 15;
+    int_arg[0] = 16;
+    unsigned_int_arg[0] = 17;
+    long_arg[0] = 18;
+    unsigned_long_arg[0] = 19;
+    long_long_arg[0] = 20;
+    // unsigned_long_long_arg[0] = 111;
+    float_arg[0] = 112;
+    double_arg[0] = 113;
+  }
+}
--- a/Examples/test-suite/java_director_typemaps.i
+++ b/Examples/test-suite/java_director_typemaps.i
@ -0,0 +1,368 @@
+/*
+ * Test Lib/java/typemaps.i
+ */
+
+%module(directors="1") java_director
+
+%feature("director", assumeoverride=1) Quux;
+
+%include <typemaps.i>
+
+%apply bool& OUTPUT {bool&};
+
+%apply signed char& OUTPUT {signed char&};
+%apply unsigned char& OUTPUT {unsigned char&};
+
+%apply short& OUTPUT {short&};
+%apply unsigned short& OUTPUT {unsigned short&};
+
+%apply int& OUTPUT {int&};
+%apply unsigned int& OUTPUT {unsigned int&};
+
+%apply long& OUTPUT {long&};
+%apply unsigned long& OUTPUT {unsigned long&};
+
+%apply long long& OUTPUT {long long&};
+// %apply unsigned long long& OUTPUT {unsigned long long&};
+
+%apply float& OUTPUT {float&};
+%apply double& OUTPUT {double&};
+
+%apply bool& OUTPUT {bool& boolarg_output};
+
+%apply signed char& OUTPUT {signed char& signed_chararg_output};
+%apply unsigned char& OUTPUT {unsigned char& unsigned_chararg_output};
+
+%apply short& OUTPUT {short& shortarg_output};
+%apply unsigned short& OUTPUT {unsigned short& unsigned_shortarg_output};
+
+%apply int& OUTPUT {int& intarg_output};
+%apply unsigned int& OUTPUT {unsigned int& unsigned_intarg_output};
+
+%apply long& OUTPUT {long& longarg_output};
+%apply unsigned long& OUTPUT {unsigned long& unsigned_longarg_output};
+
+%apply long long& OUTPUT {long long& long_longarg_output};
+// %apply unsigned long long& OUTPUT {unsigned long long& unsigned_long_longarg_output};
+
+%apply float& OUTPUT {float& floatarg_output};
+%apply double& OUTPUT {double& doublearg_output};
+
+%apply bool& INOUT {bool& boolarg_inout};
+
+%apply signed char& INOUT {signed char& signed_chararg_inout};
+%apply unsigned char& INOUT {unsigned char& unsigned_chararg_inout};
+
+%apply short& INOUT {short& shortarg_inout};
+%apply unsigned short& INOUT {unsigned short& unsigned_shortarg_inout};
+
+%apply int& INOUT {int& intarg_inout};
+%apply unsigned int& INOUT {unsigned int& unsigned_intarg_inout};
+
+%apply long& INOUT {long& longarg_inout};
+%apply unsigned long& INOUT {unsigned long& unsigned_longarg_inout};
+
+%apply long long& INOUT {long long& long_longarg_inout};
+// %apply unsigned long long& INOUT {unsigned long long& unsigned_long_longarg_inout};
+
+%apply float& INOUT {float& floatarg_inout};
+%apply double& INOUT {double& doublearg_inout};
+
+%inline %{
+#include <assert.h>
+
+class Quux {
+public:
+  Quux() {}
+  virtual ~Quux() {}
+
+  virtual void director_method_bool_output(
+    bool& boolarg_output,
+
+    signed char& signed_chararg_output,
+    unsigned char& unsigned_chararg_output,
+
+    short& shortarg_output,
+    unsigned short& unsigned_shortarg_output,
+
+    int& intarg_output,
+    unsigned int& unsigned_intarg_output,
+
+    long& longarg_output,
+    unsigned long& unsigned_longarg_output,
+
+    long long& long_longarg_output,
+    // unsigned long long& unsigned_long_longarg_output,
+
+    float& floatarg_output,
+    double& doublearg_output)
+  {
+    boolarg_output = false;
+
+    signed_chararg_output = 50;
+    unsigned_chararg_output = 50;
+
+    shortarg_output = 50;
+    unsigned_shortarg_output = 50;
+
+    intarg_output = 50;
+    unsigned_intarg_output = 50;
+
+    longarg_output = 50;
+    unsigned_longarg_output = 50;
+
+    long_longarg_output = 50;
+    // unsigned_long_longarg_output = 50;
+
+    floatarg_output = 50;
+    doublearg_output = 50;
+  }
+
+  virtual void director_method_bool_inout(
+    bool& boolarg_inout,
+
+    signed char& signed_chararg_inout,
+    unsigned char& unsigned_chararg_inout,
+
+    short& shortarg_inout,
+    unsigned short& unsigned_shortarg_inout,
+
+    int& intarg_inout,
+    unsigned int& unsigned_intarg_inout,
+
+    long& longarg_inout,
+    unsigned long& unsigned_longarg_inout,
+
+    long long& long_longarg_inout,
+    // unsigned long long& unsigned_long_longarg_inout,
+
+    float& floatarg_inout,
+    double& doublearg_inout)
+  {
+    boolarg_inout = false;
+
+    signed_chararg_inout = 50;
+    unsigned_chararg_inout = 50;
+
+    shortarg_inout = 50;
+    unsigned_shortarg_inout = 50;
+
+    intarg_inout = 50;
+    unsigned_intarg_inout = 50;
+
+    longarg_inout = 50;
+    unsigned_longarg_inout = 50;
+
+    long_longarg_inout = 50;
+    // unsigned_long_longarg_inout = 50;
+
+    floatarg_inout = 50;
+    doublearg_inout = 50;
+  }
+
+  virtual void director_method_bool_nameless_args(
+    bool& ,
+
+    signed char& ,
+    unsigned char& ,
+
+    short& ,
+    unsigned short& ,
+
+    int& ,
+    unsigned int& ,
+
+    long& ,
+    unsigned long& ,
+
+    long long& ,
+    // unsigned long long& ,
+
+    float& ,
+    double&)
+  {
+  }
+
+  void etest() {
+    bool boolarg_inout = false;
+
+    signed char signed_chararg_inout = 150;
+    unsigned char unsigned_chararg_inout = 150;
+
+    short shortarg_inout = 150;
+    unsigned short unsigned_shortarg_inout = 150;
+
+    int intarg_inout = 150;
+    unsigned int unsigned_intarg_inout = 150;
+
+    long longarg_inout = 150;
+    unsigned long unsigned_longarg_inout = 150;
+
+    long long long_longarg_inout = 150;
+    // unsigned long long unsigned_long_longarg_inout = 150;
+
+    float floatarg_inout = 150;
+    double doublearg_inout = 150;
+
+    director_method_bool_output(
+       boolarg_inout,
+
+       signed_chararg_inout,
+       unsigned_chararg_inout,
+
+       shortarg_inout,
+       unsigned_shortarg_inout,
+
+       intarg_inout,
+       unsigned_intarg_inout,
+
+       longarg_inout,
+       unsigned_longarg_inout,
+
+       long_longarg_inout,
+       // unsigned_long_longarg_inout,
+
+       floatarg_inout,
+       doublearg_inout);
+
+    assert(boolarg_inout == true);
+    assert(signed_chararg_inout == 1);
+    assert(unsigned_chararg_inout == 2);
+
+    assert(shortarg_inout == 3);
+    assert(unsigned_shortarg_inout == 4);
+
+    assert(intarg_inout == 5);
+    assert(unsigned_intarg_inout == 6);
+
+    assert(longarg_inout == 7);
+    assert(unsigned_longarg_inout == 8);
+
+    assert(long_longarg_inout == 9);
+    // assert(unsigned_long_longarg_inout == 10);
+
+    assert(floatarg_inout == 11);
+    assert(doublearg_inout == 12);
+
+    boolarg_inout = false;
+
+    signed_chararg_inout = 101;
+    unsigned_chararg_inout = 101;
+
+    shortarg_inout = 101;
+    unsigned_shortarg_inout = 101;
+
+    intarg_inout = 101;
+    unsigned_intarg_inout = 101;
+
+    longarg_inout = 101;
+    unsigned_longarg_inout = 101;
+
+    long_longarg_inout = 101;
+    // unsigned_long_longarg_inout = 101;
+
+    floatarg_inout = 101;
+    doublearg_inout = 101;
+
+    director_method_bool_inout(
+       boolarg_inout,
+
+       signed_chararg_inout,
+       unsigned_chararg_inout,
+
+       shortarg_inout,
+       unsigned_shortarg_inout,
+
+       intarg_inout,
+       unsigned_intarg_inout,
+
+       longarg_inout,
+       unsigned_longarg_inout,
+
+       long_longarg_inout,
+       // unsigned_long_longarg_inout,
+
+       floatarg_inout,
+       doublearg_inout);
+
+    assert(boolarg_inout == false);
+    assert(signed_chararg_inout == 11);
+    assert(unsigned_chararg_inout == 12);
+
+    assert(shortarg_inout == 13);
+    assert(unsigned_shortarg_inout == 14);
+
+    assert(intarg_inout == 15);
+    assert(unsigned_intarg_inout == 16);
+
+    assert(longarg_inout == 17);
+    assert(unsigned_longarg_inout == 18);
+
+    assert(long_longarg_inout == 19);
+    // assert(unsigned_long_longarg_inout == 110);
+
+    assert(floatarg_inout == 111);
+    assert(doublearg_inout == 112);
+
+    director_method_bool_nameless_args(
+       boolarg_inout,
+
+       signed_chararg_inout,
+       unsigned_chararg_inout,
+
+       shortarg_inout,
+       unsigned_shortarg_inout,
+
+       intarg_inout,
+       unsigned_intarg_inout,
+
+       longarg_inout,
+       unsigned_longarg_inout,
+
+       long_longarg_inout,
+       // unsigned_long_longarg_inout,
+
+       floatarg_inout,
+       doublearg_inout);
+
+    assert(boolarg_inout == true);
+    assert(signed_chararg_inout == 12);
+    assert(unsigned_chararg_inout == 13);
+
+    assert(shortarg_inout == 14);
+    assert(unsigned_shortarg_inout == 15);
+
+    assert(intarg_inout == 16);
+    assert(unsigned_intarg_inout == 17);
+
+    assert(longarg_inout == 18);
+    assert(unsigned_longarg_inout == 19);
+
+    assert(long_longarg_inout == 20);
+    // assert(unsigned_long_longarg_inout == 111);
+
+    assert(floatarg_inout == 112);
+    assert(doublearg_inout == 113);
+  }
+};
+%}
+
+%clear bool&;
+
+%clear signed char&;
+%clear unsigned char&;
+
+%clear short&;
+%clear unsigned short&;
+
+%clear int&;
+%clear unsigned int&;
+
+%clear long&;
+%clear unsigned long&;
+
+%clear long long&;
+// %clear unsigned long long&;
+
+%clear float&;
+%clear double&;
--- a/Lib/java/java.swg
+++ b/Lib/java/java.swg
@ -363,11 +363,13 @@ SWIGINTERN const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz) {

  JCALL3(ReleaseByteArrayElements, jenv, ba, bae, 0);
  bigint = JCALL3(NewObject, jenv, clazz, mid, ba);
+  JCALL1(DeleteLocalRef, jenv, ba);
  $result = bigint;
 }

 /* Convert to BigInteger (see out typemap) */
-%typemap(directorin, descriptor="Ljava/math/BigInteger;") unsigned long long, const unsigned long long & {
+%typemap(directorin, descriptor="Ljava/math/BigInteger;", noblock=1) unsigned long long, const unsigned long long & {
+{
  jbyteArray ba = JCALL1(NewByteArray, jenv, 9);
  jbyte* bae = JCALL2(GetByteArrayElements, jenv, ba, 0);
  jclass clazz = JCALL1(FindClass, jenv, "java/math/BigInteger");
@ -382,8 +384,10 @@ SWIGINTERN const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz) {

  JCALL3(ReleaseByteArrayElements, jenv, ba, bae, 0);
  bigint = JCALL3(NewObject, jenv, clazz, mid, ba);
+  JCALL1(DeleteLocalRef, jenv, ba);
  $input = bigint;
 }
+Swig::LocalRefGuard $1_refguard(jenv, $input); }

 %typemap(javadirectorin) unsigned long long "$jniinput"
 %typemap(javadirectorout) unsigned long long "$javacall"
@ -611,6 +615,7 @@ SWIGINTERN const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz) {

  JCALL3(ReleaseByteArrayElements, jenv, ba, bae, 0);
  bigint = JCALL3(NewObject, jenv, clazz, mid, ba);
+  JCALL1(DeleteLocalRef, jenv, ba);
  $result = bigint;
 }

@ -1352,14 +1357,18 @@ SWIG_PROXY_CONSTRUCTOR(true, true, SWIGTYPE)
 %typemap(argout)  (char *STRING, size_t LENGTH) {
  if ($input) JCALL3(ReleaseByteArrayElements, jenv, $input, (jbyte *)$1, 0);
 }
-%typemap(directorin, descriptor="[B") (char *STRING, size_t LENGTH) {
-  jbyteArray jb = (jenv)->NewByteArray((jsize)$2);
-  (jenv)->SetByteArrayRegion(jb, 0, (jsize)$2, (jbyte *)$1);
-  $input = jb;
+%typemap(directorin, descriptor="[B", noblock=1) (char *STRING, size_t LENGTH) {
+  $input = 0;
+  if ($1) {
+    $input = JCALL1(NewByteArray, jenv, (jsize)$2);
+    if (!$input) return $null;
+    JCALL4(SetByteArrayRegion, jenv, $input, 0, (jsize)$2, (jbyte *)$1);
+  }
+  Swig::LocalRefGuard $1_refguard(jenv, $input);
+}
+%typemap(directorargout) (char *STRING, size_t LENGTH) {
+  if ($input && $1) (jenv)->GetByteArrayRegion($input, 0, (jsize)$2, (jbyte *)$1);
 }
-%typemap(directorargout) (char *STRING, size_t LENGTH)
-%{(jenv)->GetByteArrayRegion($input, 0, (jsize)$2, (jbyte *)$1);
-(jenv)->DeleteLocalRef($input);%}
 %typemap(javadirectorin, descriptor="[B") (char *STRING, size_t LENGTH) "$jniinput"
 %apply (char *STRING, size_t LENGTH) { (char *STRING, int LENGTH) }

--- a/Lib/java/typemaps.i
+++ b/Lib/java/typemaps.i
@ -187,6 +187,8 @@ There are no char *OUTPUT typemaps, however you can apply the signed char * type
 %typemap(jtype) TYPE *OUTPUT, TYPE &OUTPUT "JTYPE[]"
 %typemap(jstype) TYPE *OUTPUT, TYPE &OUTPUT "JTYPE[]"
 %typemap(javain) TYPE *OUTPUT, TYPE &OUTPUT "$javainput"
+%typemap(javadirectorin) TYPE *OUTPUT, TYPE &OUTPUT "$jniinput"
+%typemap(javadirectorout) TYPE *OUTPUT, TYPE &OUTPUT "$javacall"

 %typemap(in) TYPE *OUTPUT($*1_ltype temp), TYPE &OUTPUT($*1_ltype temp)
 {
@ -204,29 +206,47 @@ There are no char *OUTPUT typemaps, however you can apply the signed char * type

 %typemap(freearg) TYPE *OUTPUT, TYPE &OUTPUT ""

-%typemap(argout) TYPE *OUTPUT, TYPE &OUTPUT 
+%typemap(argout) TYPE *OUTPUT, TYPE &OUTPUT
 {
  JNITYPE jvalue = (JNITYPE)temp$argnum;
  JCALL4(Set##JAVATYPE##ArrayRegion, jenv, $input, 0, 1, &jvalue);
 }

+%typemap(directorin,descriptor=JNIDESC) TYPE &OUTPUT, TYPE *OUTPUT %{
+  $input = JCALL1(New##JAVATYPE##Array, jenv, 1);
+  Swig::LocalRefGuard $1_refguard(jenv, $input); %}
+
+%typemap(directorargout, noblock=1) TYPE &OUTPUT
+{
+  JNITYPE $1_jvalue;
+  JCALL4(Get##JAVATYPE##ArrayRegion, jenv, $input, 0, 1, &$1_jvalue);
+  $result = $1_jvalue;
+}
+
+%typemap(directorargout, noblock=1) TYPE *OUTPUT
+{
+  JNITYPE $1_jvalue;
+  JCALL4(Get##JAVATYPE##ArrayRegion, jenv, $input, 0, 1, &$1_jvalue);
+  *$result = $1_jvalue;
+}
+
 %typemap(typecheck) TYPE *OUTPUT = TYPECHECKTYPE;
 %typemap(typecheck) TYPE &OUTPUT = TYPECHECKTYPE;
 %enddef

-OUTPUT_TYPEMAP(bool, jboolean, boolean, Boolean, "[Ljava/lang/Boolean;", jbooleanArray);
-OUTPUT_TYPEMAP(signed char, jbyte, byte, Byte, "[Ljava/lang/Byte;", jbyteArray);               
-OUTPUT_TYPEMAP(unsigned char, jshort, short, Short, "[Ljava/lang/Short;", jshortArray);              
-OUTPUT_TYPEMAP(short, jshort, short, Short, "[Ljava/lang/Short;", jshortArray);              
-OUTPUT_TYPEMAP(unsigned short, jint, int, Int, "[Ljava/lang/Integer;", jintArray);                
-OUTPUT_TYPEMAP(int, jint, int, Int, "[Ljava/lang/Integer;", jintArray);                
-OUTPUT_TYPEMAP(unsigned int, jlong, long, Long, "[Ljava/lang/Long;", jlongArray);               
-OUTPUT_TYPEMAP(long, jint, int, Int, "[Ljava/lang/Integer;", jintArray);                
-OUTPUT_TYPEMAP(unsigned long, jlong, long, Long, "[Ljava/lang/Long;", jlongArray);               
-OUTPUT_TYPEMAP(long long, jlong, long, Long, "[Ljava/lang/Long;", jlongArray);               
-OUTPUT_TYPEMAP(unsigned long long, jobject, java.math.BigInteger, NOTUSED, "[Ljava/lang/BigInteger;", SWIGBIGINTEGERARRAY);
-OUTPUT_TYPEMAP(float, jfloat, float, Float, "[Ljava/lang/Float;", jfloatArray);              
-OUTPUT_TYPEMAP(double, jdouble, double, Double, "[Ljava/lang/Double;", jdoubleArray);             
+OUTPUT_TYPEMAP(bool, jboolean, boolean, Boolean, "[Z", jbooleanArray);
+OUTPUT_TYPEMAP(signed char, jbyte, byte, Byte, "[B", jbyteArray);
+OUTPUT_TYPEMAP(unsigned char, jshort, short, Short, "[S", jshortArray);
+OUTPUT_TYPEMAP(short, jshort, short, Short, "[S", jshortArray);
+OUTPUT_TYPEMAP(unsigned short, jint, int, Int, "[I", jintArray);
+OUTPUT_TYPEMAP(int, jint, int, Int, "[I", jintArray);
+OUTPUT_TYPEMAP(unsigned int, jlong, long, Long, "[J", jlongArray);
+OUTPUT_TYPEMAP(long, jint, int, Int, "[I", jintArray);
+OUTPUT_TYPEMAP(unsigned long, jlong, long, Long, "[J", jlongArray);
+OUTPUT_TYPEMAP(long long, jlong, long, Long, "[J", jlongArray);
+OUTPUT_TYPEMAP(unsigned long long, jobject, java.math.BigInteger, Object, "[Ljava/math/BigInteger;", jobjectArray);
+OUTPUT_TYPEMAP(float, jfloat, float, Float, "[F", jfloatArray);
+OUTPUT_TYPEMAP(double, jdouble, double, Double, "[D", jdoubleArray);

 #undef OUTPUT_TYPEMAP

@ -262,6 +282,7 @@ OUTPUT_TYPEMAP(double, jdouble, double, Double, "[Ljava/lang/Double;", jdoubleAr

  JCALL3(ReleaseByteArrayElements, jenv, ba, bae, 0);
  bigint = JCALL3(NewObject, jenv, clazz, mid, ba);
+  JCALL1(DeleteLocalRef, jenv, ba);
  JCALL3(SetObjectArrayElement, jenv, $input, 0, bigint);
 }

@ -330,6 +351,8 @@ There are no char *INOUT typemaps, however you can apply the signed char * typem
 %typemap(jtype) TYPE *INOUT, TYPE &INOUT "JTYPE[]"
 %typemap(jstype) TYPE *INOUT, TYPE &INOUT "JTYPE[]"
 %typemap(javain) TYPE *INOUT, TYPE &INOUT "$javainput"
+%typemap(javadirectorin) TYPE *INOUT, TYPE &INOUT "$jniinput"
+%typemap(javadirectorout) TYPE *INOUT, TYPE &INOUT "$javacall"

 %typemap(in) TYPE *INOUT, TYPE &INOUT {
  if (!$input) {
@ -348,24 +371,47 @@ There are no char *INOUT typemaps, however you can apply the signed char * typem
 %typemap(argout) TYPE *INOUT, TYPE &INOUT
 { JCALL3(Release##JAVATYPE##ArrayElements, jenv, $input, (JNITYPE *)$1, 0); }

+%typemap(directorin,descriptor=JNIDESC) TYPE &INOUT %{
+    $input = JCALL1(New##JAVATYPE##Array, jenv, 1);
+    JNITYPE $1_jvalue = (JNITYPE)$1;
+    JCALL4(Set##JAVATYPE##ArrayRegion, jenv, $input, 0, 1, &$1_jvalue);
+    Swig::LocalRefGuard $1_refguard(jenv, $input); %}
+
+%typemap(directorin,descriptor=JNIDESC) TYPE *INOUT %{
+  $input = JCALL1(New##JAVATYPE##Array, jenv, 1);
+  JNITYPE $1_jvalue = (JNITYPE)*$1;
+  JCALL4(Set##JAVATYPE##ArrayRegion, jenv, $input, 0, 1, &$1_jvalue);
+  Swig::LocalRefGuard $1_refguard(jenv, $input); %}
+
+%typemap(directorargout, noblock=1) TYPE &INOUT
+{
+  JCALL4(Get##JAVATYPE##ArrayRegion, jenv, $input, 0, 1, &$1_jvalue);
+  $result = $1_jvalue;
+}
+
+%typemap(directorargout, noblock=1) TYPE *INOUT
+{
+  JCALL4(Get##JAVATYPE##ArrayRegion, jenv, $input, 0, 1, &$1_jvalue);
+  *$result = $1_jvalue;
+}

 %typemap(typecheck) TYPE *INOUT = TYPECHECKTYPE;
 %typemap(typecheck) TYPE &INOUT = TYPECHECKTYPE;
 %enddef

-INOUT_TYPEMAP(bool, jboolean, boolean, Boolean, "[Ljava/lang/Boolean;", jbooleanArray); 
-INOUT_TYPEMAP(signed char, jbyte, byte, Byte, "[Ljava/lang/Byte;", jbyteArray); 
-INOUT_TYPEMAP(unsigned char, jshort, short, Short, "[Ljava/lang/Short;", jshortArray);     
-INOUT_TYPEMAP(short, jshort, short, Short, "[Ljava/lang/Short;", jshortArray);
-INOUT_TYPEMAP(unsigned short, jint, int, Int, "[Ljava/lang/Integer;", jintArray); 
-INOUT_TYPEMAP(int, jint, int, Int, "[Ljava/lang/Integer;", jintArray);
-INOUT_TYPEMAP(unsigned int, jlong, long, Long, "[Ljava/lang/Long;", jlongArray); 
-INOUT_TYPEMAP(long, jint, int, Int, "[Ljava/lang/Integer;", jintArray);
-INOUT_TYPEMAP(unsigned long, jlong, long, Long, "[Ljava/lang/Long;", jlongArray); 
-INOUT_TYPEMAP(long long, jlong, long, Long, "[Ljava/lang/Long;", jlongArray);
-INOUT_TYPEMAP(unsigned long long, jobject, java.math.BigInteger, NOTUSED, "[Ljava.math.BigInteger;", SWIGBIGINTEGERARRAY);
-INOUT_TYPEMAP(float, jfloat, float, Float, "[Ljava/lang/Float;", jfloatArray);
-INOUT_TYPEMAP(double, jdouble, double, Double, "[Ljava/lang/Double;", jdoubleArray); 
+INOUT_TYPEMAP(bool, jboolean, boolean, Boolean, "[Z", jbooleanArray);
+INOUT_TYPEMAP(signed char, jbyte, byte, Byte, "[B", jbyteArray);
+INOUT_TYPEMAP(unsigned char, jshort, short, Short, "[S", jshortArray);
+INOUT_TYPEMAP(short, jshort, short, Short, "[S", jshortArray);
+INOUT_TYPEMAP(unsigned short, jint, int, Int, "[I", jintArray);
+INOUT_TYPEMAP(int, jint, int, Int, "[I", jintArray);
+INOUT_TYPEMAP(unsigned int, jlong, long, Long, "[J", jlongArray);
+INOUT_TYPEMAP(long, jint, int, Int, "[I", jintArray);
+INOUT_TYPEMAP(unsigned long, jlong, long, Long, "[J", jlongArray);
+INOUT_TYPEMAP(long long, jlong, long, Long, "[J", jlongArray);
+INOUT_TYPEMAP(unsigned long long, jobject, java.math.BigInteger, Object, "[java/math/BigInteger;", jobjectArray);
+INOUT_TYPEMAP(float, jfloat, float, Float, "[F", jfloatArray);
+INOUT_TYPEMAP(double, jdouble, double, Double, "[D", jdoubleArray);

 #undef INOUT_TYPEMAP

--- a/Source/Modules/java.cxx
+++ b/Source/Modules/java.cxx
@ -4399,7 +4399,7 @@ public:
      for (p = l; p;) {
 	if ((tm = Getattr(p, "tmap:directorargout"))) {
 	  addThrows(n, "tmap:directorargout", p);
-	  Replaceall(tm, "$result", "jresult");
+	  Replaceall(tm, "$result", makeParameterName(n, p, i, false));
 	  Replaceall(tm, "$input", Getattr(p, "emit:directorinput"));
 	  Printv(w->code, tm, "\n", NIL);
 	  p = Getattr(p, "tmap:directorargout:next");