{"id":2003,"date":"2015-12-06T17:17:13","date_gmt":"2015-12-06T23:17:13","guid":{"rendered":"http:\/\/dev.iachieved.it\/iachievedit\/?p=2003"},"modified":"2015-12-23T21:17:10","modified_gmt":"2015-12-24T03:17:10","slug":"more-swift-on-linux","status":"publish","type":"post","link":"https:\/\/dev.iachieved.it\/iachievedit\/more-swift-on-linux\/","title":{"rendered":"More Swift on Linux"},"content":{"rendered":"

Editor’s Note:<\/b> This article was written on December 6, 2015, days after Apple open-sourced Swift and made an Ubuntu distribution of the Swift compiler available. All of the techniques used below should be forward compatible, however, there may be easier ways of doing things in the future as the Foundation classes are implemented. Apple has posted a status page<\/a> that outlines what works and what doesn’t.<\/p>\n

Using Glibc Routines with Swift<\/h2>\n

As I mentioned in Swift on Linux!<\/a>, the Foundation classes that Objective-C and Swift developers have come to know and love are only partially implemented. And by partially implemented I really mean hardly implemented. Okay, NSError<\/code> is there and a few others, but no NSURL<\/code>, NSURLSession<\/code>, etc.<\/p>\n

What is<\/i> there is the wealth of routines from the GNU C Library<\/a>, also known as Glibc. You know, the library of rotuines you’d look up with a man page. Functions like popen<\/code> and fgets<\/code>, getcwd<\/code> and qsort<\/code>. Swift won’t be displacing Python any time soon if this is all we’re left to work with, but<\/i> you can do something useful and begin exploring the possibilities of intermixing C with Swift. In this tutorial we’ll do exactly that and write up some Swift code that uses popen<\/code> to spawn wget<\/code> to make up for the lack of NSURLSession<\/code>.<\/p>\n

So let’s get stuck in and write some Swift.<\/p>\n

Swift cat<\/h3>\n

Create a file named swiftcat.swift<\/code> and add the following code:<\/p>\n

\r\nimport Glibc\r\n\r\nguard Process.arguments.count == 2 else {\r\n  print(\"Usage:  swiftcat FILENAME\")\r\n  exit(-1)\r\n}\r\n\r\nlet filename = Process.arguments[1]\r\n\r\nlet BUFSIZE = 1024\r\nvar pp      = popen(\"cat \" + filename, \"r\")\r\nvar buf     = [CChar](count:BUFSIZE, repeatedValue:CChar(0))\r\n\r\nwhile fgets(&buf, Int32(BUFSIZE), pp) != nil {\r\n  print(String.fromCString(buf)!, terminator:\"\")\r\n}\r\n\r\nexit(0)\r\n<\/pre>\n
To get access to all of the Glibc routines we use import Glibc<\/code>.  Easy enough.  Swift 2 brought us the guard<\/code> construct, so we’ll use that to ensure that we have an argument to our script.  Our first exposure to using a Glibc function is exit(-1)<\/code>.  That’s right, nothing special about calling it, it is just the void exit(int status)<\/code> function<\/a>.<\/p>\n
We’re going to cheat a bit and leverage the \/bin\/cat<\/code> command to read the file and write to standard out.  To call it though we’ll use popen<\/code> which will pipe us a stream of bytes that we can read with fgets<\/code>.  There is one thing to notice here, and that is that Glibc routines which take const char*<\/code> arguments can be given Swift String<\/code>s directly.  Routines that take char*<\/code>, as in the case of fgets<\/code> require some finesse.<\/p>\n
fgets<\/code> does<\/i> take a char*<\/code>, so we cannot pass it a String<\/code>, but rather will use a buffer allocated as a [CChar]<\/code> (C char) array.  The array has a fixed size of 1024 and is initialized with zeroes.  Our while<\/code> loop calls fgets<\/code> with the stream pointer, and non-nil<\/code> results contain a buffer from which we can create a Swift String<\/code>.<\/p>\n
Go ahead and save this to a file called swiftcat.swift<\/code> and then run it!  <\/p>\n
\r\n# swift swiftcat.swift \r\nUsage:  swiftcat FILENAME\r\n<\/pre>\n
Pass it a file to get the equivalent of cat<\/code> output!<\/p>\n
Mixing in C<\/h3>\n
You aren’t limited to using Glibc routines with your Swift code.  Let’s say we want to use libcurl<\/code> to escape some strings and get them ready to be included in a URL.  This is easy to do with libcurl.  <\/p>\n
In a file called escapetext.c<\/code> put the following:<\/p>\n
\r\n#include \r\n#include \r\n#include \r\n#include \r\n\r\nint escapeText(const char* text, char** output) {\r\n\r\n  int rc = -1;\r\n  CURL* curl = curl_easy_init();\r\n  if (curl) {\r\n    char* escaped = curl_easy_escape(curl, text, strlen(text));\r\n    if (escaped) {\r\n      *output = (char*)malloc(strlen(escaped) + 1);\r\n      strcpy(*output, escaped);\r\n      curl_free(escaped);\r\n      rc = strlen(*output);\r\n    } \r\n  }\r\n  return rc;\r\n}\r\n\r\n#ifdef __TEST__\r\nint main(int argc, char** argv) {\r\n\r\n  if (argc < 2) {\r\n    printf(\"Usage:  escapetext STRING\\n\");\r\n    exit(-1);\r\n  }\r\n\r\n  char* text = argv[1];\r\n  char* escapedText;\r\n\r\n  int rc = 0;\r\n  if (escapeText(text, &escapedText)) {\r\n    printf(\"Escaped text:  %s\\n\", escapedText);\r\n  } else {\r\n    printf(\"Error\\n\");\r\n    rc = -1;\r\n  }\r\n  free(escapedText);\r\n  exit(rc);\r\n\r\n}\r\n#endif\r\n<\/pre>\n
Make sure you have libcurl<\/code> installed with apt-get install -y libcurl4-gnutls-dev<\/code>.<\/p>\n
Now, compile the file with:<\/p>\n
\r\nclang -D__TEST__ -o escapetext escapetext.c -lcurl\r\n<\/pre>\n
We include the -D__TEST__<\/code> here to pick up the main<\/code> function.  In a minute I'll show you how to take this routine and include it in a Swift application.  Run the C application:<\/p>\n
\r\n# .\/escapetext \"hey there\\!\"\r\nEscaped text:  hey%20there%21\r\n<\/pre>\n
Easy enough.  Now, we want to write a Swift application that uses our C routine escapeText<\/code>.  The first thing to do is compile an escapetext.o<\/code> object file without the -D__TEST__<\/code> flag set.  This will get rid of main()<\/code>.<\/p>\n
\r\nclang -c escapetext.c\r\n<\/pre>\n
Now, create a file called escapetext.h<\/code> and put the function prototype in it.<\/p>\n
\r\nint escapeText(const char* text, char** output);\r\n<\/pre>\n
Write a new file called escapeswift.swift<\/code> and add the following:<\/p>\n
\r\nimport Foundation\r\nimport Glibc\r\n\r\nguard Process.arguments.count == 2 else {\r\n  print(\"Usage:  escapeswift STRING\")\r\n  exit(-1)\r\n}\r\n\r\nlet string = Process.arguments[1]\r\nvar output:UnsafeMutablePointer = nil\r\n\r\nlet rc = escapeText(string, &output)\r\n\r\nguard rc > 0 else {\r\n  print(\"Error escaping text\")\r\n  exit(-1)\r\n}\r\n\r\nprint(\"Escaped text:  \\(String.fromCString(output)!)\")\r\nexit(0)\r\n<\/pre>\n
Compile this Swift code with:<\/p>\n
\r\nswiftc -c escapeswift.swift -import-objc-header escapetext.h \r\n<\/pre>\n
Notice that we included -import-objc-header escapetext.h<\/code>.  Without this header the Swift compiler won't be able to find the prototype for escapeText<\/code> and will subsequently fail with use of unresolved identifier<\/code>.<\/p>\n
Bringing it all together, we link our escapeswift.o<\/code> and escapetext.o<\/code> objects together, and pass in the Curl library.<\/p>\n
\r\nswiftc escapeswift.o escapetext.o -o escapeswift -lcurl\r\n<\/pre>\n
And run it!<\/p>\n
\r\n# .\/escapeswift \"how now brown cow\"\r\nEscaped text:  how%20now%20brown%20cow\r\n<\/pre>\n
Translator Application<\/h2>\n
This is a more complex example, but the principals are the same as those outlined above.  We're going to mix C objects and Swift modules together to write a command line application that translates strings from one language to another.  <\/p>\n
The REST API<\/a> we'll be using to do the actual translation returns results in JSON.  Since NSJSONSerialization<\/code> isn't yet available in Foundation on Linux, we'll use the libjson-c-dev<\/code> library, so install it with apt-get install libjson-c-dev<\/code>.<\/p>\n
jsonparse<\/h3>\n
Two files make up our JSON-parsing routine, parsejson.c<\/code> and its companion header parsejson.h<\/code>.<\/p>\n
parsejson.c<\/code>:<\/p>\n
\r\n#include \r\n#include \r\n\r\nconst char* translatedText(const char* json) {\r\n\r\n  const char* c = NULL;\r\n  json_object* jobj         = json_tokener_parse(json);\r\n  json_object* responseData = json_object_object_get(jobj,\r\n\t\t\t\t\t\t     \"responseData\");\r\n  if (responseData) {\r\n    json_object* translatedTextObj= json_object_object_get(responseData,\r\n\t\t\t\t\t\t\t   \"translatedText\");\r\n    if (translatedTextObj) {\r\n      c = json_object_get_string(translatedTextObj);\r\n    }\r\n  }\r\n  return c;\r\n}\r\n<\/pre>\n
parsejson.h<\/code><\/p>\n
\r\nconst char* translatedText(const char* json);\r\n<\/pre>\n
We can easily compile this file with clang -c jsonparse.c<\/code>.  <\/p>\n
Translator module<\/h3>\n
The workhorse of the translator application will be a Swift module called translator<\/code>.  To create this module and prepare it for inclusion with the rest of our project, start with the class file translator.swift<\/code>:<\/p>\n
\r\nimport Glibc\r\nimport Foundation\r\n\r\npublic class Translator {\r\n\r\n  let BUFSIZE = 1024\r\n\r\n  public init() {\r\n  }\r\n\r\n  public func translate(text:String, from:String, to:String,\r\n                        completion:(translation:String?, error:NSError?) -> Void) {\r\n\r\n    let curl = curl_easy_init()\r\n\r\n    guard curl != nil else {\r\n      completion(translation:nil,\r\n                 error:NSError(domain:\"translator\", code:1, userInfo:nil))\r\n      return\r\n    }\r\n\r\n    let escapedText = curl_easy_escape(curl, text, Int32(strlen(text)))\r\n\r\n    guard escapedText != nil else {\r\n      completion(translation:nil,\r\n                 error:NSError(domain:\"translator\", code:2, userInfo:nil))\r\n      return\r\n    }\r\n    \r\n    let langPair = from + \"%7c\" + to\r\n    let wgetCommand = \"wget -qO- http:\/\/api.mymemory.translated.net\/get\\\\?q\\\\=\" + String.fromCString(escapedText)! + \"\\\\&langpair\\\\=\" + langPair\r\n    \r\n    let pp      = popen(wgetCommand, \"r\")\r\n    var buf     = [CChar](count:BUFSIZE, repeatedValue:CChar(0))\r\n    \r\n    var response:String = \"\"\r\n    while fgets(&buf, Int32(BUFSIZE), pp) != nil {\r\n      response = response + String.fromCString(buf)!\r\n    }\r\n    \r\n    let translated = translatedText(response)\r\n\r\n    completion(translation:String.fromCString(translated)!,\r\n               error:nil)\r\n  }\r\n\r\n}\r\n<\/pre>\n
Take a moment to read through the code.  We're including direct calls to the Curl library here, as well as popen<\/code> and fgets<\/code>, and<\/i> our translatedText<\/code> routine that is compiled into an object file created by clang<\/code>.<\/p>\n
In addition, create a bridgingHeader.h<\/code> with the contents:<\/p>\n
\r\n#include \r\n#include \"jsonparse.h\"\r\n<\/pre>\n
There are two steps to getting this ready to use in our application:<\/p>\n
    \n
  • Create a shared library with the translator routine\n
  • Create a swiftmodule<\/code> that describes the interface\n<\/ul>\n
    I will confess, I didn't understand this until I read on Stackoverflow:<\/p>\n
    The .swiftmodule<\/code> describes the Swift module's interface but it does not contain the module's implementation. A library or set of object files is still required to link your application against.<\/p><\/blockquote>\n
    First, compile the code into a .o<\/code> and create a shared library:<\/p>\n
    \r\nswiftc -emit-library translator.swift -module-name translator -import-objc-header bridgingHeader.h\r\nclang -shared -o libtranslator.so translator.o\r\n<\/pre>\n
    Now, create the module:<\/p>\n
    \r\nswiftc -emit-module -module-name translator translator.swift -import-objc-header bridgingHeader.h\r\n<\/pre>\n
    This leaves us with three files:  libtranslator.so<\/code>, translator.swiftmodule<\/code>, and translator.swiftdoc<\/code>.<\/p>\n
    Main Routine<\/h3>\n
    Our main file, main.swift<\/code> looks like this:<\/p>\n
    \r\nimport translator\r\nimport Foundation\r\nimport Glibc\r\n\r\nguard Process.arguments.count == 6 && \r\n      Process.arguments[2]    == \"from\" &&\r\n      Process.arguments[4]    == \"to\" else {\r\n  print(\"Usage:  translate STRING from LANG to LANG\")\r\n  exit(-1)\r\n}\r\n\r\nlet string     = Process.arguments[1]\r\nlet fromLang   = Process.arguments[3]\r\nlet toLang     = Process.arguments[5]\r\nlet translator = Translator()\r\n\r\ntranslator.translate(string, from:fromLang, to:toLang) {\r\n  (translation:String?, error:NSError?) -> Void in\r\n  guard error == nil && translation != nil else {\r\n    print(\"Error:  No translation available\")\r\n    exit(-1)\r\n  }\r\n\r\n  if let translatedText = translation {\r\n    print(\"Translation:  \" + translatedText)\r\n    exit(0)\r\n  }\r\n}\r\n<\/pre>\n
    Again, we've made use of Foundation and Glibc, but we're also using import translator<\/code>.  You must have a translator.swiftmodule<\/code> in your module search path, which we add with -I.<\/code>:<\/p>\n
    \r\nswiftc -I. -c main.swift -import-objc-header bridgingHeader.h\r\n<\/pre>\n
    Let's link everything together:<\/p>\n
    \r\nswiftc -o translate.exe jsonparse.o main.o -L. -ltranslator -lcurl -ljson-c -lswiftGlibc -lFoundation\r\n<\/pre>\n
    The resulting binary is translate.exe<\/code> because we intend to wrap a helper script around it to set the LD_LIBRARY_PATH<\/code> to find the libtranslator.so<\/code> shared library.  Without the helper script (or using ldconfig<\/code> to update the search path), you need to invoke the excecutable like this:<\/p>\n
    \r\nLD_LIBRARY_PATH=.:$LD_LIBRARY_PATH .\/translate.exe \"Hello world\\!\" from en to es\r\nTranslation:  \u00a1Hola, mundo!\r\n<\/pre>\n
    Let's try Irish:<\/p>\n
    \r\nLD_LIBRARY_PATH=.:$LD_LIBRARY_PATH .\/translate.exe \"Hello world\\!\" from en to ga\r\nTranslation:  Dia duit\r\n<\/pre>\n
    Makefile<\/h3>\n
    It's not clear how \"interpreter\" friendly Swift will become.  Yes, one can create a single monolithic Swift script right now and run it with swift<\/code>.  In fact we did that above.  Using bits of code from other Swift files though, without specifying everything on the command line, remains, well, impossible.  Maybe I'm wrong and just haven't figured out the magic incantation to have Swift greedily open up files searching for code to run.  <\/p>\n
    At any rate, our translator application above needs a little help to build.  There is a new Swift builder tool, but I found make<\/code> could get the job done with some appropriate rules:<\/p>\n
    \r\nAPP=translate.exe\r\n\r\nall:\t$(APP)\r\n\r\n%.o:%.c\r\n\tclang -c $<\r\n\r\n%.o:%.swift\r\n\tswiftc -I. -c $< -import-objc-header bridgingHeader.h\r\n\r\n$(APP):\tlibtranslator.so translator.swiftmodule jsonparse.o main.o\r\n\tswiftc -o $(APP) jsonparse.o main.o -L. -ltranslator -lcurl -ljson-c -lswiftGlibc -lFoundation\r\n\r\nlibtranslator.so:\ttranslator.o\r\n\tswiftc -emit-library translator.swift -module-name translator -import-objc-header bridgingHeader.h\r\n\tclang -shared -o libtranslator.so translator.o\r\n\r\ntranslator.swiftmodule:\tlibtranslator.so\r\n\tswiftc -emit-module -module-name translator translator.swift -import-objc-header bridgingHeader.h\r\n\r\nclean:\r\n\trm -rf *.o *.swiftmodule *.swiftdoc *.so $(APP)\r\n<\/pre>\n
    Getting the Code<\/h2>\n
    You can get all of the code above from Github.  <\/p>\n
    \r\ngit clone https:\/\/github.com\/iachievedit\/moreswift\r\n<\/pre>\n
    The swiftcat<\/code> code is meant to be run with the swift<\/code> command, where as escapetext<\/code> has a simple build.sh<\/code> script, and translate<\/code> has a full-on Makefile<\/code>.<\/p>\n
    If you've enjoyed this tutorial please follow us Twitter at @iachievedit!  There will be more to come as Swift on Linux matures.<\/p>\n","protected":false},"excerpt":{"rendered":"
    Editor’s Note: This article was written on December 6, 2015, days after Apple open-sourced Swift and made an Ubuntu distribution of the Swift compiler available. All of the techniques used below should be forward compatible, however, there may be easier ways of doing things in the future as the Foundation classes are implemented. Apple has […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[11,19,5],"tags":[],"class_list":["post-2003","post","type-post","status-publish","format-standard","hentry","category-apple","category-linux","category-swift"],"_links":{"self":[{"href":"https:\/\/dev.iachieved.it\/iachievedit\/wp-json\/wp\/v2\/posts\/2003"}],"collection":[{"href":"https:\/\/dev.iachieved.it\/iachievedit\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/dev.iachieved.it\/iachievedit\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/dev.iachieved.it\/iachievedit\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/dev.iachieved.it\/iachievedit\/wp-json\/wp\/v2\/comments?post=2003"}],"version-history":[{"count":31,"href":"https:\/\/dev.iachieved.it\/iachievedit\/wp-json\/wp\/v2\/posts\/2003\/revisions"}],"predecessor-version":[{"id":2269,"href":"https:\/\/dev.iachieved.it\/iachievedit\/wp-json\/wp\/v2\/posts\/2003\/revisions\/2269"}],"wp:attachment":[{"href":"https:\/\/dev.iachieved.it\/iachievedit\/wp-json\/wp\/v2\/media?parent=2003"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/dev.iachieved.it\/iachievedit\/wp-json\/wp\/v2\/categories?post=2003"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/dev.iachieved.it\/iachievedit\/wp-json\/wp\/v2\/tags?post=2003"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}