16.2 快速开始 Hello World-编程书籍在线阅读平台-duidaima 堆代码

16.2 快速开始 Hello World

16.2.1 运行环境准备
我们直接去 Github上面去下载 kotlin-native 编译器的软件包。下载地址是：https://github.com/JetBrains/kotlin-native/releases

下载解压之后，我们可以看到 Kotlin Native 编译器 konan 的目录如下：

-rw-r--r--@  1 jack  staff   6828  6 20 22:47 GRADLE_PLUGIN.md
-rw-r--r--@  1 jack  staff  16286  6 20 22:47 INTEROP.md
-rw-r--r--@  1 jack  staff   1957  6 21 01:03 README.md
-rw-r--r--@  1 jack  staff   4606  6 20 22:47 RELEASE_NOTES.md
drwxr-xr-x@  8 jack  staff    272  6 20 23:04 bin
drwxr-xr-x   6 jack  staff    204  7 28 17:08 dependencies
drwxr-xr-x@  3 jack  staff    102  6 20 23:01 klib
drwxr-xr-x@  5 jack  staff    170  5 12 00:02 konan
drwxr-xr-x@  4 jack  staff    136  5 12 00:02 lib
drwxr-xr-x@ 22 jack  staff    748  6 22 19:04 samples

关于这个目录里面的内容我们在后面小节中介绍。另外，我们也可以自己下载源码编译，这里就不多说了。

16.2.2新建 Gradle 工程
在本小节中，我们先来使用IDEA 来创建一个普通的 Gradle 工程。

第1步，打开 File -> New -> Project ，如下图所示

第2步，新建Gradle项目。我们直接在左侧栏中选择 Gradle，点击 Next

第3步，设置项目的 GroupId、ArtifactId、Version 信息

第4步，配置 Gradle 项目的基本设置。我们直接选择本地的 Gradle 环境目录，省去下载的时间（有时候网络不好，要下载半天），具体配置如下图所示

第5步，配置项目名称和项目存放目录，点击 Finish

第6步，等待 IDEA 创建完毕，我们将得到一个如下的Gradle 工程

现在这个工程里面什么都没有。下面我们就来开始原始的手工新建文件编码。

16.2.3 源代码目录
首先我们在工程根目录下面新建 src 目录，用来存放源代码。在 src 下面新建 c 目录存放 C 代码，新建 kotlin 目录存放 Kotlin 代码。我们的源代码组织结构设计如下

src
├── c
│ ├── cn_kotlinor.c
│ ├── cn_kotlinor.h
└── kotlin
└── main.kt
16.2.4 C 代码文件
cn_kotlinor.h
C头文件中声明如下

```c#ifndef CN_KOTLINOR_H#define CN_KOTLINOR_H
void printHello();
int factorial(int n);
int fib(int n);#endif

我们简单声明了3个函数。

#### cn_kotlinor.c
C 源代码文件内容如下
```c#include "cn_kotlinor.h"#include <stdio.h>
void printHello(){
    printf("[C]HelloWorld\n");
}
int factorial(int n){
    printf("[C]calc factorial: %d\n", n);
    if(n == 0) return 1;
    return n * factorial(n - 1);
}
int fib(int n){
    printf("[C]calc fibonacci: %d\n", n);
    if(n==1||n==2) return 1;
    return fib(n-1) + fib(n-2);
}

这就是我们熟悉的 C 语言代码。

16.2.5 Kotlin 代码文件
main.kt 文件内容如下

import ckotlinor.*
fun main(args: Array<String>) {
    printHello()
    (1..7).map(::factorial).forEach(::println)
    (1..7).map(::fib).forEach(::println)
}

其中，import kotlinor.* 是 C 语言代码经过 clang 编译之后的C 的接口包路径，我们将在下面的 build.gradle 配置文件中的konanInterop中配置这个路径。

16.2.6 konan插件配置
首先，我们在 build.gradle 里面添加构建脚本 buildscript 闭包

buildscript {
    repositories {
        mavenCentral()
        maven {
            url "https://dl.bintray.com/jetbrains/kotlin-native-dependencies"
        }
    }
    dependencies {
        classpath "org.jetbrains.kotlin:kotlin-native-gradle-plugin:0.3"
    }
}

这里我们添加了Gradle 构建 Kotlin Native 工程的 DSL 插件 kotlin-native-gradle-plugin:0.3 。这里的版本号，对应我们下载的 konan 编译器的版本号，我们使用的是 v0.3，所以这里我们也使用0.3版本的插件。这个插件发布在https://dl.bintray.com/jetbrains/kotlin-native-dependencies仓库里，所以我们在repositories里面添加了这个仓库。

然后，我们应用插件 konan

apply plugin: 'konan'

konan 就是用来编译 Kotlin 为 native 代码的插件。

16.2.7 konanInterop 互操作配置

konanInterop {
    ckotlinor {
        defFile 'kotlinor.def' // interop 的配置文件
        includeDirs "src/c" // C 头文件目录，可以传入多个
    }
}

konanInterop 主要用来配置 Kotlin 调用 C 的接口。konanInterop 的配置是由konan 插件API中的 KonanInteropTask.kt来处理的（这个类的源码地址）。

这里我们声明的 ckotlinor 是插件中的KonanInteropConfig 对象。我们在下面的konanArtifacts里面会引用这个 ckotlinor 。

关于konanInterop的配置选项有

konanInterop {
      pkgName {
          defFile <def-file>  
          pkg <package with stubs>
          target <target: linux/macbook/iphone/iphone_sim>
          compilerOpts <Options for native stubs compilation>
          linkerOpts <Options for native stubs >
          headers <headers to process> 
          includeDirs <directories where headers are located> 
          linkFiles <files which will be linked with native stubs>
          dumpParameters <Option to print parameters of task before execution>
      }
      // TODO: add configuration for konan compiler
}

我们简要说明如下表所示

配置项	功能说明
defFile	互操作映射关系配置文件
pkg	C 头文件编译后映射为 Kotlin 的包名
target	编译目标平台：linux/macbook/iphone/iphone_sim等
compilerOpts	编译选项
linkerOpts	链接选项
headers	要处理的头文件
includeDirs	包括的头文件目录
linkFiles	与native stubs 链接的文件
dumpParameters	打印 Gradle 任务参数选项配置

其中，kotlinor.def 是Kotlin Native 与 C 语言互操作的配置文件，我们在kotlinor.def 里面配置 C 源码到 kotlin 的映射关系。这个文件内容如下
kotlinor.def

headers=cn_kotlinor.h
compilerOpts=-Isrc/c

同样的配置，如果我们写在 build.gradle 文件中的konanInterop配置里如下

konanInterop {
    ckotlinor {
        // defFile 'kotlinor.def' // interop 的配置文件
        compilerOpts '-Isrc/c'
        headers 'src/c/cn_kotlinor.h' // interop 的配置文件
        includeDirs "src/c" // C 头文件存放目录，可以传入多个
    }
}

关于这个配置文件的解析原理可以参考 KonanPlugin.kt 文件的源码。

16.2.8 konanArtifacts 配置
在 konan 插件中，我们使用konanArtifacts来配置编译任务执行。

konanArtifacts { 
    KotlinorApp { // (1)
        inputFiles fileTree("src/kotlin") // (2)
        useInterop 'ckotlinor' // (3)
        nativeLibrary fileTree('src/c/cn_kotlinor.bc') // (4)
        target 'macbook' // (5)
    }
}

其中：

(1)处的KotlinorApp名称，在 build 之后会生成以这个名称命名的 KotlinorApp.kexe 可执行程序。

(2)处的inputFiles配置的是 kotlin 代码目录，程序执行的入口 main 定义在这里。
(3)处的useInterop 配置的是使用哪个互操作配置。我们使用的是前面的 konanInterop 里面的配置 ckotlinor 。
(4) 处的nativeLibrary配置的是本地库文件。关于’src/c/cn_kotlinor.bc’文件的编译生成我们在下面讲。
(5) 处的target 配置的是编译的目标平台，这里我们配置为 ‘macbook’ 。

关于konanArtifacts可选的配置如下所示

konanArtifacts {
    artifactName1 {
        inputFiles "files" "to" "be" "compiled"
        outputDir "path/to/output/dir"
        library "path/to/library"
        library File("Library")
        nativeLibrary "path/to/library"
        nativeLibrary File("Library")
        noStdLib
        produce "library"|"program"|"bitcode"
        enableOptimization
        linkerOpts "linker" "args"
        target "target"
        languageVersion "version"
        apiVersion "version"
  }
   artifactName2 {
        extends artifactName1
        inputDir "someDir"
        outputDir "someDir"
   }
}

konan 编译任务配置处理类是KonanCompileTask.kt。

16.2.9 完整的 build.gradle 配置
完整的 build.gradle 配置文件内容如下

group 'com.easy.kotlin'
version '1.0-SNAPSHOT'
buildscript {
    repositories {
        mavenCentral()
        maven {
            url "https://dl.bintray.com/jetbrains/kotlin-native-dependencies"
        }
    }
    dependencies {
        classpath "org.jetbrains.kotlin:kotlin-native-gradle-plugin:0.3"
    }
}
apply plugin: 'konan' // konan 就是用来编译 Kotlin 为 native 代码的插件
konanInterop { // konanInterop 主要用来配置 Kotlin 调用 C 的接口
    ckotlinor {
        defFile 'kotlinor.def' // interop 的配置文件
        includeDirs "src/c" // C 头文件目录，可以传入多个
    }
}
konanArtifacts { //konanArtifacts 配置我们的项目
    KotlinorApp { // build 之后会生成 KotlinorApp.kexe 可执行程序
        inputFiles fileTree("src/kotlin") //kotlin 代码配置，项目入口 main 需要定义在这里
        useInterop 'ckotlinor' //使用前面的 konanInterop 里面的配置  kotlinor{ ... }
        nativeLibrary fileTree('src/c/cn_kotlinor.bc') //自己编译的 llvm 字节格式的依赖
        target 'macbook' // 编译的目标平台
    }
}

提示：关于konan 插件详细配置文档：Gradle DSL
16.2.10 使用 clang 编译 C 代码
为了实用性，我们新建一个 shell 脚本 kclang.sh 来简化 clang 编译的命令行输入参数
```#!/usr/bin/env bash
clang -std=c99 -c $1 -o $2 -emit-llvm

这样，我们把 kclang.sh 放到 C 代码目录下，然后直接使用脚本来编译：

kclang.sh cn_kotlinor.c cn_kotlinor.bc

我们将得到一个 cn_kotlinor.bc 库文件。
提示：clang是一个C++编写、基于LLVM、发布于LLVM BSD许可证下的C/C++/Objective-C/Objective-C++编译器。它与GNU C语言规范几乎完全兼容。更多关于 clang 的内容可参考： http://clang.llvm.org/docs/index.html 。
16.2.11 配置 konan 编译器主目录
最后，在执行 Gradle 构建之前，我们还需要指定konan 编译器主目录。我们在工程根目录下面新建 gradle.properties 这个属性配置文件，内容如下
konan.home=/Users/jack/soft/kotlin-native-macos-0.3

16.2.12 执行构建操作
我们直接在 IDEA 右侧的 Gradle 工具栏点击Tasks ->build -> build 命令执行构建操作
![Kotlin极简教程](/projects/EasyKotlin/16.使用 Kotlin Native/images/kotlin_native_08.png)
我们会看到终端输出

15:12:02: Executing external task ‘build’…
:assemble UP-TO-DATE
:check UP-TO-DATE
:downloadKonanCompiler
:genKotlinerInteropStubs
:compileKotlinerInteropStubs
KtFile: kotliner.kt
:compileKonanKotliner
KtFile: main.kt
ld: warning: object file (/var/folders/q5/kvt7_nsd6ngdw5qry4d99xv00000gn/T/combined697750051437954502.o) was built for newer OSX version (10.12) than being linked (10.11)
:compileKonan
:build

BUILD SUCCESSFUL in 29s
4 actionable tasks: 4 executed
15:12:31: External task execution finished ‘build’.

构建完成之后，会在build/konan/bin/目录下面生成一个KotlinorApp.kexe可执行程序，它直接在 Mac OS 上运行，不再依赖JVM 环境了。我们得到的完整的构建输出目录树如下

build
└── konan
├── bin
│ ├── KotlinorApp.kexe
│ └── KotlinorApp.kt.bc
├── interopCompiledStubs
│ └── ckotlinorInteropStubs
│ ├── ckotlinorInteropStubs
│ │ ├── linkdata
│ │ │ ├── module
│ │ │ ├── package_ckotlinor
│ │ │ └── root_package
│ │ ├── manifest
│ │ ├── resources
│ │ └── targets
│ │ └── macbook
│ │ ├── kotlin
│ │ │ └── program.kt.bc
│ │ └── native
│ └── ckotlinorInteropStubs.klib
├── interopStubs
│ └── genCkotlinorInteropStubs
│ └── ckotlinor
│ └── ckotlinor.kt
└── nativelibs
└── genCkotlinorInteropStubs
└── ckotlinorstubs.bc

16 directories, 10 files

其中在 ckotlinor.kt中，我们可以看出 konan 编译器还为我们生成了 C 代码对应的 Kotlin 的接口

```kotlin
@file:Suppress("UNUSED_EXPRESSION", "UNUSED_VARIABLE")
package ckotlinor
import konan.SymbolName
import kotlinx.cinterop.*
fun printHello(): Unit {
    val res = kni_printHello()
    return res
}
@SymbolName("ckotlinor_kni_printHello")
private external fun kni_printHello(): Unit
fun factorial(n: Int): Int {
    val _n = n
    val res = kni_factorial(_n)
    return res
}
@SymbolName("ckotlinor_kni_factorial")
private external fun kni_factorial(n: Int): Int
fun fib(n: Int): Int {
    val _n = n
    val res = kni_fib(_n)
    return res
}
@SymbolName("ckotlinor_kni_fib")
private external fun kni_fib(n: Int): Int

我们在Kotlin 代码中，调用的就是这些映射到 C 中的函数接口。
16.2.12 执行 kexe 应用程序
我们直接在命令行中执行 KotlinorApp.kexe 如下
chatper16_kotlin_native_helloworld$ build/konan/bin/KotlinorApp.kexe
我们可以看到如下输出：

[C]HelloWorld
[C]calc factorial: 1
[C]calc factorial: 0
[C]calc factorial: 2
...
[C]calc factorial: 2
[C]calc factorial: 1
[C]calc factorial: 0
1
2
6
24
120
720
5040
[C]calc fibonacci: 1
[C]calc fibonacci: 2
[C]calc fibonacci: 3
...
[C]calc fibonacci: 3
[C]calc fibonacci: 2
[C]calc fibonacci: 1
1
1
2
3
5
8
13

至此，我们完成了一次简单的Kotlin Native 与 C 语言互操作在系统级编程的体验之旅。

我们看到，Kotlin Native仍然看重互操作性(Interoperability)。它能高效地调用C函数，甚至还能从C头文件自动生成了对应的Kotlin接口，发扬了JetBrains为开发者服务的良好传统！

但是，在体验的过程中我们也发现整个过程比较手工化，显得比较繁琐（例如手工新建各种配置文件、手工使用 clang 编译C 代码等）。

不过，Kotlin Native 的 Gradle 插件用起来还是相当不错的。相信未来 IDEA 会对 Kotlin Native 开发进行智能的集成，以方便系统编程的开发者更好更快的完成项目的配置以及开发编码工作。

留下你的读书笔记
你还没登录，点击这里
 用户笔记留言