binding a c struct that contains a function pointer

[kj4tmp]

I have a c struct that contains a function pointer.

typedef struct some_struct {
    int              (*PO2SOconfigx)(ecx_contextt * context, uint16 slave);
} some_structt;

This function pointer is a callback used internally by the c library. I would like the c library to be able to call a python function that I pass into this struct.

How do I write a python function into the c struct function pointer?

I have tried:

.def_rw("PO2SOconfigx", &some_structt::PO2SOconfigx)

[Ziqi-Yang]

Hi, @wjakob. Is this a bug? I encounter the similar problem and tried many ways to pass it, but failed.

This is the definition:

typedef void (*LLVMFatalErrorHandler)(const char *Reason);

void LLVMInstallFatalErrorHandler(LLVMFatalErrorHandler Handler);

And binding code:

  m.def("install_fatal_error_handler", &LLVMInstallFatalErrorHandler, "handler"_a)

The error:

In [1]: import llvmpym.error_handling as eh

In [2]: eh.install_fatal_error_handler(lambda x: print(x + "hello"))
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[2], line 1
----> 1 eh.install_fatal_error_handler(lambda x: print(x + "hello"))

TypeError: install_fatal_error_handler(): incompatible function arguments. The following argument types are supported:
    1. install_fatal_error_handler(handler: void (char const*)) -> None

Invoked with types: function

[oremanj]

Many C libraries will invoke your callback with an opaque "context"/"cookie"/variously-named pointer that you provide. You can support these by using a wrapper function and treating the context as a PyObject*:

struct example_c_api {
    void *context;
    int (*callback)(void *context, int arg1, const char* arg2);
};
int callback_py_wrapper(void *context, int arg1, const char* arg2) {
    try {
        return nb::cast<int>(nb::borrow<nb::callable>(static_cast<PyObject*>(context))(arg1, arg2));
    } catch (nb::python_error& e) {
        e.discard_as_unraisable("example_c_api callback");
        return -1;
    } catch (nb::cast_error& e) {
        // ... handle callback returning something that wasn't convertible to int ...
        return -1;
    }
}

nb::class_<example_c_api>(...)
    .def_prop_rw(
        "callback",
        [](const example_c_api& self) -> std::optional<nb::callable> {
            if (self.callback != callback_py_wrapper) return std::nullopt;
            return nb::borrow<nb::callable>(static_cast<PyObject*>(self.context));
        },
        [](example_c_api& self, nb::callable cb) {
            self.context = static_cast<void*>(cb.ptr());
            self.callback = callback_py_wrapper;
        },
        nb::for_setter(nb::keep_alive<1, 2>()));

If you don't have such a user-controlled pointer available, the problem becomes much harder, because you need to generate a separate piece of code (separate function pointer) for every Python callable object you want to support. This is a simple form of JIT compilation and needs platform-specific support. You might be able to use libffi or the Python ctypes module, both of which can theoretically handle this case, but it's definitely not straightforward.

[wjakob]

@kj4tmp: To add to @oremanj's answer: nanobind has builtin support for converting between Python and std::function<..> (C++11 type-erased function wrappers) in both directions.

This is the easiest way to implement inter-language callbacks and is the preferred solution if you have the ability to adapt the design of your library. The higher-level problem is that just a function pointer isn't enough: you need extra data, for example to know to which Python object a call should be dispatched. std::function<..> can automatically absorb this extra data through its type-erasure mechanism. If you need to expose C-style functions pointers, then you will have to build an equivalent mechanism yourself.