SWIG VS JNA

This sounds a bit like SWIG. You give SWIG an "interface file" describing the API of a library, and it uses that to spit out a bunch of language-specific bindings for that library.

Try out http://www.swig.org/

SWIG

Check out the site www.swig.org it will answer several of your questions. XS code is specific to Perl that you have to know how to code and use. SWIG takes code from C and C++ (actually several languages) and uses code templates to generate all the XS code for you. I wrote both a C library and C++ library doing different things, and used SWIG to import them into Perl (via "use"), Python and PHP. There is a learning curve, but it's not that bad, and there is a lot of great documentation and examples on the SWIG site.

Ohhh alrightt I went through the installation of pypodofo. 1. Install podofo library. For example in archlinux, pacman -S podofo 2. Install swig tool. Note, you should have installed gcc and g++ compilers 3. Build wrapper. python setup.py build 4. Copy dynamic library to python package. cp build/lib.linux-x86_64-3.7/_api.cpython-37m-x86_64-linux-gnu.so pypodofo/ 5. Install requirements. pip install -r requirements.txt (if possible in a virtualenv). 6. Run tests. nosetests tests/

Another option is SWIG, but I don't like it too much.

* I was using SWIG (http://www.swig.org/) 15+20 years ago to bind C/C++ to Perl and Java and it still exists.*

I've used it. It took the entire thing you want to call and generated one giant file of munged C. That's sort of where that idea takes you.

But the author is on to something. There's a C to Rust translator. It sucks, because it works by emulating C pointer arithmetic in unsafe Rust, using its own set of primitives along the lines of "offset this pointer by this much". Now you have ugly, unsafe Rust.

What's needed is something that infers the meaning of an ambiguous function call from the code. Something that reasons like this:

Function call:

    int read(char* buf, size_t n)

For the parsing part it is probably not a big deal. Either your own elisp code or use something like clangd. I am not so knowledgable about the implementation deatils for LSP & Co, but it is definitely possible to parse headers and extract definitions. There are also tools like swig.

In case you haven't used it (assuming that you already know about JNI, for comparison) - https://github.com/java-native-access/jna is about as easy as it gets for native interop. Also, as mentioned in another comment, with the Java FFM (Foreign Function and Memory) API already in preview mode, pretty soon, there will be no external dependencies at all, and Java should be able to interop with any language that can talk to C.

The complexity of JNI has given rise to some community-driven libraries that make it simpler to do FFI in Java. Java Native Access (JNA) is one of them. It's built on top of JNI and at least makes FFI easier to use, especially as it removes the need to write any C binding code manually and reduces the chances of memory safety issues. Still, it has some of the disadvantages of being JNI-based and is slightly slower than JNI in many cases. However, JNA is widely used and battle-tested, so definitely a better option than using JNI directly.

This is about calling into any native operating system APIs, as long as they are callable via C or C++ (which these days means "all" operating system APIs).

JNI is somewhat harder to use, because you need custom glue on both sides of the border: Some custom classes in Java and some custom code on the C (and C++) side.

This proposal would remove the need for the glue on the C side and would allow a pure java solution.

Something like this has existed in third-party form for a while as JNA (https://github.com/java-native-access/jna), but now it's going to be built into the JRE itself (if the proposal passes through review)

I use JNA https://github.com/java-native-access/jna , as you can write the entire interface in Java faster as well as easier without the need of messing with the complexities of JNI.

This (still someone else's code) will give you access to low level operating system APIs. For example, this will let you interact directly with the Windows COM, which lets you define interfaces and implement them: https://github.com/java-native-access/jna

.. and probably with JNA: https://github.com/java-native-access/jna

ODBC is a C API. You would need to make C calls from Java. You can use JNI or JNA to access native code.

Go to https://github.com/java-native-access/jna and download both "jna-5.8.0.jar" and "jna-platform-5.8.0.jar"