Swift: Unable to cast function pointer to (void*) for use in C-style third party library - c

Question

How do I cast a function pointer in Swift to a (void*) for use in a third party C-style library?
I am programming an acquisition card that requires setting up an interrupt callback using a C-style function provided by a third party library. That particular function, which must be called to set up the callback, takes a (void*) argument for the callback. In C, this works:
// somefile.c
int PHX_StreamRead( tHandle, etAcq, void*);
PHX_StreamRead(handle, PHX_START, (void*)&phxvptrs_callback);
static void phxvptrs_callback(tHandle h, ui32 mask, void *p) {
//... stuff
}
But in Swift, I am unable to call PHX_StreamRead() using the function pointer phxvptrs_callback, because I get a compilation error (wrong pointer type):
// file.swift
PHX_StreamRead(handle, PHX_START, &phxvptrs_callback) // Does not compile
// Error: "Cannot pass immutable value as inout argument: phxvptrs_callback is a function"
However, (surprisingly to me at least), all my attempts to cast that pointer to anything that looks like an UnsafeRawPointer failed:
// attempts.swift
typealias callbackFctType = ((tHandle, ui32, UnsafeMutableRawPointer) -> Void)
let p1 = UnsafeRawPointer(&phxvptrs_callback) // does not compile
// Error: "Cannot pass immutable value as inout argument: phxvptrs_callback is a function"
let p2 = UnsafePointer<callbackFctType>(&phxvptrs_callback) // Similar error
I figured out a workaround (below) but I would like to understand why these casts are refusing to compile. I assumed pretty much anything could be cast to UnsafeRawPointer.
My workaround has been to create a small C file with the callback definition and a wrapper function MyPHX_StreamRead_START_WithCallBack() that just calls PHX_StreamRead() with the proper accepted C syntax:
// file.c
static void phxvptrs_callback(tHandle h, ui32 mask, void *p) {
//... stuff
}
int MyPHX_StreamRead_START_WithCallBack(tHandle handle) {
return PHX_StreamRead(handle, PHX_START, &phxvptrs_callback);
}
Of course, calling that wrapper from Swift is not an issue and solves my problem but I find this solution "Unswift".

Answer 1

As far as I know, the only way to convert function pointer types in Swift is using unsafeBitCast.
Try something like this:
PHX_StreamRead(handle, PHX_START, unsafeBitCast(phxvptrs_callback, to: UnsafeMutableRawPointer.self))
EDIT
If you get "fatal error: can't unsafeBitCast between types of different sizes", Swift may not be treating phxvptrs_callback as a C-function (#convention(c) closure). In such cases, a little more code needed:
typealias callbackFctType = #convention(c) (tHandle, ui32, UnsafeMutableRawPointer?)->Void
let callbackWrapper: callbackFctType = phxvptrs_callback
PHX_StreamRead(handle, PHX_START, unsafeBitCast(callbackWrapper, to: UnsafeMutableRawPointer.self))
or this would compile and work as expected:
typealias callbackFctType = #convention(c) (tHandle, ui32, UnsafeMutableRawPointer?)->Void
PHX_StreamRead(handle, PHX_START, unsafeBitCast(phxvptrs_callback as callbackFctType, to: UnsafeMutableRawPointer.self))
EDIT2
To write a callback in Swift, you can write something like this:
typealias callbackFctType = #convention(c) (tHandle, ui32, UnsafeMutableRawPointer?)->Void
let myCallback: callbackFctType = {handle, mask, p in
//This closure cannot capture the context of its surrounding scope.
//(Which means this closure cannot use `self` even when in a class.)
//...
}
PHX_StreamRead(handle, PHX_START, unsafeBitCast(myCallback, to: UnsafeMutableRawPointer.self))