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

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

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

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

Самый быстрый способ попробовать отображение API C — разместить все объявления 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. В этом учебнике мы рассмотрим расширенные варианты использования Kotlin/Native, связанные с взаимодействием с C, и многоплатформенные сборки с Gradle.

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

Используйте следующий файл сборки Gradle build.gradle(.kts).

plugins {
    kotlin("multiplatform") version "1.7.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.7.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 «Перейти к» | «Объявление или использования» или ошибок компилятора, посмотрите следующие объявления функций 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 из указателя C, полученного из вызова supply_fun():

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

Kotlin преобразует тип возвращаемого указателя на функцию в необязательный объект CPointer<CFunction<..>. Требуется явно проверить null сначала. В приведенном выше коде для этого используется оператор эльвис. Инструмент 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 охватывает более сложные сценарии взаимодействия.