[OpenSPARC-T2-SAM] / sam-t2 / devtools / amd64 / share / swig / 1.3.26 / java / arrays_java.i

/* arrays_java.i\r
 * These typemaps give more natural support for arrays. The typemaps are not efficient\r
 * as there is a lot of copying of the array values whenever the array is passed to C/C++ \r
 * from Java and visa versa. The Java array is expected to be the same size as the C array.\r
 * An exception is thrown if they are not.\r
\r
   Example usage:\r
   Wrapping:\r
\r
     %include "arrays_java.i"\r
     %inline %{\r
         short FiddleSticks[3];\r
     %}\r
\r
   Use from Java like this:\r
\r
     short[] fs = new short[] {10, 11, 12};\r
     example.setFiddleSticks(fs);\r
     fs = example.getFiddleSticks();\r
\r
 */\r
\r
/* Primitive array support is a combination of SWIG macros and functions in order to reduce \r
 * code bloat and aid maintainability. The SWIG preprocessor expands the macros into functions \r
 * for inclusion in the generated code. */\r
\r
/* Array support functions declarations macro */\r
%define JAVA_ARRAYS_DECL(CTYPE, JNITYPE, JAVATYPE, JFUNCNAME)\r
%{\r
int SWIG_JavaArrayIn##JFUNCNAME (JNIEnv *jenv, JNITYPE **jarr, CTYPE **carr, JNITYPE##Array input);\r
void SWIG_JavaArrayArgout##JFUNCNAME (JNIEnv *jenv, JNITYPE *jarr, CTYPE *carr, JNITYPE##Array input);\r
JNITYPE##Array SWIG_JavaArrayOut##JFUNCNAME (JNIEnv *jenv, CTYPE *result, jsize sz);\r
%}\r
%enddef\r
\r
/* Array support functions macro */\r
%define JAVA_ARRAYS_IMPL(CTYPE, JNITYPE, JAVATYPE, JFUNCNAME)\r
%{\r
/* CTYPE[] support */\r
int SWIG_JavaArrayIn##JFUNCNAME (JNIEnv *jenv, JNITYPE **jarr, CTYPE **carr, JNITYPE##Array input) {\r
  int i;\r
  jsize sz;\r
  if (!input) {\r
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");\r
    return 0;\r
  }\r
  sz = JCALL1(GetArrayLength, jenv, input);\r
  *jarr = JCALL2(Get##JAVATYPE##ArrayElements, jenv, input, 0);\r
  if (!*jarr)\r
    return 0; %}\r
#ifdef __cplusplus\r
%{  *carr = new CTYPE[sz]; %}\r
#else\r
%{  *carr = (CTYPE*) calloc(sz, sizeof(CTYPE)); %}\r
#endif\r
%{  if (!*carr) {\r
    SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");\r
    return 0;\r
  }\r
  for (i=0; i<sz; i++)\r
    JAVA_TYPEMAP_ARRAY_ELEMENT_ASSIGN(CTYPE)\r
  return 1;\r
}\r
\r
void SWIG_JavaArrayArgout##JFUNCNAME (JNIEnv *jenv, JNITYPE *jarr, CTYPE *carr, JNITYPE##Array input) {\r
  int i;\r
  jsize sz = JCALL1(GetArrayLength, jenv, input);\r
  for (i=0; i<sz; i++)\r
    jarr[i] = (JNITYPE)carr[i];\r
  JCALL3(Release##JAVATYPE##ArrayElements, jenv, input, jarr, 0);\r
}\r
\r
JNITYPE##Array SWIG_JavaArrayOut##JFUNCNAME (JNIEnv *jenv, CTYPE *result, jsize sz) {\r
  JNITYPE *arr;\r
  int i;\r
  JNITYPE##Array jresult = JCALL1(New##JAVATYPE##Array, jenv, sz);\r
  if (!jresult)\r
    return NULL;\r
  arr = JCALL2(Get##JAVATYPE##ArrayElements, jenv, jresult, 0);\r
  if (!arr)\r
    return NULL;\r
  for (i=0; i<sz; i++)\r
    arr[i] = (JNITYPE)result[i];\r
  JCALL3(Release##JAVATYPE##ArrayElements, jenv, jresult, arr, 0);\r
  return jresult;\r
}\r
%}\r
%enddef\r
\r
%{\r
#if defined(SWIG_NOINCLUDE) || defined(SWIG_NOARRAYS)\r
%}\r
\r
#ifdef __cplusplus\r
JAVA_ARRAYS_DECL(bool, jboolean, Boolean, Bool)       /* bool[] */\r
#endif\r
\r
JAVA_ARRAYS_DECL(signed char, jbyte, Byte, Schar)     /* signed char[] */\r
JAVA_ARRAYS_DECL(unsigned char, jshort, Short, Uchar) /* unsigned char[] */\r
JAVA_ARRAYS_DECL(short, jshort, Short, Short)         /* short[] */\r
JAVA_ARRAYS_DECL(unsigned short, jint, Int, Ushort)   /* unsigned short[] */\r
JAVA_ARRAYS_DECL(int, jint, Int, Int)                 /* int[] */\r
JAVA_ARRAYS_DECL(unsigned int, jlong, Long, Uint)     /* unsigned int[] */\r
JAVA_ARRAYS_DECL(long, jint, Int, Long)               /* long[] */\r
JAVA_ARRAYS_DECL(unsigned long, jlong, Long, Ulong)   /* unsigned long[] */\r
JAVA_ARRAYS_DECL(jlong, jlong, Long, Longlong)        /* long long[] */\r
JAVA_ARRAYS_DECL(float, jfloat, Float, Float)         /* float[] */\r
JAVA_ARRAYS_DECL(double, jdouble, Double, Double)     /* double[] */\r
\r
%{\r
#else\r
%}\r
\r
#ifdef __cplusplus\r
/* Bool array element assignment different to other types to keep Visual C++ quiet */\r
#define JAVA_TYPEMAP_ARRAY_ELEMENT_ASSIGN(CTYPE) (*carr)[i] = ((*jarr)[i] != 0);\r
JAVA_ARRAYS_IMPL(bool, jboolean, Boolean, Bool)       /* bool[] */\r
#undef JAVA_TYPEMAP_ARRAY_ELEMENT_ASSIGN\r
#endif\r
\r
#define JAVA_TYPEMAP_ARRAY_ELEMENT_ASSIGN(CTYPE) (*carr)[i] = (CTYPE)(*jarr)[i];\r
JAVA_ARRAYS_IMPL(signed char, jbyte, Byte, Schar)     /* signed char[] */\r
JAVA_ARRAYS_IMPL(unsigned char, jshort, Short, Uchar) /* unsigned char[] */\r
JAVA_ARRAYS_IMPL(short, jshort, Short, Short)         /* short[] */\r
JAVA_ARRAYS_IMPL(unsigned short, jint, Int, Ushort)   /* unsigned short[] */\r
JAVA_ARRAYS_IMPL(int, jint, Int, Int)                 /* int[] */\r
JAVA_ARRAYS_IMPL(unsigned int, jlong, Long, Uint)     /* unsigned int[] */\r
JAVA_ARRAYS_IMPL(long, jint, Int, Long)               /* long[] */\r
JAVA_ARRAYS_IMPL(unsigned long, jlong, Long, Ulong)   /* unsigned long[] */\r
JAVA_ARRAYS_IMPL(jlong, jlong, Long, Longlong)        /* long long[] */\r
JAVA_ARRAYS_IMPL(float, jfloat, Float, Float)         /* float[] */\r
JAVA_ARRAYS_IMPL(double, jdouble, Double, Double)     /* double[] */\r
\r
%{\r
#endif\r
%}\r
\r
\r
/* The rest of this file has the array typemaps */\r
\r
/* Arrays of primitive types use the following macro. The array typemaps use support functions. */\r
%define JAVA_ARRAYS_TYPEMAPS(CTYPE, JTYPE, JNITYPE, JFUNCNAME, JNIDESC)\r
\r
%typemap(jni) CTYPE[ANY], CTYPE[]               %{JNITYPE##Array%}\r
%typemap(jtype) CTYPE[ANY], CTYPE[]             %{JTYPE[]%}\r
%typemap(jstype) CTYPE[ANY], CTYPE[]            %{JTYPE[]%}\r
\r
%typemap(in) CTYPE[] (JNITYPE *jarr)\r
%{  if (!SWIG_JavaArrayIn##JFUNCNAME(jenv, &jarr, &$1, $input)) return $null; %}\r
%typemap(in) CTYPE[ANY] (JNITYPE *jarr)\r
%{  if ($input && JCALL1(GetArrayLength, jenv, $input) != $1_size) {\r
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size");\r
    return $null;\r
  }\r
  if (!SWIG_JavaArrayIn##JFUNCNAME(jenv, &jarr, &$1, $input)) return $null; %}\r
%typemap(argout) CTYPE[ANY], CTYPE[] \r
%{ SWIG_JavaArrayArgout##JFUNCNAME(jenv, jarr$argnum, $1, $input); %}\r
%typemap(out) CTYPE[ANY]\r
%{$result = SWIG_JavaArrayOut##JFUNCNAME(jenv, $1, $1_dim0); %}\r
%typemap(out) CTYPE[] \r
%{$result = SWIG_JavaArrayOut##JFUNCNAME(jenv, $1, FillMeInAsSizeCannotBeDeterminedAutomatically); %}\r
%typemap(freearg) CTYPE[ANY], CTYPE[] \r
#ifdef __cplusplus\r
%{ delete [] $1; %}\r
#else\r
%{ free($1); %}\r
#endif\r
\r
%typemap(javain) CTYPE[ANY], CTYPE[] "$javainput"\r
%typemap(javaout) CTYPE[ANY], CTYPE[] {\r
    return $jnicall;\r
  }\r
\r
%enddef\r
\r
JAVA_ARRAYS_TYPEMAPS(bool, boolean, jboolean, Bool, "[Z")       /* bool[ANY] */\r
JAVA_ARRAYS_TYPEMAPS(signed char, byte, jbyte, Schar, "[B")     /* signed char[ANY] */\r
JAVA_ARRAYS_TYPEMAPS(unsigned char, short, jshort, Uchar, "[S") /* unsigned char[ANY] */\r
JAVA_ARRAYS_TYPEMAPS(short, short, jshort, Short, "[S")         /* short[ANY] */\r
JAVA_ARRAYS_TYPEMAPS(unsigned short, int, jint, Ushort, "[I")   /* unsigned short[ANY] */\r
JAVA_ARRAYS_TYPEMAPS(int, int, jint, Int, "[I")                 /* int[ANY] */\r
JAVA_ARRAYS_TYPEMAPS(unsigned int, long, jlong, Uint, "[J")     /* unsigned int[ANY] */\r
JAVA_ARRAYS_TYPEMAPS(long, int, jint, Long, "[I")               /* long[ANY] */\r
JAVA_ARRAYS_TYPEMAPS(unsigned long, long, jlong, Ulong, "[J")   /* unsigned long[ANY] */\r
JAVA_ARRAYS_TYPEMAPS(long long, long, jlong, Longlong, "[J")    /* long long[ANY] */\r
JAVA_ARRAYS_TYPEMAPS(float, float, jfloat, Float, "[F")         /* float[ANY] */\r
JAVA_ARRAYS_TYPEMAPS(double, double, jdouble, Double, "[D")     /* double[ANY] */\r
\r
\r
%typecheck(SWIG_TYPECHECK_BOOL_ARRAY) /* Java boolean[] */\r
    bool[ANY], bool[]\r
    ""\r
\r
%typecheck(SWIG_TYPECHECK_INT8_ARRAY) /* Java byte[] */\r
    signed char[ANY], signed char[]\r
    ""\r
\r
%typecheck(SWIG_TYPECHECK_INT16_ARRAY) /* Java short[] */\r
    unsigned char[ANY], unsigned char[],\r
    short[ANY], short[]\r
    ""\r
\r
%typecheck(SWIG_TYPECHECK_INT32_ARRAY) /* Java int[] */\r
    unsigned short[ANY], unsigned short[],\r
    int[ANY], int[],\r
    long[ANY], long[]\r
    ""\r
\r
%typecheck(SWIG_TYPECHECK_INT64_ARRAY) /* Java long[] */\r
    unsigned int[ANY], unsigned int[],\r
    unsigned long[ANY], unsigned long[],\r
    long long[ANY], long long[]\r
    ""\r
\r
%typecheck(SWIG_TYPECHECK_INT128_ARRAY) /* Java BigInteger[] */\r
    unsigned long long[ANY], unsigned long long[]\r
    ""\r
\r
%typecheck(SWIG_TYPECHECK_FLOAT_ARRAY) /* Java float[] */\r
    float[ANY], float[]\r
    ""\r
\r
%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY) /* Java double[] */\r
    double[ANY], double[]\r
    ""\r
\r
\r
/* Arrays of proxy classes. The typemaps in this macro make it possible to treat an array of \r
 * class/struct/unions as an array of Java classes. \r
 * Use the following macro to use these typemaps for an array of class/struct/unions called name:\r
 * JAVA_ARRAYSOFCLASSES(name) */\r
%define JAVA_ARRAYSOFCLASSES(ARRAYSOFCLASSES)\r
\r
%typemap(jni) ARRAYSOFCLASSES[ANY] "jlongArray"\r
%typemap(jtype) ARRAYSOFCLASSES[ANY] "long[]"\r
%typemap(jstype) ARRAYSOFCLASSES[ANY] "$javaclassname[]"\r
\r
%typemap(javain) ARRAYSOFCLASSES[ANY] "$javaclassname.cArrayUnwrap($javainput)"\r
%typemap(javaout) ARRAYSOFCLASSES[ANY] {\r
    return $javaclassname.cArrayWrap($jnicall, $owner);\r
  }\r
\r
%typemap(in) ARRAYSOFCLASSES[] (jlong *jarr, jsize sz)\r
{\r
  int i;\r
  if (!$input) {\r
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");\r
    return $null;\r
  }\r
  sz = JCALL1(GetArrayLength, jenv, $input);\r
  jarr = JCALL2(GetLongArrayElements, jenv, $input, 0);\r
  if (!jarr) {\r
    return $null;\r
  }\r
#ifdef __cplusplus\r
  $1 = new $*1_ltype[sz];\r
#else\r
  $1 = ($1_ltype) calloc(sz, sizeof($*1_ltype));\r
#endif\r
  if (!$1) {\r
    SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");\r
    return $null;\r
  }\r
  for (i=0; i<sz; i++) {\r
    $1[i] = **($&1_ltype)(void *)&jarr[i];\r
  }\r
}\r
\r
%typemap(in) ARRAYSOFCLASSES[ANY] (jlong *jarr, jsize sz)\r
{\r
  int i;\r
  if (!$input) {\r
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");\r
    return $null;\r
  }\r
  sz = JCALL1(GetArrayLength, jenv, $input);\r
  if (sz != $1_size) {\r
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size");\r
    return $null;\r
  }\r
  jarr = JCALL2(GetLongArrayElements, jenv, $input, 0);\r
  if (!jarr) {\r
    return $null;\r
  }\r
#ifdef __cplusplus\r
  $1 = new $*1_ltype[sz];\r
#else\r
  $1 = ($1_ltype) calloc(sz, sizeof($*1_ltype));\r
#endif\r
  if (!$1) {\r
    SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");\r
    return $null;\r
  }\r
  for (i=0; i<sz; i++) {\r
    $1[i] = **($&1_ltype)(void *)&jarr[i];\r
  }\r
}\r
\r
%typemap(argout) ARRAYSOFCLASSES[ANY]\r
{\r
  int i;\r
  for (i=0; i<sz$argnum; i++) {\r
    jarr$argnum[i] = 0;\r
    *($&1_ltype)(void *)&jarr$argnum[i] = &$1[i];\r
  }\r
  JCALL3(ReleaseLongArrayElements, jenv, $input, jarr$argnum, 0);\r
}\r
\r
%typemap(out) ARRAYSOFCLASSES[ANY]\r
{\r
  jlong *arr;\r
  int i;\r
  $result = JCALL1(NewLongArray, jenv, $1_dim0);\r
  if (!$result) {\r
    return $null;\r
  }\r
  arr = JCALL2(GetLongArrayElements, jenv, $result, 0);\r
  if (!arr) {\r
    return $null;\r
  }\r
  for (i=0; i<$1_dim0; i++) {\r
    arr[i] = 0;\r
    *($&1_ltype)(void *)&arr[i] = &$1[i];\r
  }\r
  JCALL3(ReleaseLongArrayElements, jenv, $result, arr, 0);\r
}\r
\r
%typemap(freearg) ARRAYSOFCLASSES[ANY]\r
#ifdef __cplusplus\r
%{ delete [] $1; %}\r
#else\r
%{ free($1); %}\r
#endif\r
\r
/* Add some code to the proxy class of the array type for converting between type used in \r
 * JNI class (long[]) and type used in proxy class ( ARRAYSOFCLASSES[] ) */\r
%typemap(javacode) ARRAYSOFCLASSES %{\r
  protected static long[] cArrayUnwrap($javaclassname[] arrayWrapper) {\r
      long[] cArray = new long[arrayWrapper.length];\r
      for (int i=0; i<arrayWrapper.length; i++)\r
        cArray[i] = $javaclassname.getCPtr(arrayWrapper[i]);\r
      return cArray;\r
  }\r
\r
  protected static $javaclassname[] cArrayWrap(long[] cArray, boolean cMemoryOwn) {\r
    $javaclassname[] arrayWrapper = new $javaclassname[cArray.length];\r
    for (int i=0; i<cArray.length; i++)\r
      arrayWrapper[i] = new $javaclassname(cArray[i], cMemoryOwn);\r
    return arrayWrapper;\r
  }\r
%}\r
\r
%enddef /* JAVA_ARRAYSOFCLASSES */\r
\r
\r
/* Arrays of enums. \r
 * Use the following to use these typemaps for an array of enums called name:\r
 * %apply ARRAYSOFENUMS[ANY] { name[ANY] }; */\r
%typemap(jni) ARRAYSOFENUMS[ANY] "jintArray"\r
%typemap(jtype) ARRAYSOFENUMS[ANY] "int[]"\r
%typemap(jstype) ARRAYSOFENUMS[ANY] "int[]"\r
\r
%typemap(javain) ARRAYSOFENUMS[ANY] "$javainput"\r
%typemap(javaout) ARRAYSOFENUMS[ANY] {\r
    return $jnicall;\r
  }\r
\r
%typemap(in) ARRAYSOFENUMS[] (jint *jarr)\r
%{  if (!SWIG_JavaArrayInInt(jenv, &jarr, (int **)(void *)&$1, $input)) return $null; %}\r
%typemap(in) ARRAYSOFENUMS[ANY] (jint *jarr) {\r
  if ($input && JCALL1(GetArrayLength, jenv, $input) != $1_size) {\r
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size");\r
    return $null;\r
  }\r
  if (!SWIG_JavaArrayInInt(jenv, &jarr, (int **)(void *)&$1, $input)) return $null;\r
}\r
%typemap(argout) ARRAYSOFENUMS[ANY] \r
%{ SWIG_JavaArrayArgoutInt(jenv, jarr$argnum, (int *)$1, $input); %}\r
%typemap(out) ARRAYSOFENUMS[ANY] \r
%{$result = SWIG_JavaArrayOutInt(jenv, (int *)$1, $1_dim0); %}\r
%typemap(freearg) ARRAYSOFENUMS[ANY] \r
#ifdef __cplusplus\r
%{ delete [] $1; %}\r
#else\r
%{ free($1); %}\r
#endif\r
\r
Commit	Line	Data
920dae64 AT	1	/* arrays_java.i\r
	2	* These typemaps give more natural support for arrays. The typemaps are not efficient\r
	3	* as there is a lot of copying of the array values whenever the array is passed to C/C++ \r
	4	* from Java and visa versa. The Java array is expected to be the same size as the C array.\r
	5	* An exception is thrown if they are not.\r
	6	\r
	7	Example usage:\r
	8	Wrapping:\r
	9	\r
	10	%include "arrays_java.i"\r
	11	%inline %{\r
	12	short FiddleSticks[3];\r
	13	%}\r
	14	\r
	15	Use from Java like this:\r
	16	\r
	17	short[] fs = new short[] {10, 11, 12};\r
	18	example.setFiddleSticks(fs);\r
	19	fs = example.getFiddleSticks();\r
	20	\r
	21	*/\r
	22	\r
	23	/* Primitive array support is a combination of SWIG macros and functions in order to reduce \r
	24	* code bloat and aid maintainability. The SWIG preprocessor expands the macros into functions \r
	25	* for inclusion in the generated code. */\r
	26	\r
	27	/* Array support functions declarations macro */\r
	28	%define JAVA_ARRAYS_DECL(CTYPE, JNITYPE, JAVATYPE, JFUNCNAME)\r
	29	%{\r
	30	int SWIG_JavaArrayIn##JFUNCNAME (JNIEnv jenv, JNITYPE jarr, CTYPE *carr, JNITYPE##Array input);\r
	31	void SWIG_JavaArrayArgout##JFUNCNAME (JNIEnv jenv, JNITYPE jarr, CTYPE *carr, JNITYPE##Array input);\r
	32	JNITYPE##Array SWIG_JavaArrayOut##JFUNCNAME (JNIEnv jenv, CTYPE result, jsize sz);\r
	33	%}\r
	34	%enddef\r
	35	\r
	36	/* Array support functions macro */\r
	37	%define JAVA_ARRAYS_IMPL(CTYPE, JNITYPE, JAVATYPE, JFUNCNAME)\r
	38	%{\r
	39	/* CTYPE[] support */\r
	40	int SWIG_JavaArrayIn##JFUNCNAME (JNIEnv jenv, JNITYPE jarr, CTYPE *carr, JNITYPE##Array input) {\r
	41	int i;\r
	42	jsize sz;\r
	43	if (!input) {\r
	44	SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");\r
	45	return 0;\r
	46	}\r
	47	sz = JCALL1(GetArrayLength, jenv, input);\r
	48	*jarr = JCALL2(Get##JAVATYPE##ArrayElements, jenv, input, 0);\r
	49	if (!*jarr)\r
	50	return 0; %}\r
	51	#ifdef __cplusplus\r
	52	%{ *carr = new CTYPE[sz]; %}\r
	53	#else\r
	54	%{ carr = (CTYPE) calloc(sz, sizeof(CTYPE)); %}\r
	55	#endif\r
	56	%{ if (!*carr) {\r
	57	SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");\r
	58	return 0;\r
	59	}\r
	60	for (i=0; i<sz; i++)\r
	61	JAVA_TYPEMAP_ARRAY_ELEMENT_ASSIGN(CTYPE)\r
	62	return 1;\r
	63	}\r
	64	\r
65	void SWIG_JavaArrayArgout##JFUNCNAME (JNIEnv jenv, JNITYPE jarr, CTYPE *carr, JNITYPE##Array input) {\r
66	int i;\r
67	jsize sz = JCALL1(GetArrayLength, jenv, input);\r
68	for (i=0; i<sz; i++)\r
69	jarr[i] = (JNITYPE)carr[i];\r
70	JCALL3(Release##JAVATYPE##ArrayElements, jenv, input, jarr, 0);\r
71	}\r
72	\r
73	JNITYPE##Array SWIG_JavaArrayOut##JFUNCNAME (JNIEnv jenv, CTYPE result, jsize sz) {\r
74	JNITYPE *arr;\r
75	int i;\r
76	JNITYPE##Array jresult = JCALL1(New##JAVATYPE##Array, jenv, sz);\r
77	if (!jresult)\r
78	return NULL;\r
79	arr = JCALL2(Get##JAVATYPE##ArrayElements, jenv, jresult, 0);\r
80	if (!arr)\r
81	return NULL;\r
82	for (i=0; i<sz; i++)\r
83	arr[i] = (JNITYPE)result[i];\r
84	JCALL3(Release##JAVATYPE##ArrayElements, jenv, jresult, arr, 0);\r
85	return jresult;\r
86	}\r
87	%}\r
88	%enddef\r
89	\r
90	%{\r
91	#if defined(SWIG_NOINCLUDE) \|\| defined(SWIG_NOARRAYS)\r
92	%}\r
93	\r
94	#ifdef __cplusplus\r
95	JAVA_ARRAYS_DECL(bool, jboolean, Boolean, Bool) /* bool[] */\r
96	#endif\r
97	\r
98	JAVA_ARRAYS_DECL(signed char, jbyte, Byte, Schar) /* signed char[] */\r
99	JAVA_ARRAYS_DECL(unsigned char, jshort, Short, Uchar) /* unsigned char[] */\r
100	JAVA_ARRAYS_DECL(short, jshort, Short, Short) /* short[] */\r
101	JAVA_ARRAYS_DECL(unsigned short, jint, Int, Ushort) /* unsigned short[] */\r
102	JAVA_ARRAYS_DECL(int, jint, Int, Int) /* int[] */\r
103	JAVA_ARRAYS_DECL(unsigned int, jlong, Long, Uint) /* unsigned int[] */\r
104	JAVA_ARRAYS_DECL(long, jint, Int, Long) /* long[] */\r
105	JAVA_ARRAYS_DECL(unsigned long, jlong, Long, Ulong) /* unsigned long[] */\r
106	JAVA_ARRAYS_DECL(jlong, jlong, Long, Longlong) /* long long[] */\r
107	JAVA_ARRAYS_DECL(float, jfloat, Float, Float) /* float[] */\r
108	JAVA_ARRAYS_DECL(double, jdouble, Double, Double) /* double[] */\r
109	\r
110	%{\r
111	#else\r
112	%}\r
113	\r
114	#ifdef __cplusplus\r
115	/* Bool array element assignment different to other types to keep Visual C++ quiet */\r
116	#define JAVA_TYPEMAP_ARRAY_ELEMENT_ASSIGN(CTYPE) (carr)[i] = ((jarr)[i] != 0);\r
117	JAVA_ARRAYS_IMPL(bool, jboolean, Boolean, Bool) /* bool[] */\r
118	#undef JAVA_TYPEMAP_ARRAY_ELEMENT_ASSIGN\r
119	#endif\r
120	\r
121	#define JAVA_TYPEMAP_ARRAY_ELEMENT_ASSIGN(CTYPE) (carr)[i] = (CTYPE)(jarr)[i];\r
122	JAVA_ARRAYS_IMPL(signed char, jbyte, Byte, Schar) /* signed char[] */\r
123	JAVA_ARRAYS_IMPL(unsigned char, jshort, Short, Uchar) /* unsigned char[] */\r
124	JAVA_ARRAYS_IMPL(short, jshort, Short, Short) /* short[] */\r
125	JAVA_ARRAYS_IMPL(unsigned short, jint, Int, Ushort) /* unsigned short[] */\r
126	JAVA_ARRAYS_IMPL(int, jint, Int, Int) /* int[] */\r
127	JAVA_ARRAYS_IMPL(unsigned int, jlong, Long, Uint) /* unsigned int[] */\r
128	JAVA_ARRAYS_IMPL(long, jint, Int, Long) /* long[] */\r
129	JAVA_ARRAYS_IMPL(unsigned long, jlong, Long, Ulong) /* unsigned long[] */\r
130	JAVA_ARRAYS_IMPL(jlong, jlong, Long, Longlong) /* long long[] */\r
131	JAVA_ARRAYS_IMPL(float, jfloat, Float, Float) /* float[] */\r
132	JAVA_ARRAYS_IMPL(double, jdouble, Double, Double) /* double[] */\r
133	\r
134	%{\r
135	#endif\r
136	%}\r
137	\r
138	\r
139	/* The rest of this file has the array typemaps */\r
140	\r
141	/* Arrays of primitive types use the following macro. The array typemaps use support functions. */\r
142	%define JAVA_ARRAYS_TYPEMAPS(CTYPE, JTYPE, JNITYPE, JFUNCNAME, JNIDESC)\r
143	\r
144	%typemap(jni) CTYPE[ANY], CTYPE[] %{JNITYPE##Array%}\r
145	%typemap(jtype) CTYPE[ANY], CTYPE[] %{JTYPE[]%}\r
146	%typemap(jstype) CTYPE[ANY], CTYPE[] %{JTYPE[]%}\r
147	\r
148	%typemap(in) CTYPE[] (JNITYPE *jarr)\r
149	%{ if (!SWIG_JavaArrayIn##JFUNCNAME(jenv, &jarr, &$1, $input)) return $null; %}\r
150	%typemap(in) CTYPE[ANY] (JNITYPE *jarr)\r
151	%{ if ($input && JCALL1(GetArrayLength, jenv, $input) != $1_size) {\r
152	SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size");\r
153	return $null;\r
154	}\r
155	if (!SWIG_JavaArrayIn##JFUNCNAME(jenv, &jarr, &$1, $input)) return $null; %}\r
156	%typemap(argout) CTYPE[ANY], CTYPE[] \r
157	%{ SWIG_JavaArrayArgout##JFUNCNAME(jenv, jarr$argnum, $1, $input); %}\r
158	%typemap(out) CTYPE[ANY]\r
159	%{$result = SWIG_JavaArrayOut##JFUNCNAME(jenv, $1, $1_dim0); %}\r
160	%typemap(out) CTYPE[] \r
161	%{$result = SWIG_JavaArrayOut##JFUNCNAME(jenv, $1, FillMeInAsSizeCannotBeDeterminedAutomatically); %}\r
162	%typemap(freearg) CTYPE[ANY], CTYPE[] \r
163	#ifdef __cplusplus\r
164	%{ delete [] $1; %}\r
165	#else\r
166	%{ free($1); %}\r
167	#endif\r
168	\r
169	%typemap(javain) CTYPE[ANY], CTYPE[] "$javainput"\r
170	%typemap(javaout) CTYPE[ANY], CTYPE[] {\r
171	return $jnicall;\r
172	}\r
173	\r
174	%enddef\r
175	\r
176	JAVA_ARRAYS_TYPEMAPS(bool, boolean, jboolean, Bool, "[Z") /* bool[ANY] */\r
177	JAVA_ARRAYS_TYPEMAPS(signed char, byte, jbyte, Schar, "[B") /* signed char[ANY] */\r
178	JAVA_ARRAYS_TYPEMAPS(unsigned char, short, jshort, Uchar, "[S") /* unsigned char[ANY] */\r
179	JAVA_ARRAYS_TYPEMAPS(short, short, jshort, Short, "[S") /* short[ANY] */\r
180	JAVA_ARRAYS_TYPEMAPS(unsigned short, int, jint, Ushort, "[I") /* unsigned short[ANY] */\r
181	JAVA_ARRAYS_TYPEMAPS(int, int, jint, Int, "[I") /* int[ANY] */\r
182	JAVA_ARRAYS_TYPEMAPS(unsigned int, long, jlong, Uint, "[J") /* unsigned int[ANY] */\r
183	JAVA_ARRAYS_TYPEMAPS(long, int, jint, Long, "[I") /* long[ANY] */\r
184	JAVA_ARRAYS_TYPEMAPS(unsigned long, long, jlong, Ulong, "[J") /* unsigned long[ANY] */\r
185	JAVA_ARRAYS_TYPEMAPS(long long, long, jlong, Longlong, "[J") /* long long[ANY] */\r
186	JAVA_ARRAYS_TYPEMAPS(float, float, jfloat, Float, "[F") /* float[ANY] */\r
187	JAVA_ARRAYS_TYPEMAPS(double, double, jdouble, Double, "[D") /* double[ANY] */\r
188	\r
189	\r
190	%typecheck(SWIG_TYPECHECK_BOOL_ARRAY) /* Java boolean[] */\r
191	bool[ANY], bool[]\r
192	""\r
193	\r
194	%typecheck(SWIG_TYPECHECK_INT8_ARRAY) /* Java byte[] */\r
195	signed char[ANY], signed char[]\r
196	""\r
197	\r
198	%typecheck(SWIG_TYPECHECK_INT16_ARRAY) /* Java short[] */\r
199	unsigned char[ANY], unsigned char[],\r
200	short[ANY], short[]\r
201	""\r
202	\r
203	%typecheck(SWIG_TYPECHECK_INT32_ARRAY) /* Java int[] */\r
204	unsigned short[ANY], unsigned short[],\r
205	int[ANY], int[],\r
206	long[ANY], long[]\r
207	""\r
208	\r
209	%typecheck(SWIG_TYPECHECK_INT64_ARRAY) /* Java long[] */\r
210	unsigned int[ANY], unsigned int[],\r
211	unsigned long[ANY], unsigned long[],\r
212	long long[ANY], long long[]\r
213	""\r
214	\r
215	%typecheck(SWIG_TYPECHECK_INT128_ARRAY) /* Java BigInteger[] */\r
216	unsigned long long[ANY], unsigned long long[]\r
217	""\r
218	\r
219	%typecheck(SWIG_TYPECHECK_FLOAT_ARRAY) /* Java float[] */\r
220	float[ANY], float[]\r
221	""\r
222	\r
223	%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY) /* Java double[] */\r
224	double[ANY], double[]\r
225	""\r
226	\r
227	\r
228	/* Arrays of proxy classes. The typemaps in this macro make it possible to treat an array of \r
229	* class/struct/unions as an array of Java classes. \r
230	* Use the following macro to use these typemaps for an array of class/struct/unions called name:\r
231	* JAVA_ARRAYSOFCLASSES(name) */\r
232	%define JAVA_ARRAYSOFCLASSES(ARRAYSOFCLASSES)\r
233	\r
234	%typemap(jni) ARRAYSOFCLASSES[ANY] "jlongArray"\r
235	%typemap(jtype) ARRAYSOFCLASSES[ANY] "long[]"\r
236	%typemap(jstype) ARRAYSOFCLASSES[ANY] "$javaclassname[]"\r
237	\r
238	%typemap(javain) ARRAYSOFCLASSES[ANY] "$javaclassname.cArrayUnwrap($javainput)"\r
239	%typemap(javaout) ARRAYSOFCLASSES[ANY] {\r
240	return $javaclassname.cArrayWrap($jnicall, $owner);\r
241	}\r
242	\r
243	%typemap(in) ARRAYSOFCLASSES[] (jlong *jarr, jsize sz)\r
244	{\r
245	int i;\r
246	if (!$input) {\r
247	SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");\r
248	return $null;\r
249	}\r
250	sz = JCALL1(GetArrayLength, jenv, $input);\r
251	jarr = JCALL2(GetLongArrayElements, jenv, $input, 0);\r
252	if (!jarr) {\r
253	return $null;\r
254	}\r
255	#ifdef __cplusplus\r
256	$1 = new $*1_ltype[sz];\r
257	#else\r
258	$1 = ($1_ltype) calloc(sz, sizeof($*1_ltype));\r
259	#endif\r
260	if (!$1) {\r
261	SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");\r
262	return $null;\r
263	}\r
264	for (i=0; i<sz; i++) {\r
265	$1[i] = *($&1_ltype)(void )&jarr[i];\r
266	}\r
267	}\r
268	\r
269	%typemap(in) ARRAYSOFCLASSES[ANY] (jlong *jarr, jsize sz)\r
270	{\r
271	int i;\r
272	if (!$input) {\r
273	SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");\r
274	return $null;\r
275	}\r
276	sz = JCALL1(GetArrayLength, jenv, $input);\r
277	if (sz != $1_size) {\r
278	SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size");\r
279	return $null;\r
280	}\r
281	jarr = JCALL2(GetLongArrayElements, jenv, $input, 0);\r
282	if (!jarr) {\r
283	return $null;\r
284	}\r
285	#ifdef __cplusplus\r
286	$1 = new $*1_ltype[sz];\r
287	#else\r
288	$1 = ($1_ltype) calloc(sz, sizeof($*1_ltype));\r
289	#endif\r
290	if (!$1) {\r
291	SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");\r
292	return $null;\r
293	}\r
294	for (i=0; i<sz; i++) {\r
295	$1[i] = *($&1_ltype)(void )&jarr[i];\r
296	}\r
297	}\r
298	\r
299	%typemap(argout) ARRAYSOFCLASSES[ANY]\r
300	{\r
301	int i;\r
302	for (i=0; i<sz$argnum; i++) {\r
303	jarr$argnum[i] = 0;\r
304	($&1_ltype)(void )&jarr$argnum[i] = &$1[i];\r
305	}\r
306	JCALL3(ReleaseLongArrayElements, jenv, $input, jarr$argnum, 0);\r
307	}\r
308	\r
309	%typemap(out) ARRAYSOFCLASSES[ANY]\r
310	{\r
311	jlong *arr;\r
312	int i;\r
313	$result = JCALL1(NewLongArray, jenv, $1_dim0);\r
314	if (!$result) {\r
315	return $null;\r
316	}\r
317	arr = JCALL2(GetLongArrayElements, jenv, $result, 0);\r
318	if (!arr) {\r
319	return $null;\r
320	}\r
321	for (i=0; i<$1_dim0; i++) {\r
322	arr[i] = 0;\r
323	($&1_ltype)(void )&arr[i] = &$1[i];\r
324	}\r
325	JCALL3(ReleaseLongArrayElements, jenv, $result, arr, 0);\r
326	}\r
327	\r
328	%typemap(freearg) ARRAYSOFCLASSES[ANY]\r
329	#ifdef __cplusplus\r
330	%{ delete [] $1; %}\r
331	#else\r
332	%{ free($1); %}\r
333	#endif\r
334	\r
335	/* Add some code to the proxy class of the array type for converting between type used in \r
336	* JNI class (long[]) and type used in proxy class ( ARRAYSOFCLASSES[] ) */\r
337	%typemap(javacode) ARRAYSOFCLASSES %{\r
338	protected static long[] cArrayUnwrap($javaclassname[] arrayWrapper) {\r
339	long[] cArray = new long[arrayWrapper.length];\r
340	for (int i=0; i<arrayWrapper.length; i++)\r
341	cArray[i] = $javaclassname.getCPtr(arrayWrapper[i]);\r
342	return cArray;\r
343	}\r
344	\r
345	protected static $javaclassname[] cArrayWrap(long[] cArray, boolean cMemoryOwn) {\r
346	$javaclassname[] arrayWrapper = new $javaclassname[cArray.length];\r
347	for (int i=0; i<cArray.length; i++)\r
348	arrayWrapper[i] = new $javaclassname(cArray[i], cMemoryOwn);\r
349	return arrayWrapper;\r
350	}\r
351	%}\r
352	\r
353	%enddef /* JAVA_ARRAYSOFCLASSES */\r
354	\r
355	\r
356	/* Arrays of enums. \r
357	* Use the following to use these typemaps for an array of enums called name:\r
358	* %apply ARRAYSOFENUMS[ANY] { name[ANY] }; */\r
359	%typemap(jni) ARRAYSOFENUMS[ANY] "jintArray"\r
360	%typemap(jtype) ARRAYSOFENUMS[ANY] "int[]"\r
361	%typemap(jstype) ARRAYSOFENUMS[ANY] "int[]"\r
362	\r
363	%typemap(javain) ARRAYSOFENUMS[ANY] "$javainput"\r
364	%typemap(javaout) ARRAYSOFENUMS[ANY] {\r
365	return $jnicall;\r
366	}\r
367	\r
368	%typemap(in) ARRAYSOFENUMS[] (jint *jarr)\r
369	%{ if (!SWIG_JavaArrayInInt(jenv, &jarr, (int *)(void )&$1, $input)) return $null; %}\r
370	%typemap(in) ARRAYSOFENUMS[ANY] (jint *jarr) {\r
371	if ($input && JCALL1(GetArrayLength, jenv, $input) != $1_size) {\r
372	SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size");\r
373	return $null;\r
374	}\r
375	if (!SWIG_JavaArrayInInt(jenv, &jarr, (int *)(void )&$1, $input)) return $null;\r
376	}\r
377	%typemap(argout) ARRAYSOFENUMS[ANY] \r
378	%{ SWIG_JavaArrayArgoutInt(jenv, jarr$argnum, (int *)$1, $input); %}\r
379	%typemap(out) ARRAYSOFENUMS[ANY] \r
380	%{$result = SWIG_JavaArrayOutInt(jenv, (int *)$1, $1_dim0); %}\r
381	%typemap(freearg) ARRAYSOFENUMS[ANY] \r
382	#ifdef __cplusplus\r
383	%{ delete [] $1; %}\r
384	#else\r
385	%{ free($1); %}\r
386	#endif\r
387	\r