source-engine/devtools/swigwin-1.3.34/Lib/java/arrays_java.i
FluorescentCIAAfricanAmerican 3bf9df6b27 1
2020-04-22 12:56:21 -04:00

392 lines
13 KiB
OpenEdge ABL

/* -----------------------------------------------------------------------------
* See the LICENSE file for information on copyright, usage and redistribution
* of SWIG, and the README file for authors - http://www.swig.org/release.html.
*
* arrays_java.i
*
* These typemaps give more natural support for arrays. The typemaps are not efficient
* as there is a lot of copying of the array values whenever the array is passed to C/C++
* from Java and vice versa. The Java array is expected to be the same size as the C array.
* An exception is thrown if they are not.
*
* Example usage:
* Wrapping:
*
* %include <arrays_java.i>
* %inline %{
* short FiddleSticks[3];
* %}
*
* Use from Java like this:
*
* short[] fs = new short[] {10, 11, 12};
* example.setFiddleSticks(fs);
* fs = example.getFiddleSticks();
* ----------------------------------------------------------------------------- */
/* Primitive array support is a combination of SWIG macros and functions in order to reduce
* code bloat and aid maintainability. The SWIG preprocessor expands the macros into functions
* for inclusion in the generated code. */
/* Array support functions declarations macro */
%define JAVA_ARRAYS_DECL(CTYPE, JNITYPE, JAVATYPE, JFUNCNAME)
%{
int SWIG_JavaArrayIn##JFUNCNAME (JNIEnv *jenv, JNITYPE **jarr, CTYPE **carr, JNITYPE##Array input);
void SWIG_JavaArrayArgout##JFUNCNAME (JNIEnv *jenv, JNITYPE *jarr, CTYPE *carr, JNITYPE##Array input);
JNITYPE##Array SWIG_JavaArrayOut##JFUNCNAME (JNIEnv *jenv, CTYPE *result, jsize sz);
%}
%enddef
/* Array support functions macro */
%define JAVA_ARRAYS_IMPL(CTYPE, JNITYPE, JAVATYPE, JFUNCNAME)
%{
/* CTYPE[] support */
int SWIG_JavaArrayIn##JFUNCNAME (JNIEnv *jenv, JNITYPE **jarr, CTYPE **carr, JNITYPE##Array input) {
int i;
jsize sz;
if (!input) {
SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
return 0;
}
sz = JCALL1(GetArrayLength, jenv, input);
*jarr = JCALL2(Get##JAVATYPE##ArrayElements, jenv, input, 0);
if (!*jarr)
return 0; %}
#ifdef __cplusplus
%{ *carr = new CTYPE[sz]; %}
#else
%{ *carr = (CTYPE*) calloc(sz, sizeof(CTYPE)); %}
#endif
%{ if (!*carr) {
SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
return 0;
}
for (i=0; i<sz; i++)
JAVA_TYPEMAP_ARRAY_ELEMENT_ASSIGN(CTYPE)
return 1;
}
void SWIG_JavaArrayArgout##JFUNCNAME (JNIEnv *jenv, JNITYPE *jarr, CTYPE *carr, JNITYPE##Array input) {
int i;
jsize sz = JCALL1(GetArrayLength, jenv, input);
for (i=0; i<sz; i++)
jarr[i] = (JNITYPE)carr[i];
JCALL3(Release##JAVATYPE##ArrayElements, jenv, input, jarr, 0);
}
JNITYPE##Array SWIG_JavaArrayOut##JFUNCNAME (JNIEnv *jenv, CTYPE *result, jsize sz) {
JNITYPE *arr;
int i;
JNITYPE##Array jresult = JCALL1(New##JAVATYPE##Array, jenv, sz);
if (!jresult)
return NULL;
arr = JCALL2(Get##JAVATYPE##ArrayElements, jenv, jresult, 0);
if (!arr)
return NULL;
for (i=0; i<sz; i++)
arr[i] = (JNITYPE)result[i];
JCALL3(Release##JAVATYPE##ArrayElements, jenv, jresult, arr, 0);
return jresult;
}
%}
%enddef
%{
#if defined(SWIG_NOINCLUDE) || defined(SWIG_NOARRAYS)
%}
#ifdef __cplusplus
JAVA_ARRAYS_DECL(bool, jboolean, Boolean, Bool) /* bool[] */
#endif
JAVA_ARRAYS_DECL(signed char, jbyte, Byte, Schar) /* signed char[] */
JAVA_ARRAYS_DECL(unsigned char, jshort, Short, Uchar) /* unsigned char[] */
JAVA_ARRAYS_DECL(short, jshort, Short, Short) /* short[] */
JAVA_ARRAYS_DECL(unsigned short, jint, Int, Ushort) /* unsigned short[] */
JAVA_ARRAYS_DECL(int, jint, Int, Int) /* int[] */
JAVA_ARRAYS_DECL(unsigned int, jlong, Long, Uint) /* unsigned int[] */
JAVA_ARRAYS_DECL(long, jint, Int, Long) /* long[] */
JAVA_ARRAYS_DECL(unsigned long, jlong, Long, Ulong) /* unsigned long[] */
JAVA_ARRAYS_DECL(jlong, jlong, Long, Longlong) /* long long[] */
JAVA_ARRAYS_DECL(float, jfloat, Float, Float) /* float[] */
JAVA_ARRAYS_DECL(double, jdouble, Double, Double) /* double[] */
%{
#else
%}
#ifdef __cplusplus
/* Bool array element assignment different to other types to keep Visual C++ quiet */
#define JAVA_TYPEMAP_ARRAY_ELEMENT_ASSIGN(CTYPE) (*carr)[i] = ((*jarr)[i] != 0);
JAVA_ARRAYS_IMPL(bool, jboolean, Boolean, Bool) /* bool[] */
#undef JAVA_TYPEMAP_ARRAY_ELEMENT_ASSIGN
#endif
#define JAVA_TYPEMAP_ARRAY_ELEMENT_ASSIGN(CTYPE) (*carr)[i] = (CTYPE)(*jarr)[i];
JAVA_ARRAYS_IMPL(signed char, jbyte, Byte, Schar) /* signed char[] */
JAVA_ARRAYS_IMPL(unsigned char, jshort, Short, Uchar) /* unsigned char[] */
JAVA_ARRAYS_IMPL(short, jshort, Short, Short) /* short[] */
JAVA_ARRAYS_IMPL(unsigned short, jint, Int, Ushort) /* unsigned short[] */
JAVA_ARRAYS_IMPL(int, jint, Int, Int) /* int[] */
JAVA_ARRAYS_IMPL(unsigned int, jlong, Long, Uint) /* unsigned int[] */
JAVA_ARRAYS_IMPL(long, jint, Int, Long) /* long[] */
JAVA_ARRAYS_IMPL(unsigned long, jlong, Long, Ulong) /* unsigned long[] */
JAVA_ARRAYS_IMPL(jlong, jlong, Long, Longlong) /* long long[] */
JAVA_ARRAYS_IMPL(float, jfloat, Float, Float) /* float[] */
JAVA_ARRAYS_IMPL(double, jdouble, Double, Double) /* double[] */
%{
#endif
%}
/* The rest of this file has the array typemaps */
/* Arrays of primitive types use the following macro. The array typemaps use support functions. */
%define JAVA_ARRAYS_TYPEMAPS(CTYPE, JTYPE, JNITYPE, JFUNCNAME, JNIDESC)
%typemap(jni) CTYPE[ANY], CTYPE[] %{JNITYPE##Array%}
%typemap(jtype) CTYPE[ANY], CTYPE[] %{JTYPE[]%}
%typemap(jstype) CTYPE[ANY], CTYPE[] %{JTYPE[]%}
%typemap(in) CTYPE[] (JNITYPE *jarr)
%{ if (!SWIG_JavaArrayIn##JFUNCNAME(jenv, &jarr, &$1, $input)) return $null; %}
%typemap(in) CTYPE[ANY] (JNITYPE *jarr)
%{ if ($input && JCALL1(GetArrayLength, jenv, $input) != $1_size) {
SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size");
return $null;
}
if (!SWIG_JavaArrayIn##JFUNCNAME(jenv, &jarr, &$1, $input)) return $null; %}
%typemap(argout) CTYPE[ANY], CTYPE[]
%{ SWIG_JavaArrayArgout##JFUNCNAME(jenv, jarr$argnum, $1, $input); %}
%typemap(out) CTYPE[ANY]
%{$result = SWIG_JavaArrayOut##JFUNCNAME(jenv, $1, $1_dim0); %}
%typemap(out) CTYPE[]
%{$result = SWIG_JavaArrayOut##JFUNCNAME(jenv, $1, FillMeInAsSizeCannotBeDeterminedAutomatically); %}
%typemap(freearg) CTYPE[ANY], CTYPE[]
#ifdef __cplusplus
%{ delete [] $1; %}
#else
%{ free($1); %}
#endif
%typemap(javain) CTYPE[ANY], CTYPE[] "$javainput"
%typemap(javaout) CTYPE[ANY], CTYPE[] {
return $jnicall;
}
%enddef
JAVA_ARRAYS_TYPEMAPS(bool, boolean, jboolean, Bool, "[Z") /* bool[ANY] */
JAVA_ARRAYS_TYPEMAPS(signed char, byte, jbyte, Schar, "[B") /* signed char[ANY] */
JAVA_ARRAYS_TYPEMAPS(unsigned char, short, jshort, Uchar, "[S") /* unsigned char[ANY] */
JAVA_ARRAYS_TYPEMAPS(short, short, jshort, Short, "[S") /* short[ANY] */
JAVA_ARRAYS_TYPEMAPS(unsigned short, int, jint, Ushort, "[I") /* unsigned short[ANY] */
JAVA_ARRAYS_TYPEMAPS(int, int, jint, Int, "[I") /* int[ANY] */
JAVA_ARRAYS_TYPEMAPS(unsigned int, long, jlong, Uint, "[J") /* unsigned int[ANY] */
JAVA_ARRAYS_TYPEMAPS(long, int, jint, Long, "[I") /* long[ANY] */
JAVA_ARRAYS_TYPEMAPS(unsigned long, long, jlong, Ulong, "[J") /* unsigned long[ANY] */
JAVA_ARRAYS_TYPEMAPS(long long, long, jlong, Longlong, "[J") /* long long[ANY] */
JAVA_ARRAYS_TYPEMAPS(float, float, jfloat, Float, "[F") /* float[ANY] */
JAVA_ARRAYS_TYPEMAPS(double, double, jdouble, Double, "[D") /* double[ANY] */
%typecheck(SWIG_TYPECHECK_BOOL_ARRAY) /* Java boolean[] */
bool[ANY], bool[]
""
%typecheck(SWIG_TYPECHECK_INT8_ARRAY) /* Java byte[] */
signed char[ANY], signed char[]
""
%typecheck(SWIG_TYPECHECK_INT16_ARRAY) /* Java short[] */
unsigned char[ANY], unsigned char[],
short[ANY], short[]
""
%typecheck(SWIG_TYPECHECK_INT32_ARRAY) /* Java int[] */
unsigned short[ANY], unsigned short[],
int[ANY], int[],
long[ANY], long[]
""
%typecheck(SWIG_TYPECHECK_INT64_ARRAY) /* Java long[] */
unsigned int[ANY], unsigned int[],
unsigned long[ANY], unsigned long[],
long long[ANY], long long[]
""
%typecheck(SWIG_TYPECHECK_INT128_ARRAY) /* Java BigInteger[] */
unsigned long long[ANY], unsigned long long[]
""
%typecheck(SWIG_TYPECHECK_FLOAT_ARRAY) /* Java float[] */
float[ANY], float[]
""
%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY) /* Java double[] */
double[ANY], double[]
""
/* Arrays of proxy classes. The typemaps in this macro make it possible to treat an array of
* class/struct/unions as an array of Java classes.
* Use the following macro to use these typemaps for an array of class/struct/unions called name:
* JAVA_ARRAYSOFCLASSES(name)
* Note that multiple copies of the class/struct is made when using the array as a parameter input. */
%define JAVA_ARRAYSOFCLASSES(ARRAYSOFCLASSES)
%typemap(jni) ARRAYSOFCLASSES[ANY], ARRAYSOFCLASSES[] "jlongArray"
%typemap(jtype) ARRAYSOFCLASSES[ANY], ARRAYSOFCLASSES[] "long[]"
%typemap(jstype) ARRAYSOFCLASSES[ANY], ARRAYSOFCLASSES[] "$javaclassname[]"
%typemap(javain) ARRAYSOFCLASSES[ANY], ARRAYSOFCLASSES[] "$javaclassname.cArrayUnwrap($javainput)"
%typemap(javaout) ARRAYSOFCLASSES[ANY], ARRAYSOFCLASSES[] {
return $javaclassname.cArrayWrap($jnicall, $owner);
}
%typemap(in) ARRAYSOFCLASSES[] (jlong *jarr, jsize sz)
{
int i;
if (!$input) {
SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
return $null;
}
sz = JCALL1(GetArrayLength, jenv, $input);
jarr = JCALL2(GetLongArrayElements, jenv, $input, 0);
if (!jarr) {
return $null;
}
#ifdef __cplusplus
$1 = new $*1_ltype[sz];
#else
$1 = ($1_ltype) calloc(sz, sizeof($*1_ltype));
#endif
if (!$1) {
SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
return $null;
}
for (i=0; i<sz; i++) {
$1[i] = **($&1_ltype)&jarr[i];
}
}
%typemap(in) ARRAYSOFCLASSES[ANY] (jlong *jarr, jsize sz)
{
int i;
if (!$input) {
SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
return $null;
}
sz = JCALL1(GetArrayLength, jenv, $input);
if (sz != $1_size) {
SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size");
return $null;
}
jarr = JCALL2(GetLongArrayElements, jenv, $input, 0);
if (!jarr) {
return $null;
}
#ifdef __cplusplus
$1 = new $*1_ltype[sz];
#else
$1 = ($1_ltype) calloc(sz, sizeof($*1_ltype));
#endif
if (!$1) {
SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
return $null;
}
for (i=0; i<sz; i++) {
$1[i] = **($&1_ltype)&jarr[i];
}
}
%typemap(argout) ARRAYSOFCLASSES[ANY], ARRAYSOFCLASSES[]
{
int i;
for (i=0; i<sz$argnum; i++) {
**($&1_ltype)&jarr$argnum[i] = $1[i];
}
JCALL3(ReleaseLongArrayElements, jenv, $input, jarr$argnum, 0);
}
%typemap(out) ARRAYSOFCLASSES[ANY]
{
jlong *arr;
int i;
$result = JCALL1(NewLongArray, jenv, $1_dim0);
if (!$result) {
return $null;
}
arr = JCALL2(GetLongArrayElements, jenv, $result, 0);
if (!arr) {
return $null;
}
for (i=0; i<$1_dim0; i++) {
arr[i] = 0;
*($&1_ltype)&arr[i] = &$1[i];
}
JCALL3(ReleaseLongArrayElements, jenv, $result, arr, 0);
}
%typemap(freearg) ARRAYSOFCLASSES[ANY], ARRAYSOFCLASSES[]
#ifdef __cplusplus
%{ delete [] $1; %}
#else
%{ free($1); %}
#endif
/* Add some code to the proxy class of the array type for converting between type used in
* JNI class (long[]) and type used in proxy class ( ARRAYSOFCLASSES[] ) */
%typemap(javacode) ARRAYSOFCLASSES %{
protected static long[] cArrayUnwrap($javaclassname[] arrayWrapper) {
long[] cArray = new long[arrayWrapper.length];
for (int i=0; i<arrayWrapper.length; i++)
cArray[i] = $javaclassname.getCPtr(arrayWrapper[i]);
return cArray;
}
protected static $javaclassname[] cArrayWrap(long[] cArray, boolean cMemoryOwn) {
$javaclassname[] arrayWrapper = new $javaclassname[cArray.length];
for (int i=0; i<cArray.length; i++)
arrayWrapper[i] = new $javaclassname(cArray[i], cMemoryOwn);
return arrayWrapper;
}
%}
%enddef /* JAVA_ARRAYSOFCLASSES */
/* Arrays of enums.
* Use the following to use these typemaps for an array of enums called name:
* %apply ARRAYSOFENUMS[ANY] { name[ANY] }; */
%typemap(jni) ARRAYSOFENUMS[ANY], ARRAYSOFENUMS[] "jintArray"
%typemap(jtype) ARRAYSOFENUMS[ANY], ARRAYSOFENUMS[] "int[]"
%typemap(jstype) ARRAYSOFENUMS[ANY], ARRAYSOFENUMS[] "int[]"
%typemap(javain) ARRAYSOFENUMS[ANY], ARRAYSOFENUMS[] "$javainput"
%typemap(javaout) ARRAYSOFENUMS[ANY], ARRAYSOFENUMS[] {
return $jnicall;
}
%typemap(in) ARRAYSOFENUMS[] (jint *jarr)
%{ if (!SWIG_JavaArrayInInt(jenv, &jarr, (int **)&$1, $input)) return $null; %}
%typemap(in) ARRAYSOFENUMS[ANY] (jint *jarr) {
if ($input && JCALL1(GetArrayLength, jenv, $input) != $1_size) {
SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size");
return $null;
}
if (!SWIG_JavaArrayInInt(jenv, &jarr, (int **)&$1, $input)) return $null;
}
%typemap(argout) ARRAYSOFENUMS[ANY], ARRAYSOFENUMS[]
%{ SWIG_JavaArrayArgoutInt(jenv, jarr$argnum, (int *)$1, $input); %}
%typemap(out) ARRAYSOFENUMS[ANY]
%{$result = SWIG_JavaArrayOutInt(jenv, (int *)$1, $1_dim0); %}
%typemap(freearg) ARRAYSOFENUMS[ANY], ARRAYSOFENUMS[]
#ifdef __cplusplus
%{ delete [] $1; %}
#else
%{ free($1); %}
#endif