The right way to use a Swift library in C

The right way to construct a C suitable Swift library?

With the intention to create a Swift library that is going to work with C, now we have to mess around with unsafe reminiscence pointers to create a C suitable interface. Thankfully I used to be capable of finding a pleasant instance, which served me as a great place to begin, on the Swift boards created by Cory Benfield, so that is what we’ll use on this case. Thanks you. 🙏

ultimate class MyType {
    var depend: Int = 69
}

@_cdecl("mytype_create")
public func mytype_create() -> OpaquePointer {
    let sort = MyType()
    let retained = Unmanaged.passRetained(sort).toOpaque()
    return OpaquePointer(retained)
}

@_cdecl("mytype_get_count")
public func mytype_get_count(_ sort: OpaquePointer) -> CInt {
    let sort = Unmanaged<MyType>.fromOpaque(UnsafeRawPointer(sort)).takeUnretainedValue()
    return CInt(sort.depend)
}

@_cdecl("mytype_destroy")
public func mytype_destroy(_ sort: OpaquePointer) {
    _ = Unmanaged<MyType>.fromOpaque(UnsafeRawPointer(sort)).takeRetainedValue()
}

The excellent news is that we do not obligatory should create a separate header file for our interfaces, however the Swift compiler can generate it for us if we offer the -emit-objc-header flag.

I’ve an article about the swiftc command for inexperienced persons and I additionally wrote some issues about the Swift compiler, the place I discuss concerning the out there flags. This time we’ll use the -module-name choice to specify our module title, we’ll generate the required recordsdata utilizing the -emit-dependencies flag, parse the supply recordsdata as a library (-parse-as-library), since we would prefer to generate a Swift library present the mandatory goal and model data and emit a header file.

# macOS
swiftc 
        -module-name mytype 
        -emit-dependencies 
        -parse-as-library 
        -c mytype.swift 
        -target arm64-apple-macosx12.0 
        -swift-version 5 
        -emit-objc-header 
        -emit-objc-header-path mytype.h

# Linux (with out the goal possibility)
swiftc 
    -module-name mytype 
    -emit-dependencies 
    -parse-as-library 
    -c mytype.swift 
    -swift-version 5 
    -emit-objc-header 
    -emit-objc-header-path mytype.h

This could generate a mytype.h and a mytype.o file plus some extra Swift module associated output recordsdata. We will use these recordsdata to construct our ultimate executable, however there are a couple of extra extra issues I would like to say.

Underneath Linux the header file will not work. It incorporates a line #embody Basis/Basis.h and naturally there is no such thing as a such header file for Linux. It’s attainable to put in the GNUstep bundle (e.g. through yum: sudo yum set up gnustep-base gnustep-base-devel gcc-objc, however for me the clang command nonetheless complained concerning the location of the objc.h file. Anyway, I simply eliminated the embody Basis assertion from the header file and I used to be good to go. 😅

The second factor I would like to say is that if you wish to export a category for Swift, that is going to be a bit tougher, as a result of lessons will not be included within the generated header file. You might have two choices on this case. The primary one is to show them into Goal-C lessons, however it will result in issues when utilizing Linux, anyway, that is how you are able to do it:

import Basis

@objc public ultimate class MyType: NSObject {
    public var depend: Int = 69
}

I want the second possibility, when you do not change the Swift file, however you create a separate header file and outline your object sort as a struct with a customized sort (mytype_struct.h).

typedef struct mytype mytype_t;

We will want this kind (with the corresponding header file), as a result of the mytype_create perform returns a pointer that we are able to use to name the opposite mytype_get_count technique. 🤔

Compiling C sources utilizing Swift libraries So how can we use these uncovered Swift objects in C? Within the C programming language you simply should import the headers after which voilá you should utilize every thing outlined in these headers.

#embody 
#embody "mytype.h"

int predominant() {
    mytype_t *merchandise = mytype_create();

    int i = mytype_get_count(merchandise);
 
    printf("Whats up, World! %dn", i);

    return 0;
}

We are able to use clang to compile the primary.c file into an object file utilizing the mandatory header recordsdata.

# macOS
clang -x objective-c -include mytype.h -include mytype_struct.h -c predominant.c

# Linux
clang -include mytype.h -include mytype_struct.h -c predominant.c

This command will construct a predominant.o file, which we are able to use to create the ultimate executable. 💪

Linking the ultimate executable

This was the toughest half to determine, however I used to be in a position to hyperlink the 2 object recordsdata collectively after a couple of hours of battling the ld command and different framework instruments I made a decision to provide it up and let swiftc maintain the job, since it could construct and hyperlink each C and Swift-based executables.

We will want a listing of the article recordsdata that we’ll hyperlink collectively.

ls *.o > LinkFileList

Then we are able to name swiftc to do the job for us. I suppose it’s going to invoke the ld command underneath the hood, however I am not a linker knowledgeable, so if you recognize extra about this, be happy to achieve out and present me extra data concerning the course of. I’ve to learn this e book for positive. 📚

# macOS
swiftc 
        -sdk /Purposes/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX12.1.sdk 
        -F /Purposes/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/Library/Frameworks 
        -I /Purposes/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/usr/lib 
        -L /Purposes/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/usr/lib 
        -L /Customers/tib/swiftfromc/ 
        -module-name Instance 
        -emit-executable 
        -Xlinker -rpath 
        -Xlinker @loader_path @/Customers/tib/swiftfromc/LinkFileList 
        -Xlinker -rpath 
        -Xlinker /Purposes/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/macosx 
        -Xlinker -rpath 
        -Xlinker /Purposes/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift-5.5/macosx 
        -target arm64-apple-macosx12.1 
        -Xlinker -add_ast_path 
        -Xlinker /Customers/tib/swiftfromc/mytype.swiftmodule 
        -L /Purposes/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib

# Linux
swiftc 
    -L /dwelling/ec2-user/swiftfromc 
    -module-name Instance 
    -emit-executable 
    -Xlinker -rpath 
    -Xlinker @loader_path @/dwelling/ec2-user/swiftfromc/LinkFileList

The command above will produce the ultimate linked executable file that you would be able to run through the use of the ./Instance snippet and hopefully you will see the “Whats up, World! 69” message. 🙈

If you wish to know extra concerning the rpath linker flag, I extremely advocate studying the article by Marcin Krzyzanowski. If you wish to learn extra about Swift / Goal-C interoperability and utilizing the swiftc command, it is best to take a look at this text by RDerik. Lastly if you wish to name C code from Swift and go the opposite approach, it is best to check out my different weblog submit.