How to return a optional string from native methods?

[Maurizio Cimadamore]

Yes, if native code is allocating stuff, the way to go is to use 
reinterpret. This is covered here:

https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/lang/foreign/Linker.html#by-ref

And, in more details, here

https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/lang/foreign/MemorySegment.html#wrapping-addresses

If you don't want to resize all your segments explicitly and work in 
"sudo" mode, an escape hatch is also possible: create an address layout 
whose target layout has maximal size:

```
static final AddressLayout ADDRESS_UNBOUNDED = 
ValueLayout.ADDRESS.withTargetLayout(MemoryLayout.sequenceLayout(Long.MAX_VALUE, 
ValueLayout.JAVA_BYTE));
```

And then use `ADDRESS_UNBOUNDED` everywhere. Now all the segments 
wrapping pointers returned by native code will have maximal size, and no 
OOBE will be issued.

Which approach you take, and how much safety you want to enforce, is up 
to you. The API presents you with a choice and a range of options here.

Cheers
Maurizio


On 29/09/2023 15:23, tison wrote:
> I found reinterpret that can help in the first step where length=0 for 
> the returned memory. So we may return a leading long with how many 
> bytes is followed?
>
> final MemorySegment version = (MemorySegment) 
> datafusionVersionMethodHandle.invokeExact();
> return version.reinterpret(10, arena).getUtf8String(0);
>
> Best,
> tison.
>
>
> tison <wander4096 at gmail.com> 于2023年9月29日周五 22:08写道：
>
>     Here is my native method written in Rust:
>
>     #[no_mangle]
>     pub unsafe extern "C" fn datafusion_version() -> *const c_char {
>     CString::new(datafusion::DATAFUSION_VERSION).unwrap().into_raw()
>     }
>
>     And below is my attempt to bind it with FFM APIs:
>
>         static MethodHandle createMethodHandle(String name,
>     FunctionDescriptor descriptor) {
>             final MemorySegment fp =
>     LOADER.lookup.find(name).orElseThrow();
>             return LOADER.linker.downcallHandle(fp, descriptor);
>         }
>
>         private static final MethodHandle
>     datafusionVersionMethodHandle =
>     NativeLoader.createMethodHandle(datafusionVersionMethodName,
>     datafusionVersionMethodDesc);
>
>         @SneakyThrows
>         public static String datafusionVersion() {
>             final MemorySegment version = (MemorySegment)
>     datafusionVersionMethodHandle.invokeExact();
>             return version.getUtf8String(0);
>         }
>
>     I noticed that the returned MemorySegment is always with length 0
>     and thus any access with return OutOfBoundException.
>
>     In the demos from JEP, all memory segments are allocated from the
>     Java side and the native code only move or modify those allocated
>     memory segments instead of allocate/shrink memory.
>
>     I wonder what is the formal method to allocate a string from
>     native methods and pass back to the Java world.
>
>     And, if we think of error handling, how do we properly return a
>     NULL from native methods, and how do we throw exceptions from
>     native methods?
>
>     MemorySegment.NULL seems an Object without overriding equals, and
>     JNIEnv's throw counterpart is missing or I don't find it (perhaps
>     upcall helps but it's still a bit away from real-world usage).
>
>     Best,
>     tison.
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <https://mail.openjdk.org/pipermail/panama-dev/attachments/20230929/d60e6b33/attachment.htm>