Kotlin / Procédure de construction et d'installation de l'environnement de développement natif et tutoriel

introduction

Ceci est un résumé de la procédure d'installation de l'environnement de build pour macOS / Linux (* sans l'outil de build Gradle) de Kotlin / Native. Cependant, en janvier 2020, Kotlin / Native lui-même est toujours en version bêta.

supposition

Le JDK (environnement Java) est requis pour compiler le code source Kotlin, donc installez-le à l'avance.

Installation de Kotlin / Native

https://github.com/JetBrains/kotlin/releases/latest Utilisez la dernière version de la version officielle sur.

Ici, la commande wget est utilisée pour le téléchargement, donc si vous ne l'avez pas installée, veuillez l'installer si nécessaire.

Préparation préalable

macOS

$ brew install wget

Linux(Ubuntu)

$ sudo apt install wget

Téléchargez le compilateur

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

Installer le compilateur

commun à macOS / Linux

Décompressez-le à un emplacement approprié et placez-le dans le chemin de la variable d'environnement. Ici, nous le placerons dans / 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

Ajoutez le chemin à ~ / .bash_profile pour passer le chemin au binaire du compilateur.

~/.bash_profile

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

[Option] Installation d'IntelliJ IDEA

Si vous n'utilisez pas Gradle, vous devrez trouver les packages supplémentaires dont vous avez besoin (par exemple, kotlinx: kotlinx-coroutines-core-native pour Coroutines) et les spécifier dans les options de ligne de commande. Le problème dans ce cas est que vous ne savez pas où le télécharger. Par conséquent, il est pratique d'installer IntelliJ IDEA afin de pouvoir également utiliser l'environnement Gradle ...

Téléchargez depuis ici. Dans le cas de l'environnement macOS, il s'agit d'un fichier dmg, donc installez-le par opération GUI. D'un autre côté, dans le cas d'un environnement Linux, vous pouvez l'utiliser simplement en le décompressant à un emplacement approprié et en le passant par le chemin.

De plus, je pense que le plug-in Kotlin est déjà installé, vous pouvez donc l'utiliser tel quel pour créer un nouveau projet.

Code source pour le contrôle de fonctionnement

hello.kt

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

compiler

La première fois qu'il s'exécute, le téléchargement et l'installation des packages dépendants tels que LLVM prend du temps.

$ kotlinc-native hello.kt -o hello

De plus, les options Java peuvent être transmises avec l'option -D, donc si vous avez besoin de paramètres de proxy dans un environnement réseau, veuillez exécuter comme suit. La source d'information est ici.

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

Courir

$ ./hello.kexe
Hello, World!

J'ai pu exécuter le programme Kotlin dans l'environnement natif de macOS / Linux!

Génération de bibliothèque

En utilisant l'option -p, il est possible de créer une bibliothèque dans plusieurs formats, et le fichier d'en-tête est également généré automatiquement. Il est compatible avec le framework iOS / macOS et est assez bien fait, mais j'estime que le fichier d'en-tête pour C / C ++ lorsque dynamique est spécifié est assez mal fait ... Je veux que vous en fassiez une macro un peu plus décente ...

$ kotlinc-native hello.kt -p dynamic

Si vous ne savez pas comment l'utiliser, vous pouvez consulter le message d'aide avec l'option -h.

$ 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

Impressions que j'ai essayé d'utiliser

Quant à l'impression que j'ai utilisée, elle fonctionne normalement, mais la construction est lente quand même ... Il semble que Kotlin 1.4 mettra à jour le compilateur, donc je l'attends avec impatience.