Help binding a function

[keastrid]

Hi, I am trying to create bindings for CFITSIO, but have encountered an issue with binding ffomem. I've successfully bound other functions, but this one is giving me some trouble - attempting to invoke it cause a crash, with no exception nor a hs_pid_err file. I am unsure how to proceed in this situation. I'm assuming there's something with the arguments I'm passing to it

It's header is:

int ffomem(fitsfile **fptr, const char *name, int mode, void **buffptr,
           size_t *buffsize, size_t deltasize,
           void *(*mem_realloc)(void *p, size_t newsize),
           int *status);

Binding:

int ffomem(PointerByReference fptr, String filename, int ioMode,
               //todo How to pass size_t by reference?
               Buffer buffer, @size_t LongLongByReference memSize, @size_t long deltaSize, MemRealloc resizer,
               IntByReference status);

interface MemRealloc {
        @Delegate
        void resize(Pointer p, int newSize);//todo size_t, tried with (Byte)Buffer instead of Pointer, but JNR throws on that case
    }

[basshelal]

This is probably the worst situation to be in, a crash with no clue on what causes, though usually when the Hotspot VM crashes it dumps the hs_err_pid.log files, not dumping it is strange and you may want to look into that. It's unrelated to JNR-FFI but it's worth making sure you get those files being dumped because at the very least you can know which part of your Java code is causing the crash and hopefully figure out where it maps on the native side. Often it's not a JNR-FFI issue but rather, the native library is trying to access some inaccessible or invalid memory, either you didn't allocate the memory, it got freed, or it's not in the correct format the library expects (ie passed a pointer to an int when the library expected a pointer to a large struct and thus tried to access beyond the pointer's limits).

I think maybe your callback isn't mapped correctly? I might be wrong, C's syntax here is weird. Try:

interface MemRealloc {
        @Delegate
        Pointer resize(Pointer p, int newSize); 
        // Try returning a Pointer instead of void, void *(*mem_realloc)(void *p, size_t newsize) looks like it returns a pointer
    }

Otherwise I would suggest trying to use Pointer wherever possible and see what you get:

int ffomem(Pointer fptr, Pointer filename, int ioMode,
               Pointer buffer, Pointer memSize, @size_t long deltaSize, MemRealloc resizer,
               Pointer status);

interface MemRealloc {
        @Delegate
        void resize(Pointer p, int newSize); // And also try returning Pointer as we did above
    }

Switching to Pointer is usually a safe bet in my experience to figure out where you are wrong, chances are your mapping is incorrect.

Pointers can be allocated using any of the static methods in Memory such as:

Pointer myPointer1 = Memory.allocate(...); // Allocate some memory
Pointer myPointer2 = Memory.allocateDirect(...); // Allocate direct memory
Pointer myPointer3 = Memory.allocateTemporary(...); // Allocate temorary memory

With Struct or Union types you can set their backing Pointer using the instance method:
useMemory(Pointer p)

and getting the backing Pointer using the static method:
Struct.getMemory(Struct s)

And with a Pointer you can call a wide number methods to put and get values, just make sure your allocated Pointer is large enough when putting, though JNR-FFI should usually throw exceptions in cases where the bounds are off in both putting and getting.

I hope this helps, let me know how this works out, I am curious to understand what the problem is.
Many thanks 😊

[keastrid]

Thanks, the new method signature seems to work! Though realloc isn't tested/used on this method, it will be on others.

End up with your interface and

int ffomem(PointerByReference fptr, String filename, int ioMode,
               PointerByReference buffer, /*@size_t*/ NativeLongByReference memSize, /*@size_t*/ long deltaSize, MemRealloc resizer,
               IntByReference status);

@size_t on deltaSize causes a crash (with a hs_err file! though I still need to learn to read those). memSize of LongLongBR also seems to cause it to crash when dereferencing(?) the value, so I'm not really sure what is going on with those. I'm only targeting 64bit systems, so I think NativeLong is fine.

Ended up needing to pass buffer as

var f = Files.readAllBytes(...);
var p = Memory.allocateDirect(runtime, f.length);
p.put(0, file, 0, f.length);
var bp = new PointerByReference(p);//pass this

Is there no way to verify method signatures?

[basshelal]

Nice! Glad it worked out 😁!

Is there no way to verify method signatures?

If you mean is there any way to verify that the Java signature is the same as or is compatible with the native signature?
I don't think this is possible.

On the ABI level (matching the Java signature with the native library) is probably impossible, especially if debug symbols are stripped, which they often are in production/release builds to save space and add obfuscation.

On the API level, maybe, in theory one could have a command line tool that could parse C header files and Java files/directories that correspond to those header files and vice versa to make sure they're compatible, a tool like this exists for JNA, JNAerator.

But even then you can always use different mappings for different needs. For example for a C enum type you can use int, long, an enum or even EnumSet depending on your needs. Similarly you may want to use Pointer instead of IntByReference or LongByReference etc etc, all are valid depending on your needs and what works at runtime with your specific library.

This is a good idea but fairly low priority. From my little experience with JNAerator, it would often still do things differently from how I would do them.

Anyway glad we could be of help! 😊