Question

I’m having issues passing in an appropriate Java data type for the fetchByType C function’s length parameter from my Java implementation (both below). On the C side, the *length parameter is a pointer to a length variable (output) to indicate the size of the data to be returned from the fetchByType C function. I’ve tried to use the SWIG %apply int32_t { int32_t * } and pass an int initialized at 0 from my Java implementation but that fails. I’ve also tried passing in a SWIGTYPE_p_int as shown below, but that also doesn’t work. I don’t have an exception unfortunately as this just crashes.

C Function:

void * fetchByType(struct row_t *result_row, type_t attribute, int32_t *length);

Generated Java from SWIG:

public static String fetchByType(SWIGTYPE_p_result_row_t result_row, type_t attribute, SWIGTYPE_p_int length)

Java Implementation:

SWIGTYPE_p_int length = new SWIGTYPE_p_int();
fetchByType(result_row, attribute, length)

Answer 1

The problem here is that you need to pass something that can be changed into the C function. That means you can’t use a primitive in Java (e.g. int) since Java always passes primitives by value.

There’s only really one sensible way you can work around this. SWIG in fact already provides a few typemap we can use that passes this as an array instead. Arrays in Java are “objects” and so int[] is passed by reference even though int isn’t. A simplified example based on the function you show above, first test.h:

inline void fetchByType(int32_t *length) {
  *length = 123;
}

And a module file, test.i:

%module test

%{
#include "test.h"
%}

// knows about things like int *OUTPUT:
%include "typemaps.i"
// knows about int32_t
%include "stdint.i"
// let's have an int32_t *OUTPUT for our int32_t *lenght
%apply int32_t *OUTPUT { int32_t *length }

%include "test.h"

This just makes sure we apply the appropriate *OUTPUT typemap. (stdint.i maps this onto a real C primitive for you). I tested with:

public class run {
  public static void main(String[] argv) {
    int arr[] = new int[1];
    test.fetchByType(arr);
    System.out.println(arr[0]);
  }
}

It’s a bit of a hack¹, but it’s usable. Another approach might be to use a java.lang.Integer, which also represents an int and is a proper Object so gets passed by reference. The problem there is that java.lange.Integer is immutable however and I’m not actually sure enough how that works on the JNI side to provide an example of this.

¹ Other languages SWIG supports alter the return type for some typemaps and return a tuple or similar for OUTPUT arguments, but that’s not really feasible with Java.