diff --git a/Lib/java/arrays_java.i b/Lib/java/arrays_java.i index fedc8743c..8fc303364 100644 --- a/Lib/java/arrays_java.i +++ b/Lib/java/arrays_java.i @@ -182,8 +182,38 @@ JAVA_ARRAYS_IMPL(double, jdouble, Double, Double) /* double[] */ %typemap(jstype) float[ANY] "float[]" %typemap(jstype) double[ANY] "double[]" +%typemap(directorin) bool[ANY], + signed char[ANY], + unsigned char[ANY], + short[ANY], + unsigned short[ANY], + int[ANY], + unsigned int[ANY], + long[ANY], + unsigned long[ANY], + long long[ANY], + /* unsigned long long[ANY], */ + float[ANY], + double[ANY] + "$jniinput" + +%typemap(directorout) bool[ANY], + signed char[ANY], + unsigned char[ANY], + short[ANY], + unsigned short[ANY], + int[ANY], + unsigned int[ANY], + long[ANY], + unsigned long[ANY], + long long[ANY], + /* unsigned long long[ANY], */ + float[ANY], + double[ANY] + "$javacall" + /* Arrays of primitive types use the following macro. The array typemaps use support functions. */ -%define JAVA_ARRAYS_TYPEMAPS(CTYPE, JNITYPE, JFUNCNAME) +%define JAVA_ARRAYS_TYPEMAPS(CTYPE, JNITYPE, JFUNCNAME, JNIDESC) %typemap(in) CTYPE[] (JNITYPE *jarr) %{ if (!SWIG_JavaArrayIn##JFUNCNAME(jenv, &jarr, &$1, $input)) return $null; %} @@ -195,6 +225,8 @@ JAVA_ARRAYS_IMPL(double, jdouble, Double, Double) /* double[] */ if (!SWIG_JavaArrayIn##JFUNCNAME(jenv, &jarr, &$1, $input)) return $null; %} %typemap(argout) CTYPE[ANY] %{ SWIG_JavaArrayArgout##JFUNCNAME(jenv, jarr$argnum, $1, $input); %} +%typemap(inv,parse=JNIDESC) CTYPE[ANY] +%{$input = SWIG_JavaArrayOut##JFUNCNAME(jenv, $1, $1_dim0); %} %typemap(out) CTYPE[ANY] %{$result = SWIG_JavaArrayOut##JFUNCNAME(jenv, $1, $1_dim0); %} %typemap(freearg) CTYPE[ANY] @@ -203,21 +235,25 @@ JAVA_ARRAYS_IMPL(double, jdouble, Double, Double) /* double[] */ #else %{ free($1); %} #endif +%typemap(director_in) CTYPE[ANY] +%{$result = SWIG_JavaArrayOut##JFUNCNAME(jenv, $1, $1_dim0); %} +%typemap(director_out) CTYPE[] (JNITYPE *jarr) +%{ if (!SWIG_JavaArrayIn##JFUNCNAME(jenv, &jarr, &$1, $input)) return $null; %} %enddef -JAVA_ARRAYS_TYPEMAPS(bool, jboolean, Bool) /* bool[ANY] */ -JAVA_ARRAYS_TYPEMAPS(signed char, jbyte, Schar) /* signed char[ANY] */ -JAVA_ARRAYS_TYPEMAPS(unsigned char, jshort, Uchar) /* unsigned char[ANY] */ -JAVA_ARRAYS_TYPEMAPS(short, jshort, Short) /* short[ANY] */ -JAVA_ARRAYS_TYPEMAPS(unsigned short, jint, Ushort) /* unsigned short[ANY] */ -JAVA_ARRAYS_TYPEMAPS(int, jint, Int) /* int[ANY] */ -JAVA_ARRAYS_TYPEMAPS(unsigned int, jlong, Uint) /* unsigned int[ANY] */ -JAVA_ARRAYS_TYPEMAPS(long, jint, Long) /* long[ANY] */ -JAVA_ARRAYS_TYPEMAPS(unsigned long, jlong, Ulong) /* unsigned long[ANY] */ -JAVA_ARRAYS_TYPEMAPS(long long, jlong, Longlong) /* long long[ANY] */ -JAVA_ARRAYS_TYPEMAPS(float, jfloat, Float) /* float[ANY] */ -JAVA_ARRAYS_TYPEMAPS(double, jdouble, Double) /* double[ANY] */ +JAVA_ARRAYS_TYPEMAPS(bool, jboolean, Bool, "[Z") /* bool[ANY] */ +JAVA_ARRAYS_TYPEMAPS(signed char, jbyte, Schar, "[B") /* signed char[ANY] */ +JAVA_ARRAYS_TYPEMAPS(unsigned char, jshort, Uchar, "[S") /* unsigned char[ANY] */ +JAVA_ARRAYS_TYPEMAPS(short, jshort, Short, "[S") /* short[ANY] */ +JAVA_ARRAYS_TYPEMAPS(unsigned short, jint, Ushort, "[I") /* unsigned short[ANY] */ +JAVA_ARRAYS_TYPEMAPS(int, jint, Int, "[I") /* int[ANY] */ +JAVA_ARRAYS_TYPEMAPS(unsigned int, jlong, Uint, "[J") /* unsigned int[ANY] */ +JAVA_ARRAYS_TYPEMAPS(long, jint, Long, "[I") /* long[ANY] */ +JAVA_ARRAYS_TYPEMAPS(unsigned long, jlong, Ulong, "[J") /* unsigned long[ANY] */ +JAVA_ARRAYS_TYPEMAPS(long long, jlong, Longlong, "[J") /* long long[ANY] */ +JAVA_ARRAYS_TYPEMAPS(float, jfloat, Float, "[F") /* float[ANY] */ +JAVA_ARRAYS_TYPEMAPS(double, jdouble, Double, "[D") /* double[ANY] */ %typecheck(SWIG_TYPECHECK_BOOL_ARRAY) /* Java boolean[] */ bool[ANY] diff --git a/Lib/java/director.swg b/Lib/java/director.swg new file mode 100644 index 000000000..6a6e7c041 --- /dev/null +++ b/Lib/java/director.swg @@ -0,0 +1,94 @@ +/*********************************************************************** + * director.swg + * + * This file contains support for director classes that proxy + * method calls from C++ to Java extensions. + * + * Author : Scott Michel (scottm@aero.org) + * + * N.B.: This file was + adapted from the python director.swg, written by + * Mark Rose (mrose@stm.lbl.gov) + ************************************************************************/ + +#ifdef __cplusplus + +/* director base class */ +class __DIRECTOR__ { +private: + /* pointer to java virtual machine */ + JavaVM *__jvm; + +protected: + /* pointer to the wrapped java object */ + jobject __self; + /* ricochet flag: Prevent user from shooting themselves in the + foot by detecting recursive upcall */ + bool __ricochet; + + /* Acquire Java VM environment from Java VM */ + JNIEnv *__acquire_jenv() const { + JNIEnv *env; + assert(__jvm); + __jvm->AttachCurrentThread((void **) &env, NULL); + return env; + } + +public: + /* the default constructor should not be called */ + __DIRECTOR__() : __jvm(NULL), __self(NULL), __ricochet(false) { + assert(0); + } + + /* Default constructor */ + __DIRECTOR__(JNIEnv *jenv): + __jvm((JavaVM *) NULL), + __self(NULL), + __ricochet(false) + { + /* Acquire the Java VM pointer */ + jenv->GetJavaVM(&__jvm); + } + + /* Remove the Java object global lock at destruction */ + virtual ~__DIRECTOR__() + { + if (__self) { + JNIEnv *jenv; + + jenv = __acquire_jenv(); + jenv->DeleteGlobalRef(__self); + __self = (jobject) NULL; + } + } + + /* Set __self and get Java global reference on object */ + inline void __set_self(JNIEnv *jenv, jobject jself) + { + __self = jenv->NewGlobalRef(jself); + } + + /* return a pointer to the wrapped java object */ + inline jobject __get_self() const + { return __self; } + + /* Get ricochet flag, resetting it on the way out */ + inline bool __get_ricochet() + { + bool __r = __ricochet; + __ricochet = false; + return __r; + } + + /* Set the ricochet flag */ + inline void __set_ricochet() + { __ricochet = true; } + + /* Clear the ricochet flag */ + inline void __clear_ricochet() + { __ricochet = false; } +}; + +#endif /* __cplusplus */ + + diff --git a/Lib/java/java.swg b/Lib/java/java.swg index 33b4b2d8f..5827ce841 100644 --- a/Lib/java/java.swg +++ b/Lib/java/java.swg @@ -161,6 +161,9 @@ %typemap(in) bool %{ $1 = $input ? true : false; %} +%typemap(directorin) bool "$jniinput" +%typemap(directorout) bool "$javacall" + %typemap(in) char, signed char, unsigned char, @@ -176,6 +179,51 @@ enum SWIGTYPE %{ $1 = ($1_ltype)$input; %} +%typemap(inv, parse="Z") bool "$input = (jboolean) $1;" +%typemap(inv, parse="C") char "$input = (jint) $1;" +%typemap(inv, parse="B") signed char "$input = (jbyte) $1;" +%typemap(inv, parse="S") unsigned char "$input = (jshort) $1;" +%typemap(inv, parse="S") short "$input = (jshort) $1;" +%typemap(inv, parse="I") unsigned short "$input = (jint) $1;" +%typemap(inv, parse="I") int "$input = (jint) $1;" +%typemap(inv, parse="J") unsigned int "$input = (jlong) $1;" +%typemap(inv, parse="I") long "$input = (jint) $1;" +%typemap(inv, parse="J") unsigned long "$input = (jlong) $1;" +%typemap(inv, parse="J") long long "$input = (jlong) $1;" +%typemap(inv, parse="F") float "$input = (jfloat) $1;" +%typemap(inv, parse="D") double "$input = (jdouble) $1;" +%typemap(inv, parse="I") enum SWIGTYPE "$input = (jing) $1;" + +%typemap(directorin) char, + signed char, + unsigned char, + short, + unsigned short, + int, + unsigned int, + long, + unsigned long, + long long, + float, + double, + enum SWIGTYPE + "$jniinput" + +%typemap(directorout) char, + signed char, + unsigned char, + short, + unsigned short, + int, + unsigned int, + long, + unsigned long, + long long, + float, + double, + enum SWIGTYPE + "$javacall" + %typemap(out) bool %{ $result = (jboolean)$1; %} %typemap(out) char %{ $result = (jchar)$1; %} %typemap(out) signed char %{ $result = (jbyte)$1; %} @@ -191,7 +239,6 @@ %typemap(out) double %{ $result = (jdouble)$1; %} %typemap(out) enum SWIGTYPE %{ $result = (jint)$1; %} - /* unsigned long long */ /* Convert from BigInteger using the toByteArray member function */ %typemap(in) unsigned long long { @@ -244,6 +291,28 @@ $result = bigint; } +/* Convert to BigInteger (see out typemap) */ +%typemap(inv, parse="Ljava/math/Biginteger;") 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"); + jmethodID mid = JCALL3(GetMethodID, jenv, clazz, "", "([B)V"); + jobject bigint; + int i; + + bae[0] = 0; + for(i=1; i<9; i++ ) { + bae[i] = (jbyte)($1>>8*(8-i)); + } + + JCALL3(ReleaseByteArrayElements, jenv, ba, bae, 0); + bigint = JCALL3(NewObject, jenv, clazz, mid, ba); + $input = bigint; +} + +%typemap(directorin) unsigned long long "$jniinput" +%typemap(directorout) unsigned long long "$javacall" + /* char * - treat as String */ %typemap(in) char * { $1 = 0; @@ -252,16 +321,32 @@ if (!$1) return $null; } } + +%typemap(inv, parse="Ljava/lang/string;") char * { + $input = 0; + if ($1) { + $input = JCALL1(NewStringUTF, jenv, $1); + if (!$input) return $null; + } +} %typemap(freearg) char * { if ($1) JCALL2(ReleaseStringUTFChars, jenv, $input, $1); } %typemap(out) char * { if($1) $result = JCALL1(NewStringUTF, jenv, $1); } +%typemap(directorin) char * "$jniinput" +%typemap(directorout) char * "$javacall" %typemap(out) void "" +%typemap(directorin) void "$jniinput" +%typemap(directorout) void "$javacall" +%typemap(inv, parse="V") void "" /* primitive types by reference */ %typemap(in) const bool & (bool temp) %{ temp = $input ? true : false; $1 = &temp; %} +%typemap(directorin) const bool & "$jniinput" +%typemap(directorout) const bool & "$javacall" + %typemap(in) const char & (char temp), const signed char & (signed char temp), const unsigned char & (unsigned char temp), @@ -277,6 +362,49 @@ %{ temp = ($*1_ltype)$input; $1 = &temp; %} +%typemap(inv, parse="Z") const bool & "$input = (jboolean)$1_name;" +%typemap(inv, parse="C") const char & "$input = (jchar)$1_name;" +%typemap(inv, parse="B") const signed char & "$input = (jbyte)$1_name;" +%typemap(inv, parse="S") const unsigned char & "$input = (jshort)$1_name;" +%typemap(inv, parse="S") const short & "$input = (jshort)$1_name;" +%typemap(inv, parse="I") const unsigned short & "$input = (jint)$1_name;" +%typemap(inv, parse="I") const int & "$input = (jint)$1_name;" +%typemap(inv, parse="J") const unsigned int & "$input = (jlong)$1_name;" +%typemap(inv, parse="I") const long & "$input = (jint)$1_name;" +%typemap(inv, parse="J") const unsigned long & "$input = (jlong)$1_name;" +%typemap(inv, parse="J") const long long & "$input = (jlong)$1_name;" +%typemap(inv, parse="F") const float & "$input = (jfloat)$1_name;" +%typemap(inv, parse="D") const double & "$input = (jdouble)$1_name;" + +%typemap(directorin) const char & (char temp), + const signed char & (signed char temp), + const unsigned char & (unsigned char temp), + const short & (short temp), + const unsigned short & (unsigned short temp), + const int & (int temp), + const unsigned int & (unsigned int temp), + const long & (long temp), + const unsigned long & (unsigned long temp), + const long long & ($*1_ltype temp), + const float & (float temp), + const double & (double temp) + "$jniinput" + +%typemap(directorout) const char & (char temp), + const signed char & (signed char temp), + const unsigned char & (unsigned char temp), + const short & (short temp), + const unsigned short & (unsigned short temp), + const int & (int temp), + const unsigned int & (unsigned int temp), + const long & (long temp), + const unsigned long & (unsigned long temp), + const long long & ($*1_ltype temp), + const float & (float temp), + const double & (double temp) + "$javacall" + + %typemap(out) const bool & %{ $result = (jboolean)*$1; %} %typemap(out) const char & %{ $result = (jchar)*$1; %} %typemap(out) const signed char & %{ $result = (jbyte)*$1; %} @@ -343,6 +471,9 @@ $result = bigint; } +%typemap(directorin) const unsigned long long & "$jniinput" +%typemap(directorout) const unsigned long long & "$javacall" + /* Default handling. Object passed by value. Convert to a pointer */ %typemap(in) SWIGTYPE ($&1_type argp) %{ argp = *($&1_ltype*)&$input; @@ -351,6 +482,7 @@ return $null; } $1 = *argp; %} + %typemap(out) SWIGTYPE #ifdef __cplusplus %{*($&1_ltype*)&$result = new $1_ltype(($1_ltype &)$1); %} @@ -362,6 +494,10 @@ } #endif +%typemap(inv,parse="L$packagepath/$javaclassname;") SWIGTYPE "*(($&1_type)&$input) = &$1;" +%typemap(directorin) SWIGTYPE "new $javaclassname($jniinput, false)" +%typemap(directorout) SWIGTYPE "$javaclassname.getCPtr($javacall)" + /* Generic pointers and references */ %typemap(in) SWIGTYPE *, SWIGTYPE (CLASS::*) %{ $1 = *($&1_ltype)&$input; %} %typemap(in) SWIGTYPE & %{ $1 = *($&1_ltype)&$input; @@ -369,8 +505,19 @@ SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "$1_type reference is null"); return $null; } %} -%typemap(out) SWIGTYPE *, SWIGTYPE &, SWIGTYPE (CLASS::*) %{ *($&1_ltype)&$result = $1; %} +%typemap(out) SWIGTYPE *, SWIGTYPE (CLASS::*) +%{ *($&1_ltype)&$result = $1; %} +%typemap(out) SWIGTYPE & +%{ *($&1_ltype)&$result = $1; %} +%typemap(inv,parse="L$packagepath/$javaclassname;") SWIGTYPE *, SWIGTYPE (CLASS::*), SWIGTYPE &, const SWIGTYPE & +%{ *(($&1_ltype)&$input) = $1; %} + +%typemap(inv,parse="L$packagepath/$javaclassname;") SWIGTYPE &, const SWIGTYPE & +%{ *($&1_ltype)&$input = &$1; %} + +%typemap(directorin) SWIGTYPE *, SWIGTYPE (CLASS::*), SWIGTYPE &, const SWIGTYPE & "new $javaclassname($jniinput, false)" +%typemap(directorout) SWIGTYPE *, SWIGTYPE (CLASS::*), SWIGTYPE &, const SWIGTYPE & "$javaclassname.getCPtr($javacall)" /* Default array handling */ %typemap(in) SWIGTYPE [] %{ $1 = *($&1_ltype)&$input; %} @@ -384,9 +531,14 @@ if (!$1) return $null; } } + +%typemap(inv,parse="Ljava/lang/String;") char[ANY] "$input = JCALL1(NewStringUTF, jenv, $1_name);" + %typemap(argout) char[ANY] "" %typemap(freearg) char[ANY] { if ($1) JCALL2(ReleaseStringUTFChars, jenv, $input, $1); } %typemap(out) char[ANY] { if($1) $result = JCALL1(NewStringUTF, jenv, $1); } +%typemap(directorin) char[ANY] "$jniinput" +%typemap(directorout) char[ANY] "$javacall" /* JNI types */ %typemap(in) jboolean, @@ -431,6 +583,67 @@ jobjectArray %{ $result = $1; %} +%typemap(inv,parse="Z") jboolean "$input = $1;" +%typemap(inv,parse="C") jchar "$input = $1;" +%typemap(inv,parse="B") jbyte "$input = $1;" +%typemap(inv,parse="S") jshort "$input = $1;" +%typemap(inv,parse="I") jint "$input = $1;" +%typemap(inv,parse="J") jlong "$input = $1;" +%typemap(inv,parse="F") jfloat "$input = $1;" +%typemap(inv,parse="D") jdouble "$input = $1;" +%typemap(inv,parse="Ljava/lang/String;") jstring "$input = $1;" +%typemap(inv,parse="Ljava/lang/Object;") jobject "$input = $1;" +%typemap(inv,parse="[Z") jbooleanArray "$input = $1;" +%typemap(inv,parse="[C") jcharArray "$input = $1;" +%typemap(inv,parse="[B") jbyteArray "$input = $1;" +%typemap(inv,parse="[S") jshortArray "$input = $1;" +%typemap(inv,parse="[I") jintArray "$input = $1;" +%typemap(inv,parse="[J") jlongArray "$input = $1;" +%typemap(inv,parse="[F") jfloatArray "$input = $1;" +%typemap(inv,parse="[D") jdoubleArray "$input = $1;" +%typemap(inv,parse="[Ljava/lang/Object;") jobjectArray "$input = $1;" + +%typemap(directorin) jboolean, + jchar, + jbyte, + jshort, + jint, + jlong, + jfloat, + jdouble, + jstring, + jobject, + jbooleanArray, + jcharArray, + jbyteArray, + jshortArray, + jintArray, + jlongArray, + jfloatArray, + jdoubleArray, + jobjectArray + "$jniinput" + +%typemap(directorout) jboolean, + jchar, + jbyte, + jshort, + jint, + jlong, + jfloat, + jdouble, + jstring, + jobject, + jbooleanArray, + jcharArray, + jbyteArray, + jshortArray, + jintArray, + jlongArray, + jfloatArray, + jdoubleArray, + jobjectArray + "$javacall" /* Typecheck typemaps - The purpose of these is merely to issue a warning for overloaded C++ functions * that cannot be overloaded in Java as more than one C++ type maps to a single Java type */ @@ -536,6 +749,10 @@ jdoubleArray "" +%typecheck(SWIG_TYPECHECK_OBJECT_ARRAY) /* Java jobject[] */ + jobjectArray + "" + %typecheck(SWIG_TYPECHECK_POINTER) /* Default */ SWIGTYPE, SWIGTYPE *, diff --git a/Lib/java/javahead.swg b/Lib/java/javahead.swg index be33ae657..872d56d7a 100644 --- a/Lib/java/javahead.swg +++ b/Lib/java/javahead.swg @@ -48,6 +48,8 @@ typedef enum { SWIG_JavaArithmeticException, SWIG_JavaIllegalArgumentException, SWIG_JavaNullPointerException, + SWIG_JavaDirectorRicochet, + SWIG_JavaDirectorPureVirtual, SWIG_JavaUnknownError } SWIG_JavaExceptionCodes; @@ -71,6 +73,8 @@ void SWIG_JavaThrowException(JNIEnv *jenv, SWIG_JavaExceptionCodes code, const c { SWIG_JavaArithmeticException, "java/lang/ArithmeticException" }, { SWIG_JavaIllegalArgumentException, "java/lang/IllegalArgumentException" }, { SWIG_JavaNullPointerException, "java/lang/NullPointerException" }, + { SWIG_JavaDirectorRicochet, "java/lang/RuntimeException" }, + { SWIG_JavaDirectorPureVirtual, "java/lang/RuntimeException" }, { SWIG_JavaUnknownError, "java/lang/UnknownError" }, { (SWIG_JavaExceptionCodes)0, "java/lang/UnknownError" } }; const SWIG_JavaExceptions_t *except_ptr = java_exceptions; @@ -87,4 +91,3 @@ void SWIG_JavaThrowException(JNIEnv *jenv, SWIG_JavaExceptionCodes code, const c %insert(runtime) %{ #endif %} - diff --git a/Lib/java/std_string.i b/Lib/java/std_string.i index 27a9d91f0..9fe839fd0 100644 --- a/Lib/java/std_string.i +++ b/Lib/java/std_string.i @@ -28,6 +28,8 @@ class string; %typemap(jni) string "jstring" %typemap(jtype) string "String" %typemap(jstype) string "String" +%typemap(directorin) string "$jniinput" +%typemap(directorout) string "$javacall" %typemap(in) string %{if($input) { @@ -41,6 +43,9 @@ class string; return $null; } %} +%typemap(inv,parse="Ljava/lang/String;") string +%{ $input = jenv->NewStringUTF($1.c_str()); %} + %typemap(out) string %{ $result = jenv->NewStringUTF($1.c_str()); %} @@ -56,6 +61,8 @@ class string; %typemap(jni) const string & "jstring" %typemap(jtype) const string & "String" %typemap(jstype) const string & "String" +%typemap(directorin) const string & "$jniinput" +%typemap(directorout) const string & "$javacall" %typemap(in) const string & %{$1 = NULL; @@ -73,6 +80,9 @@ class string; %typemap(freearg) const string & %{ delete $1; %} +%typemap(inv,parse="Ljava/lang/String;") const string & +%{ $input = jenv->NewStringUTF($1.c_str()); %} + %typemap(out) const string & %{ $result = jenv->NewStringUTF($1->c_str()); %} @@ -109,6 +119,8 @@ class wstring; %typemap(jni) wstring "jstring" %typemap(jtype) wstring "String" %typemap(jstype) wstring "String" +%typemap(directorin) wstring "$jniinput" +%typemap(directorout) wstring "$javacall" %typemap(in) wstring %{if($input) { @@ -130,6 +142,15 @@ class wstring; return $null; } %} +%typemap(inv,parse="Ljava/lang/String;") wstring +%{jsize len = $1.length(); + jchar *conv_buf = new jchar[len]; + for (jsize i = 0; i < len; ++i) { + conv_buf[i] = (jchar)$1[i]; + } + $input = jenv->NewString(conv_buf, len); + delete [] conv_buf; %} + %typemap(out) wstring %{jsize len = $1.length(); jchar *conv_buf = new jchar[len]; @@ -149,6 +170,8 @@ class wstring; %typemap(jni) const wstring & "jstring" %typemap(jtype) const wstring & "String" %typemap(jstype) const wstring & "String" +%typemap(directorin) const wstring & "$jniinput" +%typemap(directorout) const wstring & "$javacall" %typemap(in) const wstring & %{$1 = NULL; @@ -171,6 +194,15 @@ class wstring; return $null; } %} +%typemap(inv,parse="Ljava/lang/String;") const wstring & +%{jsize len = $1->length(); + jchar *conv_buf = new jchar[len]; + for (jsize i = 0; i < len; ++i) { + conv_buf[i] = (jchar)(*$1)[i]; + } + $input = jenv->NewString(conv_buf, len); + delete [] conv_buf; %} + %typemap(out) const wstring & %{jsize len = $1->length(); jchar *conv_buf = new jchar[len]; diff --git a/Lib/java/typemaps.i b/Lib/java/typemaps.i index 912afc57b..340f1facb 100644 --- a/Lib/java/typemaps.i +++ b/Lib/java/typemaps.i @@ -58,37 +58,47 @@ In Java you could then use it like this: */ -%define INPUT_TYPEMAP(CTYPE, JNITYPE, JTYPE) +%define INPUT_TYPEMAP(CTYPE, JNITYPE, JTYPE, JNIDESC) %typemap(jni) CTYPE *INPUT "JNITYPE" %typemap(jtype) CTYPE *INPUT "JTYPE" %typemap(jstype) CTYPE *INPUT "JTYPE" %typemap(javain) CTYPE *INPUT "$javainput" +%typemap(directorin) CTYPE *INPUT "$jninput" +%typemap(directorout) CTYPE *INPUT "$javacall" %typemap(jni) CTYPE &INPUT "JNITYPE" %typemap(jtype) CTYPE &INPUT "JTYPE" %typemap(jstype) CTYPE &INPUT "JTYPE" %typemap(javain) CTYPE &INPUT "$javainput" +%typemap(directorin) CTYPE *INPUT "$jniinput" +%typemap(directorout) CTYPE *INPUT "$javacall" %typemap(in) CTYPE *INPUT, CTYPE &INPUT %{ $1 = ($1_ltype)&$input; %} +%typemap(inv,parse=JNIDESC) CYTPE &INPUT +%{ *(($&1_ltype) $input) = (JNITYPE *) &$1; %} + +%typemap(inv,parse=JNIDESC) CTYPE *INPUT +%{ *(($&1_ltype) $input) = (JNITYPE *) $1; %} + %typemap(typecheck) CTYPE *INPUT = CTYPE; %typemap(typecheck) CTYPE &INPUT = CTYPE; %enddef -INPUT_TYPEMAP(bool, jboolean, boolean); -INPUT_TYPEMAP(signed char, jbyte, byte); -INPUT_TYPEMAP(unsigned char, jshort, short); -INPUT_TYPEMAP(short, jshort, short); -INPUT_TYPEMAP(unsigned short, jint, int); -INPUT_TYPEMAP(int, jint, int); -INPUT_TYPEMAP(unsigned int, jlong, long); -INPUT_TYPEMAP(long, jint, int); -INPUT_TYPEMAP(unsigned long, jlong, long); -INPUT_TYPEMAP(long long, jlong, long); -INPUT_TYPEMAP(unsigned long long, jobject, java.math.BigInteger); -INPUT_TYPEMAP(float, jfloat, float); -INPUT_TYPEMAP(double, jdouble, double); +INPUT_TYPEMAP(bool, jboolean, boolean, "Z"); +INPUT_TYPEMAP(signed char, jbyte, byte, "B"); +INPUT_TYPEMAP(unsigned char, jshort, short, "S"); +INPUT_TYPEMAP(short, jshort, short, "S"); +INPUT_TYPEMAP(unsigned short, jint, int, "I"); +INPUT_TYPEMAP(int, jint, int, "I"); +INPUT_TYPEMAP(unsigned int, jlong, long, "J"); +INPUT_TYPEMAP(long, jint, int, "I"); +INPUT_TYPEMAP(unsigned long, jlong, long, "J"); +INPUT_TYPEMAP(long long, jlong, long, "J"); +INPUT_TYPEMAP(unsigned long long, jobject, java.math.BigInteger, "Ljava/math/BigInteger;"); +INPUT_TYPEMAP(float, jfloat, float, "F"); +INPUT_TYPEMAP(double, jdouble, double, "D"); #undef INPUT_TYPEMAP @@ -179,18 +189,23 @@ value in the single element array. In Java you would use it like this: */ -%typecheck(SWIG_TYPECHECK_INT128_ARRAY) SWIGBIGINTEGERARRAY "" /* Java BigInteger[] */ +/* Java BigInteger[] */ +%typecheck(SWIG_TYPECHECK_INT128_ARRAY) SWIGBIGINTEGERARRAY "" -%define OUTPUT_TYPEMAP(CTYPE, JNITYPE, JTYPE, JAVATYPE, TYPECHECKTYPE) +%define OUTPUT_TYPEMAP(CTYPE, JNITYPE, JTYPE, JAVATYPE, JNIDESC, TYPECHECKTYPE) %typemap(jni) CTYPE *OUTPUT %{JNITYPE##Array%} %typemap(jtype) CTYPE *OUTPUT "JTYPE[]" %typemap(jstype) CTYPE *OUTPUT "JTYPE[]" %typemap(javain) CTYPE *OUTPUT "$javainput" +%typemap(directorin) CTYPE *OUTPUT "$jniinput" +%typemap(directorout) CTYPE *OUTPUT "$javacall" %typemap(jni) CTYPE &OUTPUT %{JNITYPE##Array%} %typemap(jtype) CTYPE &OUTPUT "JTYPE[]" %typemap(jstype) CTYPE &OUTPUT "JTYPE[]" %typemap(javain) CTYPE &OUTPUT "$javainput" +%typemap(directorin) CTYPE &OUTPUT "$jniinput" +%typemap(directorout) CTYPE &OUTPUT "$javacall" %typemap(in) CTYPE *OUTPUT($*1_ltype temp), CTYPE &OUTPUT($*1_ltype temp) { @@ -205,6 +220,14 @@ value in the single element array. In Java you would use it like this: $1 = &temp; } +%typemap(inv,parse=JNIDESC) CTYPE &OUTPUT +%{ *(($&1_ltype) $input = &$1; %} + +%typemap(inv,parse=JNIDESC) CTYPE *OUTPUT +%{ +#error "Need to provide OUT inv typemap, CTYPE array length is unknown" +%} + %typemap(argout) CTYPE *OUTPUT, CTYPE &OUTPUT { JCALL4(Set##JAVATYPE##ArrayRegion, jenv, $input, 0, 1, (JNITYPE *)&temp$argnum); } @@ -212,19 +235,19 @@ value in the single element array. In Java you would use it like this: %typemap(typecheck) CTYPE &INOUT = TYPECHECKTYPE; %enddef -OUTPUT_TYPEMAP(bool, jboolean, boolean, Boolean, jbooleanArray); -OUTPUT_TYPEMAP(signed char, jbyte, byte, Byte, jbyteArray); -OUTPUT_TYPEMAP(unsigned char, jshort, short, Short, jshortArray); -OUTPUT_TYPEMAP(short, jshort, short, Short, jshortArray); -OUTPUT_TYPEMAP(unsigned short, jint, int, Int, jintArray); -OUTPUT_TYPEMAP(int, jint, int, Int, jintArray); -OUTPUT_TYPEMAP(unsigned int, jlong, long, Long, jlongArray); -OUTPUT_TYPEMAP(long, jint, int, Int, jintArray); -OUTPUT_TYPEMAP(unsigned long, jlong, long, Long, jlongArray); -OUTPUT_TYPEMAP(long long, jlong, long, Long, jlongArray); -OUTPUT_TYPEMAP(unsigned long long, jobject, java.math.BigInteger, NOTUSED, SWIGBIGINTEGERARRAY); -OUTPUT_TYPEMAP(float, jfloat, float, Float, jfloatArray); -OUTPUT_TYPEMAP(double, jdouble, double, Double, jdoubleArray); +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); #undef OUTPUT_TYPEMAP @@ -304,16 +327,20 @@ of the function return value. This difference is due to Java being a typed langu */ -%define INOUT_TYPEMAP(CTYPE, JNITYPE, JTYPE, JAVATYPE, TYPECHECKTYPE) +%define INOUT_TYPEMAP(CTYPE, JNITYPE, JTYPE, JAVATYPE, JNIDESC, TYPECHECKTYPE) %typemap(jni) CTYPE *INOUT %{JNITYPE##Array%} %typemap(jtype) CTYPE *INOUT "JTYPE[]" %typemap(jstype) CTYPE *INOUT "JTYPE[]" %typemap(javain) CTYPE *INOUT "$javainput" +%typemap(directorin) CTYPE *INOUT "$jniinput" +%typemap(directorout) CTYPE *INOUT "$javacall" %typemap(jni) CTYPE &INOUT %{JNITYPE##Array%} %typemap(jtype) CTYPE &INOUT "JTYPE[]" %typemap(jstype) CTYPE &INOUT "JTYPE[]" %typemap(javain) CTYPE &INOUT "$javainput" +%typemap(directorin) CTYPE &INOUT "$jniinput" +%typemap(directorout) CTYPE &INOUT "$javacall" %typemap(in) CTYPE *INOUT, CTYPE &INOUT { if (!$input) { @@ -327,6 +354,14 @@ of the function return value. This difference is due to Java being a typed langu $1 = ($1_ltype) JCALL2(Get##JAVATYPE##ArrayElements, jenv, $input, 0); } +%typemap(inv,parse=JNIDESC) CTYPE &INOUT +%{ *(($&1_ltype)&$input) = &$1; %} + +%typemap(inv,parse=JNIDESC) CTYPE *INOUT, CTYPE &INOUT +{ +#error "Need to provide INOUT inv typemap, CTYPE array length is unknown" +} + %typemap(argout) CTYPE *INOUT, CTYPE &INOUT { JCALL3(Release##JAVATYPE##ArrayElements, jenv, $input, (JNITYPE *)$1, 0); } @@ -334,19 +369,19 @@ of the function return value. This difference is due to Java being a typed langu %typemap(typecheck) CTYPE &INOUT = TYPECHECKTYPE; %enddef -INOUT_TYPEMAP(bool, jboolean, boolean, Boolean, jbooleanArray); -INOUT_TYPEMAP(signed char, jbyte, byte, Byte, jbyteArray); -INOUT_TYPEMAP(unsigned char, jshort, short, Short, jshortArray); -INOUT_TYPEMAP(short, jshort, short, Short, jshortArray); -INOUT_TYPEMAP(unsigned short, jint, int, Int, jintArray); -INOUT_TYPEMAP(int, jint, int, Int, jintArray); -INOUT_TYPEMAP(unsigned int, jlong, long, Long, jlongArray); -INOUT_TYPEMAP(long, jint, int, Int, jintArray); -INOUT_TYPEMAP(unsigned long, jlong, long, Long, jlongArray); -INOUT_TYPEMAP(long long, jlong, long, Long, jlongArray); -INOUT_TYPEMAP(unsigned long long, jobject, java.math.BigInteger, NOTUSED, SWIGBIGINTEGERARRAY); -INOUT_TYPEMAP(float, jfloat, float, Float, jfloatArray); -INOUT_TYPEMAP(double, jdouble, double, Double, jdoubleArray); +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); #undef INOUT_TYPEMAP @@ -395,6 +430,3 @@ INOUT_TYPEMAP(double, jdouble, double, Double, jdoubleArray); %typemap(argout) unsigned long long *INOUT = unsigned long long *OUTPUT; %typemap(argout) unsigned long long &INOUT = unsigned long long &OUTPUT; - - - diff --git a/Lib/java/various.i b/Lib/java/various.i index e19188e0d..e35e31789 100644 --- a/Lib/java/various.i +++ b/Lib/java/various.i @@ -8,6 +8,8 @@ %typemap(jni) char **STRING_IN "jobjectArray" %typemap(jtype) char **STRING_IN "String[]" %typemap(jstype) char **STRING_IN "String[]" +%typemap(directorin) char **STRING_IN "$jniinput" +%typemap(directorout) char **STRING_IN "$javacall" %typemap(in) char **STRING_IN { int i; jsize sz = JCALL1(GetArrayLength, jenv, $input); @@ -28,10 +30,15 @@ %typemap(freearg) char **STRING_IN %{ free($1); %} +%typemap(inv, parse="Ljava/lang/String;") char **STRING_IN +%{ $input = JCALL1(NewStringUTF, jenv, *$1); %} + /* char **STRING_OUT - result must be a null terminated string */ %typemap(jni) char **STRING_OUT "jobjectArray" %typemap(jtype) char **STRING_OUT "String[]" %typemap(jstype) char **STRING_OUT "String[]" +%typemap(directorin) char **STRING_OUT "$jniinput" +%typemap(directorout) char **STRING_OUT "$javacall" %typemap(in) char **STRING_OUT (char *s) %{ $1 = &s; %} %typemap(argout) char **STRING_OUT { @@ -40,10 +47,15 @@ } } +%typemap(inv,parse="Ljava/lang/String;") char **STRING_OUT +%{ $input = JCALL1(NewStringUTF, jenv, *$1); %} + /* char **STRING_RET - a NULL terminated array of char* */ %typemap(jni) char **STRING_RET "jarray" %typemap(jtype) char **STRING_RET "String[]" %typemap(jstype) char **STRING_RET "String[]" +%typemap(directorin) char **STRING_RET "$jniinput" +%typemap(directorout) char **STRING_RET "$javacall" %typemap(out) char **STRING_RET { if($1 != NULL) { char **p = $1; @@ -63,10 +75,15 @@ } } +%typemap(inv,parse="Ljava/lang/String;") char **STRING_RET +%{ $input = JCALL1(NewStringUTF, jenv, *$1; %} + /* float *FLOAT_ARRAY_RETURN */ %typemap(jni) float *FLOAT_ARRAY_RETURN "jfloatArray" %typemap(jtype) float *FLOAT_ARRAY_RETURN "float[]" %typemap(jstype) float *FLOAT_ARRAY_RETURN "float[]" +%typemap(directorin) float *FLOAT_ARRAY_RETURN "$jniinput" +%typemap(directorout) float *FLOAT_ARRAY_RETURN "$javacall" %typemap(out) float *FLOAT_ARRAY_RETURN { if($1) { float *fp = $1; @@ -89,10 +106,17 @@ } } +%typemap(inv,parse="[F") float *FLOATARRAYRETURN +%{ +#error "Need inv typemape for FLOATARRAYRETURN, array input size is unknown." +%} + /* char *BYTE */ %typemap(jni) char *BYTE "jbyteArray" %typemap(jtype) char *BYTE "byte[]" %typemap(jstype) char *BYTE "byte[]" +%typemap(directorin) char *BYTE "$jniinput" +%typemap(directorout) char *BYTE "$javacall" %typemap(in) char *BYTE { $1 = (char *) JCALL2(GetByteArrayElements, jenv, $input, 0); } @@ -101,6 +125,10 @@ JCALL3(ReleaseByteArrayElements, jenv, $input, (jbyte *) $1, 0); } +%typemap(inv,parse="[B") char *BYTE +%{ +#error "Need inv typemape for BYTE, array input size is unknown." +%} + /* Prevent default freearg typemap from being used */ %typemap(freearg) char *BYTE "" -