Wie wähle ich Swift am besten von C aus?

Question

Der Aufruf von Swift in C ist ziemlich einfach, aber ich bin dabei, einen bidirektionalen Wrapper in C zu erstellen, also muss mein C Swift-Funktionen aufrufen.

Jetzt kann ich dies tun, indem ich Funktionszeiger in C deklariere und meine C-Funktionen sie aufrufen, nachdem die Swift-Seite sie eingerichtet hat, um den Code in Swift aufzurufen.

Meine C-Header-Datei:

typedef void (*callback_t)(void); 

void callBackIntoSwift(callback_t cb); 

Meine C-Implementierungsdatei:

#include "stuff.h" 
#include <stdio.h> 

void callBackIntoSwift(callback_t cb) 
{ 
    printf("Will call back into Swift\n"); 
    cb(); 
    printf("Did call back into Swift\n"); 
} 

Nach meiner C-Header-Datei in dem Überbrückungs Header einschließlich, kann ich folgendes auf der Swift Seite tun:

let cb: callback_t = { 
    someKindOfSwiftFunction() 
} 

callBackIntoSwift(cb) 

Oder auch:

callBackIntoSwift { 
    someKindOfSwiftFunction() 
} 

Gibt es eine bessere Möglichkeit, dies zu tun, wo Funktionszeiger und Rückrufe nicht benötigt werden? Ich möchte die C-Seite someKindOfSwiftFunction direkt aufrufen lassen ... aber wenn ich versuche, @convention (c) auf Funktionsdeklarationen anzuwenden, erhalte ich die Nachricht, dass das Attribut nur auf Typen und nicht auf Deklarationen angewendet werden kann.

Irgendwelche Ideen oder Codebasen in z.B. Github kann ich mir ansehen?

Answer 1

Sie können etwas tun:

FileSwift.swift

public class SwiftTest: NSObject { 
    @objc public static func testMethod() { 
     print("Test") 
    } 
} 

FileSwiftWrapper.h

void SwiftFunctionWrapper(); 

FileSwiftWrapper.m

#import "ProductModuleName-Swift.h" 

void SwiftFunctionWrapper() { 
     [SwiftTest testMethod]; 
} 

Answer 2

Nach Joe Groff:

Es gibt noch keinen offiziellen Weg. Abgesehen vom Namen Mangling verwenden Swift-Funktionen eine andere Aufrufkonvention von C. Inoffiziell, wenn Sie bereit sind, mit mehr als der üblichen Menge an Code-Bruch und Compiler-Bugs umzugehen, gibt es ein inoffizielles Attribut @ _cdecl, das dies tut:

@_cdecl("mymodule_foo") 
func foo(x: Int) -> Int { 
    return x * 2 
} 

die Sie dann von C aufrufen können:

#include <stdint.h> 

intptr_t mymodule_foo(intptr_t); 

intptr_t invoke_foo(intptr_t x) { 
    return mymodule_foo(x); 
}