The answer depends mostly on whether the foreign call is a safe or an unsafe call. An unsafe C call is basically just a function call, so if there’s no (nontrivial) type conversion, there are three function calls if you make three foreign calls, and between one and four when you write a wrapper in … Read more
With the API you can use Builder::clang_arg with arbitrary arguments: let b = bindgen::builder().header(“foo.h”).clang_arg(“-I/path”); From the command line you can do the same by appending arguments after –, like: bindgen foo.h — -I/path
If you just want some C function to mutably borrow the Vec, you can do it like this: extern “C” { fn some_c_function(ptr: *mut i32, len: ffi::size_t); } fn safe_wrapper(a: &mut [i32]) { unsafe { some_c_function(a.as_mut_ptr(), a.len() as ffi::size_t); } } Of course, the C function shouldn’t store this pointer somewhere else because that would … Read more
You cannot do it unless the C API allows passing a user-provided callback parameter. If it does not, you can only use static functions. The reason is that closures are not “just” functions. As their name implies, closures “close over” variables from their lexical scope. Each closure has an associated piece of data which holds … Read more
Try update ffi and sassc： bundle update ffi sassc
The gem install ffi fails due to the gem trying to build a bundled copy of libffi, which does not work due to assumptions that /usr/bin/env exists and too old libffi copy. However, you can build the ffi gem against the system libffi – install the packages: apt install clang make ruby-dev libffi-dev After that … Read more
You can’t cast a struct to c_void, but you can cast a reference to the struct to *mut c_void and back using some pointer casts: fn my_callback(con: *tsm_screen, …, data: *mut c_void) { // unsafe is needed because we dereference a raw pointer here let data: &mut State = unsafe { &mut *(data as *mut … Read more
The best way to work with C strings in Rust is to use structures from the std::ffi module, namely CStr and CString. CStr is a dynamically sized type and so it can only be used through a pointer. This makes it very similar to the regular str type. You can construct a &CStr from *const … Read more
Provided you can get your Python code to call C, you can call Haskell functions that have been exported via the FFI Another approach would be to write a standard IPC interface, in the case of darcs and pandoc just calling them as vanilla executables and parsing their output might be the way to go. … Read more
The benefit of Haskell is the powerful abstractions it allows you to use. You’re not thinking in terms of ones and zeros and addresses and registers but computations and type properties and continuations. The benefit of C++ is how tightly you can optimize it when necessary. You aren’t thinking about high-minded monads, arrows, partial application, … Read more