jyapayne/swig
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Directors implementation contributed by Scott Michel.

Browse source 
git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/trunk/SWIG@5074 626c5289-ae23-0410-ae9c-e8d60b6d4f22
This commit is contained in:
William S Fulton 2003-09-04 23:12:20 +00:00
commit c8d535b30b
7 changed files with 505 additions and 63 deletions
Download patch file Download diff file Expand all files Collapse all files

62
Lib/java/arrays_java.i
View file

@ -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]

94
Lib/java/director.swg Normal file
View file

@ -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 */

221
Lib/java/java.swg
View file

@ -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, "<init>", "([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 *,

5
Lib/java/javahead.swg
View file

@ -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
%}

32
Lib/java/std_string.i
View file

@ -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];

124
Lib/java/typemaps.i
View file

@ -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;

30
Lib/java/various.i
View file

@ -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 ""