Картирование указателей на функции из C – учебник

Картирование типов указателей на функции из C

Лучший способ понять сопоставление между Kotlin и C — это попробовать небольшой пример. Объявите функцию, которая принимает указатель на функцию в качестве параметра, и другую функцию, которая возвращает указатель на функцию.

Kotlin/Native поставляется с инструментом cinterop; инструмент генерирует связи между языком C и Kotlin. Он использует файл .def для указания C-библиотеки для импорта. Более подробная информация об этом содержится в Взаимодействие с C-библиотеками.

Самый быстрый способ попробовать сопоставление C-API — это поместить все объявления C в файл interop.def, не создавая никаких файлов .h или .c. Затем поместите объявления C в файл .def после специальной разделительной строки ---.

---

int myFun(int i) {
  return i+1;
}

typedef int  (*MyFun)(int);

void accept_fun(MyFun f) {
  f(42);
}

MyFun supply_fun() {
  return myFun;
}

Файл interop.def достаточно для компиляции и запуска приложения или для его открытия в IDE. Теперь пришло время создать файлы проекта, открыть проект в IntelliJ IDEA и запустить его.

Просмотр сгенерированных Kotlin-API для C-библиотеки

Хотя можно использовать командную строку, либо напрямую, либо комбинируя ее со скриптовым файлом (например, с файлом .sh или .bat), такой подход плохо масштабируется для больших проектов, содержащих сотни файлов и библиотек. В этом случае лучше использовать компилятор Kotlin/Native с системой сборки, поскольку она помогает загружать и кэшировать двоичные файлы и библиотеки компилятора Kotlin/Native с транзитивными зависимостями и запускать компилятор и тесты. Kotlin/Native может использовать систему сборки Gradle через плагин kotlin-multiplatform.

Основы настройки IDE-совместимого проекта с Gradle мы рассмотрели в учебнике Простой пример Kotlin/Native приложения. Пожалуйста, ознакомьтесь с ним, если вы ищете подробные начальные шаги и инструкции по созданию нового проекта Kotlin/Native и его открытию в IntelliJ IDEA. В этом учебнике мы рассмотрим расширенное использование C-взаимодействия с Kotlin/Native и сборки с помощью Gradle.

Сначала создайте папку проекта. Все пути в этом руководстве будут относительными к этой папке. Иногда необходимо создать отсутствующие каталоги перед добавлением новых файлов.

Используйте следующий файл сборки Gradle:

plugins {
    kotlin("multiplatform") version "1.6.20"
}

repositories {
    mavenCentral()
}

kotlin {
  linuxX64("native") { // on Linux
  // macosX64("native") { // on x86_64 macOS
  // macosArm64("native") { // on Apple Silicon macOS
  // mingwX64("native") { // on Windows
    val main by compilations.getting
    val interop by main.cinterops.creating
    
    binaries {
      executable()
    }
  }
}

tasks.wrapper {
  gradleVersion = "6.7.1"
  distributionType = Wrapper.DistributionType.BIN
}

plugins {
    id 'org.jetbrains.kotlin.multiplatform' version '1.6.20'
}

repositories {
    mavenCentral()
}

kotlin {
  linuxX64('native') { // on Linux
  // macosX64("native") { // on x86_64 macOS
  // macosArm64("native") { // on Apple Silicon macOS  
  // mingwX64('native') { // on Windows
    compilations.main.cinterops {
      interop 
    }
    
    binaries {
      executable()
    }
  }
}

wrapper {
  gradleVersion = '6.7.1'
  distributionType = 'BIN'
}

Файл проекта настраивает C-взаимодействие как дополнительный шаг сборки. Давайте переместим файл interop.def в каталог src/nativeInterop/cinterop. Gradle рекомендует использовать соглашения вместо конфигураций, например, ожидается, что исходные файлы будут в папке src/nativeMain/kotlin. По умолчанию все символы из C импортируются в пакет interop, вы можете импортировать весь пакет в наши файлы .kt. Ознакомьтесь с документацией по плагину kotlin-multiplatform, чтобы узнать обо всех возможных способах его настройки.

Давайте создадим файл-заглушку src/nativeMain/kotlin/hello.kt со следующим содержимым, чтобы увидеть, как объявления примитивных типов C видны из Kotlin:

import interop.*

fun main() {
  println("Hello Kotlin/Native!")
  
  accept_fun(https://kotlinlang.org/*fix me */)
  val useMe = supply_fun()
}

Теперь вы готовы открыть проект в IntelliJ IDEA и посмотреть, как исправить пример проекта. При этом посмотрите, как функции C отображаются в объявлениях Kotlin/Native.

Указатели на функции C в Kotlin

С помощью IntelliJ IDEA's Перейти | Объявление или использования или ошибок компилятора, посмотрите следующие объявления для функций C:

fun accept_fun(f: MyFun? /* = CPointer<CFunction<(Int) -> Int>>? */)
fun supply_fun(): MyFun? /* = CPointer<CFunction<(Int) -> Int>>? */

fun myFun(i: kotlin.Int): kotlin.Int

typealias MyFun = kotlinx.cinterop.CPointer<kotlinx.cinterop.CFunction<(kotlin.Int) -> kotlin.Int>>

typealias MyFunVar = kotlinx.cinterop.CPointerVarOf<lib.MyFun>

Вы видите, что функция typedef из C была преобразована в Kotlin typealias. Она использует тип CPointer<..> для представления параметров-указателей и CFunction<(Int)->Int> для представления сигнатуры функции. Существует функция-расширение оператора invoke для всех типов CPointer<CFunction<..>, что позволяет вызывать ее так же, как и любую другую функцию в Kotlin.

Передача функции Kotlin в качестве указателя на функцию C

Пришло время попробовать использовать функции C из программы Kotlin. Вызовите функцию accept_fun и передайте указатель на функцию C в лямбда-выражение Kotlin:

fun myFun() {
  accept_fun(staticCFunction<Int, Int> { it + 1 })
}

Этот вызов использует вспомогательную функцию staticCFunction{..} из Kotlin/Native для обертывания лямбда-функции Kotlin в указатель на функцию C. Она позволяет использовать только несвязанные и не захватывающие лямбда-функции. Например, она не может использовать локальную переменную из функции. Вы можете использовать только глобальные объявления. Исключение исключений из staticCFunction{..} приведет к непредсказуемым побочным эффектам. Важно убедиться, что ваш код не генерирует внезапные исключения.

Использование указателя на функцию C из Kotlin

Следующим шагом является вызов указателя на функцию C из указателя на функцию, полученного из вызова supply_fun().

fun myFun2() {
  val functionFromC = supply_fun() ?: error("No function is returned")
  
  functionFromC(42)
}

Kotlin преобразует возвращаемый тип указателя на функцию в объект CPointer<CFunction<..>. Необходимо явным образом проверить null в первую очередь. Для этого в приведенном выше коде используется оператор Elvis. Инструмент cinterop помогает преобразовать указатель на функцию C в легко вызываемый объект в Kotlin. Именно это мы сделали в последней строке.

Исправление кода

Вы увидели все определения, и пришло время исправить и запустить код. Запустите задачу runDebugExecutableNative Gradle в IDE или используйте следующую команду для запуска кода:

./gradlew runDebugExecutableNative

Код в файле hello.kt может выглядеть так:

import interop.*
import kotlinx.cinterop.*

fun main() {
  println("Hello Kotlin/Native!")
 
  val cFunctionPointer = staticCFunction<Int, Int> { it + 1 }
  accept_fun(cFunctionPointer)

  val funFromC = supply_fun() ?: error("No function is returned")
  funFromC(42)
}

Следующие шаги

Продолжайте изучение других типов языка C и их представления в Kotlin/Native в следующих учебниках:

• Картирование примитивных типов данных из C

• Картирование структур и объединений из C

• Картирование строк из C

Документация по C-взаимодействию охватывает более сложные сценарии взаимодействия.