1/* -----------------------------------------------------------------------------
2 * various.i
3 *
4 * SWIG Typemap library for Java.
5 * Various useful typemaps.
6 * ----------------------------------------------------------------------------- */
7
8/*
9 * char **STRING_ARRAY typemaps.
10 * These typemaps are for C String arrays which are NULL terminated.
11 *   char *values[] = { "one", "two", "three", NULL }; // note NULL
12 * char ** is mapped to a Java String[].
13 *
14 * Example usage wrapping:
15 *   %apply char **STRING_ARRAY { char **input };
16 *   char ** foo(char **input);
17 *
18 * Java usage:
19 *   String numbers[] = { "one", "two", "three" };
20 *   String[] ret = modulename.foo( numbers };
21 */
22%typemap(jni) char **STRING_ARRAY "jobjectArray"
23%typemap(jtype) char **STRING_ARRAY "String[]"
24%typemap(jstype) char **STRING_ARRAY "String[]"
25%typemap(in) char **STRING_ARRAY (jint size) {
26  int i = 0;
27  if ($input) {
28    size = JCALL1(GetArrayLength, jenv, $input);
29#ifdef __cplusplus
30    $1 = new char*[size+1];
31#else
32    $1 = (char **)calloc(size+1, sizeof(char *));
33#endif
34    for (i = 0; i<size; i++) {
35      jstring j_string = (jstring)JCALL2(GetObjectArrayElement, jenv, $input, i);
36      const char *c_string = JCALL2(GetStringUTFChars, jenv, j_string, 0);
37#ifdef __cplusplus
38      $1[i] = new char [strlen(c_string)+1];
39#else
40      $1[i] = (char *)calloc(strlen(c_string)+1, sizeof(const char *));
41#endif
42      strcpy($1[i], c_string);
43      JCALL2(ReleaseStringUTFChars, jenv, j_string, c_string);
44      JCALL1(DeleteLocalRef, jenv, j_string);
45    }
46    $1[i] = 0;
47  } else {
48    $1 = 0;
49    size = 0;
50  }
51}
52
53%typemap(freearg) char **STRING_ARRAY {
54  int i;
55  for (i=0; i<size$argnum-1; i++)
56#ifdef __cplusplus
57    delete[] $1[i];
58  delete[] $1;
59#else
60  free($1[i]);
61  free($1);
62#endif
63}
64
65%typemap(out) char **STRING_ARRAY {
66  if ($1) {
67    int i;
68    int len=0;
69    jstring temp_string;
70    const jclass clazz = JCALL1(FindClass, jenv, "java/lang/String");
71
72    while ($1[len]) len++;
73    $result = JCALL3(NewObjectArray, jenv, len, clazz, NULL);
74    /* exception checking omitted */
75
76    for (i=0; i<len; i++) {
77      temp_string = JCALL1(NewStringUTF, jenv, *$1++);
78      JCALL3(SetObjectArrayElement, jenv, $result, i, temp_string);
79      JCALL1(DeleteLocalRef, jenv, temp_string);
80    }
81  }
82}
83
84%typemap(javain) char **STRING_ARRAY "$javainput"
85%typemap(javaout) char **STRING_ARRAY {
86    return $jnicall;
87  }
88
89/*
90 * char **STRING_OUT typemaps.
91 * These are typemaps for returning strings when using a C char ** parameter type.
92 * The returned string appears in the 1st element of the passed in Java String array.
93 *
94 * Example usage wrapping:
95 *   void foo(char **string_out);
96 *
97 * Java usage:
98 *   String stringOutArray[] = { "" };
99 *   modulename.foo(stringOutArray);
100 *   System.out.println( stringOutArray[0] );
101 */
102%typemap(jni) char **STRING_OUT "jobjectArray"
103%typemap(jtype) char **STRING_OUT "String[]"
104%typemap(jstype) char **STRING_OUT "String[]"
105%typemap(javain) char **STRING_OUT "$javainput"
106
107%typemap(in) char **STRING_OUT($*1_ltype temp) {
108  if (!$input) {
109    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
110    return $null;
111  }
112  if (JCALL1(GetArrayLength, jenv, $input) == 0) {
113    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
114    return $null;
115  }
116  $1 = &temp;
117  *$1 = 0;
118}
119
120%typemap(argout) char **STRING_OUT {
121  jstring jnewstring = NULL;
122  if ($1) {
123     jnewstring = JCALL1(NewStringUTF, jenv, *$1);
124  }
125  JCALL3(SetObjectArrayElement, jenv, $input, 0, jnewstring);
126}
127
128/*
129 * char *BYTE typemaps.
130 * These are input typemaps for mapping a Java byte[] array to a C char array.
131 * Note that as a Java array is used and thus passeed by reference, the C routine
132 * can return data to Java via the parameter.
133 *
134 * Example usage wrapping:
135 *   void foo(char *array);
136 *
137 * Java usage:
138 *   byte b[] = new byte[20];
139 *   modulename.foo(b);
140 */
141%typemap(jni) char *BYTE "jbyteArray"
142%typemap(jtype) char *BYTE "byte[]"
143%typemap(jstype) char *BYTE "byte[]"
144%typemap(in) char *BYTE {
145  $1 = (char *) JCALL2(GetByteArrayElements, jenv, $input, 0);
146}
147
148%typemap(argout) char *BYTE {
149  JCALL3(ReleaseByteArrayElements, jenv, $input, (jbyte *) $1, 0);
150}
151
152%typemap(javain) char *BYTE "$javainput"
153
154/* Prevent default freearg typemap from being used */
155%typemap(freearg) char *BYTE ""
156
157