[LINUX] Konstruktions- und Installationsverfahren für Kotlin / Native Development Environment & Tutorial

Einführung

Dies ist eine Zusammenfassung des Installationsvorgangs der Build-Umgebung für macOS / Linux (* ohne das Build-Tool Gradle) von Kotlin / Native. Ab Januar 2020 befindet sich Kotlin / Native selbst noch in der Beta.

Annahme

Das JDK (Java-Umgebung) ist erforderlich, um den Kotlin-Quellcode zu kompilieren. Installieren Sie ihn daher im Voraus.

Installation von Kotlin / Native

https://github.com/JetBrains/kotlin/releases/latest Verwenden Sie die neueste Version der offiziellen Version unter.

Da der Befehl wget hier zum Herunterladen verwendet wird, installieren Sie ihn gegebenenfalls, falls Sie ihn nicht installiert haben.

Vorbereitungen

macOS

$ brew install wget

Linux(Ubuntu)

$ sudo apt install wget

Laden Sie den Compiler herunter

macOS

$ wget https://github.com/JetBrains/kotlin/releases/download/v1.3.61/kotlin-native-macos-1.3.61.tar.gz

Linux(Ubuntu)

$ wget https://github.com/JetBrains/kotlin/releases/download/v1.3.61/kotlin-native-linux-1.3.61.tar.gz

Compiler installieren

gemeinsam mit macOS / Linux

Entpacken Sie es an einen geeigneten Ort und fügen Sie es in den Pfad der Umgebungsvariablen ein. Hier platzieren wir es in / usr / local / kotlin-native.

$ tar xzvf kotlin-native-macos-1.3.61.tar.gz
$ sudo mkdir -p /usr/local/kotlin-native
$ sudo mv kotlin-native-macos-1.3.61/* /usr/local/kotlin-native

Fügen Sie den Pfad zu ~ / .bash_profile hinzu, um den Pfad an die Compiler-Binärdatei zu übergeben.

~/.bash_profile

$ export PATH=$PATH:/usr/local/kotlin-native/bin/

[Option] IntelliJ IDEA-Installation

Wenn Sie Gradle nicht verwenden, müssen Sie die zusätzlichen Pakete finden, die Sie benötigen (z. B. kotlinx: kotlinx-coroutines-core-native für Coroutines) und diese in den Befehlszeilenoptionen angeben. Das Problem in diesem Fall ist, dass Sie nicht wissen, wo Sie es herunterladen sollen. Daher ist es praktisch, IntelliJ IDEA installiert zu haben, damit Sie auch die Gradle-Umgebung verwenden können ...

Download von hier. In der MacOS-Umgebung handelt es sich um eine DMG-Datei. Installieren Sie sie daher über die GUI. Auf der anderen Seite können Sie es in einer Linux-Umgebung verwenden, indem Sie es einfach an einen geeigneten Ort entpacken und über den Pfad weiterleiten.

Außerdem denke ich, dass das Kotlin-Plug-In bereits installiert ist, sodass Sie es so verwenden können, wie es zum Erstellen eines neuen Projekts ist.

Quellcode für die Betriebsprüfung

hello.kt

fun main(args: Array<String>) {
    println("Hello, World!")
}

kompilieren

Bei der ersten Ausführung dauert es einige Zeit, abhängige Pakete wie LLVM herunterzuladen und zu installieren.

$ kotlinc-native hello.kt -o hello

Darüber hinaus können Java-Optionen mit der Option -D übergeben werden. Wenn Sie also Proxy-Einstellungen in einer Netzwerkumgebung benötigen, führen Sie diese wie folgt aus. Die Informationsquelle ist hier.

$ kotlinc-native hello.kt -o hello ¥
     -Dhttp.proxyHost=hoge.host.co.jp -Dhttp.proxyPort=12345 ¥
     -Dhttps.proxyHost=hoge.host.co.jp -Dhttps.proxyPort=12345

Lauf

$ ./hello.kexe
Hello, World!

Ich konnte das Kotlin-Programm in der nativen Umgebung von macOS / Linux ausführen!

Bibliotheksgenerierung

Mit der Option -p ist es möglich, eine Bibliothek in verschiedenen Formaten zu erstellen, und die Header-Datei wird ebenfalls automatisch generiert. Es ist kompatibel mit dem iOS / MacOS-Framework und ziemlich gut gemacht, aber ich denke, dass die Header-Datei für C / C ++, wenn Dynamik angegeben ist, ziemlich schlecht gemacht ist ... Ich möchte, dass du es ein bisschen anständiger machst ...

$ kotlinc-native hello.kt -p dynamic

Wenn Sie nicht wissen, wie Sie es verwenden sollen, können Sie die Hilfemeldung mit der Option -h überprüfen.

$ kotlinc-native -h
Usage: kotlinc-native <options> <source files>
where possible options include:
  -g                         Enable emitting debug information
  -enable-assertions (-ea)   Enable runtime assertions in generated code
  -friend-modules <path>     Paths to friend modules
  -generate-no-exit-test-runner (-trn)
                             Produce a runner for unit tests not forcing exit
  -generate-test-runner (-tr) Produce a runner for unit tests
  -generate-worker-test-runner (-trw)
                             Produce a worker runner for unit tests
  -include-binary (-ib) <path> Pack external binary within the klib
  -library (-l) <path>       Link with the library
  -library-version (-lv) <version>
                             Set library version
  -linker-options <arg>      Pass arguments to linker
  -list-targets              List available hardware targets
  -entry (-e) <name>         Qualified entry point name
  -manifest <path>           Provide a maniferst addend file
  -memory-model <model>      Memory model to use, 'strict' and 'relaxed' are currently supported
  -module-name <name>        Specify a name for the compilation module
  -native-library (-nl) <path> Include the native bitcode library
  -no-default-libs           Don't link the libraries from dist/klib automatically
  -no-endorsed-libs          Don't link the endorsed libraries from dist automatically
  -nomain                    Assume 'main' entry point to be provided by external libraries
  -nopack                    Don't pack the library into a klib file
  -nostdlib                  Don't link with stdlib
  -opt                       Enable optimizations during compilation
  -output (-o) <name>        Output name
  -produce (-p) {program|static|dynamic|framework|library|bitcode}
                             Specify output file kind
  -repo (-r) <path>          Library search path
  -linker-option <arg>       Pass argument to linker
  -target <target>           Set hardware target
  -Werror                    Report an error if there are any warnings
  -api-version <version>     Allow to use declarations only from the specified version of bundled libraries
  -X                         Print a synopsis of advanced options
  -help (-h)                 Print a synopsis of standard options
  -kotlin-home <path>        Path to Kotlin compiler home directory, used for runtime libraries discovery
  -language-version <version> Provide source compatibility with specified language version
  -P plugin:<pluginId>:<optionName>=<value>
                             Pass an option to a plugin
  -progressive               Enable progressive compiler mode.
                             In this mode, deprecations and bug fixes for unstable code take effect immediately,
                             instead of going through a graceful migration cycle.
                             Code written in the progressive mode is backward compatible; however, code written in
                             non-progressive mode may cause compilation errors in the progressive mode.
  -nowarn                    Generate no warnings
  -verbose                   Enable verbose logging output
  -version                   Display compiler version
  @<argfile>                 Read compiler arguments and file paths from the given file

Impressionen habe ich ausprobiert

Der Eindruck, den ich verwendet habe, funktioniert normal, aber der Build ist trotzdem langsam ... Es scheint, dass Kotlin 1.4 den Compiler aktualisieren wird, also freue ich mich darauf.