From 53884f8da6ee92ee1d0354b22813b2142650e024 Mon Sep 17 00:00:00 2001 From: Svyatoslav Scherbina Date: Wed, 19 Oct 2016 15:56:30 +0300 Subject: [PATCH 01/11] Interop/StubGenerator: add minor code improvements --- .../native/interop/gen/jvm/StubGenerator.kt | 72 +++++++++---------- 1 file changed, 35 insertions(+), 37 deletions(-) diff --git a/Interop/StubGenerator/src/main/kotlin/org/jetbrains/kotlin/native/interop/gen/jvm/StubGenerator.kt b/Interop/StubGenerator/src/main/kotlin/org/jetbrains/kotlin/native/interop/gen/jvm/StubGenerator.kt index 5fb933c44c1..40606e6cb9b 100644 --- a/Interop/StubGenerator/src/main/kotlin/org/jetbrains/kotlin/native/interop/gen/jvm/StubGenerator.kt +++ b/Interop/StubGenerator/src/main/kotlin/org/jetbrains/kotlin/native/interop/gen/jvm/StubGenerator.kt @@ -107,6 +107,15 @@ class StubGenerator( return withOutput({ oldOut(" $it") }, action) } + private fun block(header: String, body: () -> R): R { + out("$header {") + val res = indent { + body() + } + out("}") + return res + } + /** * Returns the expression which could be used for this type in C code. * @@ -418,8 +427,7 @@ class StubGenerator( } val className = decl.kotlinName - out("class $className(ptr: NativePtr) : NativeStruct(ptr) {") - indent { + block("class $className(ptr: NativePtr) : NativeStruct(ptr)") { out("") out("companion object : Type<$className>(${def.size}, ::$className)") out("") @@ -435,7 +443,6 @@ class StubGenerator( } } } - out("}") } /** @@ -443,9 +450,9 @@ class StubGenerator( */ private fun generateForwardStruct(s: StructDecl) { val className = s.kotlinName - out("class $className(ptr: NativePtr) : NativeRef(ptr) {") - out(" companion object : Type<$className>(::$className)") - out("}") + block("class $className(ptr: NativePtr) : NativeRef(ptr)") { + out("companion object : Type<$className>(::$className)") + } } /** @@ -459,26 +466,23 @@ class StubGenerator( val baseRefType = getKotlinTypeForRefTo(e.baseType) - out("enum class ${e.kotlinName}(val value: ${e.baseType.kotlinType}) {") - indent { + block("enum class ${e.kotlinName}(val value: ${e.baseType.kotlinType})") { e.values.forEach { out("${it.name}(${it.value}),") } out(";") out("") - out("companion object {") - out(" fun byValue(value: ${e.baseType.kotlinType}) = ${e.kotlinName}.values().find { it.value == value }!!") - out("}") + block("companion object") { + out("fun byValue(value: ${e.baseType.kotlinType}) = ${e.kotlinName}.values().find { it.value == value }!!") + } out("") - out("class ref(ptr: NativePtr) : NativeRef(ptr) {") - out(" companion object : TypeWithSize(${baseRefType.typeExpr}.size, ::ref)") - out(" var value: ${e.kotlinName}") - out(" get() = byValue(${baseRefType.typeExpr}.byPtr(ptr).value)") - out(" set(value) { ${baseRefType.typeExpr}.byPtr(ptr).value = value.value }") - out("}") - + block("class ref(ptr: NativePtr) : NativeRef(ptr)") { + out("companion object : TypeWithSize(${baseRefType.typeExpr}.size, ::ref)") + out("var value: ${e.kotlinName}") + out(" get() = byValue(${baseRefType.typeExpr}.byPtr(ptr).value)") + out(" set(value) { ${baseRefType.typeExpr}.byPtr(ptr).value = value.value }") + } } - out("}") } /** @@ -646,10 +650,8 @@ class StubGenerator( val constructorArgsStr = constructorArgs.joinToString(", ") - out("object $name : NativeFunctionType<$kotlinFunctionType>($constructorArgsStr) {") - indent { - out("override fun invoke(function: $kotlinFunctionType, args: NativeArray, ret: NativePtr) {") - indent { + block("object $name : NativeFunctionType<$kotlinFunctionType>($constructorArgsStr)") { + block("override fun invoke(function: $kotlinFunctionType, args: NativeArray, ret: NativePtr)") { val args = type.parameterTypes.mapIndexed { i, paramType -> val refType = getKotlinTypeForRefTo(paramType) val ref = "args[$i].value.asRef(${refType.typeExpr})!!" @@ -671,9 +673,7 @@ class StubGenerator( } } - out("}") } - out("}") } /** @@ -734,8 +734,7 @@ class StubGenerator( out("") } - out("object externals {") - indent { + block("object externals") { out("init { System.loadLibrary(\"$libName\") }") functionsToBind.forEach { try { @@ -748,7 +747,6 @@ class StubGenerator( } } } - out("}") } /** @@ -819,16 +817,16 @@ class StubGenerator( } val jniFuncName = "Java_" + funcFullName.replace("_", "_1").replace('.', '_').replace("$", "_00024") - out("JNIEXPORT $cReturnType JNICALL $jniFuncName (JNIEnv *env, jobject obj$args) {") + block("JNIEXPORT $cReturnType JNICALL $jniFuncName (JNIEnv *env, jobject obj$args)") { - if (cReturnType == "void") { - out(" $callExpr;") - } else if (funcReturnType is RecordType) { - out(" *(${funcReturnType.decl.spelling}*)retValPlacement = $callExpr;") - out(" return ($cReturnType) retValPlacement;") - } else { - out(" return ($cReturnType) ($callExpr);") + if (cReturnType == "void") { + out("$callExpr;") + } else if (funcReturnType is RecordType) { + out("*(${funcReturnType.decl.spelling}*)retValPlacement = $callExpr;") + out("return ($cReturnType) retValPlacement;") + } else { + out("return ($cReturnType) ($callExpr);") + } } - out("}") } } From 8a66de216d9af51485fa4cfd5bb12f05c6d00df5 Mon Sep 17 00:00:00 2001 From: Svyatoslav Scherbina Date: Wed, 19 Oct 2016 15:59:55 +0300 Subject: [PATCH 02/11] Interop: rework String auto conversion use memScoped --- .../kotlin/kotlin_native/interop/Utils.kt | 16 ++++----- .../native/interop/gen/jvm/StubGenerator.kt | 33 ++++++++++--------- 2 files changed, 25 insertions(+), 24 deletions(-) diff --git a/Interop/Runtime/src/main/kotlin/kotlin_native/interop/Utils.kt b/Interop/Runtime/src/main/kotlin/kotlin_native/interop/Utils.kt index ae0f1f701fb..b5c9c5bc373 100644 --- a/Interop/Runtime/src/main/kotlin/kotlin_native/interop/Utils.kt +++ b/Interop/Runtime/src/main/kotlin/kotlin_native/interop/Utils.kt @@ -32,13 +32,15 @@ fun Placement.allocNativeArrayOf(elements: ByteArray): NativeArray { } fun CString.Companion.fromString(str: String?): CString? { - if (str == null) { - return null - } + return str?.toCString(heap) +} - val bytes = str.toByteArray() // TODO: encoding +fun Int8Box.asCString() = CString.fromArray(NativeArray.byRefToFirstElem(this, Int8Box)) + +fun String.toCString(retValPlacement: Placement): CString { + val bytes = this.toByteArray() // TODO: encoding val len = bytes.size - val nativeBytes = malloc(NativeArray of Int8Box length (len + 1)) + val nativeBytes = retValPlacement.alloc(array[len + 1](Int8Box)) bytes.forEachIndexed { i, byte -> nativeBytes[i].value = byte @@ -48,10 +50,6 @@ fun CString.Companion.fromString(str: String?): CString? { return CString.fromArray(nativeBytes) } -fun NativeArray.asCString() = CString.fromArray(this) -fun Int8Box.asCString() = CString.fromArray(NativeArray.byRefToFirstElem(this, Int8Box)) -fun String.toCString() = CString.fromString(this) - class MemScope private constructor(private val arena: Arena) : Placement by arena { val memScope: Placement get() = this diff --git a/Interop/StubGenerator/src/main/kotlin/org/jetbrains/kotlin/native/interop/gen/jvm/StubGenerator.kt b/Interop/StubGenerator/src/main/kotlin/org/jetbrains/kotlin/native/interop/gen/jvm/StubGenerator.kt index 40606e6cb9b..054f54db7d3 100644 --- a/Interop/StubGenerator/src/main/kotlin/org/jetbrains/kotlin/native/interop/gen/jvm/StubGenerator.kt +++ b/Interop/StubGenerator/src/main/kotlin/org/jetbrains/kotlin/native/interop/gen/jvm/StubGenerator.kt @@ -229,12 +229,12 @@ class StubGenerator( * * @param kotlinType the name of Kotlin type to be used for this value in Kotlin. * @param kotlinConv the function such that `kotlinConv(name)` converts variable `name` to pass it into JNI stub - * @param convFree the function such that `convFree(name)` is the statement that frees the result of conversion + * @param memScoped the conversion allocates memory and should be placed into `memScoped {}` block * @param kotlinJniBridgeType the name of Kotlin type to be used for this value in JNI stub */ class OutValueBinding(val kotlinType: String, val kotlinConv: ((String) -> String)? = null, - val convFree: ((String) -> String)? = null, + val memScoped: Boolean = false, val kotlinJniBridgeType: String = kotlinType) /** @@ -312,8 +312,8 @@ class StubGenerator( ) is Int8Type -> return OutValueBinding( kotlinType = "String?", - kotlinConv = { name -> "CString.fromString($name).getNativePtr().asLong()" }, - convFree = { name -> "free(NativePtr.byValue($name))" }, + kotlinConv = { name -> "$name?.toCString(memScope).getNativePtr().asLong()" }, + memScoped = true, kotlinJniBridgeType = "Long" ) } @@ -564,8 +564,9 @@ class StubGenerator( "$name: " + paramBindings[i].kotlinType }.joinToString(", ") - out("fun ${func.name}($args): ${retValBinding.kotlinType} {") - indent { + val header = "fun ${func.name}($args): ${retValBinding.kotlinType}" + + fun generateBody() { val externalParamNames = paramNames.mapIndexed { i: Int, name: String -> val binding = paramBindings[i] val externalParamName: String @@ -581,13 +582,6 @@ class StubGenerator( } out("val res = externals.${func.name}(" + externalParamNames.joinToString(", ") + ")") - paramNames.forEachIndexed { i, name -> - val binding = paramBindings[i] - if (binding.convFree != null) { - assert(binding.kotlinConv != null) - out(binding.convFree.invoke(externalParamNames[i])) - } - } if (dumpShims) { val returnValueRepresentation = retValBinding.conv("res") @@ -599,9 +593,18 @@ class StubGenerator( } out("return " + retValBinding.conv("res")) - } - out("}") + + block(header) { + val memScoped = paramBindings.any { it.memScoped } + if (memScoped) { + block("memScoped") { + generateBody() + } + } else { + generateBody() + } + } } private fun getFfiStructType(elementTypes: List) = From 3095044420a7098b0cdc75195a767bcd899ac5e2 Mon Sep 17 00:00:00 2001 From: Svyatoslav Scherbina Date: Wed, 16 Nov 2016 13:53:28 +0700 Subject: [PATCH 03/11] build: use Kotlin 1.1-M02 to build all Kotlin JVM sources --- Interop/Indexer/build.gradle | 13 ++++++------- Interop/Runtime/build.gradle | 13 ++++++------- Interop/StubGenerator/build.gradle | 13 ++++++------- InteropExample/build.gradle | 9 ++++----- backend.native/build.gradle | 4 +++- build.gradle | 7 +++++++ gradle.properties | 2 +- 7 files changed, 33 insertions(+), 28 deletions(-) diff --git a/Interop/Indexer/build.gradle b/Interop/Indexer/build.gradle index 7478f6dafdb..1b7443aaea7 100644 --- a/Interop/Indexer/build.gradle +++ b/Interop/Indexer/build.gradle @@ -1,7 +1,10 @@ buildscript { - repositories { - mavenCentral() - } + repositories { + mavenCentral() + maven { + url "http://dl.bintray.com/kotlin/kotlin-eap-1.1" + } + } dependencies { classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version" @@ -43,10 +46,6 @@ sourceSets { } } -repositories { - mavenCentral() -} - dependencies { compile "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version" compile project(':Interop:Runtime') diff --git a/Interop/Runtime/build.gradle b/Interop/Runtime/build.gradle index 0c25acce013..957eb22ca99 100644 --- a/Interop/Runtime/build.gradle +++ b/Interop/Runtime/build.gradle @@ -1,7 +1,10 @@ buildscript { - repositories { - mavenCentral() - } + repositories { + mavenCentral() + maven { + url "http://dl.bintray.com/kotlin/kotlin-eap-1.1" + } + } dependencies { classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version" @@ -32,10 +35,6 @@ model { } -repositories { - mavenCentral() -} - dependencies { compile "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version" } diff --git a/Interop/StubGenerator/build.gradle b/Interop/StubGenerator/build.gradle index bb0f5d74bdb..4598aee8b33 100644 --- a/Interop/StubGenerator/build.gradle +++ b/Interop/StubGenerator/build.gradle @@ -1,7 +1,10 @@ buildscript { - repositories { - mavenCentral() - } + repositories { + mavenCentral() + maven { + url "http://dl.bintray.com/kotlin/kotlin-eap-1.1" + } + } dependencies { classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version" @@ -13,10 +16,6 @@ apply plugin: 'application' mainClassName = "org.jetbrains.kotlin.native.interop.gen.jvm.MainKt" -repositories { - mavenCentral() -} - dependencies { compile "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version" compile project(':Interop:Indexer') diff --git a/InteropExample/build.gradle b/InteropExample/build.gradle index 86dbc1c0d11..0bca5ce9273 100644 --- a/InteropExample/build.gradle +++ b/InteropExample/build.gradle @@ -1,6 +1,9 @@ buildscript { repositories { - mavenCentral() + mavenCentral() + maven { + url "http://dl.bintray.com/kotlin/kotlin-eap-1.1" + } } dependencies { @@ -12,10 +15,6 @@ apply plugin: 'kotlin' apply plugin: org.jetbrains.kotlin.NativeInteropPlugin apply plugin: 'application' -repositories { - mavenCentral() -} - kotlinNativeInterop { llvm { defFile '../backend.native/llvm.def' diff --git a/backend.native/build.gradle b/backend.native/build.gradle index 2f167a98755..708671c7c16 100644 --- a/backend.native/build.gradle +++ b/backend.native/build.gradle @@ -1,6 +1,9 @@ buildscript { repositories { mavenCentral() + maven { + url "http://dl.bintray.com/kotlin/kotlin-eap-1.1" + } } dependencies { @@ -21,7 +24,6 @@ String kotlinCompilerModule = 'org.jetbrains.kotlin:kotlin-compiler:1.1-20161121 // (gets applied to this project and all its subprojects) allprojects { repositories { - mavenCentral() maven { url 'http://oss.sonatype.org/content/repositories/snapshots' } diff --git a/build.gradle b/build.gradle index 344e9556f1e..5d0deb98374 100644 --- a/build.gradle +++ b/build.gradle @@ -13,6 +13,13 @@ allprojects { evaluationDependsOn(":dependencies") } + repositories { + mavenCentral() + maven { + url "http://dl.bintray.com/kotlin/kotlin-eap-1.1" + } + } + ext.clangPath = ["$llvmDir/bin"] ext.clangArgs = [] final String binDir diff --git a/gradle.properties b/gradle.properties index d09f037bee0..4cb81d3b8fe 100644 --- a/gradle.properties +++ b/gradle.properties @@ -1 +1 @@ -kotlin_version=1.0.4 +kotlin_version=1.1-M02 From f0df5f9435ece6e363d0efb6a4264b4ca4b14f81 Mon Sep 17 00:00:00 2001 From: Svyatoslav Scherbina Date: Tue, 22 Nov 2016 12:47:57 +0700 Subject: [PATCH 04/11] Interop: implement new version --- .../kotlin/native/interop/indexer/Indexer.kt | 45 ++- .../native/interop/indexer/NativeIndex.kt | 16 +- Interop/Runtime/build.gradle | 3 + .../kotlin/kotlin_/cinterop/JvmCallbacks.kt | 262 ++++++++++++ .../kotlin/kotlin_/cinterop/JvmNativeMem.kt | 67 ++++ .../jvm/kotlin/kotlin_/cinterop/JvmTypes.kt | 30 ++ .../src/main/kotlin/kotlin_/cinterop/Types.kt | 331 ++++++++++++++++ .../src/main/kotlin/kotlin_/cinterop/Utils.kt | 222 +++++++++++ .../src/main/kotlin/kotlin_/package-info.java | 4 + .../native/interop/gen/jvm/StubGenerator.kt | 375 ++++++++++-------- 10 files changed, 1188 insertions(+), 167 deletions(-) create mode 100644 Interop/Runtime/src/jvm/kotlin/kotlin_/cinterop/JvmCallbacks.kt create mode 100644 Interop/Runtime/src/jvm/kotlin/kotlin_/cinterop/JvmNativeMem.kt create mode 100644 Interop/Runtime/src/jvm/kotlin/kotlin_/cinterop/JvmTypes.kt create mode 100644 Interop/Runtime/src/main/kotlin/kotlin_/cinterop/Types.kt create mode 100644 Interop/Runtime/src/main/kotlin/kotlin_/cinterop/Utils.kt create mode 100644 Interop/Runtime/src/main/kotlin/kotlin_/package-info.java diff --git a/Interop/Indexer/src/main/kotlin/org/jetbrains/kotlin/native/interop/indexer/Indexer.kt b/Interop/Indexer/src/main/kotlin/org/jetbrains/kotlin/native/interop/indexer/Indexer.kt index 86dcdb37ad4..4db3c86e6db 100644 --- a/Interop/Indexer/src/main/kotlin/org/jetbrains/kotlin/native/interop/indexer/Indexer.kt +++ b/Interop/Indexer/src/main/kotlin/org/jetbrains/kotlin/native/interop/indexer/Indexer.kt @@ -10,8 +10,8 @@ private class StructDeclImpl(spelling: String) : StructDecl(spelling) { override var def: StructDefImpl? = null } -private class StructDefImpl(size: Long, decl: StructDecl, hasNaturalLayout: Boolean) : - StructDef(size, decl, hasNaturalLayout) { +private class StructDefImpl(size: Long, align: Int, decl: StructDecl, hasNaturalLayout: Boolean) : + StructDef(size, align, decl, hasNaturalLayout) { override val fields = mutableListOf() } @@ -38,6 +38,11 @@ private class NativeIndexImpl : NativeIndex() { override val enums: List get() = enumById.values.toList() + val typedefById = mutableMapOf() + + override val typedefs: List + get() = typedefById.values.toList() + val functionByName = mutableMapOf() override val functions: List @@ -94,6 +99,31 @@ private class NativeIndexImpl : NativeIndex() { return res } + fun getTypedef(type: CXType): Type { + assert (type.kind.value == CXType_Typedef) + val declCursor = clang_getTypeDeclaration(type, arena) + val name = clang_getCursorSpelling(declCursor, arena).convertAndDispose() + + val underlying = convertType(clang_getTypedefDeclUnderlyingType(declCursor, arena)) + if ((underlying is RecordType && underlying.decl.spelling.split(' ').last() == name) || + (underlying is EnumType && underlying.def.spelling.split(' ').last() == name)) { + + // special handling for: + // typedef struct { ... } name; + // typedef enum { ... } name; + // FIXME: implement better solution + return underlying + } + + val declId = getDeclarationId(declCursor) + val typedefDef = typedefById.getOrPut(declId) { + + TypedefDef(underlying, name) + } + + return Typedef(typedefDef) + } + /** * Computes [StructDef.hasNaturalLayout] property. */ @@ -152,10 +182,7 @@ private class NativeIndexImpl : NativeIndex() { CXType_LongLong -> Int64Type CXType_Typedef -> { - val declaration = clang_getTypeDeclaration(type, arena) - val underlying = clang_getTypedefDeclUnderlyingType(declaration, arena) - assert (underlying.kind.value != CXType_Invalid) - convertType(underlying) + getTypedef(type) } CXType_Record -> RecordType(getStructTypeDecl(type)) @@ -211,9 +238,11 @@ private class NativeIndexImpl : NativeIndex() { CXIdxEntity_Struct, CXIdxEntity_Union -> { val structDecl = getStructDeclAt(cursor) if (clang_isCursorDefinition(cursor) != 0) { - val size = clang_Type_getSizeOf(clang_getCursorType(cursor, arena)) + val type = clang_getCursorType(cursor, arena) + val size = clang_Type_getSizeOf(type) + val align = clang_Type_getAlignOf(clang_getCursorType(cursor, arena)).toInt() val hasNaturalLayout = structHasNaturalLayout(cursor) - structDecl.def = StructDefImpl(size, structDecl, hasNaturalLayout) + structDecl.def = StructDefImpl(size, align, structDecl, hasNaturalLayout) } } diff --git a/Interop/Indexer/src/main/kotlin/org/jetbrains/kotlin/native/interop/indexer/NativeIndex.kt b/Interop/Indexer/src/main/kotlin/org/jetbrains/kotlin/native/interop/indexer/NativeIndex.kt index 6390ddd6d89..73681c415ef 100644 --- a/Interop/Indexer/src/main/kotlin/org/jetbrains/kotlin/native/interop/indexer/NativeIndex.kt +++ b/Interop/Indexer/src/main/kotlin/org/jetbrains/kotlin/native/interop/indexer/NativeIndex.kt @@ -13,6 +13,7 @@ fun buildNativeIndex(headerFile: File, args: List): NativeIndex = buildN abstract class NativeIndex { abstract val structs: List abstract val enums: List + abstract val typedefs: List abstract val functions: List } @@ -35,7 +36,9 @@ abstract class StructDecl(val spelling: String) { * @param hasNaturalLayout must be `false` if the struct has unnatural layout, e.g. it is `packed`. * May be `false` even if the struct has natural layout. */ -abstract class StructDef(val size: Long, val decl: StructDecl, val hasNaturalLayout: Boolean) { +abstract class StructDef(val size: Long, val align: Int, + val decl: StructDecl, + val hasNaturalLayout: Boolean) { abstract val fields: List } @@ -63,6 +66,15 @@ class Parameter(val name: String?, val type: Type) */ class FunctionDecl(val name: String, val parameters: List, val returnType: Type) +/** + * C typedef definition. + * + * ``` + * typedef $aliased $name; + * ``` + */ +class TypedefDef(val aliased: Type, val name: String) + /** * C type. @@ -103,4 +115,6 @@ interface ArrayType : Type { data class ConstArrayType(override val elemType: Type, val length: Long) : ArrayType data class IncompleteArrayType(override val elemType: Type) : ArrayType +data class Typedef(val def: TypedefDef) : Type + object UnsupportedType : Type \ No newline at end of file diff --git a/Interop/Runtime/build.gradle b/Interop/Runtime/build.gradle index 957eb22ca99..07ac2f8b004 100644 --- a/Interop/Runtime/build.gradle +++ b/Interop/Runtime/build.gradle @@ -37,8 +37,11 @@ model { dependencies { compile "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version" + compile "org.jetbrains.kotlin:kotlin-reflect:$kotlin_version" } +sourceSets.main.kotlin.srcDirs += "src/jvm/kotlin" + task nativelibs(type: Copy) { dependsOn 'callbacksSharedLibrary' diff --git a/Interop/Runtime/src/jvm/kotlin/kotlin_/cinterop/JvmCallbacks.kt b/Interop/Runtime/src/jvm/kotlin/kotlin_/cinterop/JvmCallbacks.kt new file mode 100644 index 00000000000..5827836e8e6 --- /dev/null +++ b/Interop/Runtime/src/jvm/kotlin/kotlin_/cinterop/JvmCallbacks.kt @@ -0,0 +1,262 @@ +package kotlin_.cinterop + +/** + * This class provides a way to create a stable handle to any Kotlin object. + * Its [value] can be safely passed to native code e.g. to be received in a Kotlin callback. + * + * Any [StableObjPtr] should be manually [disposed][dispose] + */ +data class StableObjPtr private constructor(val value: COpaquePointer) { + + companion object { + + /** + * Creates a handle for given object. + */ + fun create(any: Any) = fromValue(newGlobalRef(any)) + + private fun fromValue(value: NativePtr) = fromValue(CPointer.create(value)) + + /** + * Creates [StableObjPtr] from given raw value. + * + * @param value must be a [value] of some [StableObjPtr] + */ + fun fromValue(value: COpaquePointer) = StableObjPtr(value) + + init { + loadCallbacksLibrary() + } + } + + /** + * Disposes the handle. It must not be [used][get] after that. + */ + fun dispose() { + deleteGlobalRef(value.rawValue) + } + + /** + * Returns the object this handle was [created][create] for. + */ + fun get(): Any = derefGlobalRef(value.rawValue) + +} + +/** + * Describes the type of C function with adapter for Kotlin functions. + * + * The instances of this class are supposed to be Kotlin object declarations (singletons), + * because it is required by [CAdaptedFunctionType] and + * because creating the instance implies allocating some amount of non-freeable memory for the instance itself + * and for any unique Kotlin function "converted" to this type. + * + * Native function type definition consists in the following: + * - Definitions of native function's parameter and return types to be passed into the constructor + * - Implementation of [invoke] method which describes how to convert between these types and Kotlin types used in [F] + * + * @param F Kotlin function type corresponding to given native function type + */ +abstract class CAdaptedFunctionTypeImpl> + protected constructor(returnType: CType, vararg paramTypes: CType) : CAdaptedFunctionType { + + override fun fromStatic(function: F): NativePtr { + // TODO: optimize synchronization + synchronized(cache) { + return cache.getOrPut(function, { createFromStatic(function) }) + } + } + + /** + * Describes the C type of a function's parameter or return value. + * It is supposed to be constructed using the primitive types (such as [SInt32]) and the [Struct] combinator. + * + * This description omits the details that are irrelevant for the ABI. + */ + protected open class CType internal constructor(val ffiType: ffi_type) { + internal constructor(ffiTypePtr: Long) : this(interpretPointed(ffiTypePtr)) + } + + protected object Void : CType(ffiTypeVoid()) + protected object UInt8 : CType(ffiTypeUInt8()) + protected object SInt8 : CType(ffiTypeSInt8()) + protected object UInt16 : CType(ffiTypeUInt16()) + protected object SInt16 : CType(ffiTypeSInt16()) + protected object UInt32 : CType(ffiTypeUInt32()) + protected object SInt32 : CType(ffiTypeSInt32()) + protected object UInt64 : CType(ffiTypeUInt64()) + protected object SInt64 : CType(ffiTypeSInt64()) + protected object Pointer : CType(ffiTypePointer()) + + protected class Struct(vararg elementTypes: CType) : CType( + ffiTypeStruct( + elementTypes.map { it.ffiType } + ) + ) + + /** + * This method should invoke given Kotlin function. + * + * @param args array of pointers to arguments to be passed to [function] + * @param ret pointer to memory to be filled with return value of [function] + */ + protected abstract fun invoke(function: F, args: CArray, ret: COpaquePointer) + + companion object { + init { + loadCallbacksLibrary() + } + } + + private val ffiCif = ffiCreateCif(returnType.ffiType, paramTypes.map { it.ffiType }) + + /** + * Allocates a native function of this type for given Kotlin function. + */ + private fun createFromStatic(function: F): NativePtr { + if (!isStatic(function)) { + throw IllegalArgumentException() + } + + val impl: UserData = { ret: COpaquePointer, args: CArray -> + invoke(function, args, ret) + } + + return ffiCreateClosure(ffiCif, impl) + } + + /** + * Returns `true` if given function is *static* as defined in [fromStatic]. + */ + private fun isStatic(function: Function<*>): Boolean { + // TODO: revise + try { + with(function.javaClass.getDeclaredField("INSTANCE")) { + if (!java.lang.reflect.Modifier.isStatic(modifiers) || !java.lang.reflect.Modifier.isFinal(modifiers)) { + return false + } + + isAccessible = true // TODO: undo + + return get(null) == function + } + } catch (e: NoSuchFieldException) { + return false + } + } + + private val cache = mutableMapOf() +} + +private typealias UserData = (ret: COpaquePointer, args: CArray)->Unit + +inline fun > CAdaptedFunctionTypeImpl.Companion.of(): T = + T::class.objectInstance!! + +private fun loadCallbacksLibrary() { + System.loadLibrary("callbacks") +} + + +/** + * Reference to `ffi_type` struct instance. + */ +internal class ffi_type(override val rawPtr: NativePtr) : COpaque + +/** + * Reference to `ffi_cif` struct instance. + */ +internal class ffi_cif(override val rawPtr: NativePtr) : COpaque + +private external fun ffiTypeVoid(): Long +private external fun ffiTypeUInt8(): Long +private external fun ffiTypeSInt8(): Long +private external fun ffiTypeUInt16(): Long +private external fun ffiTypeSInt16(): Long +private external fun ffiTypeUInt32(): Long +private external fun ffiTypeSInt32(): Long +private external fun ffiTypeUInt64(): Long +private external fun ffiTypeSInt64(): Long +private external fun ffiTypePointer(): Long + +private external fun ffiTypeStruct0(elements: Long): Long + +/** + * Allocates and initializes `ffi_type` describing the struct. + * + * @param elements types of the struct elements + */ +private fun ffiTypeStruct(elementTypes: List): ffi_type { + val elements = nativeHeap.allocArrayOfPointersTo(*elementTypes.toTypedArray(), null) + val res = ffiTypeStruct0(elements.rawPtr) + if (res == 0L) { + throw OutOfMemoryError() + } + return interpretPointed(res) +} + +private external fun ffiCreateCif0(nArgs: Int, rType: Long, argTypes: Long): Long + +/** + * Creates and prepares an `ffi_cif`. + * + * @param returnType native function return value type + * @param paramTypes native function parameter types + * + * @return the initialized `ffi_cif` + */ +private fun ffiCreateCif(returnType: ffi_type, paramTypes: List): ffi_cif { + val nArgs = paramTypes.size + val argTypes = nativeHeap.allocArrayOfPointersTo(*paramTypes.toTypedArray(), null) + val res = ffiCreateCif0(nArgs, returnType.rawPtr, argTypes.rawPtr) + + when (res) { + 0L -> throw OutOfMemoryError() + -1L -> throw Error("FFI_BAD_TYPEDEF") + -2L -> throw Error("FFI_BAD_ABI") + -3L -> throw Error("libffi error occurred") + } + + return interpretPointed(res) +} + +private fun ffiFunImpl0(ffiCif: Long, ret: Long, args: Long, userData: Any) { + ffiFunImpl(interpretPointed(ffiCif), + CPointer.create(ret), + interpretPointed(args), + userData as UserData) +} + +/** + * This function is called from native code when a native function created with [ffiCreateClosure] is invoked. + * + * @param ret pointer to memory to be filled with return value of the invoked native function + * @param args pointer to array of pointers to arguments passed to the invoked native function + */ +private fun ffiFunImpl(ffiCif: ffi_cif, ret: COpaquePointer, args: CArray, + userData: UserData) { + + userData.invoke(ret, args) +} + +private external fun ffiCreateClosure0(ffiCif: Long, userData: Any): Long + +/** + * Uses libffi to allocate a native function which will call [ffiFunImpl] when invoked. + * + * @param ffiCif describes the type of the function to create + */ +private fun ffiCreateClosure(ffiCif: ffi_cif, userData: UserData): NativePtr { + val res = ffiCreateClosure0(ffiCif.rawPtr, userData) + + when (res) { + 0L -> throw OutOfMemoryError() + -1L -> throw Error("libffi error occurred") + } + + return res +} + +private external fun newGlobalRef(any: Any): Long +private external fun derefGlobalRef(ref: Long): Any +private external fun deleteGlobalRef(ref: Long) \ No newline at end of file diff --git a/Interop/Runtime/src/jvm/kotlin/kotlin_/cinterop/JvmNativeMem.kt b/Interop/Runtime/src/jvm/kotlin/kotlin_/cinterop/JvmNativeMem.kt new file mode 100644 index 00000000000..048ded7c1cd --- /dev/null +++ b/Interop/Runtime/src/jvm/kotlin/kotlin_/cinterop/JvmNativeMem.kt @@ -0,0 +1,67 @@ +package kotlin_.cinterop + +import sun.misc.Unsafe + +private val NativePointed.address: Long + get() = this.rawPtr + +private enum class DataModel(val pointerSize: Long) { + _32BIT(4), + _64BIT(8) +} + +private val dataModel: DataModel = when (System.getProperty("sun.arch.data.model")) { + null -> TODO() + "32" -> DataModel._32BIT + "64" -> DataModel._64BIT + else -> throw IllegalStateException() +} + +internal val pointerSize: Int = dataModel.pointerSize.toInt() + +object nativeMemUtils { + fun getByte(mem: NativePointed) = unsafe.getByte(mem.address) + fun putByte(mem: NativePointed, value: Byte) = unsafe.putByte(mem.address, value) + + fun getShort(mem: NativePointed) = unsafe.getShort(mem.address) + fun putShort(mem: NativePointed, value: Short) = unsafe.putShort(mem.address, value) + + fun getInt(mem: NativePointed) = unsafe.getInt(mem.address) + fun putInt(mem: NativePointed, value: Int) = unsafe.putInt(mem.address, value) + + fun getLong(mem: NativePointed) = unsafe.getLong(mem.address) + fun putLong(mem: NativePointed, value: Long) = unsafe.putLong(mem.address, value) + + fun getFloat(mem: NativePointed) = unsafe.getFloat(mem.address) + fun putFloat(mem: NativePointed, value: Float) = unsafe.putFloat(mem.address, value) + + fun getDouble(mem: NativePointed) = unsafe.getDouble(mem.address) + fun putDouble(mem: NativePointed, value: Double) = unsafe.putDouble(mem.address, value) + + fun getPtr(mem: NativePointed): NativePtr = when (dataModel) { + DataModel._32BIT -> getInt(mem).toLong() + DataModel._64BIT -> getLong(mem) + } + + fun putPtr(mem: NativePointed, value: NativePtr) = when (dataModel) { + DataModel._32BIT -> putInt(mem, value.toInt()) + DataModel._64BIT -> putLong(mem, value) + } + + internal class NativeAllocated(override val rawPtr: NativePtr) : NativePointed + + fun alloc(size: Long, align: Int): NativePointed { + val address = unsafe.allocateMemory(size) + if (address % align != 0L) TODO(align.toString()) + return interpretPointed(address) + } + + fun free(mem: NativePointed) { + unsafe.freeMemory(mem.rawPtr) + } + + private val unsafe = with(Unsafe::class.java.getDeclaredField("theUnsafe")) { + isAccessible = true + return@with this.get(null) as Unsafe + } +} \ No newline at end of file diff --git a/Interop/Runtime/src/jvm/kotlin/kotlin_/cinterop/JvmTypes.kt b/Interop/Runtime/src/jvm/kotlin/kotlin_/cinterop/JvmTypes.kt new file mode 100644 index 00000000000..ecf369bc997 --- /dev/null +++ b/Interop/Runtime/src/jvm/kotlin/kotlin_/cinterop/JvmTypes.kt @@ -0,0 +1,30 @@ +package kotlin_.cinterop + +import kotlin.reflect.companionObjectInstance +import kotlin.reflect.primaryConstructor + +typealias NativePtr = Long +val nativeNullPtr: NativePtr = 0L + +// TODO: the functions below should eventually be intrinsified + +inline fun CVariable.Type.Companion.of() = T::class.companionObjectInstance as CVariable.Type + +/** + * Returns interpretation of entity with given pointer. + * + * @param T must not be abstract + */ +inline fun interpretPointed(ptr: NativePtr): T { + return ensuringNotNull(ptr) { + val kClass = T::class + val primaryConstructor = kClass.primaryConstructor + if (primaryConstructor == null) { + throw IllegalArgumentException("${kClass.simpleName} doesn't have a constructor") + } + (primaryConstructor as (NativePtr) -> T)(ptr) + } +} + +inline fun > CAdaptedFunctionType.Companion.getInstanceOf(): T = + T::class.objectInstance!! \ No newline at end of file diff --git a/Interop/Runtime/src/main/kotlin/kotlin_/cinterop/Types.kt b/Interop/Runtime/src/main/kotlin/kotlin_/cinterop/Types.kt new file mode 100644 index 00000000000..ff3ec8e7b84 --- /dev/null +++ b/Interop/Runtime/src/main/kotlin/kotlin_/cinterop/Types.kt @@ -0,0 +1,331 @@ +package kotlin_.cinterop + +/** + * The entity which has an associated native pointer. + * Subtypes are supposed to represent interpretations of the pointed data or code. + * + * This interface is likely to be handled by compiler magic and shouldn't be subtyped by arbitrary classes. + */ +interface NativePointed { + val rawPtr: NativePtr +} + +// `null` value of `NativePointed?` is mapped to `nativeNullPtr`. +val NativePointed?.rawPtr: NativePtr + get() = this?.rawPtr ?: nativeNullPtr + +/** + * Returns interpretation of entity with given pointer, or `null` if it is null. + * + * @param T must not be abstract + */ +inline fun interpretNullablePointed(ptr: NativePtr): T? { + return ifNotNull(ptr) { + interpretPointed(it) + } +} + +/** + * Applies the function to the pointer if it is not null, otherwise returns `null`. + */ +inline fun ifNotNull(ptr: NativePtr, function: (NativePtr)->T): T? { + return if (ptr == nativeNullPtr) { + null + } else { + function(ptr) + } +} + +/** + * Applies the function to the pointer ensuring that it is not null. + */ +inline fun ensuringNotNull(ptr: NativePtr, function: (NativePtr)->T): T { + if (ptr == nativeNullPtr) { + throw IllegalArgumentException() + } else { + return function(ptr) + } +} + +/** + * Changes the interpretation of the pointed data or code. + */ +inline fun NativePointed.reinterpret(): T = interpretPointed(this.rawPtr) + +/** + * C data or code. + */ +interface CPointed : NativePointed + +/** + * C pointer. + */ +class CPointer private constructor(val rawValue: NativePtr) { + companion object { + fun create(rawValue: NativePtr) = ensuringNotNull(rawValue) { + CPointer(rawValue) + } + + fun createNullable(rawValue: NativePtr) = ifNotNull(rawValue) { + CPointer(it) + } + } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true // fast path + } + + return (other is CPointer<*>) && (rawValue == other.rawValue) + } + + override fun hashCode(): Int { + return rawValue.hashCode() + } + + override fun toString(): String { + val hex = "%x".format(rawValue) + return "CPointer(raw=0x$hex)" + } +} + +/** + * Returns the pointer to this data or code. + */ +val T.ptr: CPointer + get() = CPointer.create(this.rawPtr) + +/** + * Returns the corresponding [CPointed]. + * + * @param T must not be abstract + */ +inline val CPointer.pointed: T + get() = interpretPointed(this.rawValue) + +// `null` value of `CPointer?` is mapped to `nativeNullPtr` +val CPointer<*>?.rawValue: NativePtr + get() = this?.rawValue ?: nativeNullPtr + +fun CPointer<*>.reinterpret() = this as CPointer + +/** + * The [CPointed] without any specified interpretation. + */ +interface COpaque : CPointed // TODO: should it correspond to COpaquePointer? + +/** + * The pointer with an opaque type. + */ +typealias COpaquePointer = CPointer // FIXME + +/** + * The variable containing a [COpaquePointer]. + */ +typealias COpaquePointerVar = CPointerVarWithValueMappedTo + +/** + * The C data variable located in memory. + * + * The non-abstract subclasses should represent the (complete) C data type and thus specify size and alignment. + * Each such subclass must have a companion object which is a [Type]. + */ +interface CVariable : CPointed { + + /** + * The (complete) C data type. + * + * @param size the size in bytes of data of this type + * @param align the alignments in bytes that is enough for this data type. + * It may be greater than actually required for simplicity. + */ + open class Type(val size: Long, val align: Int) { + + init { + assert (size % align == 0L) + } + + companion object + } + + companion object { + inline fun sizeOf() = Type.of().size + inline fun alignOf() = Type.of().align + } +} + +/** + * The C data which is composed from number of members. + */ +interface CAggregate : CPointed + +/** + * Returns the member of this [CAggregate] which is located by given offset in bytes. + */ +inline fun CAggregate.memberAt(offset: Long): T { + return interpretPointed(this.rawPtr + offset) +} + +/** + * The C struct-typed variable located in memory. + */ +abstract class CStructVar : CVariable, CAggregate { + open class Type(size: Long, align: Int) : CVariable.Type(size, align) +} + +/** + * The C primitive-typed variable located in memory. + */ +sealed class CPrimitiveVar : CVariable { + // aligning by size is obviously enough + open class Type(size: Int, align: Int = size) : CVariable.Type(size.toLong(), align) +} + +abstract class CEnumVar : CPrimitiveVar() + +// generics below are used for typedef support +// these classes are not supposed to be used directly, instead the typealiases are provided. + +class CInt8VarWithValueMappedTo(override val rawPtr: NativePtr) : CPrimitiveVar() { + companion object : Type(1) +} + +class CInt16VarWithValueMappedTo(override val rawPtr: NativePtr) : CPrimitiveVar() { + companion object : Type(2) +} + +class CInt32VarWithValueMappedTo(override val rawPtr: NativePtr) : CPrimitiveVar() { + companion object : Type(4) +} + +class CInt64VarWithValueMappedTo(override val rawPtr: NativePtr) : CPrimitiveVar() { + companion object : Type(8) +} + +class CFloat32VarWithValueMappedTo(override val rawPtr: NativePtr) : CPrimitiveVar() { + companion object : Type(4) +} + +class CFloat64VarWithValueMappedTo(override val rawPtr: NativePtr) : CPrimitiveVar() { + companion object : Type(8) +} + +typealias CInt8Var = CInt8VarWithValueMappedTo +typealias CInt16Var = CInt16VarWithValueMappedTo +typealias CInt32Var = CInt32VarWithValueMappedTo +typealias CInt64Var = CInt64VarWithValueMappedTo +typealias CFloat32Var = CFloat32VarWithValueMappedTo +typealias CFloat64Var = CFloat64VarWithValueMappedTo + +var CInt8VarWithValueMappedTo.value: T + get() = nativeMemUtils.getByte(this) as T + set(value) = nativeMemUtils.putByte(this, value) + +var CInt16VarWithValueMappedTo.value: T + get() = nativeMemUtils.getShort(this) as T + set(value) = nativeMemUtils.putShort(this, value) + +var CInt32VarWithValueMappedTo.value: T + get() = nativeMemUtils.getInt(this) as T + set(value) = nativeMemUtils.putInt(this, value) + +var CInt64VarWithValueMappedTo.value: T + get() = nativeMemUtils.getLong(this) as T + set(value) = nativeMemUtils.putLong(this, value) + +// TODO: ensure native floats have the appropriate binary representation + +var CFloat32VarWithValueMappedTo.value: T + get() = nativeMemUtils.getFloat(this) as T + set(value) = nativeMemUtils.putFloat(this, value) + +var CFloat64VarWithValueMappedTo.value: T + get() = nativeMemUtils.getDouble(this) as T + set(value) = nativeMemUtils.putDouble(this, value) + + +class CPointerVarWithValueMappedTo>(override val rawPtr: NativePtr) : CVariable { + companion object : CVariable.Type(pointerSize.toLong(), pointerSize) +} + +/** + * The C data variable containing the pointer to `T`. + */ +typealias CPointerVar = CPointerVarWithValueMappedTo> + +/** + * The value of this variable. + */ +inline var > CPointerVarWithValueMappedTo

.value: P? + get() = CPointer.createNullable(nativeMemUtils.getPtr(this)) as P? + set(value) = nativeMemUtils.putPtr(this, value.rawValue) + +/** + * The code or data pointed by the value of this variable. + * + * @param T must not be abstract + */ +inline var > CPointerVarWithValueMappedTo

.pointed: T? + get() = this.value?.pointed + set(value) { + this.value = value?.ptr as P? + } + +class CArray(override val rawPtr: NativePtr) : CAggregate + +inline fun CArray.elementOffset(index: Long) = if (index == 0L) { + 0L // optimization for JVM impl which uses reflection for now. +} else { + index * CVariable.sizeOf() +} + +inline operator fun CArray.get(index: Long): T = memberAt(elementOffset(index)) +inline operator fun CArray.get(index: Int) = this.get(index.toLong()) + +/** + * The type of C function. + */ +interface CFunctionType + +/** + * The type of C function constructed from some Kotlin function, possibly using an adapter. + * The (non-abstract) implementation classes are supposed to be object declarations. + */ +interface CAdaptedFunctionType> : CFunctionType { + + /** + * Returns a raw pointer to C function of this type, which calls given Kotlin *static* function. + * + * This inconvenient method should not be used directly; use [staticCFunction] instead. + * + * @param function must be *static*, i.e. an (unbound) reference to a Kotlin function or + * a closure which doesn't capture any variable + */ + fun fromStatic(function: F): NativePtr + + companion object +} + +/** + * Returns a pointer to `T`-typed C function which calls given Kotlin *static* function. + * @see CAdaptedFunctionType.fromStatic + */ +inline fun , reified T : CAdaptedFunctionType> staticCFunction(body: F): CFunctionPointer { + val type = CAdaptedFunctionType.getInstanceOf() + return interpretPointed>(type.fromStatic(body)).ptr +} + +/** + * The C function. + */ +class CFunction(override val rawPtr: NativePtr) : CPointed + +/** + * The pointer to [CFunction]. + */ +typealias CFunctionPointer = CPointer> + +/** + * The variable containing a [CFunctionPointer]. + */ +typealias CFunctionPointerVar = CPointerVarWithValueMappedTo> \ No newline at end of file diff --git a/Interop/Runtime/src/main/kotlin/kotlin_/cinterop/Utils.kt b/Interop/Runtime/src/main/kotlin/kotlin_/cinterop/Utils.kt new file mode 100644 index 00000000000..f1a255c5e49 --- /dev/null +++ b/Interop/Runtime/src/main/kotlin/kotlin_/cinterop/Utils.kt @@ -0,0 +1,222 @@ +package kotlin_.cinterop + +interface NativePlacement { + + fun alloc(size: Long, align: Int): NativePointed + + fun alloc(size: Int, align: Int) = alloc(size.toLong(), align) +} + +interface NativeFreeablePlacement : NativePlacement { + fun free(mem: NativePointed) +} + +object nativeHeap : NativeFreeablePlacement { + override fun alloc(size: Long, align: Int) = nativeMemUtils.alloc(size, align) + + override fun free(mem: NativePointed) = nativeMemUtils.free(mem) +} + +// TODO: implement optimally +class Arena(private val parent: NativeFreeablePlacement = nativeHeap) : NativePlacement { + + private val allocatedChunks = mutableListOf() + + override fun alloc(size: Long, align: Int): NativePointed { + val res = nativeHeap.alloc(size, align) + try { + allocatedChunks.add(res) + return res + } catch (e: Throwable) { + nativeHeap.free(res) + throw e + } + } + + fun clear() { + allocatedChunks.forEach { + nativeHeap.free(it) + } + + allocatedChunks.clear() + } + +} + +fun NativePlacement.alloc(size: Int, align: Int) = alloc(size.toLong(), align) + +/** + * Allocates variable of given type. + * + * @param T must not be abstract + */ +inline fun NativePlacement.alloc(): T = + alloc(CVariable.sizeOf(), CVariable.alignOf()).reinterpret() + +/** + * Allocates C array of given elements type and length. + * + * @param T must not be abstract + */ +inline fun NativePlacement.allocArray(length: Long): CArray = + alloc(CVariable.sizeOf() * length, CVariable.alignOf()).reinterpret() + +/** + * Allocates C array of given elements type and length. + * + * @param T must not be abstract + */ +inline fun NativePlacement.allocArray(length: Int): CArray = + allocArray(length.toLong()) + +/** + * Allocates C array of given elements type and length, and initializes its elements applying given block. + * + * @param T must not be abstract + */ +inline fun NativePlacement.allocArray(length: Long, + initializer: T.(Long)->Unit): CArray { + val res = allocArray(length) + + (0 until length).forEach { + res[it].initializer(it) + } + + return res +} + +/** + * Allocates C array of given elements type and length, and initializes its elements applying given block. + * + * @param T must not be abstract + */ +inline fun NativePlacement.allocArray(length: Int, initializer: T.(Long)->Unit) = + allocArray(length.toLong(), initializer) + + +/** + * Allocates C array of pointers to given elements. + */ +fun NativePlacement.allocArrayOfPointersTo(elements: List): CArray> { + val res = allocArray>(elements.size) + elements.forEachIndexed { index, value -> + res[index].value = value?.ptr + } + return res +} + +/** + * Allocates C array of pointers to given elements. + */ +fun NativePlacement.allocArrayOfPointersTo(vararg elements: T?) = + allocArrayOfPointersTo(elements.toList()) + +/** + * Allocates C array of given values. + */ +inline fun > + NativePlacement.allocArrayOf(vararg elements: T?): CArray> { + + return allocArrayOf(elements.toList()) +} + +/** + * Allocates C array of given values. + */ +inline fun > + NativePlacement.allocArrayOf(elements: List): CArray> { + + val res = allocArray>(elements.size) + elements.forEachIndexed { index, value -> + res[index].value = value + } + + return res +} + +fun NativePlacement.allocArrayOf(elements: ByteArray): CArray { + val res = allocArray(elements.size) + elements.forEachIndexed { i, byte -> + res[i].value = byte + } + return res +} + +fun NativePlacement.allocPointerTo() = alloc>() + +/** + * The zero-terminated string. + */ +class CString private constructor(override val rawPtr: NativePtr) : CPointed { + + companion object { + fun fromArray(array: CArray) = CString(array.rawPtr) + } + + fun length(): Int { + val array = reinterpret>() + + var res = 0 + while (array[res].value != 0.toByte()) { + ++res + } + return res + } + + override fun toString(): String { + val array = reinterpret>() + + val bytes = ByteArray(this.length()) + bytes.forEachIndexed { i, byte -> + bytes[i] = array[i].value + } + return String(bytes) // TODO: encoding + } + + fun asCharPtr() = reinterpret() +} + +fun CString.Companion.fromString(str: String?, placement: NativePlacement): CString? { + if (str == null) { + return null + } + + val bytes = str.toByteArray() // TODO: encoding + val len = bytes.size + val nativeBytes = nativeHeap.allocArray(len + 1) + + bytes.forEachIndexed { i, byte -> + nativeBytes[i].value = byte + } + nativeBytes[len].value = 0 + + return CString.fromArray(nativeBytes) +} + +fun CPointer.asCString() = CString.fromArray(this.reinterpret>().pointed) +fun String.toCString(placement: NativePlacement) = CString.fromString(this, placement) + +class MemScope private constructor(private val arena: Arena) : NativePlacement by arena { + val memScope: NativePlacement + get() = this + + companion object { + internal inline fun use(block: MemScope.()->R): R { + val memScope = MemScope(Arena()) + try { + return memScope.block() + } finally { + memScope.arena.clear() + } + } + } +} + +/** + * Runs given [block] providing allocation of memory + * which will be automatically disposed at the end of this scope. + */ +inline fun memScoped(block: MemScope.()->R): R { + @Suppress("NON_PUBLIC_CALL_FROM_PUBLIC_INLINE") // TODO: it is a hack + return MemScope.use(block) +} \ No newline at end of file diff --git a/Interop/Runtime/src/main/kotlin/kotlin_/package-info.java b/Interop/Runtime/src/main/kotlin/kotlin_/package-info.java new file mode 100644 index 00000000000..8729a26605b --- /dev/null +++ b/Interop/Runtime/src/main/kotlin/kotlin_/package-info.java @@ -0,0 +1,4 @@ +/** + * TODO: rename to kotlin + */ +package kotlin_; \ No newline at end of file diff --git a/Interop/StubGenerator/src/main/kotlin/org/jetbrains/kotlin/native/interop/gen/jvm/StubGenerator.kt b/Interop/StubGenerator/src/main/kotlin/org/jetbrains/kotlin/native/interop/gen/jvm/StubGenerator.kt index 054f54db7d3..97e981b405b 100644 --- a/Interop/StubGenerator/src/main/kotlin/org/jetbrains/kotlin/native/interop/gen/jvm/StubGenerator.kt +++ b/Interop/StubGenerator/src/main/kotlin/org/jetbrains/kotlin/native/interop/gen/jvm/StubGenerator.kt @@ -72,7 +72,7 @@ class StubGenerator( val FunctionType.kotlinName: String get() { return usedFunctionTypes.getOrPut(this, { - "NativeFunctionType" + (usedFunctionTypes.size + 1) + "CFunctionType" + (usedFunctionTypes.size + 1) }) } @@ -156,6 +156,8 @@ class StubGenerator( this.def.spelling } + is Typedef -> this.def.name + else -> throw kotlin.NotImplementedError() } } @@ -173,55 +175,169 @@ class StubGenerator( } /** - * Describes the Kotlin native reference type - * - * @param typeName the name of the Kotlin native reference type - * @param typeExpr such Kotlin expression that `typeExpr(ptr)` constructs the reference of this type - * to the value located at `ptr` + * Describes the Kotlin types used to represent some C type. */ - class NativeRefType(val typeName: String, val typeExpr: String = typeName) + private sealed class TypeMirror(val pointedTypeName: String, val info: TypeInfo) { + /** + * Type to be used in bindings for argument or return value. + */ + abstract val argType: String + + /** + * Mirror for C type to be represented in Kotlin as by-value type. + */ + class ByValue(pointedTypeName: String, info: TypeInfo, val valueTypeName: String) : + TypeMirror(pointedTypeName, info) { + + override val argType: String + get() = valueTypeName + if (info is TypeInfo.Pointer) "?" else "" + } + + /** + * Mirror for C type to be represented in Kotlin as by-ref type. + */ + class ByRef(pointedTypeName: String, info: TypeInfo) : TypeMirror(pointedTypeName, info) { + override val argType: String + get() = pointedTypeName + } + } /** - * Returns the Kotlin type which describes the reference to value of given (C) type. + * Describes various type conversions for [TypeMirror]. */ - fun getKotlinTypeForRefTo(type: Type): NativeRefType = when (type) { - is Int8Type, is UInt8Type -> NativeRefType("Int8Box") - is Int16Type, is UInt16Type -> NativeRefType("Int16Box") - is Int32Type, is UInt32Type -> NativeRefType("Int32Box") - is IntPtrType, is UIntPtrType, // TODO: 64-bit specific - is Int64Type, is UInt64Type -> NativeRefType("Int64Box") + private sealed class TypeInfo { + /** + * The conversion from [TypeMirror.argType] to [jniType]. + */ + abstract fun argToJni(name: String): String - is RecordType -> NativeRefType("${type.kotlinName}") + /** + * The conversion from [jniType] to [TypeMirror.argType]. + */ + abstract fun argFromJni(name: String): String + + /** + * The type to be used for passing [TypeMirror.argType] through JNI. + */ + abstract val jniType: String + + /** + * If this info is for [TypeMirror.ByValue], then this method describes how to + * construct pointed-type from value type. + */ + abstract fun constructPointedType(valueType: String): String + + class Primitive(override val jniType: String, val varTypeName: String) : TypeInfo() { + + override fun argToJni(name: String) = name + override fun argFromJni(name: String) = name + + override fun constructPointedType(valueType: String) = "${varTypeName}WithValueMappedTo<$valueType>" + } + + class Enum(val className: String, val baseType: String) : TypeInfo() { + override fun argToJni(name: String) = "$name.value" + + override fun argFromJni(name: String) = "$className.byValue($name)" + + override val jniType: String + get() = baseType + + override fun constructPointedType(valueType: String) = "$className.Var" // TODO: improve + + } + + class Pointer(val pointee: String) : TypeInfo() { + override fun argToJni(name: String) = "$name.rawValue" + + override fun argFromJni(name: String) = "CPointer.createNullable<$pointee>($name)" + + override val jniType: String + get() = "Long" + + override fun constructPointedType(valueType: String) = "CPointerVarWithValueMappedTo<$valueType>" + } + + class ByRef(val pointed: String) : TypeInfo() { + override fun argToJni(name: String) = "$name.rawPtr" + + override fun argFromJni(name: String) = "interpretPointed<$pointed>($name)" + + override val jniType: String + get() = "Long" + + override fun constructPointedType(valueType: String): String { + // TODO: this method must not exist + throw UnsupportedOperationException() + } + } + } + + private fun mirror(type: PrimitiveType): TypeMirror { + val varTypeName = when (type) { + is Int8Type, is UInt8Type -> "CInt8Var" + is Int16Type, is UInt16Type -> "CInt16Var" + is Int32Type, is UInt32Type -> "CInt32Var" + is IntPtrType, is UIntPtrType, // TODO: 64-bit specific + is Int64Type, is UInt64Type -> "CInt64Var" + else -> TODO(type.toString()) + } + + val info = TypeInfo.Primitive(type.kotlinType, varTypeName) + return TypeMirror.ByValue(varTypeName, info, type.kotlinType) + } + + private fun byRefTypeMirror(pointedTypeName: String) : TypeMirror.ByRef { + val info = TypeInfo.ByRef(pointedTypeName) + return TypeMirror.ByRef(pointedTypeName, info) + } + + private fun mirror(type: Type): TypeMirror = when (type) { + is PrimitiveType -> mirror(type) + + is RecordType -> byRefTypeMirror(type.kotlinName) is EnumType -> if (type.isKotlinEnum) { - NativeRefType("${type.kotlinName}.ref") + val className = type.kotlinName + val info = TypeInfo.Enum(className, type.def.baseType.kotlinType) + TypeMirror.ByValue("$className.Var", info, className) } else { - getKotlinTypeForRefTo(type.def.baseType) + mirror(type.def.baseType) } is PointerType -> { val pointeeType = type.pointeeType if (pointeeType is VoidType) { - NativeRefType("NativePtrBox") + val info = TypeInfo.Pointer("COpaque") + TypeMirror.ByValue("COpaquePointerVar", info, "COpaquePointer") } else if (pointeeType is FunctionType) { - NativeRefType("NativeFunctionBox<${getKotlinFunctionType(pointeeType)}>", "${pointeeType.kotlinName}.ref") + val kotlinName = pointeeType.kotlinName + val info = TypeInfo.Pointer("CFunction<$kotlinName>") + TypeMirror.ByValue("CFunctionPointerVar<$kotlinName>", info, "CFunctionPointer<$kotlinName>") } else { - val pointeeRefType = getKotlinTypeForRefTo(pointeeType) - NativeRefType("RefBox<${pointeeRefType.typeName}>", "${pointeeRefType.typeExpr}.ref") + val pointeeMirror = mirror(pointeeType) + val info = TypeInfo.Pointer(pointeeMirror.pointedTypeName) + TypeMirror.ByValue("CPointerVar<${pointeeMirror.pointedTypeName}>", info, + "CPointer<${pointeeMirror.pointedTypeName}>") } } - is ConstArrayType -> { - val elemRefType = getKotlinTypeForRefTo(type.elemType) - NativeRefType("NativeArray<${elemRefType.typeName}>", "array[${type.length}](${elemRefType.typeExpr})") + is ArrayType -> { + val elemMirror = mirror(type.elemType) + byRefTypeMirror("CArray<${elemMirror.pointedTypeName}>") } - is IncompleteArrayType -> { - val elemRefType = getKotlinTypeForRefTo(type.elemType) - NativeRefType("NativeArray<${elemRefType.typeName}>", "array(${elemRefType.typeExpr})") + is Typedef -> { + val baseType = mirror(type.def.aliased) + val name = type.def.name + when (baseType) { + is TypeMirror.ByValue -> TypeMirror.ByValue("${name}Var", baseType.info, name) + is TypeMirror.ByRef -> TypeMirror.ByRef(name, baseType.info) + } + } - else -> throw NotImplementedError() + else -> TODO(type.toString()) } /** @@ -248,85 +364,36 @@ class StubGenerator( val conv: ((String) -> String) = { it }, val kotlinType: String = kotlinJniBridgeType) - /** - * Constructs [OutValueBinding] for the value represented by given native reference type in Kotlin. - */ - fun outValueRefBinding(refType: NativeRefType) = OutValueBinding( - kotlinType = refType.typeName + "?", - kotlinConv = { "$it.getNativePtr().asLong()" }, - kotlinJniBridgeType = "Long" - ) - - /** - * Constructs [InValueBinding] for the value represented by given native reference type in Kotlin. - */ - fun inValueRefBinding(refType: NativeRefType) = InValueBinding( - kotlinJniBridgeType = "Long", - conv = { "NativePtr.byValue($it).asRef(${refType.typeExpr})" }, - kotlinType = refType.typeName + "?" - ) - /** * Constructs [OutValueBinding] for the value of given C type. */ - fun getOutValueBinding(type: Type): OutValueBinding = when (type) { - - is PrimitiveType -> OutValueBinding(type.kotlinType) - - is PointerType -> { - if (type.pointeeType is VoidType || type.pointeeType is FunctionType) { - OutValueBinding( - kotlinType = "NativePtr?", - kotlinConv = { "$it.asLong()" }, - kotlinJniBridgeType = "Long" - ) - } else { - outValueRefBinding(getKotlinTypeForRefTo(type.pointeeType)) - } + fun getOutValueBinding(type: Type): OutValueBinding { + if (type is ArrayType) { + // array-typed C function argument or return value is actually a pointer to array. + return getOutValueBinding(PointerType(type)) } - is EnumType -> if (type.isKotlinEnum) { - OutValueBinding( - kotlinType = type.kotlinName, - kotlinConv = { "$it.value" }, - kotlinJniBridgeType = type.def.baseType.kotlinType - ) - } else { - getOutValueBinding(type.def.baseType) - } + val mirror = mirror(type) - is ArrayType -> outValueRefBinding(getKotlinTypeForRefTo(type)) - - else -> throw NotImplementedError() + return OutValueBinding( + kotlinType = mirror.argType, + kotlinConv = mirror.info::argToJni, + kotlinJniBridgeType = mirror.info.jniType + ) } fun getCFunctionParamBinding(type: Type): OutValueBinding { when (type) { is PointerType -> { - val pointeeType = type.pointeeType - when (pointeeType) { - is FunctionType -> return OutValueBinding( - kotlinType = "(" + getKotlinFunctionType(pointeeType) + ")?", - kotlinConv = { "$it?.staticAsNative(${pointeeType.kotlinName}).asLong()" }, - kotlinJniBridgeType = "Long" - ) + when (type.pointeeType) { is Int8Type -> return OutValueBinding( kotlinType = "String?", - kotlinConv = { name -> "$name?.toCString(memScope).getNativePtr().asLong()" }, + kotlinConv = { name -> "$name?.toCString(memScope).rawPtr" }, memScoped = true, kotlinJniBridgeType = "Long" ) } } - is RecordType -> { - val refType = getKotlinTypeForRefTo(type) - // pointer will be converted to value in C code - return OutValueBinding( - kotlinType = refType.typeName, - kotlinConv = { "$it.getNativePtr().asLong()" }, - kotlinJniBridgeType = "Long" - ) - } } return getOutValueBinding(type) @@ -347,65 +414,30 @@ class StubGenerator( /** * Constructs [InValueBinding] for the value of given C type. */ - fun getInValueBinding(type: Type): InValueBinding = when (type) { - - is PrimitiveType -> InValueBinding(type.kotlinType) - - is PointerType -> { - if (type.pointeeType is VoidType || type.pointeeType is FunctionType) { - InValueBinding( - kotlinJniBridgeType = "Long", - conv = { "NativePtr.byValue($it)" }, - kotlinType = "NativePtr?" - ) - } else { - inValueRefBinding(getKotlinTypeForRefTo(type.pointeeType)) - } + fun getInValueBinding(type: Type): InValueBinding { + if (type is ArrayType) { + // array-typed C function argument or return value is actually a pointer to array. + return getInValueBinding(PointerType(type)) } - is EnumType -> if (type.isKotlinEnum) { - InValueBinding( - kotlinJniBridgeType = type.def.baseType.kotlinType, - conv = { "${type.kotlinName}.byValue($it)" }, - kotlinType = type.kotlinName - ) - } else { - getInValueBinding(type.def.baseType) - } + val mirror = mirror(type) - is ArrayType -> inValueRefBinding(getKotlinTypeForRefTo(type)) - - else -> throw NotImplementedError() + return InValueBinding( + kotlinJniBridgeType = mirror.info.jniType, + conv = mirror.info::argFromJni, + kotlinType = mirror.argType + ) } fun getCFunctionRetValBinding(type: Type): InValueBinding { when (type) { is VoidType -> return InValueBinding("Unit") - - is RecordType -> { - val refType = getKotlinTypeForRefTo(type) - return InValueBinding( - kotlinJniBridgeType = "Long", - conv = { "NativePtr.byValue($it).asRef(${refType.typeExpr})!!" }, - kotlinType = refType.typeName - ) - } } return getInValueBinding(type) } fun getCallbackParamBinding(type: Type): InValueBinding { - when (type) { - is RecordType -> { - val refType = getKotlinTypeForRefTo(type) - return InValueBinding( - kotlinJniBridgeType = "Long", - conv = { throw UnsupportedOperationException() }, - kotlinType = refType.typeName - ) - } - } return getInValueBinding(type) } @@ -427,17 +459,19 @@ class StubGenerator( } val className = decl.kotlinName - block("class $className(ptr: NativePtr) : NativeStruct(ptr)") { + block("class $className(override val rawPtr: NativePtr) : CStructVar()") { out("") - out("companion object : Type<$className>(${def.size}, ::$className)") + out("companion object : Type(${def.size}, ${def.align})") // FIXME: align out("") def.fields.forEach { field -> try { if (field.offset < 0) throw NotImplementedError(); assert(field.offset % 8 == 0L) val offset = field.offset / 8 - val fieldRefType = getKotlinTypeForRefTo(field.type) - out("val ${field.name} by ${fieldRefType.typeExpr} at $offset") + val fieldRefType = mirror(field.type) + out("val ${field.name}: ${fieldRefType.pointedTypeName}") + out(" get() = memberAt($offset)") + out("") } catch (e: Throwable) { println("Warning: cannot generate definition for field $className.${field.name}") } @@ -450,9 +484,7 @@ class StubGenerator( */ private fun generateForwardStruct(s: StructDecl) { val className = s.kotlinName - block("class $className(ptr: NativePtr) : NativeRef(ptr)") { - out("companion object : Type<$className>(::$className)") - } + out("class $className(override val rawPtr: NativePtr) : COpaque") } /** @@ -464,7 +496,7 @@ class StubGenerator( return } - val baseRefType = getKotlinTypeForRefTo(e.baseType) + val baseTypeMirror = mirror(e.baseType) block("enum class ${e.kotlinName}(val value: ${e.baseType.kotlinType})") { e.values.forEach { @@ -476,11 +508,11 @@ class StubGenerator( out("fun byValue(value: ${e.baseType.kotlinType}) = ${e.kotlinName}.values().find { it.value == value }!!") } out("") - block("class ref(ptr: NativePtr) : NativeRef(ptr)") { - out("companion object : TypeWithSize(${baseRefType.typeExpr}.size, ::ref)") + block("class Var(override val rawPtr: NativePtr) : CEnumVar()") { + out("companion object : Type(${baseTypeMirror.pointedTypeName}.size.toInt())") out("var value: ${e.kotlinName}") - out(" get() = byValue(${baseRefType.typeExpr}.byPtr(ptr).value)") - out(" set(value) { ${baseRefType.typeExpr}.byPtr(ptr).value = value.value }") + out(" get() = byValue(this.reinterpret<${baseTypeMirror.pointedTypeName}>().value)") + out(" set(value) { this.reinterpret<${baseTypeMirror.pointedTypeName}>().value = value.value }") } } } @@ -504,6 +536,23 @@ class StubGenerator( } } + private fun generateTypedef(def: TypedefDef) { + val mirror = mirror(Typedef(def)) + val baseMirror = mirror(def.aliased) + + when (baseMirror) { + is TypeMirror.ByValue -> { + val name = def.name + val varTypeName = mirror.info.constructPointedType(name) + out("typealias ${mirror.pointedTypeName} = $varTypeName") + out("typealias ${(mirror as TypeMirror.ByValue).valueTypeName} = ${baseMirror.valueTypeName}") + } + is TypeMirror.ByRef -> { + out("typealias ${mirror.pointedTypeName} = ${baseMirror.pointedTypeName}") + } + } + } + /** * Constructs [InValueBinding] for return value of Kotlin binding for given C function. */ @@ -519,12 +568,11 @@ class StubGenerator( val retValType = func.returnType if (retValType is RecordType) { - val retValRefType = getKotlinTypeForRefTo(retValType) - val typeExpr = retValRefType.typeExpr + val retValMirror = mirror(retValType) paramBindings.add(OutValueBinding( - kotlinType = "Placement", - kotlinConv = { name -> "$name.alloc($typeExpr.size).asLong()" }, + kotlinType = "NativePlacement", + kotlinConv = { name -> "$name.alloc<${retValMirror.pointedTypeName}>().rawPtr" }, kotlinJniBridgeType = "Long" )) } @@ -653,13 +701,13 @@ class StubGenerator( val constructorArgsStr = constructorArgs.joinToString(", ") - block("object $name : NativeFunctionType<$kotlinFunctionType>($constructorArgsStr)") { - block("override fun invoke(function: $kotlinFunctionType, args: NativeArray, ret: NativePtr)") { + block("object $name : CAdaptedFunctionTypeImpl<$kotlinFunctionType>($constructorArgsStr)") { + block("override fun invoke(function: $kotlinFunctionType, args: CArray, ret: COpaquePointer)") { val args = type.parameterTypes.mapIndexed { i, paramType -> - val refType = getKotlinTypeForRefTo(paramType) - val ref = "args[$i].value.asRef(${refType.typeExpr})!!" + val pointedTypeName = mirror(paramType).pointedTypeName + val ref = "args[$i].value!!.reinterpret<$pointedTypeName>().pointed" when (paramType) { - is RecordType -> "$ref" + is RecordType -> ref else -> "$ref.value" } }.joinToString(", ") @@ -670,8 +718,8 @@ class StubGenerator( is RecordType -> throw NotImplementedError() is VoidType -> {} // nothing to do else -> { - val retRefType = getKotlinTypeForRefTo(type.returnType) - out("${retRefType.typeExpr}.byPtr(ret).value = res") + val pointedTypeName = mirror(type.returnType).pointedTypeName + out("ret.reinterpret<$pointedTypeName>().pointed.value = res") } } @@ -702,7 +750,7 @@ class StubGenerator( out("package $pkgName") out("") } - out("import kotlin_native.interop.*") + out("import kotlin_.cinterop.*") out("") functionsToBind.forEach { @@ -732,6 +780,17 @@ class StubGenerator( out("") } + nativeIndex.typedefs.forEach { t -> + try { + transaction { + generateTypedef(t) + out("") + } + } catch (e: Throwable) { + println("Warning: cannot generate typedef ${t.name}") + } + } + usedFunctionTypes.entries.forEach { generateFunctionType(it.key, it.value) out("") From 8a486d7fae2e958664c05087815cea56cb813459 Mon Sep 17 00:00:00 2001 From: Svyatoslav Scherbina Date: Tue, 22 Nov 2016 12:52:21 +0700 Subject: [PATCH 05/11] backend: partially port code to new interop --- .../backend/konan/llvm/CodeGenerator.kt | 7 ++- .../kotlin/backend/konan/llvm/Context.kt | 4 +- .../kotlin/backend/konan/llvm/ContextUtils.kt | 4 +- .../kotlin/backend/konan/llvm/DataLayout.kt | 2 +- .../kotlin/backend/konan/llvm/HashUtils.kt | 22 ++++---- .../kotlin/backend/konan/llvm/IrToBitcode.kt | 10 ++-- .../kotlin/backend/konan/llvm/LlvmUtils.kt | 54 +++++++++---------- .../kotlin/backend/konan/llvm/Logger.kt | 8 +-- .../backend/konan/llvm/MetadataGenerator.kt | 33 ++++++------ .../backend/konan/llvm/RTTIGenerator.kt | 5 +- .../kotlin/backend/konan/llvm/Runtime.kt | 22 ++++---- .../kotlin/backend/konan/llvm/hacks.kt | 11 ++++ 12 files changed, 91 insertions(+), 91 deletions(-) create mode 100644 backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/hacks.kt diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/CodeGenerator.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/CodeGenerator.kt index cb58c7d7554..7e77b66de05 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/CodeGenerator.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/CodeGenerator.kt @@ -1,7 +1,7 @@ package org.jetbrains.kotlin.backend.konan.llvm -import kotlin_native.interop.* +import kotlin_.cinterop.* import llvm.* import org.jetbrains.kotlin.descriptors.ClassConstructorDescriptor import org.jetbrains.kotlin.descriptors.ClassDescriptor @@ -118,9 +118,8 @@ internal class CodeGenerator(override val context:Context) : ContextUtils { fun call(llvmFunction: LLVMOpaqueValue?, args: List, result: String?): LLVMOpaqueValue? { if (args.size == 0) return LLVMBuildCall(context.llvmBuilder, llvmFunction, null, 0, result) memScoped { - val rargs = alloc(array[args.size](Ref to LLVMOpaqueValue)) - args.forEachIndexed { i, llvmOpaqueValue -> rargs[i].value = args[i] } - return LLVMBuildCall(context.llvmBuilder, llvmFunction, rargs[0], args.size, result) + val rargs = allocArrayOf(args) + return LLVMBuildCall(context.llvmBuilder, llvmFunction, rargs[0].ptr, args.size, result) } } diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/Context.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/Context.kt index c6c61b57756..63824c7eb3f 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/Context.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/Context.kt @@ -4,12 +4,12 @@ import llvm.* import org.jetbrains.kotlin.backend.konan.ModuleIndex import org.jetbrains.kotlin.ir.declarations.IrModuleFragment -internal class Context(val irModule: IrModuleFragment, val runtime: Runtime, val llvmModule: LLVMOpaqueModule) { +internal class Context(val irModule: IrModuleFragment, val runtime: Runtime, val llvmModule: LLVMModuleRef) { val moduleIndex = ModuleIndex(irModule) val llvmBuilder = LLVMCreateBuilder() - private fun importFunction(name: String, otherModule: LLVMOpaqueModule): LLVMOpaqueValue { + private fun importFunction(name: String, otherModule: LLVMModuleRef): LLVMValueRef { if (LLVMGetNamedFunction(llvmModule, name) != null) { throw IllegalArgumentException("function $name already exists") } diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/ContextUtils.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/ContextUtils.kt index 9fd1b3650e7..1b870f6b58c 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/ContextUtils.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/ContextUtils.kt @@ -1,6 +1,6 @@ package org.jetbrains.kotlin.backend.konan.llvm -import kotlin_native.interop.* +import kotlin_.cinterop.* import llvm.* import org.jetbrains.kotlin.backend.konan.hash.GlobalHash import org.jetbrains.kotlin.descriptors.ClassDescriptor @@ -22,7 +22,7 @@ internal interface ContextUtils { val runtime: Runtime get() = context.runtime - val llvmTargetData: LLVMOpaqueTargetData + val llvmTargetData: LLVMTargetDataRef get() = runtime.targetData val staticData: StaticData diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/DataLayout.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/DataLayout.kt index 57fd099fbb6..64ee7c19a40 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/DataLayout.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/DataLayout.kt @@ -4,7 +4,7 @@ import llvm.* import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.types.KotlinType -internal fun getLLVMType(type: KotlinType): LLVMOpaqueType { +internal fun getLLVMType(type: KotlinType): LLVMTypeRef { return when { KotlinBuiltIns.isBoolean(type) -> LLVMInt1Type() KotlinBuiltIns.isByte(type) -> LLVMInt8Type() diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/HashUtils.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/HashUtils.kt index 72a83d26c32..c1b4f3e99df 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/HashUtils.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/HashUtils.kt @@ -1,22 +1,22 @@ package org.jetbrains.kotlin.backend.konan.llvm -import kotlin_native.interop.* +import kotlin_.cinterop.* import org.jetbrains.kotlin.backend.konan.hash.* internal fun localHash(data: ByteArray): Long { memScoped { - val hashBox = alloc(Int64Box) - val bytes = allocNativeArrayOf(data) - MakeLocalHash(bytes.ptr, data.size, hashBox) - return hashBox.value + val res = alloc() + val bytes = allocArrayOf(data) + MakeLocalHash(bytes[0].ptr, data.size, res.ptr) + return res.value } } -internal fun globalHash(data: ByteArray, retValPlacement: Placement): GlobalHash { - val res = retValPlacement.alloc(GlobalHash) +internal fun globalHash(data: ByteArray, retValPlacement: NativePlacement): GlobalHash { + val res = retValPlacement.alloc() memScoped { - val bytes = allocNativeArrayOf(data) - MakeGlobalHash(bytes.ptr, data.size, res) + val bytes = allocArrayOf(data) + MakeGlobalHash(bytes[0].ptr, data.size, res.ptr) } return res } @@ -24,8 +24,8 @@ internal fun globalHash(data: ByteArray, retValPlacement: Placement): GlobalHash internal fun base64Encode(data: ByteArray): String { memScoped { val resultSize = 4 * data.size / 3 + 3 + 1 - val result = alloc(NativeArray of Int8Box length resultSize) - val bytes = allocNativeArrayOf(data) + val result = allocArray(resultSize) + val bytes = allocArrayOf(data) Base64Encode(bytes.ptr, data.size, result.ptr, resultSize) // TODO: any better way to do that without two copies? return CString.fromArray(result).toString() diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/IrToBitcode.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/IrToBitcode.kt index 4b767885513..964f1a6f291 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/IrToBitcode.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/IrToBitcode.kt @@ -1,6 +1,6 @@ package org.jetbrains.kotlin.backend.konan.llvm -import kotlin_native.interop.* +import kotlin_.cinterop.* import llvm.* import org.jetbrains.kotlin.backend.konan.* import org.jetbrains.kotlin.builtins.KotlinBuiltIns @@ -36,10 +36,10 @@ fun emitLLVM(module: IrModuleFragment, runtimeFile: String, outFile: String) { println("\n--- Generate bitcode ------------------------------------------------------\n") module.acceptVoid(CodeGeneratorVisitor(context)) memScoped { - val errorRef = alloc(Int8Box.ref) + val errorRef = allocPointerTo() // TODO: use LLVMDisposeMessage() on errorRef, once possible in interop. if (LLVMVerifyModule( - llvmModule, LLVMVerifierFailureAction.LLVMPrintMessageAction, errorRef) == 1) { + llvmModule, LLVMVerifierFailureAction.LLVMPrintMessageAction, errorRef.ptr) == 1) { LLVMDumpModule(llvmModule) throw Error("Invalid module"); } @@ -532,8 +532,8 @@ internal class CodeGeneratorVisitor(val context: Context) : IrElementVisitorVoid val objHeaderPtr = codegen.bitcast(kObjHeaderPtr, thisPtr, codegen.newVar()) val typePtr = pointerType(codegen.classType(value.containingDeclaration as ClassDescriptor)) memScoped { - val args = allocNativeArrayOf(LLVMOpaqueValue, kImmOne) - val objectPtr = LLVMBuildGEP(codegen.context.llvmBuilder, objHeaderPtr, args[0], 1, codegen.newVar()) + val args = allocArrayOf(kImmOne) + val objectPtr = LLVMBuildGEP(codegen.context.llvmBuilder, objHeaderPtr, args[0].ptr, 1, codegen.newVar()) val typedObjPtr = codegen.bitcast(typePtr, objectPtr!!, codegen.newVar()) val fieldPtr = LLVMBuildStructGEP(codegen.context.llvmBuilder, typedObjPtr, codegen.indexInClass(value), codegen.newVar()) return fieldPtr diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/LlvmUtils.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/LlvmUtils.kt index f754974c101..d10721d3922 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/LlvmUtils.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/LlvmUtils.kt @@ -1,6 +1,6 @@ package org.jetbrains.kotlin.backend.konan.llvm -import kotlin_native.interop.* +import kotlin_.cinterop.* import llvm.* import org.jetbrains.kotlin.descriptors.ClassConstructorDescriptor import org.jetbrains.kotlin.descriptors.FunctionDescriptor @@ -11,9 +11,9 @@ import org.jetbrains.kotlin.utils.singletonOrEmptyList */ internal interface ConstValue { - fun getLlvmValue(): LLVMOpaqueValue? + fun getLlvmValue(): LLVMValueRef? - fun getLlvmType(): LLVMOpaqueType { + fun getLlvmType(): LLVMTypeRef { return LLVMTypeOf(getLlvmValue())!! } @@ -23,45 +23,45 @@ internal interface ConstPointer : ConstValue { fun getElementPtr(index: Int): ConstPointer = ConstGetElementPtr(this, index) } -internal fun constPointer(value: LLVMOpaqueValue?) = object : ConstPointer { +internal fun constPointer(value: LLVMValueRef?) = object : ConstPointer { override fun getLlvmValue() = value } private class ConstGetElementPtr(val pointer: ConstPointer, val index: Int) : ConstPointer { - override fun getLlvmValue(): LLVMOpaqueValue? { + override fun getLlvmValue(): LLVMValueRef? { // TODO: probably it should be computed once when initialized? // TODO: squash multiple GEPs val indices = intArrayOf(0, index).map { Int32(it).getLlvmValue() } memScoped { - val indicesArray = allocNativeArrayOf(LLVMOpaqueValue, indices) - return LLVMConstInBoundsGEP(pointer.getLlvmValue(), indicesArray[0], indices.size) + val indicesArray = allocArrayOf(indices) + return LLVMConstInBoundsGEP(pointer.getLlvmValue(), indicesArray[0].ptr, indices.size) } } } -internal fun ConstPointer.bitcast(toType: LLVMOpaqueType) = constPointer(LLVMConstBitCast(this.getLlvmValue(), toType)) +internal fun ConstPointer.bitcast(toType: LLVMTypeRef) = constPointer(LLVMConstBitCast(this.getLlvmValue(), toType)) -internal class ConstArray(val elemType: LLVMOpaqueType?, val elements: List) : ConstValue { +internal class ConstArray(val elemType: LLVMTypeRef?, val elements: List) : ConstValue { - override fun getLlvmValue(): LLVMOpaqueValue? { + override fun getLlvmValue(): LLVMValueRef? { val values = elements.map { it.getLlvmValue() }.toTypedArray() memScoped { - val valuesNativeArrayPtr = allocNativeArrayOf(LLVMOpaqueValue, *values)[0] + val valuesNativeArrayPtr = allocArrayOf(*values)[0].ptr return LLVMConstArray(elemType, valuesNativeArrayPtr, values.size) } } } -internal open class Struct(val type: LLVMOpaqueType?, val elements: List) : ConstValue { +internal open class Struct(val type: LLVMTypeRef?, val elements: List) : ConstValue { - constructor(type: LLVMOpaqueType?, vararg elements: ConstValue) : this(type, elements.toList()) + constructor(type: LLVMTypeRef?, vararg elements: ConstValue) : this(type, elements.toList()) - override fun getLlvmValue(): LLVMOpaqueValue? { + override fun getLlvmValue(): LLVMValueRef? { val values = elements.map { it.getLlvmValue() }.toTypedArray() memScoped { - val valuesNativeArrayPtr = allocNativeArrayOf(LLVMOpaqueValue, *values)[0] + val valuesNativeArrayPtr = allocArrayOf(*values)[0].ptr return LLVMConstNamedStruct(type, valuesNativeArrayPtr, values.size) } } @@ -79,43 +79,43 @@ internal class Int64(val value: Long) : ConstValue { override fun getLlvmValue() = LLVMConstInt(LLVMInt64Type(), value, 1) } -internal class Zero(val type: LLVMOpaqueType?) : ConstValue { +internal class Zero(val type: LLVMTypeRef?) : ConstValue { override fun getLlvmValue() = LLVMConstNull(type) } -internal class NullPointer(val pointeeType: LLVMOpaqueType?): ConstPointer { +internal class NullPointer(val pointeeType: LLVMTypeRef?): ConstPointer { override fun getLlvmValue() = LLVMConstNull(pointerType(pointeeType)) } -internal fun constValue(value: LLVMOpaqueValue?) = object : ConstValue { +internal fun constValue(value: LLVMValueRef?) = object : ConstValue { override fun getLlvmValue() = value } internal val int8Type = LLVMInt8Type() internal val int32Type = LLVMInt32Type() -internal fun pointerType(pointeeType: LLVMOpaqueType?) = LLVMPointerType(pointeeType, 0) +internal fun pointerType(pointeeType: LLVMTypeRef?) = LLVMPointerType(pointeeType, 0) -internal fun structType(vararg types: LLVMOpaqueType?): LLVMOpaqueType = memScoped { - LLVMStructType(allocNativeArrayOf(LLVMOpaqueType, *types)[0], types.size, 0)!! +internal fun structType(vararg types: LLVMTypeRef?): LLVMTypeRef = memScoped { + LLVMStructType(allocArrayOf(*types)[0].ptr, types.size, 0)!! } -internal fun getLlvmFunctionType(function: FunctionDescriptor): LLVMOpaqueType? { +internal fun getLlvmFunctionType(function: FunctionDescriptor): LLVMTypeRef? { val returnType = getLLVMType(function.returnType!!) val params = function.dispatchReceiverParameter.singletonOrEmptyList() + function.extensionReceiverParameter.singletonOrEmptyList() + function.valueParameters - var extraParam = listOf() + var extraParam = listOf() if (function is ClassConstructorDescriptor) { extraParam += pointerType(LLVMInt8Type()) } - val paramTypes:List = params.map { getLLVMType(it.type) } + val paramTypes:List = params.map { getLLVMType(it.type) } extraParam += paramTypes if (extraParam.size == 0) return LLVMFunctionType(returnType, null, 0, 0) memScoped { - val paramTypesPtr = allocNativeArrayOf(LLVMOpaqueType, *extraParam.toTypedArray())[0] // TODO: dispose + val paramTypesPtr = allocArrayOf(extraParam)[0].ptr return LLVMFunctionType(returnType, paramTypesPtr, extraParam.size, 0) } } @@ -123,10 +123,10 @@ internal fun getLlvmFunctionType(function: FunctionDescriptor): LLVMOpaqueType? /** * Reads [size] bytes contained in this array. */ -internal fun NativeArray.getBytes(size: Int) = +internal fun CArray.getBytes(size: Long) = (0 .. size-1).map { this[it].value }.toByteArray() -internal fun getFunctionType(ptrToFunction: LLVMOpaqueValue?): LLVMOpaqueType { +internal fun getFunctionType(ptrToFunction: LLVMValueRef?): LLVMTypeRef { val typeOfPtrToFunction = LLVMTypeOf(ptrToFunction) return LLVMGetElementType(typeOfPtrToFunction)!! } diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/Logger.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/Logger.kt index 9ebc2065306..68d30c2bd31 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/Logger.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/Logger.kt @@ -1,11 +1,7 @@ package org.jetbrains.kotlin.backend.konan.llvm -import kotlin_native.interop.asCString -import llvm.LLVMPrintModuleToString -import llvm.LLVMPrintValueToString -import llvm.LLVMOpaqueValue -import org.jetbrains.kotlin.backend.konan.llvm.Context -import org.jetbrains.kotlin.backend.konan.llvm.ContextUtils +import kotlin_.cinterop.* +import llvm.* import org.jetbrains.kotlin.ir.IrElement import org.jetbrains.kotlin.ir.util.DumpIrTreeVisitor import java.io.StringWriter diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/MetadataGenerator.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/MetadataGenerator.kt index d2147b9755a..e4921051b5a 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/MetadataGenerator.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/MetadataGenerator.kt @@ -1,7 +1,7 @@ package org.jetbrains.kotlin.backend.konan.llvm -import kotlin_native.interop.* +import kotlin_.cinterop.* import llvm.* import org.jetbrains.kotlin.ir.declarations.IrFunction import org.jetbrains.kotlin.ir.declarations.IrModuleFragment @@ -33,21 +33,21 @@ fun readModuleMetadata(file: File): String { class MetadataReader(file: File) { - lateinit var llvmModule: LLVMOpaqueModule - lateinit var llvmContext: LLVMOpaqueContext + lateinit var llvmModule: LLVMModuleRef + lateinit var llvmContext: LLVMContextRef init { memScoped { - val bufRef = alloc(LLVMOpaqueMemoryBuffer.ref) - val errorRef = alloc(Int8Box.ref) - val res = LLVMCreateMemoryBufferWithContentsOfFile(file.toString(), bufRef, errorRef) + val bufRef = alloc() + val errorRef = allocPointerTo() + val res = LLVMCreateMemoryBufferWithContentsOfFile(file.toString(), bufRef.ptr, errorRef.ptr) if (res != 0) { throw Error(errorRef.value?.asCString()?.toString()) } llvmContext = LLVMContextCreate()!! - val moduleRef = alloc(LLVMOpaqueModule.ref) - val parseResult = LLVMParseBitcodeInContext2(llvmContext, bufRef.value, moduleRef) + val moduleRef = alloc() + val parseResult = LLVMParseBitcodeInContext2(llvmContext, bufRef.value, moduleRef.ptr) if (parseResult != 0) { throw Error(parseResult.toString()) } @@ -59,8 +59,8 @@ class MetadataReader(file: File) { fun string(node: LLVMOpaqueValue): String { memScoped { - val len = alloc(Int32Box) - val str1 = LLVMGetMDString(node, len)!! + val len = alloc() + val str1 = LLVMGetMDString(node, len.ptr)!! val str = str1.asCString().toString() return str @@ -70,9 +70,9 @@ class MetadataReader(file: File) { fun namedMetadataNode(name: String, index: Int): LLVMOpaqueValue { memScoped { val nodeCount = LLVMGetNamedMetadataNumOperands(llvmModule, "kmetadata")!! - val nodeArray = alloc(array[nodeCount](Ref to LLVMOpaqueValue)) + val nodeArray = allocArray(nodeCount) - LLVMGetNamedMetadataOperands(llvmModule, "kmetadata", nodeArray[0])!! + LLVMGetNamedMetadataOperands(llvmModule, "kmetadata", nodeArray[0].ptr)!! return nodeArray[0].value!! } @@ -81,9 +81,9 @@ class MetadataReader(file: File) { fun metadataOperand(metadataNode: LLVMOpaqueValue, index: Int): LLVMOpaqueValue { memScoped { val operandCount = LLVMGetMDNodeNumOperands(metadataNode)!! - val operandArray = alloc(array[operandCount](Ref to LLVMOpaqueValue)) + val operandArray = allocArray(operandCount) - LLVMGetMDNodeOperands(metadataNode, operandArray[0])!! + LLVMGetMDNodeOperands(metadataNode, operandArray[0].ptr)!! return operandArray[0].value!! } @@ -104,9 +104,8 @@ internal class MetadataGenerator(override val context: Context): ContextUtils { private fun metadataNode(args: List): LLVMOpaqueValue { memScoped { - val references = alloc(array[args.size](Ref to LLVMOpaqueValue)) - args.forEachIndexed { i, llvmOpaqueValue -> references[i].value = args[i]} - return LLVMMDNode(references[0], args.size)!! + val references = allocArrayOf(args) + return LLVMMDNode(references[0].ptr, args.size)!! } } diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/RTTIGenerator.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/RTTIGenerator.kt index b5c4db8fc56..37d3898e950 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/RTTIGenerator.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/RTTIGenerator.kt @@ -1,8 +1,7 @@ package org.jetbrains.kotlin.backend.konan.llvm -import kotlin_native.interop.allocNativeArrayOf -import kotlin_native.interop.memScoped +import kotlin_.cinterop.* import llvm.* import org.jetbrains.kotlin.backend.konan.implementation import org.jetbrains.kotlin.backend.konan.implementedInterfaces @@ -66,7 +65,7 @@ internal class RTTIGenerator(override val context: Context) : ContextUtils { memScoped { val fieldTypesNativeArrayPtr = if (fieldTypes.size > 0) { - allocNativeArrayOf(LLVMOpaqueType, *fieldTypes)[0] + allocArrayOf(*fieldTypes)[0].ptr } else { null } diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/Runtime.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/Runtime.kt index ff6916fdbb6..e1bca6c09a5 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/Runtime.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/Runtime.kt @@ -1,32 +1,28 @@ package org.jetbrains.kotlin.backend.konan.llvm -import kotlin_native.interop.* +import kotlin_.cinterop.* import llvm.* class Runtime(private val bitcodeFile: String) { - val llvmModule: LLVMOpaqueModule + val llvmModule: LLVMModuleRef init { - val arena = Arena() - try { + llvmModule = memScoped { - val bufRef = arena.alloc(LLVMOpaqueMemoryBuffer.ref) - val errorRef = arena.alloc(Int8Box.ref) - val res = LLVMCreateMemoryBufferWithContentsOfFile(bitcodeFile, bufRef, errorRef) + val bufRef = allocPointerTo() + val errorRef = allocPointerTo() + val res = LLVMCreateMemoryBufferWithContentsOfFile(bitcodeFile, bufRef.ptr, errorRef.ptr) if (res != 0) { throw Error(errorRef.value?.asCString()?.toString()) } - val moduleRef = arena.alloc(LLVMOpaqueModule.ref) - val parseRes = LLVMParseBitcode2(bufRef.value, moduleRef) + val moduleRef = alloc() + val parseRes = LLVMParseBitcode2(bufRef.value, moduleRef.ptr) if (parseRes != 0) { throw Error(parseRes.toString()) } - llvmModule = moduleRef.value!! - - } finally { - arena.clear() + moduleRef.value!! } } diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/hacks.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/hacks.kt new file mode 100644 index 00000000000..61ae7f895cc --- /dev/null +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/hacks.kt @@ -0,0 +1,11 @@ +package org.jetbrains.kotlin.backend.konan.llvm + +import kotlin_.cinterop.CPointer +import kotlin_.cinterop.CPointerVarWithValueMappedTo + +// TODO: the definitions below are required to perform smooth migration to new interop; +// remove after replacing with LLVM*Ref typedefs + +typealias LLVMOpaqueValue = CPointer +typealias LLVMOpaqueType = CPointer +typealias LLVMOpaqueBasicBlock = CPointer From c5f00c3301dd0e2b407e5ab91eb4c655fd82087c Mon Sep 17 00:00:00 2001 From: Svyatoslav Scherbina Date: Tue, 22 Nov 2016 13:18:49 +0700 Subject: [PATCH 06/11] InteropExample: port to new interop --- InteropExample/src/main/kotlin/main.kt | 31 ++++++++++++-------------- 1 file changed, 14 insertions(+), 17 deletions(-) diff --git a/InteropExample/src/main/kotlin/main.kt b/InteropExample/src/main/kotlin/main.kt index 9a0c14a55e3..a617122187a 100644 --- a/InteropExample/src/main/kotlin/main.kt +++ b/InteropExample/src/main/kotlin/main.kt @@ -1,13 +1,12 @@ -import kotlin_native.interop.* +import kotlin_.cinterop.* import llvm.* -fun main(args: Array) { +fun main(args: Array) = memScoped { val module = LLVMModuleCreateWithName("module") - println("module=" + module.getNativePtr().asLong()) + println("module=" + module.rawValue) - val paramTypes = mallocNativeArrayOf(LLVMOpaqueType, LLVMInt32Type(), LLVMInt32Type()) - val retType = LLVMFunctionType(LLVMInt32Type(), paramTypes[0], 2, 0) - free(paramTypes) + val paramTypes = allocArrayOf(LLVMInt32Type(), LLVMInt32Type()) + val retType = LLVMFunctionType(LLVMInt32Type(), paramTypes[0].ptr, 2, 0) val sum = LLVMAddFunction(module, "sum", retType) val entry = LLVMAppendBasicBlock(sum, "entry") @@ -15,34 +14,32 @@ fun main(args: Array) { LLVMPositionBuilderAtEnd(builder, entry) val tmp = LLVMBuildAdd(builder, LLVMGetParam(sum, 0), LLVMGetParam(sum, 1), "tmp") LLVMBuildRet(builder, tmp) - val engineRef = malloc(Ref to LLVMOpaqueExecutionEngine) - val errorRef = malloc(Ref to Int8Box) + val engineRef = alloc() + val errorRef = allocPointerTo() LLVMInitializeNativeTarget() errorRef.value = null - if (LLVMCreateExecutionEngineForModule(engineRef, module, errorRef) != 0) { + if (LLVMCreateExecutionEngineForModule(engineRef.ptr, module, errorRef.ptr) != 0) { println("failed to create execution engine") return } val error = errorRef.value if (error != null) { - println(CString.fromArray(NativeArray.byRefToFirstElem(error, Int8Box)).toString()) + println(error.asCString().toString()) return } println(LLVMGetTypeKind(LLVMInt32Type())) val x = 5L val y = 6L - val args = malloc(array[2](Ref to LLVMOpaqueGenericValue)) - args[0].value = LLVMCreateGenericValueOfInt(LLVMInt32Type(), x, 0) - args[1].value = LLVMCreateGenericValueOfInt(LLVMInt32Type(), y, 0) - val runRes = LLVMRunFunction(engineRef.value, sum, 2, args[0]) + val args = allocArrayOf( + LLVMCreateGenericValueOfInt(LLVMInt32Type(), x, 0), + LLVMCreateGenericValueOfInt(LLVMInt32Type(), y, 0)) + + val runRes = LLVMRunFunction(engineRef.value, sum, 2, args[0].ptr) println(LLVMGenericValueToInt(runRes, 0)) if (LLVMWriteBitcodeToFile(module, "/tmp/sum.bc") != 0) { println("error writing bitcode to file, skipping") } LLVMDisposeBuilder(builder) LLVMDisposeExecutionEngine(engineRef.value) - - - } \ No newline at end of file From 183f6a6d2fdfcd732519b855a4ae442282bfac13 Mon Sep 17 00:00:00 2001 From: Svyatoslav Scherbina Date: Tue, 22 Nov 2016 12:54:25 +0700 Subject: [PATCH 07/11] Interop/Indexer: update prebuilts with new interop versions also port Interop/Runtime/libcallbacks to new interop --- .../nativeInteropStubs/kotlin/clang/Clang.kt | 3418 ++++++++++------- .../kotlin/native/interop/indexer/Indexer.kt | 43 +- Interop/Runtime/src/callbacks/c/callbacks.c | 66 +- 3 files changed, 2037 insertions(+), 1490 deletions(-) diff --git a/Interop/Indexer/prebuilt/nativeInteropStubs/kotlin/clang/Clang.kt b/Interop/Indexer/prebuilt/nativeInteropStubs/kotlin/clang/Clang.kt index 03d658f40de..ffbef74fc09 100644 --- a/Interop/Indexer/prebuilt/nativeInteropStubs/kotlin/clang/Clang.kt +++ b/Interop/Indexer/prebuilt/nativeInteropStubs/kotlin/clang/Clang.kt @@ -1,71 +1,73 @@ package clang -import kotlin_native.interop.* +import kotlin_.cinterop.* -fun asctime(arg0: tm?): Int8Box? { - val _arg0 = arg0.getNativePtr().asLong() +fun asctime(arg0: CPointer?): CPointer? { + val _arg0 = arg0.rawValue val res = externals.asctime(_arg0) - return NativePtr.byValue(res).asRef(Int8Box) + return CPointer.createNullable(res) } -fun clock(): Long { +fun clock(): clock_t { val res = externals.clock() return res } -fun ctime(arg0: Int64Box?): Int8Box? { - val _arg0 = arg0.getNativePtr().asLong() +fun ctime(arg0: CPointer?): CPointer? { + val _arg0 = arg0.rawValue val res = externals.ctime(_arg0) - return NativePtr.byValue(res).asRef(Int8Box) + return CPointer.createNullable(res) } -fun getdate(arg0: String?): tm? { - val _arg0 = CString.fromString(arg0).getNativePtr().asLong() - val res = externals.getdate(_arg0) - free(NativePtr.byValue(_arg0)) - return NativePtr.byValue(res).asRef(tm) +fun getdate(arg0: String?): CPointer? { + memScoped { + val _arg0 = arg0?.toCString(memScope).rawPtr + val res = externals.getdate(_arg0) + return CPointer.createNullable(res) + } } -fun gmtime(arg0: Int64Box?): tm? { - val _arg0 = arg0.getNativePtr().asLong() +fun gmtime(arg0: CPointer?): CPointer? { + val _arg0 = arg0.rawValue val res = externals.gmtime(_arg0) - return NativePtr.byValue(res).asRef(tm) + return CPointer.createNullable(res) } -fun localtime(arg0: Int64Box?): tm? { - val _arg0 = arg0.getNativePtr().asLong() +fun localtime(arg0: CPointer?): CPointer? { + val _arg0 = arg0.rawValue val res = externals.localtime(_arg0) - return NativePtr.byValue(res).asRef(tm) + return CPointer.createNullable(res) } -fun mktime(arg0: tm?): Long { - val _arg0 = arg0.getNativePtr().asLong() +fun mktime(arg0: CPointer?): time_t { + val _arg0 = arg0.rawValue val res = externals.mktime(_arg0) return res } -fun strftime(arg0: String?, arg1: Long, arg2: String?, arg3: tm?): Long { - val _arg0 = CString.fromString(arg0).getNativePtr().asLong() - val _arg2 = CString.fromString(arg2).getNativePtr().asLong() - val _arg3 = arg3.getNativePtr().asLong() - val res = externals.strftime(_arg0, arg1, _arg2, _arg3) - free(NativePtr.byValue(_arg0)) - free(NativePtr.byValue(_arg2)) - return res +fun strftime(arg0: String?, arg1: size_t, arg2: String?, arg3: CPointer?): size_t { + memScoped { + val _arg0 = arg0?.toCString(memScope).rawPtr + val _arg1 = arg1 + val _arg2 = arg2?.toCString(memScope).rawPtr + val _arg3 = arg3.rawValue + val res = externals.strftime(_arg0, _arg1, _arg2, _arg3) + return res + } } -fun strptime(arg0: String?, arg1: String?, arg2: tm?): Int8Box? { - val _arg0 = CString.fromString(arg0).getNativePtr().asLong() - val _arg1 = CString.fromString(arg1).getNativePtr().asLong() - val _arg2 = arg2.getNativePtr().asLong() - val res = externals.strptime(_arg0, _arg1, _arg2) - free(NativePtr.byValue(_arg0)) - free(NativePtr.byValue(_arg1)) - return NativePtr.byValue(res).asRef(Int8Box) +fun strptime(arg0: String?, arg1: String?, arg2: CPointer?): CPointer? { + memScoped { + val _arg0 = arg0?.toCString(memScope).rawPtr + val _arg1 = arg1?.toCString(memScope).rawPtr + val _arg2 = arg2.rawValue + val res = externals.strptime(_arg0, _arg1, _arg2) + return CPointer.createNullable(res) + } } -fun time(arg0: Int64Box?): Long { - val _arg0 = arg0.getNativePtr().asLong() +fun time(arg0: CPointer?): time_t { + val _arg0 = arg0.rawValue val res = externals.time(_arg0) return res } @@ -75,38 +77,41 @@ fun tzset(): Unit { return res } -fun asctime_r(arg0: tm?, arg1: String?): Int8Box? { - val _arg0 = arg0.getNativePtr().asLong() - val _arg1 = CString.fromString(arg1).getNativePtr().asLong() - val res = externals.asctime_r(_arg0, _arg1) - free(NativePtr.byValue(_arg1)) - return NativePtr.byValue(res).asRef(Int8Box) +fun asctime_r(arg0: CPointer?, arg1: String?): CPointer? { + memScoped { + val _arg0 = arg0.rawValue + val _arg1 = arg1?.toCString(memScope).rawPtr + val res = externals.asctime_r(_arg0, _arg1) + return CPointer.createNullable(res) + } } -fun ctime_r(arg0: Int64Box?, arg1: String?): Int8Box? { - val _arg0 = arg0.getNativePtr().asLong() - val _arg1 = CString.fromString(arg1).getNativePtr().asLong() - val res = externals.ctime_r(_arg0, _arg1) - free(NativePtr.byValue(_arg1)) - return NativePtr.byValue(res).asRef(Int8Box) +fun ctime_r(arg0: CPointer?, arg1: String?): CPointer? { + memScoped { + val _arg0 = arg0.rawValue + val _arg1 = arg1?.toCString(memScope).rawPtr + val res = externals.ctime_r(_arg0, _arg1) + return CPointer.createNullable(res) + } } -fun gmtime_r(arg0: Int64Box?, arg1: tm?): tm? { - val _arg0 = arg0.getNativePtr().asLong() - val _arg1 = arg1.getNativePtr().asLong() +fun gmtime_r(arg0: CPointer?, arg1: CPointer?): CPointer? { + val _arg0 = arg0.rawValue + val _arg1 = arg1.rawValue val res = externals.gmtime_r(_arg0, _arg1) - return NativePtr.byValue(res).asRef(tm) + return CPointer.createNullable(res) } -fun localtime_r(arg0: Int64Box?, arg1: tm?): tm? { - val _arg0 = arg0.getNativePtr().asLong() - val _arg1 = arg1.getNativePtr().asLong() +fun localtime_r(arg0: CPointer?, arg1: CPointer?): CPointer? { + val _arg0 = arg0.rawValue + val _arg1 = arg1.rawValue val res = externals.localtime_r(_arg0, _arg1) - return NativePtr.byValue(res).asRef(tm) + return CPointer.createNullable(res) } -fun posix2time(arg0: Long): Long { - val res = externals.posix2time(arg0) +fun posix2time(arg0: time_t): time_t { + val _arg0 = arg0 + val res = externals.posix2time(_arg0) return res } @@ -115,44 +120,72 @@ fun tzsetwall(): Unit { return res } -fun time2posix(arg0: Long): Long { - val res = externals.time2posix(arg0) +fun time2posix(arg0: time_t): time_t { + val _arg0 = arg0 + val res = externals.time2posix(_arg0) return res } -fun timelocal(arg0: tm?): Long { - val _arg0 = arg0.getNativePtr().asLong() +fun timelocal(arg0: CPointer?): time_t { + val _arg0 = arg0.rawValue val res = externals.timelocal(_arg0) return res } -fun timegm(arg0: tm?): Long { - val _arg0 = arg0.getNativePtr().asLong() +fun timegm(arg0: CPointer?): time_t { + val _arg0 = arg0.rawValue val res = externals.timegm(_arg0) return res } -fun nanosleep(arg0: timespec?, arg1: timespec?): Int { - val _arg0 = arg0.getNativePtr().asLong() - val _arg1 = arg1.getNativePtr().asLong() - val res = externals.nanosleep(_arg0, _arg1) +fun nanosleep(__rqtp: CPointer?, __rmtp: CPointer?): Int { + val ___rqtp = __rqtp.rawValue + val ___rmtp = __rmtp.rawValue + val res = externals.nanosleep(___rqtp, ___rmtp) return res } -fun clang_getCString(string: CXString): Int8Box? { - val _string = string.getNativePtr().asLong() +fun clock_getres(__clock_id: clockid_t, __res: CPointer?): Int { + val ___clock_id = __clock_id.value + val ___res = __res.rawValue + val res = externals.clock_getres(___clock_id, ___res) + return res +} + +fun clock_gettime(__clock_id: clockid_t, __tp: CPointer?): Int { + val ___clock_id = __clock_id.value + val ___tp = __tp.rawValue + val res = externals.clock_gettime(___clock_id, ___tp) + return res +} + +fun clock_gettime_nsec_np(__clock_id: clockid_t): __uint64_t { + val ___clock_id = __clock_id.value + val res = externals.clock_gettime_nsec_np(___clock_id) + return res +} + +fun clock_settime(__clock_id: clockid_t, __tp: CPointer?): Int { + val ___clock_id = __clock_id.value + val ___tp = __tp.rawValue + val res = externals.clock_settime(___clock_id, ___tp) + return res +} + +fun clang_getCString(string: CXString): CPointer? { + val _string = string.rawPtr val res = externals.clang_getCString(_string) - return NativePtr.byValue(res).asRef(Int8Box) + return CPointer.createNullable(res) } fun clang_disposeString(string: CXString): Unit { - val _string = string.getNativePtr().asLong() + val _string = string.rawPtr val res = externals.clang_disposeString(_string) return res } -fun clang_disposeStringSet(set: CXStringSet?): Unit { - val _set = set.getNativePtr().asLong() +fun clang_disposeStringSet(set: CPointer?): Unit { + val _set = set.rawValue val res = externals.clang_disposeStringSet(_set) return res } @@ -162,353 +195,371 @@ fun clang_getBuildSessionTimestamp(): Long { return res } -fun clang_VirtualFileOverlay_create(options: Int): CXVirtualFileOverlayImpl? { - val res = externals.clang_VirtualFileOverlay_create(options) - return NativePtr.byValue(res).asRef(CXVirtualFileOverlayImpl) +fun clang_VirtualFileOverlay_create(options: Int): CXVirtualFileOverlay? { + val _options = options + val res = externals.clang_VirtualFileOverlay_create(_options) + return CPointer.createNullable(res) } -fun clang_VirtualFileOverlay_addFileMapping(arg0: CXVirtualFileOverlayImpl?, virtualPath: String?, realPath: String?): CXErrorCode { - val _arg0 = arg0.getNativePtr().asLong() - val _virtualPath = CString.fromString(virtualPath).getNativePtr().asLong() - val _realPath = CString.fromString(realPath).getNativePtr().asLong() - val res = externals.clang_VirtualFileOverlay_addFileMapping(_arg0, _virtualPath, _realPath) - free(NativePtr.byValue(_virtualPath)) - free(NativePtr.byValue(_realPath)) +fun clang_VirtualFileOverlay_addFileMapping(arg0: CXVirtualFileOverlay?, virtualPath: String?, realPath: String?): CXErrorCode { + memScoped { + val _arg0 = arg0.rawValue + val _virtualPath = virtualPath?.toCString(memScope).rawPtr + val _realPath = realPath?.toCString(memScope).rawPtr + val res = externals.clang_VirtualFileOverlay_addFileMapping(_arg0, _virtualPath, _realPath) + return CXErrorCode.byValue(res) + } +} + +fun clang_VirtualFileOverlay_setCaseSensitivity(arg0: CXVirtualFileOverlay?, caseSensitive: Int): CXErrorCode { + val _arg0 = arg0.rawValue + val _caseSensitive = caseSensitive + val res = externals.clang_VirtualFileOverlay_setCaseSensitivity(_arg0, _caseSensitive) return CXErrorCode.byValue(res) } -fun clang_VirtualFileOverlay_setCaseSensitivity(arg0: CXVirtualFileOverlayImpl?, caseSensitive: Int): CXErrorCode { - val _arg0 = arg0.getNativePtr().asLong() - val res = externals.clang_VirtualFileOverlay_setCaseSensitivity(_arg0, caseSensitive) +fun clang_VirtualFileOverlay_writeToBuffer(arg0: CXVirtualFileOverlay?, options: Int, out_buffer_ptr: CPointer>?, out_buffer_size: CPointer?): CXErrorCode { + val _arg0 = arg0.rawValue + val _options = options + val _out_buffer_ptr = out_buffer_ptr.rawValue + val _out_buffer_size = out_buffer_size.rawValue + val res = externals.clang_VirtualFileOverlay_writeToBuffer(_arg0, _options, _out_buffer_ptr, _out_buffer_size) return CXErrorCode.byValue(res) } -fun clang_VirtualFileOverlay_writeToBuffer(arg0: CXVirtualFileOverlayImpl?, options: Int, out_buffer_ptr: RefBox?, out_buffer_size: Int32Box?): CXErrorCode { - val _arg0 = arg0.getNativePtr().asLong() - val _out_buffer_ptr = out_buffer_ptr.getNativePtr().asLong() - val _out_buffer_size = out_buffer_size.getNativePtr().asLong() - val res = externals.clang_VirtualFileOverlay_writeToBuffer(_arg0, options, _out_buffer_ptr, _out_buffer_size) - return CXErrorCode.byValue(res) -} - -fun clang_free(buffer: NativePtr?): Unit { - val _buffer = buffer.asLong() +fun clang_free(buffer: COpaquePointer?): Unit { + val _buffer = buffer.rawValue val res = externals.clang_free(_buffer) return res } -fun clang_VirtualFileOverlay_dispose(arg0: CXVirtualFileOverlayImpl?): Unit { - val _arg0 = arg0.getNativePtr().asLong() +fun clang_VirtualFileOverlay_dispose(arg0: CXVirtualFileOverlay?): Unit { + val _arg0 = arg0.rawValue val res = externals.clang_VirtualFileOverlay_dispose(_arg0) return res } -fun clang_ModuleMapDescriptor_create(options: Int): CXModuleMapDescriptorImpl? { - val res = externals.clang_ModuleMapDescriptor_create(options) - return NativePtr.byValue(res).asRef(CXModuleMapDescriptorImpl) +fun clang_ModuleMapDescriptor_create(options: Int): CXModuleMapDescriptor? { + val _options = options + val res = externals.clang_ModuleMapDescriptor_create(_options) + return CPointer.createNullable(res) } -fun clang_ModuleMapDescriptor_setFrameworkModuleName(arg0: CXModuleMapDescriptorImpl?, name: String?): CXErrorCode { - val _arg0 = arg0.getNativePtr().asLong() - val _name = CString.fromString(name).getNativePtr().asLong() - val res = externals.clang_ModuleMapDescriptor_setFrameworkModuleName(_arg0, _name) - free(NativePtr.byValue(_name)) +fun clang_ModuleMapDescriptor_setFrameworkModuleName(arg0: CXModuleMapDescriptor?, name: String?): CXErrorCode { + memScoped { + val _arg0 = arg0.rawValue + val _name = name?.toCString(memScope).rawPtr + val res = externals.clang_ModuleMapDescriptor_setFrameworkModuleName(_arg0, _name) + return CXErrorCode.byValue(res) + } +} + +fun clang_ModuleMapDescriptor_setUmbrellaHeader(arg0: CXModuleMapDescriptor?, name: String?): CXErrorCode { + memScoped { + val _arg0 = arg0.rawValue + val _name = name?.toCString(memScope).rawPtr + val res = externals.clang_ModuleMapDescriptor_setUmbrellaHeader(_arg0, _name) + return CXErrorCode.byValue(res) + } +} + +fun clang_ModuleMapDescriptor_writeToBuffer(arg0: CXModuleMapDescriptor?, options: Int, out_buffer_ptr: CPointer>?, out_buffer_size: CPointer?): CXErrorCode { + val _arg0 = arg0.rawValue + val _options = options + val _out_buffer_ptr = out_buffer_ptr.rawValue + val _out_buffer_size = out_buffer_size.rawValue + val res = externals.clang_ModuleMapDescriptor_writeToBuffer(_arg0, _options, _out_buffer_ptr, _out_buffer_size) return CXErrorCode.byValue(res) } -fun clang_ModuleMapDescriptor_setUmbrellaHeader(arg0: CXModuleMapDescriptorImpl?, name: String?): CXErrorCode { - val _arg0 = arg0.getNativePtr().asLong() - val _name = CString.fromString(name).getNativePtr().asLong() - val res = externals.clang_ModuleMapDescriptor_setUmbrellaHeader(_arg0, _name) - free(NativePtr.byValue(_name)) - return CXErrorCode.byValue(res) -} - -fun clang_ModuleMapDescriptor_writeToBuffer(arg0: CXModuleMapDescriptorImpl?, options: Int, out_buffer_ptr: RefBox?, out_buffer_size: Int32Box?): CXErrorCode { - val _arg0 = arg0.getNativePtr().asLong() - val _out_buffer_ptr = out_buffer_ptr.getNativePtr().asLong() - val _out_buffer_size = out_buffer_size.getNativePtr().asLong() - val res = externals.clang_ModuleMapDescriptor_writeToBuffer(_arg0, options, _out_buffer_ptr, _out_buffer_size) - return CXErrorCode.byValue(res) -} - -fun clang_ModuleMapDescriptor_dispose(arg0: CXModuleMapDescriptorImpl?): Unit { - val _arg0 = arg0.getNativePtr().asLong() +fun clang_ModuleMapDescriptor_dispose(arg0: CXModuleMapDescriptor?): Unit { + val _arg0 = arg0.rawValue val res = externals.clang_ModuleMapDescriptor_dispose(_arg0) return res } -fun clang_createIndex(excludeDeclarationsFromPCH: Int, displayDiagnostics: Int): NativePtr? { - val res = externals.clang_createIndex(excludeDeclarationsFromPCH, displayDiagnostics) - return NativePtr.byValue(res) +fun clang_createIndex(excludeDeclarationsFromPCH: Int, displayDiagnostics: Int): CXIndex? { + val _excludeDeclarationsFromPCH = excludeDeclarationsFromPCH + val _displayDiagnostics = displayDiagnostics + val res = externals.clang_createIndex(_excludeDeclarationsFromPCH, _displayDiagnostics) + return CPointer.createNullable(res) } -fun clang_disposeIndex(index: NativePtr?): Unit { - val _index = index.asLong() +fun clang_disposeIndex(index: CXIndex?): Unit { + val _index = index.rawValue val res = externals.clang_disposeIndex(_index) return res } -fun clang_CXIndex_setGlobalOptions(arg0: NativePtr?, options: Int): Unit { - val _arg0 = arg0.asLong() - val res = externals.clang_CXIndex_setGlobalOptions(_arg0, options) +fun clang_CXIndex_setGlobalOptions(arg0: CXIndex?, options: Int): Unit { + val _arg0 = arg0.rawValue + val _options = options + val res = externals.clang_CXIndex_setGlobalOptions(_arg0, _options) return res } -fun clang_CXIndex_getGlobalOptions(arg0: NativePtr?): Int { - val _arg0 = arg0.asLong() +fun clang_CXIndex_getGlobalOptions(arg0: CXIndex?): Int { + val _arg0 = arg0.rawValue val res = externals.clang_CXIndex_getGlobalOptions(_arg0) return res } -fun clang_getFileName(SFile: NativePtr?, retValPlacement: Placement): CXString { - val _SFile = SFile.asLong() - val _retValPlacement = retValPlacement.alloc(CXString.size).asLong() +fun clang_getFileName(SFile: CXFile?, retValPlacement: NativePlacement): CXString { + val _SFile = SFile.rawValue + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_getFileName(_SFile, _retValPlacement) - return NativePtr.byValue(res).asRef(CXString)!! + return interpretPointed(res) } -fun clang_getFileTime(SFile: NativePtr?): Long { - val _SFile = SFile.asLong() +fun clang_getFileTime(SFile: CXFile?): time_t { + val _SFile = SFile.rawValue val res = externals.clang_getFileTime(_SFile) return res } -fun clang_getFileUniqueID(file: NativePtr?, outID: CXFileUniqueID?): Int { - val _file = file.asLong() - val _outID = outID.getNativePtr().asLong() +fun clang_getFileUniqueID(file: CXFile?, outID: CPointer?): Int { + val _file = file.rawValue + val _outID = outID.rawValue val res = externals.clang_getFileUniqueID(_file, _outID) return res } -fun clang_isFileMultipleIncludeGuarded(tu: CXTranslationUnitImpl?, file: NativePtr?): Int { - val _tu = tu.getNativePtr().asLong() - val _file = file.asLong() +fun clang_isFileMultipleIncludeGuarded(tu: CXTranslationUnit?, file: CXFile?): Int { + val _tu = tu.rawValue + val _file = file.rawValue val res = externals.clang_isFileMultipleIncludeGuarded(_tu, _file) return res } -fun clang_getFile(tu: CXTranslationUnitImpl?, file_name: String?): NativePtr? { - val _tu = tu.getNativePtr().asLong() - val _file_name = CString.fromString(file_name).getNativePtr().asLong() - val res = externals.clang_getFile(_tu, _file_name) - free(NativePtr.byValue(_file_name)) - return NativePtr.byValue(res) +fun clang_getFile(tu: CXTranslationUnit?, file_name: String?): CXFile? { + memScoped { + val _tu = tu.rawValue + val _file_name = file_name?.toCString(memScope).rawPtr + val res = externals.clang_getFile(_tu, _file_name) + return CPointer.createNullable(res) + } } -fun clang_File_isEqual(file1: NativePtr?, file2: NativePtr?): Int { - val _file1 = file1.asLong() - val _file2 = file2.asLong() +fun clang_File_isEqual(file1: CXFile?, file2: CXFile?): Int { + val _file1 = file1.rawValue + val _file2 = file2.rawValue val res = externals.clang_File_isEqual(_file1, _file2) return res } -fun clang_getNullLocation(retValPlacement: Placement): CXSourceLocation { - val _retValPlacement = retValPlacement.alloc(CXSourceLocation.size).asLong() +fun clang_getNullLocation(retValPlacement: NativePlacement): CXSourceLocation { + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_getNullLocation(_retValPlacement) - return NativePtr.byValue(res).asRef(CXSourceLocation)!! + return interpretPointed(res) } fun clang_equalLocations(loc1: CXSourceLocation, loc2: CXSourceLocation): Int { - val _loc1 = loc1.getNativePtr().asLong() - val _loc2 = loc2.getNativePtr().asLong() + val _loc1 = loc1.rawPtr + val _loc2 = loc2.rawPtr val res = externals.clang_equalLocations(_loc1, _loc2) return res } -fun clang_getLocation(tu: CXTranslationUnitImpl?, file: NativePtr?, line: Int, column: Int, retValPlacement: Placement): CXSourceLocation { - val _tu = tu.getNativePtr().asLong() - val _file = file.asLong() - val _retValPlacement = retValPlacement.alloc(CXSourceLocation.size).asLong() - val res = externals.clang_getLocation(_tu, _file, line, column, _retValPlacement) - return NativePtr.byValue(res).asRef(CXSourceLocation)!! +fun clang_getLocation(tu: CXTranslationUnit?, file: CXFile?, line: Int, column: Int, retValPlacement: NativePlacement): CXSourceLocation { + val _tu = tu.rawValue + val _file = file.rawValue + val _line = line + val _column = column + val _retValPlacement = retValPlacement.alloc().rawPtr + val res = externals.clang_getLocation(_tu, _file, _line, _column, _retValPlacement) + return interpretPointed(res) } -fun clang_getLocationForOffset(tu: CXTranslationUnitImpl?, file: NativePtr?, offset: Int, retValPlacement: Placement): CXSourceLocation { - val _tu = tu.getNativePtr().asLong() - val _file = file.asLong() - val _retValPlacement = retValPlacement.alloc(CXSourceLocation.size).asLong() - val res = externals.clang_getLocationForOffset(_tu, _file, offset, _retValPlacement) - return NativePtr.byValue(res).asRef(CXSourceLocation)!! +fun clang_getLocationForOffset(tu: CXTranslationUnit?, file: CXFile?, offset: Int, retValPlacement: NativePlacement): CXSourceLocation { + val _tu = tu.rawValue + val _file = file.rawValue + val _offset = offset + val _retValPlacement = retValPlacement.alloc().rawPtr + val res = externals.clang_getLocationForOffset(_tu, _file, _offset, _retValPlacement) + return interpretPointed(res) } fun clang_Location_isInSystemHeader(location: CXSourceLocation): Int { - val _location = location.getNativePtr().asLong() + val _location = location.rawPtr val res = externals.clang_Location_isInSystemHeader(_location) return res } fun clang_Location_isFromMainFile(location: CXSourceLocation): Int { - val _location = location.getNativePtr().asLong() + val _location = location.rawPtr val res = externals.clang_Location_isFromMainFile(_location) return res } -fun clang_getNullRange(retValPlacement: Placement): CXSourceRange { - val _retValPlacement = retValPlacement.alloc(CXSourceRange.size).asLong() +fun clang_getNullRange(retValPlacement: NativePlacement): CXSourceRange { + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_getNullRange(_retValPlacement) - return NativePtr.byValue(res).asRef(CXSourceRange)!! + return interpretPointed(res) } -fun clang_getRange(begin: CXSourceLocation, end: CXSourceLocation, retValPlacement: Placement): CXSourceRange { - val _begin = begin.getNativePtr().asLong() - val _end = end.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXSourceRange.size).asLong() +fun clang_getRange(begin: CXSourceLocation, end: CXSourceLocation, retValPlacement: NativePlacement): CXSourceRange { + val _begin = begin.rawPtr + val _end = end.rawPtr + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_getRange(_begin, _end, _retValPlacement) - return NativePtr.byValue(res).asRef(CXSourceRange)!! + return interpretPointed(res) } fun clang_equalRanges(range1: CXSourceRange, range2: CXSourceRange): Int { - val _range1 = range1.getNativePtr().asLong() - val _range2 = range2.getNativePtr().asLong() + val _range1 = range1.rawPtr + val _range2 = range2.rawPtr val res = externals.clang_equalRanges(_range1, _range2) return res } fun clang_Range_isNull(range: CXSourceRange): Int { - val _range = range.getNativePtr().asLong() + val _range = range.rawPtr val res = externals.clang_Range_isNull(_range) return res } -fun clang_getExpansionLocation(location: CXSourceLocation, file: NativePtrBox?, line: Int32Box?, column: Int32Box?, offset: Int32Box?): Unit { - val _location = location.getNativePtr().asLong() - val _file = file.getNativePtr().asLong() - val _line = line.getNativePtr().asLong() - val _column = column.getNativePtr().asLong() - val _offset = offset.getNativePtr().asLong() +fun clang_getExpansionLocation(location: CXSourceLocation, file: CPointer?, line: CPointer?, column: CPointer?, offset: CPointer?): Unit { + val _location = location.rawPtr + val _file = file.rawValue + val _line = line.rawValue + val _column = column.rawValue + val _offset = offset.rawValue val res = externals.clang_getExpansionLocation(_location, _file, _line, _column, _offset) return res } -fun clang_getPresumedLocation(location: CXSourceLocation, filename: CXString?, line: Int32Box?, column: Int32Box?): Unit { - val _location = location.getNativePtr().asLong() - val _filename = filename.getNativePtr().asLong() - val _line = line.getNativePtr().asLong() - val _column = column.getNativePtr().asLong() +fun clang_getPresumedLocation(location: CXSourceLocation, filename: CPointer?, line: CPointer?, column: CPointer?): Unit { + val _location = location.rawPtr + val _filename = filename.rawValue + val _line = line.rawValue + val _column = column.rawValue val res = externals.clang_getPresumedLocation(_location, _filename, _line, _column) return res } -fun clang_getInstantiationLocation(location: CXSourceLocation, file: NativePtrBox?, line: Int32Box?, column: Int32Box?, offset: Int32Box?): Unit { - val _location = location.getNativePtr().asLong() - val _file = file.getNativePtr().asLong() - val _line = line.getNativePtr().asLong() - val _column = column.getNativePtr().asLong() - val _offset = offset.getNativePtr().asLong() +fun clang_getInstantiationLocation(location: CXSourceLocation, file: CPointer?, line: CPointer?, column: CPointer?, offset: CPointer?): Unit { + val _location = location.rawPtr + val _file = file.rawValue + val _line = line.rawValue + val _column = column.rawValue + val _offset = offset.rawValue val res = externals.clang_getInstantiationLocation(_location, _file, _line, _column, _offset) return res } -fun clang_getSpellingLocation(location: CXSourceLocation, file: NativePtrBox?, line: Int32Box?, column: Int32Box?, offset: Int32Box?): Unit { - val _location = location.getNativePtr().asLong() - val _file = file.getNativePtr().asLong() - val _line = line.getNativePtr().asLong() - val _column = column.getNativePtr().asLong() - val _offset = offset.getNativePtr().asLong() +fun clang_getSpellingLocation(location: CXSourceLocation, file: CPointer?, line: CPointer?, column: CPointer?, offset: CPointer?): Unit { + val _location = location.rawPtr + val _file = file.rawValue + val _line = line.rawValue + val _column = column.rawValue + val _offset = offset.rawValue val res = externals.clang_getSpellingLocation(_location, _file, _line, _column, _offset) return res } -fun clang_getFileLocation(location: CXSourceLocation, file: NativePtrBox?, line: Int32Box?, column: Int32Box?, offset: Int32Box?): Unit { - val _location = location.getNativePtr().asLong() - val _file = file.getNativePtr().asLong() - val _line = line.getNativePtr().asLong() - val _column = column.getNativePtr().asLong() - val _offset = offset.getNativePtr().asLong() +fun clang_getFileLocation(location: CXSourceLocation, file: CPointer?, line: CPointer?, column: CPointer?, offset: CPointer?): Unit { + val _location = location.rawPtr + val _file = file.rawValue + val _line = line.rawValue + val _column = column.rawValue + val _offset = offset.rawValue val res = externals.clang_getFileLocation(_location, _file, _line, _column, _offset) return res } -fun clang_getRangeStart(range: CXSourceRange, retValPlacement: Placement): CXSourceLocation { - val _range = range.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXSourceLocation.size).asLong() +fun clang_getRangeStart(range: CXSourceRange, retValPlacement: NativePlacement): CXSourceLocation { + val _range = range.rawPtr + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_getRangeStart(_range, _retValPlacement) - return NativePtr.byValue(res).asRef(CXSourceLocation)!! + return interpretPointed(res) } -fun clang_getRangeEnd(range: CXSourceRange, retValPlacement: Placement): CXSourceLocation { - val _range = range.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXSourceLocation.size).asLong() +fun clang_getRangeEnd(range: CXSourceRange, retValPlacement: NativePlacement): CXSourceLocation { + val _range = range.rawPtr + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_getRangeEnd(_range, _retValPlacement) - return NativePtr.byValue(res).asRef(CXSourceLocation)!! + return interpretPointed(res) } -fun clang_getSkippedRanges(tu: CXTranslationUnitImpl?, file: NativePtr?): CXSourceRangeList? { - val _tu = tu.getNativePtr().asLong() - val _file = file.asLong() +fun clang_getSkippedRanges(tu: CXTranslationUnit?, file: CXFile?): CPointer? { + val _tu = tu.rawValue + val _file = file.rawValue val res = externals.clang_getSkippedRanges(_tu, _file) - return NativePtr.byValue(res).asRef(CXSourceRangeList) + return CPointer.createNullable(res) } -fun clang_disposeSourceRangeList(ranges: CXSourceRangeList?): Unit { - val _ranges = ranges.getNativePtr().asLong() +fun clang_disposeSourceRangeList(ranges: CPointer?): Unit { + val _ranges = ranges.rawValue val res = externals.clang_disposeSourceRangeList(_ranges) return res } -fun clang_getNumDiagnosticsInSet(Diags: NativePtr?): Int { - val _Diags = Diags.asLong() +fun clang_getNumDiagnosticsInSet(Diags: CXDiagnosticSet?): Int { + val _Diags = Diags.rawValue val res = externals.clang_getNumDiagnosticsInSet(_Diags) return res } -fun clang_getDiagnosticInSet(Diags: NativePtr?, Index: Int): NativePtr? { - val _Diags = Diags.asLong() - val res = externals.clang_getDiagnosticInSet(_Diags, Index) - return NativePtr.byValue(res) +fun clang_getDiagnosticInSet(Diags: CXDiagnosticSet?, Index: Int): CXDiagnostic? { + val _Diags = Diags.rawValue + val _Index = Index + val res = externals.clang_getDiagnosticInSet(_Diags, _Index) + return CPointer.createNullable(res) } -fun clang_loadDiagnostics(file: String?, error: CXLoadDiag_Error.ref?, errorString: CXString?): NativePtr? { - val _file = CString.fromString(file).getNativePtr().asLong() - val _error = error.getNativePtr().asLong() - val _errorString = errorString.getNativePtr().asLong() - val res = externals.clang_loadDiagnostics(_file, _error, _errorString) - free(NativePtr.byValue(_file)) - return NativePtr.byValue(res) +fun clang_loadDiagnostics(file: String?, error: CPointer?, errorString: CPointer?): CXDiagnosticSet? { + memScoped { + val _file = file?.toCString(memScope).rawPtr + val _error = error.rawValue + val _errorString = errorString.rawValue + val res = externals.clang_loadDiagnostics(_file, _error, _errorString) + return CPointer.createNullable(res) + } } -fun clang_disposeDiagnosticSet(Diags: NativePtr?): Unit { - val _Diags = Diags.asLong() +fun clang_disposeDiagnosticSet(Diags: CXDiagnosticSet?): Unit { + val _Diags = Diags.rawValue val res = externals.clang_disposeDiagnosticSet(_Diags) return res } -fun clang_getChildDiagnostics(D: NativePtr?): NativePtr? { - val _D = D.asLong() +fun clang_getChildDiagnostics(D: CXDiagnostic?): CXDiagnosticSet? { + val _D = D.rawValue val res = externals.clang_getChildDiagnostics(_D) - return NativePtr.byValue(res) + return CPointer.createNullable(res) } -fun clang_getNumDiagnostics(Unit: CXTranslationUnitImpl?): Int { - val _Unit = Unit.getNativePtr().asLong() +fun clang_getNumDiagnostics(Unit: CXTranslationUnit?): Int { + val _Unit = Unit.rawValue val res = externals.clang_getNumDiagnostics(_Unit) return res } -fun clang_getDiagnostic(Unit: CXTranslationUnitImpl?, Index: Int): NativePtr? { - val _Unit = Unit.getNativePtr().asLong() - val res = externals.clang_getDiagnostic(_Unit, Index) - return NativePtr.byValue(res) +fun clang_getDiagnostic(Unit: CXTranslationUnit?, Index: Int): CXDiagnostic? { + val _Unit = Unit.rawValue + val _Index = Index + val res = externals.clang_getDiagnostic(_Unit, _Index) + return CPointer.createNullable(res) } -fun clang_getDiagnosticSetFromTU(Unit: CXTranslationUnitImpl?): NativePtr? { - val _Unit = Unit.getNativePtr().asLong() +fun clang_getDiagnosticSetFromTU(Unit: CXTranslationUnit?): CXDiagnosticSet? { + val _Unit = Unit.rawValue val res = externals.clang_getDiagnosticSetFromTU(_Unit) - return NativePtr.byValue(res) + return CPointer.createNullable(res) } -fun clang_disposeDiagnostic(Diagnostic: NativePtr?): Unit { - val _Diagnostic = Diagnostic.asLong() +fun clang_disposeDiagnostic(Diagnostic: CXDiagnostic?): Unit { + val _Diagnostic = Diagnostic.rawValue val res = externals.clang_disposeDiagnostic(_Diagnostic) return res } -fun clang_formatDiagnostic(Diagnostic: NativePtr?, Options: Int, retValPlacement: Placement): CXString { - val _Diagnostic = Diagnostic.asLong() - val _retValPlacement = retValPlacement.alloc(CXString.size).asLong() - val res = externals.clang_formatDiagnostic(_Diagnostic, Options, _retValPlacement) - return NativePtr.byValue(res).asRef(CXString)!! +fun clang_formatDiagnostic(Diagnostic: CXDiagnostic?, Options: Int, retValPlacement: NativePlacement): CXString { + val _Diagnostic = Diagnostic.rawValue + val _Options = Options + val _retValPlacement = retValPlacement.alloc().rawPtr + val res = externals.clang_formatDiagnostic(_Diagnostic, _Options, _retValPlacement) + return interpretPointed(res) } fun clang_defaultDiagnosticDisplayOptions(): Int { @@ -516,112 +567,120 @@ fun clang_defaultDiagnosticDisplayOptions(): Int { return res } -fun clang_getDiagnosticSeverity(arg0: NativePtr?): CXDiagnosticSeverity { - val _arg0 = arg0.asLong() +fun clang_getDiagnosticSeverity(arg0: CXDiagnostic?): CXDiagnosticSeverity { + val _arg0 = arg0.rawValue val res = externals.clang_getDiagnosticSeverity(_arg0) return CXDiagnosticSeverity.byValue(res) } -fun clang_getDiagnosticLocation(arg0: NativePtr?, retValPlacement: Placement): CXSourceLocation { - val _arg0 = arg0.asLong() - val _retValPlacement = retValPlacement.alloc(CXSourceLocation.size).asLong() +fun clang_getDiagnosticLocation(arg0: CXDiagnostic?, retValPlacement: NativePlacement): CXSourceLocation { + val _arg0 = arg0.rawValue + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_getDiagnosticLocation(_arg0, _retValPlacement) - return NativePtr.byValue(res).asRef(CXSourceLocation)!! + return interpretPointed(res) } -fun clang_getDiagnosticSpelling(arg0: NativePtr?, retValPlacement: Placement): CXString { - val _arg0 = arg0.asLong() - val _retValPlacement = retValPlacement.alloc(CXString.size).asLong() +fun clang_getDiagnosticSpelling(arg0: CXDiagnostic?, retValPlacement: NativePlacement): CXString { + val _arg0 = arg0.rawValue + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_getDiagnosticSpelling(_arg0, _retValPlacement) - return NativePtr.byValue(res).asRef(CXString)!! + return interpretPointed(res) } -fun clang_getDiagnosticOption(Diag: NativePtr?, Disable: CXString?, retValPlacement: Placement): CXString { - val _Diag = Diag.asLong() - val _Disable = Disable.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXString.size).asLong() +fun clang_getDiagnosticOption(Diag: CXDiagnostic?, Disable: CPointer?, retValPlacement: NativePlacement): CXString { + val _Diag = Diag.rawValue + val _Disable = Disable.rawValue + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_getDiagnosticOption(_Diag, _Disable, _retValPlacement) - return NativePtr.byValue(res).asRef(CXString)!! + return interpretPointed(res) } -fun clang_getDiagnosticCategory(arg0: NativePtr?): Int { - val _arg0 = arg0.asLong() +fun clang_getDiagnosticCategory(arg0: CXDiagnostic?): Int { + val _arg0 = arg0.rawValue val res = externals.clang_getDiagnosticCategory(_arg0) return res } -fun clang_getDiagnosticCategoryName(Category: Int, retValPlacement: Placement): CXString { - val _retValPlacement = retValPlacement.alloc(CXString.size).asLong() - val res = externals.clang_getDiagnosticCategoryName(Category, _retValPlacement) - return NativePtr.byValue(res).asRef(CXString)!! +fun clang_getDiagnosticCategoryName(Category: Int, retValPlacement: NativePlacement): CXString { + val _Category = Category + val _retValPlacement = retValPlacement.alloc().rawPtr + val res = externals.clang_getDiagnosticCategoryName(_Category, _retValPlacement) + return interpretPointed(res) } -fun clang_getDiagnosticCategoryText(arg0: NativePtr?, retValPlacement: Placement): CXString { - val _arg0 = arg0.asLong() - val _retValPlacement = retValPlacement.alloc(CXString.size).asLong() +fun clang_getDiagnosticCategoryText(arg0: CXDiagnostic?, retValPlacement: NativePlacement): CXString { + val _arg0 = arg0.rawValue + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_getDiagnosticCategoryText(_arg0, _retValPlacement) - return NativePtr.byValue(res).asRef(CXString)!! + return interpretPointed(res) } -fun clang_getDiagnosticNumRanges(arg0: NativePtr?): Int { - val _arg0 = arg0.asLong() +fun clang_getDiagnosticNumRanges(arg0: CXDiagnostic?): Int { + val _arg0 = arg0.rawValue val res = externals.clang_getDiagnosticNumRanges(_arg0) return res } -fun clang_getDiagnosticRange(Diagnostic: NativePtr?, Range: Int, retValPlacement: Placement): CXSourceRange { - val _Diagnostic = Diagnostic.asLong() - val _retValPlacement = retValPlacement.alloc(CXSourceRange.size).asLong() - val res = externals.clang_getDiagnosticRange(_Diagnostic, Range, _retValPlacement) - return NativePtr.byValue(res).asRef(CXSourceRange)!! +fun clang_getDiagnosticRange(Diagnostic: CXDiagnostic?, Range: Int, retValPlacement: NativePlacement): CXSourceRange { + val _Diagnostic = Diagnostic.rawValue + val _Range = Range + val _retValPlacement = retValPlacement.alloc().rawPtr + val res = externals.clang_getDiagnosticRange(_Diagnostic, _Range, _retValPlacement) + return interpretPointed(res) } -fun clang_getDiagnosticNumFixIts(Diagnostic: NativePtr?): Int { - val _Diagnostic = Diagnostic.asLong() +fun clang_getDiagnosticNumFixIts(Diagnostic: CXDiagnostic?): Int { + val _Diagnostic = Diagnostic.rawValue val res = externals.clang_getDiagnosticNumFixIts(_Diagnostic) return res } -fun clang_getDiagnosticFixIt(Diagnostic: NativePtr?, FixIt: Int, ReplacementRange: CXSourceRange?, retValPlacement: Placement): CXString { - val _Diagnostic = Diagnostic.asLong() - val _ReplacementRange = ReplacementRange.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXString.size).asLong() - val res = externals.clang_getDiagnosticFixIt(_Diagnostic, FixIt, _ReplacementRange, _retValPlacement) - return NativePtr.byValue(res).asRef(CXString)!! +fun clang_getDiagnosticFixIt(Diagnostic: CXDiagnostic?, FixIt: Int, ReplacementRange: CPointer?, retValPlacement: NativePlacement): CXString { + val _Diagnostic = Diagnostic.rawValue + val _FixIt = FixIt + val _ReplacementRange = ReplacementRange.rawValue + val _retValPlacement = retValPlacement.alloc().rawPtr + val res = externals.clang_getDiagnosticFixIt(_Diagnostic, _FixIt, _ReplacementRange, _retValPlacement) + return interpretPointed(res) } -fun clang_getTranslationUnitSpelling(CTUnit: CXTranslationUnitImpl?, retValPlacement: Placement): CXString { - val _CTUnit = CTUnit.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXString.size).asLong() +fun clang_getTranslationUnitSpelling(CTUnit: CXTranslationUnit?, retValPlacement: NativePlacement): CXString { + val _CTUnit = CTUnit.rawValue + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_getTranslationUnitSpelling(_CTUnit, _retValPlacement) - return NativePtr.byValue(res).asRef(CXString)!! + return interpretPointed(res) } -fun clang_createTranslationUnitFromSourceFile(CIdx: NativePtr?, source_filename: String?, num_clang_command_line_args: Int, clang_command_line_args: RefBox?, num_unsaved_files: Int, unsaved_files: CXUnsavedFile?): CXTranslationUnitImpl? { - val _CIdx = CIdx.asLong() - val _source_filename = CString.fromString(source_filename).getNativePtr().asLong() - val _clang_command_line_args = clang_command_line_args.getNativePtr().asLong() - val _unsaved_files = unsaved_files.getNativePtr().asLong() - val res = externals.clang_createTranslationUnitFromSourceFile(_CIdx, _source_filename, num_clang_command_line_args, _clang_command_line_args, num_unsaved_files, _unsaved_files) - free(NativePtr.byValue(_source_filename)) - return NativePtr.byValue(res).asRef(CXTranslationUnitImpl) +fun clang_createTranslationUnitFromSourceFile(CIdx: CXIndex?, source_filename: String?, num_clang_command_line_args: Int, clang_command_line_args: CPointer>?, num_unsaved_files: Int, unsaved_files: CPointer?): CXTranslationUnit? { + memScoped { + val _CIdx = CIdx.rawValue + val _source_filename = source_filename?.toCString(memScope).rawPtr + val _num_clang_command_line_args = num_clang_command_line_args + val _clang_command_line_args = clang_command_line_args.rawValue + val _num_unsaved_files = num_unsaved_files + val _unsaved_files = unsaved_files.rawValue + val res = externals.clang_createTranslationUnitFromSourceFile(_CIdx, _source_filename, _num_clang_command_line_args, _clang_command_line_args, _num_unsaved_files, _unsaved_files) + return CPointer.createNullable(res) + } } -fun clang_createTranslationUnit(CIdx: NativePtr?, ast_filename: String?): CXTranslationUnitImpl? { - val _CIdx = CIdx.asLong() - val _ast_filename = CString.fromString(ast_filename).getNativePtr().asLong() - val res = externals.clang_createTranslationUnit(_CIdx, _ast_filename) - free(NativePtr.byValue(_ast_filename)) - return NativePtr.byValue(res).asRef(CXTranslationUnitImpl) +fun clang_createTranslationUnit(CIdx: CXIndex?, ast_filename: String?): CXTranslationUnit? { + memScoped { + val _CIdx = CIdx.rawValue + val _ast_filename = ast_filename?.toCString(memScope).rawPtr + val res = externals.clang_createTranslationUnit(_CIdx, _ast_filename) + return CPointer.createNullable(res) + } } -fun clang_createTranslationUnit2(CIdx: NativePtr?, ast_filename: String?, out_TU: RefBox?): CXErrorCode { - val _CIdx = CIdx.asLong() - val _ast_filename = CString.fromString(ast_filename).getNativePtr().asLong() - val _out_TU = out_TU.getNativePtr().asLong() - val res = externals.clang_createTranslationUnit2(_CIdx, _ast_filename, _out_TU) - free(NativePtr.byValue(_ast_filename)) - return CXErrorCode.byValue(res) +fun clang_createTranslationUnit2(CIdx: CXIndex?, ast_filename: String?, out_TU: CPointer?): CXErrorCode { + memScoped { + val _CIdx = CIdx.rawValue + val _ast_filename = ast_filename?.toCString(memScope).rawPtr + val _out_TU = out_TU.rawValue + val res = externals.clang_createTranslationUnit2(_CIdx, _ast_filename, _out_TU) + return CXErrorCode.byValue(res) + } } fun clang_defaultEditingTranslationUnitOptions(): Int { @@ -629,124 +688,140 @@ fun clang_defaultEditingTranslationUnitOptions(): Int { return res } -fun clang_parseTranslationUnit(CIdx: NativePtr?, source_filename: String?, command_line_args: RefBox?, num_command_line_args: Int, unsaved_files: CXUnsavedFile?, num_unsaved_files: Int, options: Int): CXTranslationUnitImpl? { - val _CIdx = CIdx.asLong() - val _source_filename = CString.fromString(source_filename).getNativePtr().asLong() - val _command_line_args = command_line_args.getNativePtr().asLong() - val _unsaved_files = unsaved_files.getNativePtr().asLong() - val res = externals.clang_parseTranslationUnit(_CIdx, _source_filename, _command_line_args, num_command_line_args, _unsaved_files, num_unsaved_files, options) - free(NativePtr.byValue(_source_filename)) - return NativePtr.byValue(res).asRef(CXTranslationUnitImpl) +fun clang_parseTranslationUnit(CIdx: CXIndex?, source_filename: String?, command_line_args: CPointer>?, num_command_line_args: Int, unsaved_files: CPointer?, num_unsaved_files: Int, options: Int): CXTranslationUnit? { + memScoped { + val _CIdx = CIdx.rawValue + val _source_filename = source_filename?.toCString(memScope).rawPtr + val _command_line_args = command_line_args.rawValue + val _num_command_line_args = num_command_line_args + val _unsaved_files = unsaved_files.rawValue + val _num_unsaved_files = num_unsaved_files + val _options = options + val res = externals.clang_parseTranslationUnit(_CIdx, _source_filename, _command_line_args, _num_command_line_args, _unsaved_files, _num_unsaved_files, _options) + return CPointer.createNullable(res) + } } -fun clang_parseTranslationUnit2(CIdx: NativePtr?, source_filename: String?, command_line_args: RefBox?, num_command_line_args: Int, unsaved_files: CXUnsavedFile?, num_unsaved_files: Int, options: Int, out_TU: RefBox?): CXErrorCode { - val _CIdx = CIdx.asLong() - val _source_filename = CString.fromString(source_filename).getNativePtr().asLong() - val _command_line_args = command_line_args.getNativePtr().asLong() - val _unsaved_files = unsaved_files.getNativePtr().asLong() - val _out_TU = out_TU.getNativePtr().asLong() - val res = externals.clang_parseTranslationUnit2(_CIdx, _source_filename, _command_line_args, num_command_line_args, _unsaved_files, num_unsaved_files, options, _out_TU) - free(NativePtr.byValue(_source_filename)) - return CXErrorCode.byValue(res) +fun clang_parseTranslationUnit2(CIdx: CXIndex?, source_filename: String?, command_line_args: CPointer>?, num_command_line_args: Int, unsaved_files: CPointer?, num_unsaved_files: Int, options: Int, out_TU: CPointer?): CXErrorCode { + memScoped { + val _CIdx = CIdx.rawValue + val _source_filename = source_filename?.toCString(memScope).rawPtr + val _command_line_args = command_line_args.rawValue + val _num_command_line_args = num_command_line_args + val _unsaved_files = unsaved_files.rawValue + val _num_unsaved_files = num_unsaved_files + val _options = options + val _out_TU = out_TU.rawValue + val res = externals.clang_parseTranslationUnit2(_CIdx, _source_filename, _command_line_args, _num_command_line_args, _unsaved_files, _num_unsaved_files, _options, _out_TU) + return CXErrorCode.byValue(res) + } } -fun clang_parseTranslationUnit2FullArgv(CIdx: NativePtr?, source_filename: String?, command_line_args: RefBox?, num_command_line_args: Int, unsaved_files: CXUnsavedFile?, num_unsaved_files: Int, options: Int, out_TU: RefBox?): CXErrorCode { - val _CIdx = CIdx.asLong() - val _source_filename = CString.fromString(source_filename).getNativePtr().asLong() - val _command_line_args = command_line_args.getNativePtr().asLong() - val _unsaved_files = unsaved_files.getNativePtr().asLong() - val _out_TU = out_TU.getNativePtr().asLong() - val res = externals.clang_parseTranslationUnit2FullArgv(_CIdx, _source_filename, _command_line_args, num_command_line_args, _unsaved_files, num_unsaved_files, options, _out_TU) - free(NativePtr.byValue(_source_filename)) - return CXErrorCode.byValue(res) +fun clang_parseTranslationUnit2FullArgv(CIdx: CXIndex?, source_filename: String?, command_line_args: CPointer>?, num_command_line_args: Int, unsaved_files: CPointer?, num_unsaved_files: Int, options: Int, out_TU: CPointer?): CXErrorCode { + memScoped { + val _CIdx = CIdx.rawValue + val _source_filename = source_filename?.toCString(memScope).rawPtr + val _command_line_args = command_line_args.rawValue + val _num_command_line_args = num_command_line_args + val _unsaved_files = unsaved_files.rawValue + val _num_unsaved_files = num_unsaved_files + val _options = options + val _out_TU = out_TU.rawValue + val res = externals.clang_parseTranslationUnit2FullArgv(_CIdx, _source_filename, _command_line_args, _num_command_line_args, _unsaved_files, _num_unsaved_files, _options, _out_TU) + return CXErrorCode.byValue(res) + } } -fun clang_defaultSaveOptions(TU: CXTranslationUnitImpl?): Int { - val _TU = TU.getNativePtr().asLong() +fun clang_defaultSaveOptions(TU: CXTranslationUnit?): Int { + val _TU = TU.rawValue val res = externals.clang_defaultSaveOptions(_TU) return res } -fun clang_saveTranslationUnit(TU: CXTranslationUnitImpl?, FileName: String?, options: Int): Int { - val _TU = TU.getNativePtr().asLong() - val _FileName = CString.fromString(FileName).getNativePtr().asLong() - val res = externals.clang_saveTranslationUnit(_TU, _FileName, options) - free(NativePtr.byValue(_FileName)) - return res +fun clang_saveTranslationUnit(TU: CXTranslationUnit?, FileName: String?, options: Int): Int { + memScoped { + val _TU = TU.rawValue + val _FileName = FileName?.toCString(memScope).rawPtr + val _options = options + val res = externals.clang_saveTranslationUnit(_TU, _FileName, _options) + return res + } } -fun clang_disposeTranslationUnit(arg0: CXTranslationUnitImpl?): Unit { - val _arg0 = arg0.getNativePtr().asLong() +fun clang_disposeTranslationUnit(arg0: CXTranslationUnit?): Unit { + val _arg0 = arg0.rawValue val res = externals.clang_disposeTranslationUnit(_arg0) return res } -fun clang_defaultReparseOptions(TU: CXTranslationUnitImpl?): Int { - val _TU = TU.getNativePtr().asLong() +fun clang_defaultReparseOptions(TU: CXTranslationUnit?): Int { + val _TU = TU.rawValue val res = externals.clang_defaultReparseOptions(_TU) return res } -fun clang_reparseTranslationUnit(TU: CXTranslationUnitImpl?, num_unsaved_files: Int, unsaved_files: CXUnsavedFile?, options: Int): Int { - val _TU = TU.getNativePtr().asLong() - val _unsaved_files = unsaved_files.getNativePtr().asLong() - val res = externals.clang_reparseTranslationUnit(_TU, num_unsaved_files, _unsaved_files, options) +fun clang_reparseTranslationUnit(TU: CXTranslationUnit?, num_unsaved_files: Int, unsaved_files: CPointer?, options: Int): Int { + val _TU = TU.rawValue + val _num_unsaved_files = num_unsaved_files + val _unsaved_files = unsaved_files.rawValue + val _options = options + val res = externals.clang_reparseTranslationUnit(_TU, _num_unsaved_files, _unsaved_files, _options) return res } -fun clang_getTUResourceUsageName(kind: CXTUResourceUsageKind): Int8Box? { +fun clang_getTUResourceUsageName(kind: CXTUResourceUsageKind): CPointer? { val _kind = kind.value val res = externals.clang_getTUResourceUsageName(_kind) - return NativePtr.byValue(res).asRef(Int8Box) + return CPointer.createNullable(res) } -fun clang_getCXTUResourceUsage(TU: CXTranslationUnitImpl?, retValPlacement: Placement): CXTUResourceUsage { - val _TU = TU.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXTUResourceUsage.size).asLong() +fun clang_getCXTUResourceUsage(TU: CXTranslationUnit?, retValPlacement: NativePlacement): CXTUResourceUsage { + val _TU = TU.rawValue + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_getCXTUResourceUsage(_TU, _retValPlacement) - return NativePtr.byValue(res).asRef(CXTUResourceUsage)!! + return interpretPointed(res) } fun clang_disposeCXTUResourceUsage(usage: CXTUResourceUsage): Unit { - val _usage = usage.getNativePtr().asLong() + val _usage = usage.rawPtr val res = externals.clang_disposeCXTUResourceUsage(_usage) return res } -fun clang_getNullCursor(retValPlacement: Placement): CXCursor { - val _retValPlacement = retValPlacement.alloc(CXCursor.size).asLong() +fun clang_getNullCursor(retValPlacement: NativePlacement): CXCursor { + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_getNullCursor(_retValPlacement) - return NativePtr.byValue(res).asRef(CXCursor)!! + return interpretPointed(res) } -fun clang_getTranslationUnitCursor(arg0: CXTranslationUnitImpl?, retValPlacement: Placement): CXCursor { - val _arg0 = arg0.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXCursor.size).asLong() +fun clang_getTranslationUnitCursor(arg0: CXTranslationUnit?, retValPlacement: NativePlacement): CXCursor { + val _arg0 = arg0.rawValue + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_getTranslationUnitCursor(_arg0, _retValPlacement) - return NativePtr.byValue(res).asRef(CXCursor)!! + return interpretPointed(res) } fun clang_equalCursors(arg0: CXCursor, arg1: CXCursor): Int { - val _arg0 = arg0.getNativePtr().asLong() - val _arg1 = arg1.getNativePtr().asLong() + val _arg0 = arg0.rawPtr + val _arg1 = arg1.rawPtr val res = externals.clang_equalCursors(_arg0, _arg1) return res } fun clang_Cursor_isNull(cursor: CXCursor): Int { - val _cursor = cursor.getNativePtr().asLong() + val _cursor = cursor.rawPtr val res = externals.clang_Cursor_isNull(_cursor) return res } fun clang_hashCursor(arg0: CXCursor): Int { - val _arg0 = arg0.getNativePtr().asLong() + val _arg0 = arg0.rawPtr val res = externals.clang_hashCursor(_arg0) return res } fun clang_getCursorKind(arg0: CXCursor): CXCursorKind { - val _arg0 = arg0.getNativePtr().asLong() + val _arg0 = arg0.rawPtr val res = externals.clang_getCursorKind(_arg0) return CXCursorKind.byValue(res) } @@ -806,827 +881,851 @@ fun clang_isUnexposed(arg0: CXCursorKind): Int { } fun clang_getCursorLinkage(cursor: CXCursor): CXLinkageKind { - val _cursor = cursor.getNativePtr().asLong() + val _cursor = cursor.rawPtr val res = externals.clang_getCursorLinkage(_cursor) return CXLinkageKind.byValue(res) } fun clang_getCursorVisibility(cursor: CXCursor): CXVisibilityKind { - val _cursor = cursor.getNativePtr().asLong() + val _cursor = cursor.rawPtr val res = externals.clang_getCursorVisibility(_cursor) return CXVisibilityKind.byValue(res) } fun clang_getCursorAvailability(cursor: CXCursor): CXAvailabilityKind { - val _cursor = cursor.getNativePtr().asLong() + val _cursor = cursor.rawPtr val res = externals.clang_getCursorAvailability(_cursor) return CXAvailabilityKind.byValue(res) } -fun clang_getCursorPlatformAvailability(cursor: CXCursor, always_deprecated: Int32Box?, deprecated_message: CXString?, always_unavailable: Int32Box?, unavailable_message: CXString?, availability: CXPlatformAvailability?, availability_size: Int): Int { - val _cursor = cursor.getNativePtr().asLong() - val _always_deprecated = always_deprecated.getNativePtr().asLong() - val _deprecated_message = deprecated_message.getNativePtr().asLong() - val _always_unavailable = always_unavailable.getNativePtr().asLong() - val _unavailable_message = unavailable_message.getNativePtr().asLong() - val _availability = availability.getNativePtr().asLong() - val res = externals.clang_getCursorPlatformAvailability(_cursor, _always_deprecated, _deprecated_message, _always_unavailable, _unavailable_message, _availability, availability_size) +fun clang_getCursorPlatformAvailability(cursor: CXCursor, always_deprecated: CPointer?, deprecated_message: CPointer?, always_unavailable: CPointer?, unavailable_message: CPointer?, availability: CPointer?, availability_size: Int): Int { + val _cursor = cursor.rawPtr + val _always_deprecated = always_deprecated.rawValue + val _deprecated_message = deprecated_message.rawValue + val _always_unavailable = always_unavailable.rawValue + val _unavailable_message = unavailable_message.rawValue + val _availability = availability.rawValue + val _availability_size = availability_size + val res = externals.clang_getCursorPlatformAvailability(_cursor, _always_deprecated, _deprecated_message, _always_unavailable, _unavailable_message, _availability, _availability_size) return res } -fun clang_disposeCXPlatformAvailability(availability: CXPlatformAvailability?): Unit { - val _availability = availability.getNativePtr().asLong() +fun clang_disposeCXPlatformAvailability(availability: CPointer?): Unit { + val _availability = availability.rawValue val res = externals.clang_disposeCXPlatformAvailability(_availability) return res } fun clang_getCursorLanguage(cursor: CXCursor): CXLanguageKind { - val _cursor = cursor.getNativePtr().asLong() + val _cursor = cursor.rawPtr val res = externals.clang_getCursorLanguage(_cursor) return CXLanguageKind.byValue(res) } -fun clang_Cursor_getTranslationUnit(arg0: CXCursor): CXTranslationUnitImpl? { - val _arg0 = arg0.getNativePtr().asLong() +fun clang_Cursor_getTranslationUnit(arg0: CXCursor): CXTranslationUnit? { + val _arg0 = arg0.rawPtr val res = externals.clang_Cursor_getTranslationUnit(_arg0) - return NativePtr.byValue(res).asRef(CXTranslationUnitImpl) + return CPointer.createNullable(res) } -fun clang_createCXCursorSet(): CXCursorSetImpl? { +fun clang_createCXCursorSet(): CXCursorSet? { val res = externals.clang_createCXCursorSet() - return NativePtr.byValue(res).asRef(CXCursorSetImpl) + return CPointer.createNullable(res) } -fun clang_disposeCXCursorSet(cset: CXCursorSetImpl?): Unit { - val _cset = cset.getNativePtr().asLong() +fun clang_disposeCXCursorSet(cset: CXCursorSet?): Unit { + val _cset = cset.rawValue val res = externals.clang_disposeCXCursorSet(_cset) return res } -fun clang_CXCursorSet_contains(cset: CXCursorSetImpl?, cursor: CXCursor): Int { - val _cset = cset.getNativePtr().asLong() - val _cursor = cursor.getNativePtr().asLong() +fun clang_CXCursorSet_contains(cset: CXCursorSet?, cursor: CXCursor): Int { + val _cset = cset.rawValue + val _cursor = cursor.rawPtr val res = externals.clang_CXCursorSet_contains(_cset, _cursor) return res } -fun clang_CXCursorSet_insert(cset: CXCursorSetImpl?, cursor: CXCursor): Int { - val _cset = cset.getNativePtr().asLong() - val _cursor = cursor.getNativePtr().asLong() +fun clang_CXCursorSet_insert(cset: CXCursorSet?, cursor: CXCursor): Int { + val _cset = cset.rawValue + val _cursor = cursor.rawPtr val res = externals.clang_CXCursorSet_insert(_cset, _cursor) return res } -fun clang_getCursorSemanticParent(cursor: CXCursor, retValPlacement: Placement): CXCursor { - val _cursor = cursor.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXCursor.size).asLong() +fun clang_getCursorSemanticParent(cursor: CXCursor, retValPlacement: NativePlacement): CXCursor { + val _cursor = cursor.rawPtr + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_getCursorSemanticParent(_cursor, _retValPlacement) - return NativePtr.byValue(res).asRef(CXCursor)!! + return interpretPointed(res) } -fun clang_getCursorLexicalParent(cursor: CXCursor, retValPlacement: Placement): CXCursor { - val _cursor = cursor.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXCursor.size).asLong() +fun clang_getCursorLexicalParent(cursor: CXCursor, retValPlacement: NativePlacement): CXCursor { + val _cursor = cursor.rawPtr + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_getCursorLexicalParent(_cursor, _retValPlacement) - return NativePtr.byValue(res).asRef(CXCursor)!! + return interpretPointed(res) } -fun clang_getOverriddenCursors(cursor: CXCursor, overridden: RefBox?, num_overridden: Int32Box?): Unit { - val _cursor = cursor.getNativePtr().asLong() - val _overridden = overridden.getNativePtr().asLong() - val _num_overridden = num_overridden.getNativePtr().asLong() +fun clang_getOverriddenCursors(cursor: CXCursor, overridden: CPointer>?, num_overridden: CPointer?): Unit { + val _cursor = cursor.rawPtr + val _overridden = overridden.rawValue + val _num_overridden = num_overridden.rawValue val res = externals.clang_getOverriddenCursors(_cursor, _overridden, _num_overridden) return res } -fun clang_disposeOverriddenCursors(overridden: CXCursor?): Unit { - val _overridden = overridden.getNativePtr().asLong() +fun clang_disposeOverriddenCursors(overridden: CPointer?): Unit { + val _overridden = overridden.rawValue val res = externals.clang_disposeOverriddenCursors(_overridden) return res } -fun clang_getIncludedFile(cursor: CXCursor): NativePtr? { - val _cursor = cursor.getNativePtr().asLong() +fun clang_getIncludedFile(cursor: CXCursor): CXFile? { + val _cursor = cursor.rawPtr val res = externals.clang_getIncludedFile(_cursor) - return NativePtr.byValue(res) + return CPointer.createNullable(res) } -fun clang_getCursor(arg0: CXTranslationUnitImpl?, arg1: CXSourceLocation, retValPlacement: Placement): CXCursor { - val _arg0 = arg0.getNativePtr().asLong() - val _arg1 = arg1.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXCursor.size).asLong() +fun clang_getCursor(arg0: CXTranslationUnit?, arg1: CXSourceLocation, retValPlacement: NativePlacement): CXCursor { + val _arg0 = arg0.rawValue + val _arg1 = arg1.rawPtr + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_getCursor(_arg0, _arg1, _retValPlacement) - return NativePtr.byValue(res).asRef(CXCursor)!! + return interpretPointed(res) } -fun clang_getCursorLocation(arg0: CXCursor, retValPlacement: Placement): CXSourceLocation { - val _arg0 = arg0.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXSourceLocation.size).asLong() +fun clang_getCursorLocation(arg0: CXCursor, retValPlacement: NativePlacement): CXSourceLocation { + val _arg0 = arg0.rawPtr + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_getCursorLocation(_arg0, _retValPlacement) - return NativePtr.byValue(res).asRef(CXSourceLocation)!! + return interpretPointed(res) } -fun clang_getCursorExtent(arg0: CXCursor, retValPlacement: Placement): CXSourceRange { - val _arg0 = arg0.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXSourceRange.size).asLong() +fun clang_getCursorExtent(arg0: CXCursor, retValPlacement: NativePlacement): CXSourceRange { + val _arg0 = arg0.rawPtr + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_getCursorExtent(_arg0, _retValPlacement) - return NativePtr.byValue(res).asRef(CXSourceRange)!! + return interpretPointed(res) } -fun clang_getCursorType(C: CXCursor, retValPlacement: Placement): CXType { - val _C = C.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXType.size).asLong() +fun clang_getCursorType(C: CXCursor, retValPlacement: NativePlacement): CXType { + val _C = C.rawPtr + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_getCursorType(_C, _retValPlacement) - return NativePtr.byValue(res).asRef(CXType)!! + return interpretPointed(res) } -fun clang_getTypeSpelling(CT: CXType, retValPlacement: Placement): CXString { - val _CT = CT.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXString.size).asLong() +fun clang_getTypeSpelling(CT: CXType, retValPlacement: NativePlacement): CXString { + val _CT = CT.rawPtr + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_getTypeSpelling(_CT, _retValPlacement) - return NativePtr.byValue(res).asRef(CXString)!! + return interpretPointed(res) } -fun clang_getTypedefDeclUnderlyingType(C: CXCursor, retValPlacement: Placement): CXType { - val _C = C.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXType.size).asLong() +fun clang_getTypedefDeclUnderlyingType(C: CXCursor, retValPlacement: NativePlacement): CXType { + val _C = C.rawPtr + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_getTypedefDeclUnderlyingType(_C, _retValPlacement) - return NativePtr.byValue(res).asRef(CXType)!! + return interpretPointed(res) } -fun clang_getEnumDeclIntegerType(C: CXCursor, retValPlacement: Placement): CXType { - val _C = C.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXType.size).asLong() +fun clang_getEnumDeclIntegerType(C: CXCursor, retValPlacement: NativePlacement): CXType { + val _C = C.rawPtr + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_getEnumDeclIntegerType(_C, _retValPlacement) - return NativePtr.byValue(res).asRef(CXType)!! + return interpretPointed(res) } fun clang_getEnumConstantDeclValue(C: CXCursor): Long { - val _C = C.getNativePtr().asLong() + val _C = C.rawPtr val res = externals.clang_getEnumConstantDeclValue(_C) return res } fun clang_getEnumConstantDeclUnsignedValue(C: CXCursor): Long { - val _C = C.getNativePtr().asLong() + val _C = C.rawPtr val res = externals.clang_getEnumConstantDeclUnsignedValue(_C) return res } fun clang_getFieldDeclBitWidth(C: CXCursor): Int { - val _C = C.getNativePtr().asLong() + val _C = C.rawPtr val res = externals.clang_getFieldDeclBitWidth(_C) return res } fun clang_Cursor_getNumArguments(C: CXCursor): Int { - val _C = C.getNativePtr().asLong() + val _C = C.rawPtr val res = externals.clang_Cursor_getNumArguments(_C) return res } -fun clang_Cursor_getArgument(C: CXCursor, i: Int, retValPlacement: Placement): CXCursor { - val _C = C.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXCursor.size).asLong() - val res = externals.clang_Cursor_getArgument(_C, i, _retValPlacement) - return NativePtr.byValue(res).asRef(CXCursor)!! +fun clang_Cursor_getArgument(C: CXCursor, i: Int, retValPlacement: NativePlacement): CXCursor { + val _C = C.rawPtr + val _i = i + val _retValPlacement = retValPlacement.alloc().rawPtr + val res = externals.clang_Cursor_getArgument(_C, _i, _retValPlacement) + return interpretPointed(res) } fun clang_Cursor_getNumTemplateArguments(C: CXCursor): Int { - val _C = C.getNativePtr().asLong() + val _C = C.rawPtr val res = externals.clang_Cursor_getNumTemplateArguments(_C) return res } fun clang_Cursor_getTemplateArgumentKind(C: CXCursor, I: Int): CXTemplateArgumentKind { - val _C = C.getNativePtr().asLong() - val res = externals.clang_Cursor_getTemplateArgumentKind(_C, I) + val _C = C.rawPtr + val _I = I + val res = externals.clang_Cursor_getTemplateArgumentKind(_C, _I) return CXTemplateArgumentKind.byValue(res) } -fun clang_Cursor_getTemplateArgumentType(C: CXCursor, I: Int, retValPlacement: Placement): CXType { - val _C = C.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXType.size).asLong() - val res = externals.clang_Cursor_getTemplateArgumentType(_C, I, _retValPlacement) - return NativePtr.byValue(res).asRef(CXType)!! +fun clang_Cursor_getTemplateArgumentType(C: CXCursor, I: Int, retValPlacement: NativePlacement): CXType { + val _C = C.rawPtr + val _I = I + val _retValPlacement = retValPlacement.alloc().rawPtr + val res = externals.clang_Cursor_getTemplateArgumentType(_C, _I, _retValPlacement) + return interpretPointed(res) } fun clang_Cursor_getTemplateArgumentValue(C: CXCursor, I: Int): Long { - val _C = C.getNativePtr().asLong() - val res = externals.clang_Cursor_getTemplateArgumentValue(_C, I) + val _C = C.rawPtr + val _I = I + val res = externals.clang_Cursor_getTemplateArgumentValue(_C, _I) return res } fun clang_Cursor_getTemplateArgumentUnsignedValue(C: CXCursor, I: Int): Long { - val _C = C.getNativePtr().asLong() - val res = externals.clang_Cursor_getTemplateArgumentUnsignedValue(_C, I) + val _C = C.rawPtr + val _I = I + val res = externals.clang_Cursor_getTemplateArgumentUnsignedValue(_C, _I) return res } fun clang_equalTypes(A: CXType, B: CXType): Int { - val _A = A.getNativePtr().asLong() - val _B = B.getNativePtr().asLong() + val _A = A.rawPtr + val _B = B.rawPtr val res = externals.clang_equalTypes(_A, _B) return res } -fun clang_getCanonicalType(T: CXType, retValPlacement: Placement): CXType { - val _T = T.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXType.size).asLong() +fun clang_getCanonicalType(T: CXType, retValPlacement: NativePlacement): CXType { + val _T = T.rawPtr + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_getCanonicalType(_T, _retValPlacement) - return NativePtr.byValue(res).asRef(CXType)!! + return interpretPointed(res) } fun clang_isConstQualifiedType(T: CXType): Int { - val _T = T.getNativePtr().asLong() + val _T = T.rawPtr val res = externals.clang_isConstQualifiedType(_T) return res } fun clang_isVolatileQualifiedType(T: CXType): Int { - val _T = T.getNativePtr().asLong() + val _T = T.rawPtr val res = externals.clang_isVolatileQualifiedType(_T) return res } fun clang_isRestrictQualifiedType(T: CXType): Int { - val _T = T.getNativePtr().asLong() + val _T = T.rawPtr val res = externals.clang_isRestrictQualifiedType(_T) return res } -fun clang_getPointeeType(T: CXType, retValPlacement: Placement): CXType { - val _T = T.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXType.size).asLong() +fun clang_getPointeeType(T: CXType, retValPlacement: NativePlacement): CXType { + val _T = T.rawPtr + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_getPointeeType(_T, _retValPlacement) - return NativePtr.byValue(res).asRef(CXType)!! + return interpretPointed(res) } -fun clang_getTypeDeclaration(T: CXType, retValPlacement: Placement): CXCursor { - val _T = T.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXCursor.size).asLong() +fun clang_getTypeDeclaration(T: CXType, retValPlacement: NativePlacement): CXCursor { + val _T = T.rawPtr + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_getTypeDeclaration(_T, _retValPlacement) - return NativePtr.byValue(res).asRef(CXCursor)!! + return interpretPointed(res) } -fun clang_getDeclObjCTypeEncoding(C: CXCursor, retValPlacement: Placement): CXString { - val _C = C.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXString.size).asLong() +fun clang_getDeclObjCTypeEncoding(C: CXCursor, retValPlacement: NativePlacement): CXString { + val _C = C.rawPtr + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_getDeclObjCTypeEncoding(_C, _retValPlacement) - return NativePtr.byValue(res).asRef(CXString)!! + return interpretPointed(res) } -fun clang_getTypeKindSpelling(K: CXTypeKind, retValPlacement: Placement): CXString { +fun clang_getTypeKindSpelling(K: CXTypeKind, retValPlacement: NativePlacement): CXString { val _K = K.value - val _retValPlacement = retValPlacement.alloc(CXString.size).asLong() + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_getTypeKindSpelling(_K, _retValPlacement) - return NativePtr.byValue(res).asRef(CXString)!! + return interpretPointed(res) } fun clang_getFunctionTypeCallingConv(T: CXType): CXCallingConv { - val _T = T.getNativePtr().asLong() + val _T = T.rawPtr val res = externals.clang_getFunctionTypeCallingConv(_T) return CXCallingConv.byValue(res) } -fun clang_getResultType(T: CXType, retValPlacement: Placement): CXType { - val _T = T.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXType.size).asLong() +fun clang_getResultType(T: CXType, retValPlacement: NativePlacement): CXType { + val _T = T.rawPtr + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_getResultType(_T, _retValPlacement) - return NativePtr.byValue(res).asRef(CXType)!! + return interpretPointed(res) } fun clang_getNumArgTypes(T: CXType): Int { - val _T = T.getNativePtr().asLong() + val _T = T.rawPtr val res = externals.clang_getNumArgTypes(_T) return res } -fun clang_getArgType(T: CXType, i: Int, retValPlacement: Placement): CXType { - val _T = T.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXType.size).asLong() - val res = externals.clang_getArgType(_T, i, _retValPlacement) - return NativePtr.byValue(res).asRef(CXType)!! +fun clang_getArgType(T: CXType, i: Int, retValPlacement: NativePlacement): CXType { + val _T = T.rawPtr + val _i = i + val _retValPlacement = retValPlacement.alloc().rawPtr + val res = externals.clang_getArgType(_T, _i, _retValPlacement) + return interpretPointed(res) } fun clang_isFunctionTypeVariadic(T: CXType): Int { - val _T = T.getNativePtr().asLong() + val _T = T.rawPtr val res = externals.clang_isFunctionTypeVariadic(_T) return res } -fun clang_getCursorResultType(C: CXCursor, retValPlacement: Placement): CXType { - val _C = C.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXType.size).asLong() +fun clang_getCursorResultType(C: CXCursor, retValPlacement: NativePlacement): CXType { + val _C = C.rawPtr + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_getCursorResultType(_C, _retValPlacement) - return NativePtr.byValue(res).asRef(CXType)!! + return interpretPointed(res) } fun clang_isPODType(T: CXType): Int { - val _T = T.getNativePtr().asLong() + val _T = T.rawPtr val res = externals.clang_isPODType(_T) return res } -fun clang_getElementType(T: CXType, retValPlacement: Placement): CXType { - val _T = T.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXType.size).asLong() +fun clang_getElementType(T: CXType, retValPlacement: NativePlacement): CXType { + val _T = T.rawPtr + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_getElementType(_T, _retValPlacement) - return NativePtr.byValue(res).asRef(CXType)!! + return interpretPointed(res) } fun clang_getNumElements(T: CXType): Long { - val _T = T.getNativePtr().asLong() + val _T = T.rawPtr val res = externals.clang_getNumElements(_T) return res } -fun clang_getArrayElementType(T: CXType, retValPlacement: Placement): CXType { - val _T = T.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXType.size).asLong() +fun clang_getArrayElementType(T: CXType, retValPlacement: NativePlacement): CXType { + val _T = T.rawPtr + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_getArrayElementType(_T, _retValPlacement) - return NativePtr.byValue(res).asRef(CXType)!! + return interpretPointed(res) } fun clang_getArraySize(T: CXType): Long { - val _T = T.getNativePtr().asLong() + val _T = T.rawPtr val res = externals.clang_getArraySize(_T) return res } fun clang_Type_getAlignOf(T: CXType): Long { - val _T = T.getNativePtr().asLong() + val _T = T.rawPtr val res = externals.clang_Type_getAlignOf(_T) return res } -fun clang_Type_getClassType(T: CXType, retValPlacement: Placement): CXType { - val _T = T.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXType.size).asLong() +fun clang_Type_getClassType(T: CXType, retValPlacement: NativePlacement): CXType { + val _T = T.rawPtr + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_Type_getClassType(_T, _retValPlacement) - return NativePtr.byValue(res).asRef(CXType)!! + return interpretPointed(res) } fun clang_Type_getSizeOf(T: CXType): Long { - val _T = T.getNativePtr().asLong() + val _T = T.rawPtr val res = externals.clang_Type_getSizeOf(_T) return res } fun clang_Type_getOffsetOf(T: CXType, S: String?): Long { - val _T = T.getNativePtr().asLong() - val _S = CString.fromString(S).getNativePtr().asLong() - val res = externals.clang_Type_getOffsetOf(_T, _S) - free(NativePtr.byValue(_S)) - return res + memScoped { + val _T = T.rawPtr + val _S = S?.toCString(memScope).rawPtr + val res = externals.clang_Type_getOffsetOf(_T, _S) + return res + } } fun clang_Cursor_getOffsetOfField(C: CXCursor): Long { - val _C = C.getNativePtr().asLong() + val _C = C.rawPtr val res = externals.clang_Cursor_getOffsetOfField(_C) return res } fun clang_Cursor_isAnonymous(C: CXCursor): Int { - val _C = C.getNativePtr().asLong() + val _C = C.rawPtr val res = externals.clang_Cursor_isAnonymous(_C) return res } fun clang_Type_getNumTemplateArguments(T: CXType): Int { - val _T = T.getNativePtr().asLong() + val _T = T.rawPtr val res = externals.clang_Type_getNumTemplateArguments(_T) return res } -fun clang_Type_getTemplateArgumentAsType(T: CXType, i: Int, retValPlacement: Placement): CXType { - val _T = T.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXType.size).asLong() - val res = externals.clang_Type_getTemplateArgumentAsType(_T, i, _retValPlacement) - return NativePtr.byValue(res).asRef(CXType)!! +fun clang_Type_getTemplateArgumentAsType(T: CXType, i: Int, retValPlacement: NativePlacement): CXType { + val _T = T.rawPtr + val _i = i + val _retValPlacement = retValPlacement.alloc().rawPtr + val res = externals.clang_Type_getTemplateArgumentAsType(_T, _i, _retValPlacement) + return interpretPointed(res) } fun clang_Type_getCXXRefQualifier(T: CXType): CXRefQualifierKind { - val _T = T.getNativePtr().asLong() + val _T = T.rawPtr val res = externals.clang_Type_getCXXRefQualifier(_T) return CXRefQualifierKind.byValue(res) } fun clang_Cursor_isBitField(C: CXCursor): Int { - val _C = C.getNativePtr().asLong() + val _C = C.rawPtr val res = externals.clang_Cursor_isBitField(_C) return res } fun clang_isVirtualBase(arg0: CXCursor): Int { - val _arg0 = arg0.getNativePtr().asLong() + val _arg0 = arg0.rawPtr val res = externals.clang_isVirtualBase(_arg0) return res } fun clang_getCXXAccessSpecifier(arg0: CXCursor): CX_CXXAccessSpecifier { - val _arg0 = arg0.getNativePtr().asLong() + val _arg0 = arg0.rawPtr val res = externals.clang_getCXXAccessSpecifier(_arg0) return CX_CXXAccessSpecifier.byValue(res) } fun clang_Cursor_getStorageClass(arg0: CXCursor): CX_StorageClass { - val _arg0 = arg0.getNativePtr().asLong() + val _arg0 = arg0.rawPtr val res = externals.clang_Cursor_getStorageClass(_arg0) return CX_StorageClass.byValue(res) } fun clang_getNumOverloadedDecls(cursor: CXCursor): Int { - val _cursor = cursor.getNativePtr().asLong() + val _cursor = cursor.rawPtr val res = externals.clang_getNumOverloadedDecls(_cursor) return res } -fun clang_getOverloadedDecl(cursor: CXCursor, index: Int, retValPlacement: Placement): CXCursor { - val _cursor = cursor.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXCursor.size).asLong() - val res = externals.clang_getOverloadedDecl(_cursor, index, _retValPlacement) - return NativePtr.byValue(res).asRef(CXCursor)!! +fun clang_getOverloadedDecl(cursor: CXCursor, index: Int, retValPlacement: NativePlacement): CXCursor { + val _cursor = cursor.rawPtr + val _index = index + val _retValPlacement = retValPlacement.alloc().rawPtr + val res = externals.clang_getOverloadedDecl(_cursor, _index, _retValPlacement) + return interpretPointed(res) } -fun clang_getIBOutletCollectionType(arg0: CXCursor, retValPlacement: Placement): CXType { - val _arg0 = arg0.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXType.size).asLong() +fun clang_getIBOutletCollectionType(arg0: CXCursor, retValPlacement: NativePlacement): CXType { + val _arg0 = arg0.rawPtr + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_getIBOutletCollectionType(_arg0, _retValPlacement) - return NativePtr.byValue(res).asRef(CXType)!! + return interpretPointed(res) } -fun clang_visitChildren(parent: CXCursor, visitor: ((CXCursor, CXCursor, NativePtr?) -> CXChildVisitResult)?, client_data: NativePtr?): Int { - val _parent = parent.getNativePtr().asLong() - val _visitor = visitor?.staticAsNative(NativeFunctionType1).asLong() - val _client_data = client_data.asLong() +fun clang_visitChildren(parent: CXCursor, visitor: CXCursorVisitor?, client_data: CXClientData?): Int { + val _parent = parent.rawPtr + val _visitor = visitor.rawValue + val _client_data = client_data.rawValue val res = externals.clang_visitChildren(_parent, _visitor, _client_data) return res } -fun clang_getCursorUSR(arg0: CXCursor, retValPlacement: Placement): CXString { - val _arg0 = arg0.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXString.size).asLong() +fun clang_getCursorUSR(arg0: CXCursor, retValPlacement: NativePlacement): CXString { + val _arg0 = arg0.rawPtr + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_getCursorUSR(_arg0, _retValPlacement) - return NativePtr.byValue(res).asRef(CXString)!! + return interpretPointed(res) } -fun clang_constructUSR_ObjCClass(class_name: String?, retValPlacement: Placement): CXString { - val _class_name = CString.fromString(class_name).getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXString.size).asLong() - val res = externals.clang_constructUSR_ObjCClass(_class_name, _retValPlacement) - free(NativePtr.byValue(_class_name)) - return NativePtr.byValue(res).asRef(CXString)!! +fun clang_constructUSR_ObjCClass(class_name: String?, retValPlacement: NativePlacement): CXString { + memScoped { + val _class_name = class_name?.toCString(memScope).rawPtr + val _retValPlacement = retValPlacement.alloc().rawPtr + val res = externals.clang_constructUSR_ObjCClass(_class_name, _retValPlacement) + return interpretPointed(res) + } } -fun clang_constructUSR_ObjCCategory(class_name: String?, category_name: String?, retValPlacement: Placement): CXString { - val _class_name = CString.fromString(class_name).getNativePtr().asLong() - val _category_name = CString.fromString(category_name).getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXString.size).asLong() - val res = externals.clang_constructUSR_ObjCCategory(_class_name, _category_name, _retValPlacement) - free(NativePtr.byValue(_class_name)) - free(NativePtr.byValue(_category_name)) - return NativePtr.byValue(res).asRef(CXString)!! +fun clang_constructUSR_ObjCCategory(class_name: String?, category_name: String?, retValPlacement: NativePlacement): CXString { + memScoped { + val _class_name = class_name?.toCString(memScope).rawPtr + val _category_name = category_name?.toCString(memScope).rawPtr + val _retValPlacement = retValPlacement.alloc().rawPtr + val res = externals.clang_constructUSR_ObjCCategory(_class_name, _category_name, _retValPlacement) + return interpretPointed(res) + } } -fun clang_constructUSR_ObjCProtocol(protocol_name: String?, retValPlacement: Placement): CXString { - val _protocol_name = CString.fromString(protocol_name).getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXString.size).asLong() - val res = externals.clang_constructUSR_ObjCProtocol(_protocol_name, _retValPlacement) - free(NativePtr.byValue(_protocol_name)) - return NativePtr.byValue(res).asRef(CXString)!! +fun clang_constructUSR_ObjCProtocol(protocol_name: String?, retValPlacement: NativePlacement): CXString { + memScoped { + val _protocol_name = protocol_name?.toCString(memScope).rawPtr + val _retValPlacement = retValPlacement.alloc().rawPtr + val res = externals.clang_constructUSR_ObjCProtocol(_protocol_name, _retValPlacement) + return interpretPointed(res) + } } -fun clang_constructUSR_ObjCIvar(name: String?, classUSR: CXString, retValPlacement: Placement): CXString { - val _name = CString.fromString(name).getNativePtr().asLong() - val _classUSR = classUSR.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXString.size).asLong() - val res = externals.clang_constructUSR_ObjCIvar(_name, _classUSR, _retValPlacement) - free(NativePtr.byValue(_name)) - return NativePtr.byValue(res).asRef(CXString)!! +fun clang_constructUSR_ObjCIvar(name: String?, classUSR: CXString, retValPlacement: NativePlacement): CXString { + memScoped { + val _name = name?.toCString(memScope).rawPtr + val _classUSR = classUSR.rawPtr + val _retValPlacement = retValPlacement.alloc().rawPtr + val res = externals.clang_constructUSR_ObjCIvar(_name, _classUSR, _retValPlacement) + return interpretPointed(res) + } } -fun clang_constructUSR_ObjCMethod(name: String?, isInstanceMethod: Int, classUSR: CXString, retValPlacement: Placement): CXString { - val _name = CString.fromString(name).getNativePtr().asLong() - val _classUSR = classUSR.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXString.size).asLong() - val res = externals.clang_constructUSR_ObjCMethod(_name, isInstanceMethod, _classUSR, _retValPlacement) - free(NativePtr.byValue(_name)) - return NativePtr.byValue(res).asRef(CXString)!! +fun clang_constructUSR_ObjCMethod(name: String?, isInstanceMethod: Int, classUSR: CXString, retValPlacement: NativePlacement): CXString { + memScoped { + val _name = name?.toCString(memScope).rawPtr + val _isInstanceMethod = isInstanceMethod + val _classUSR = classUSR.rawPtr + val _retValPlacement = retValPlacement.alloc().rawPtr + val res = externals.clang_constructUSR_ObjCMethod(_name, _isInstanceMethod, _classUSR, _retValPlacement) + return interpretPointed(res) + } } -fun clang_constructUSR_ObjCProperty(property: String?, classUSR: CXString, retValPlacement: Placement): CXString { - val _property = CString.fromString(property).getNativePtr().asLong() - val _classUSR = classUSR.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXString.size).asLong() - val res = externals.clang_constructUSR_ObjCProperty(_property, _classUSR, _retValPlacement) - free(NativePtr.byValue(_property)) - return NativePtr.byValue(res).asRef(CXString)!! +fun clang_constructUSR_ObjCProperty(property: String?, classUSR: CXString, retValPlacement: NativePlacement): CXString { + memScoped { + val _property = property?.toCString(memScope).rawPtr + val _classUSR = classUSR.rawPtr + val _retValPlacement = retValPlacement.alloc().rawPtr + val res = externals.clang_constructUSR_ObjCProperty(_property, _classUSR, _retValPlacement) + return interpretPointed(res) + } } -fun clang_getCursorSpelling(arg0: CXCursor, retValPlacement: Placement): CXString { - val _arg0 = arg0.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXString.size).asLong() +fun clang_getCursorSpelling(arg0: CXCursor, retValPlacement: NativePlacement): CXString { + val _arg0 = arg0.rawPtr + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_getCursorSpelling(_arg0, _retValPlacement) - return NativePtr.byValue(res).asRef(CXString)!! + return interpretPointed(res) } -fun clang_Cursor_getSpellingNameRange(arg0: CXCursor, pieceIndex: Int, options: Int, retValPlacement: Placement): CXSourceRange { - val _arg0 = arg0.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXSourceRange.size).asLong() - val res = externals.clang_Cursor_getSpellingNameRange(_arg0, pieceIndex, options, _retValPlacement) - return NativePtr.byValue(res).asRef(CXSourceRange)!! +fun clang_Cursor_getSpellingNameRange(arg0: CXCursor, pieceIndex: Int, options: Int, retValPlacement: NativePlacement): CXSourceRange { + val _arg0 = arg0.rawPtr + val _pieceIndex = pieceIndex + val _options = options + val _retValPlacement = retValPlacement.alloc().rawPtr + val res = externals.clang_Cursor_getSpellingNameRange(_arg0, _pieceIndex, _options, _retValPlacement) + return interpretPointed(res) } -fun clang_getCursorDisplayName(arg0: CXCursor, retValPlacement: Placement): CXString { - val _arg0 = arg0.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXString.size).asLong() +fun clang_getCursorDisplayName(arg0: CXCursor, retValPlacement: NativePlacement): CXString { + val _arg0 = arg0.rawPtr + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_getCursorDisplayName(_arg0, _retValPlacement) - return NativePtr.byValue(res).asRef(CXString)!! + return interpretPointed(res) } -fun clang_getCursorReferenced(arg0: CXCursor, retValPlacement: Placement): CXCursor { - val _arg0 = arg0.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXCursor.size).asLong() +fun clang_getCursorReferenced(arg0: CXCursor, retValPlacement: NativePlacement): CXCursor { + val _arg0 = arg0.rawPtr + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_getCursorReferenced(_arg0, _retValPlacement) - return NativePtr.byValue(res).asRef(CXCursor)!! + return interpretPointed(res) } -fun clang_getCursorDefinition(arg0: CXCursor, retValPlacement: Placement): CXCursor { - val _arg0 = arg0.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXCursor.size).asLong() +fun clang_getCursorDefinition(arg0: CXCursor, retValPlacement: NativePlacement): CXCursor { + val _arg0 = arg0.rawPtr + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_getCursorDefinition(_arg0, _retValPlacement) - return NativePtr.byValue(res).asRef(CXCursor)!! + return interpretPointed(res) } fun clang_isCursorDefinition(arg0: CXCursor): Int { - val _arg0 = arg0.getNativePtr().asLong() + val _arg0 = arg0.rawPtr val res = externals.clang_isCursorDefinition(_arg0) return res } -fun clang_getCanonicalCursor(arg0: CXCursor, retValPlacement: Placement): CXCursor { - val _arg0 = arg0.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXCursor.size).asLong() +fun clang_getCanonicalCursor(arg0: CXCursor, retValPlacement: NativePlacement): CXCursor { + val _arg0 = arg0.rawPtr + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_getCanonicalCursor(_arg0, _retValPlacement) - return NativePtr.byValue(res).asRef(CXCursor)!! + return interpretPointed(res) } fun clang_Cursor_getObjCSelectorIndex(arg0: CXCursor): Int { - val _arg0 = arg0.getNativePtr().asLong() + val _arg0 = arg0.rawPtr val res = externals.clang_Cursor_getObjCSelectorIndex(_arg0) return res } fun clang_Cursor_isDynamicCall(C: CXCursor): Int { - val _C = C.getNativePtr().asLong() + val _C = C.rawPtr val res = externals.clang_Cursor_isDynamicCall(_C) return res } -fun clang_Cursor_getReceiverType(C: CXCursor, retValPlacement: Placement): CXType { - val _C = C.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXType.size).asLong() +fun clang_Cursor_getReceiverType(C: CXCursor, retValPlacement: NativePlacement): CXType { + val _C = C.rawPtr + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_Cursor_getReceiverType(_C, _retValPlacement) - return NativePtr.byValue(res).asRef(CXType)!! + return interpretPointed(res) } fun clang_Cursor_getObjCPropertyAttributes(C: CXCursor, reserved: Int): Int { - val _C = C.getNativePtr().asLong() - val res = externals.clang_Cursor_getObjCPropertyAttributes(_C, reserved) + val _C = C.rawPtr + val _reserved = reserved + val res = externals.clang_Cursor_getObjCPropertyAttributes(_C, _reserved) return res } fun clang_Cursor_getObjCDeclQualifiers(C: CXCursor): Int { - val _C = C.getNativePtr().asLong() + val _C = C.rawPtr val res = externals.clang_Cursor_getObjCDeclQualifiers(_C) return res } fun clang_Cursor_isObjCOptional(C: CXCursor): Int { - val _C = C.getNativePtr().asLong() + val _C = C.rawPtr val res = externals.clang_Cursor_isObjCOptional(_C) return res } fun clang_Cursor_isVariadic(C: CXCursor): Int { - val _C = C.getNativePtr().asLong() + val _C = C.rawPtr val res = externals.clang_Cursor_isVariadic(_C) return res } -fun clang_Cursor_getCommentRange(C: CXCursor, retValPlacement: Placement): CXSourceRange { - val _C = C.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXSourceRange.size).asLong() +fun clang_Cursor_getCommentRange(C: CXCursor, retValPlacement: NativePlacement): CXSourceRange { + val _C = C.rawPtr + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_Cursor_getCommentRange(_C, _retValPlacement) - return NativePtr.byValue(res).asRef(CXSourceRange)!! + return interpretPointed(res) } -fun clang_Cursor_getRawCommentText(C: CXCursor, retValPlacement: Placement): CXString { - val _C = C.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXString.size).asLong() +fun clang_Cursor_getRawCommentText(C: CXCursor, retValPlacement: NativePlacement): CXString { + val _C = C.rawPtr + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_Cursor_getRawCommentText(_C, _retValPlacement) - return NativePtr.byValue(res).asRef(CXString)!! + return interpretPointed(res) } -fun clang_Cursor_getBriefCommentText(C: CXCursor, retValPlacement: Placement): CXString { - val _C = C.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXString.size).asLong() +fun clang_Cursor_getBriefCommentText(C: CXCursor, retValPlacement: NativePlacement): CXString { + val _C = C.rawPtr + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_Cursor_getBriefCommentText(_C, _retValPlacement) - return NativePtr.byValue(res).asRef(CXString)!! + return interpretPointed(res) } -fun clang_Cursor_getMangling(arg0: CXCursor, retValPlacement: Placement): CXString { - val _arg0 = arg0.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXString.size).asLong() +fun clang_Cursor_getMangling(arg0: CXCursor, retValPlacement: NativePlacement): CXString { + val _arg0 = arg0.rawPtr + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_Cursor_getMangling(_arg0, _retValPlacement) - return NativePtr.byValue(res).asRef(CXString)!! + return interpretPointed(res) } -fun clang_Cursor_getCXXManglings(arg0: CXCursor): CXStringSet? { - val _arg0 = arg0.getNativePtr().asLong() +fun clang_Cursor_getCXXManglings(arg0: CXCursor): CPointer? { + val _arg0 = arg0.rawPtr val res = externals.clang_Cursor_getCXXManglings(_arg0) - return NativePtr.byValue(res).asRef(CXStringSet) + return CPointer.createNullable(res) } -fun clang_Cursor_getModule(C: CXCursor): NativePtr? { - val _C = C.getNativePtr().asLong() +fun clang_Cursor_getModule(C: CXCursor): CXModule? { + val _C = C.rawPtr val res = externals.clang_Cursor_getModule(_C) - return NativePtr.byValue(res) + return CPointer.createNullable(res) } -fun clang_getModuleForFile(arg0: CXTranslationUnitImpl?, arg1: NativePtr?): NativePtr? { - val _arg0 = arg0.getNativePtr().asLong() - val _arg1 = arg1.asLong() +fun clang_getModuleForFile(arg0: CXTranslationUnit?, arg1: CXFile?): CXModule? { + val _arg0 = arg0.rawValue + val _arg1 = arg1.rawValue val res = externals.clang_getModuleForFile(_arg0, _arg1) - return NativePtr.byValue(res) + return CPointer.createNullable(res) } -fun clang_Module_getASTFile(Module: NativePtr?): NativePtr? { - val _Module = Module.asLong() +fun clang_Module_getASTFile(Module: CXModule?): CXFile? { + val _Module = Module.rawValue val res = externals.clang_Module_getASTFile(_Module) - return NativePtr.byValue(res) + return CPointer.createNullable(res) } -fun clang_Module_getParent(Module: NativePtr?): NativePtr? { - val _Module = Module.asLong() +fun clang_Module_getParent(Module: CXModule?): CXModule? { + val _Module = Module.rawValue val res = externals.clang_Module_getParent(_Module) - return NativePtr.byValue(res) + return CPointer.createNullable(res) } -fun clang_Module_getName(Module: NativePtr?, retValPlacement: Placement): CXString { - val _Module = Module.asLong() - val _retValPlacement = retValPlacement.alloc(CXString.size).asLong() +fun clang_Module_getName(Module: CXModule?, retValPlacement: NativePlacement): CXString { + val _Module = Module.rawValue + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_Module_getName(_Module, _retValPlacement) - return NativePtr.byValue(res).asRef(CXString)!! + return interpretPointed(res) } -fun clang_Module_getFullName(Module: NativePtr?, retValPlacement: Placement): CXString { - val _Module = Module.asLong() - val _retValPlacement = retValPlacement.alloc(CXString.size).asLong() +fun clang_Module_getFullName(Module: CXModule?, retValPlacement: NativePlacement): CXString { + val _Module = Module.rawValue + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_Module_getFullName(_Module, _retValPlacement) - return NativePtr.byValue(res).asRef(CXString)!! + return interpretPointed(res) } -fun clang_Module_isSystem(Module: NativePtr?): Int { - val _Module = Module.asLong() +fun clang_Module_isSystem(Module: CXModule?): Int { + val _Module = Module.rawValue val res = externals.clang_Module_isSystem(_Module) return res } -fun clang_Module_getNumTopLevelHeaders(arg0: CXTranslationUnitImpl?, Module: NativePtr?): Int { - val _arg0 = arg0.getNativePtr().asLong() - val _Module = Module.asLong() +fun clang_Module_getNumTopLevelHeaders(arg0: CXTranslationUnit?, Module: CXModule?): Int { + val _arg0 = arg0.rawValue + val _Module = Module.rawValue val res = externals.clang_Module_getNumTopLevelHeaders(_arg0, _Module) return res } -fun clang_Module_getTopLevelHeader(arg0: CXTranslationUnitImpl?, Module: NativePtr?, Index: Int): NativePtr? { - val _arg0 = arg0.getNativePtr().asLong() - val _Module = Module.asLong() - val res = externals.clang_Module_getTopLevelHeader(_arg0, _Module, Index) - return NativePtr.byValue(res) +fun clang_Module_getTopLevelHeader(arg0: CXTranslationUnit?, Module: CXModule?, Index: Int): CXFile? { + val _arg0 = arg0.rawValue + val _Module = Module.rawValue + val _Index = Index + val res = externals.clang_Module_getTopLevelHeader(_arg0, _Module, _Index) + return CPointer.createNullable(res) } fun clang_CXXField_isMutable(C: CXCursor): Int { - val _C = C.getNativePtr().asLong() + val _C = C.rawPtr val res = externals.clang_CXXField_isMutable(_C) return res } fun clang_CXXMethod_isPureVirtual(C: CXCursor): Int { - val _C = C.getNativePtr().asLong() + val _C = C.rawPtr val res = externals.clang_CXXMethod_isPureVirtual(_C) return res } fun clang_CXXMethod_isStatic(C: CXCursor): Int { - val _C = C.getNativePtr().asLong() + val _C = C.rawPtr val res = externals.clang_CXXMethod_isStatic(_C) return res } fun clang_CXXMethod_isVirtual(C: CXCursor): Int { - val _C = C.getNativePtr().asLong() + val _C = C.rawPtr val res = externals.clang_CXXMethod_isVirtual(_C) return res } fun clang_CXXMethod_isConst(C: CXCursor): Int { - val _C = C.getNativePtr().asLong() + val _C = C.rawPtr val res = externals.clang_CXXMethod_isConst(_C) return res } fun clang_getTemplateCursorKind(C: CXCursor): CXCursorKind { - val _C = C.getNativePtr().asLong() + val _C = C.rawPtr val res = externals.clang_getTemplateCursorKind(_C) return CXCursorKind.byValue(res) } -fun clang_getSpecializedCursorTemplate(C: CXCursor, retValPlacement: Placement): CXCursor { - val _C = C.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXCursor.size).asLong() +fun clang_getSpecializedCursorTemplate(C: CXCursor, retValPlacement: NativePlacement): CXCursor { + val _C = C.rawPtr + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_getSpecializedCursorTemplate(_C, _retValPlacement) - return NativePtr.byValue(res).asRef(CXCursor)!! + return interpretPointed(res) } -fun clang_getCursorReferenceNameRange(C: CXCursor, NameFlags: Int, PieceIndex: Int, retValPlacement: Placement): CXSourceRange { - val _C = C.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXSourceRange.size).asLong() - val res = externals.clang_getCursorReferenceNameRange(_C, NameFlags, PieceIndex, _retValPlacement) - return NativePtr.byValue(res).asRef(CXSourceRange)!! +fun clang_getCursorReferenceNameRange(C: CXCursor, NameFlags: Int, PieceIndex: Int, retValPlacement: NativePlacement): CXSourceRange { + val _C = C.rawPtr + val _NameFlags = NameFlags + val _PieceIndex = PieceIndex + val _retValPlacement = retValPlacement.alloc().rawPtr + val res = externals.clang_getCursorReferenceNameRange(_C, _NameFlags, _PieceIndex, _retValPlacement) + return interpretPointed(res) } fun clang_getTokenKind(arg0: CXToken): CXTokenKind { - val _arg0 = arg0.getNativePtr().asLong() + val _arg0 = arg0.rawPtr val res = externals.clang_getTokenKind(_arg0) return CXTokenKind.byValue(res) } -fun clang_getTokenSpelling(arg0: CXTranslationUnitImpl?, arg1: CXToken, retValPlacement: Placement): CXString { - val _arg0 = arg0.getNativePtr().asLong() - val _arg1 = arg1.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXString.size).asLong() +fun clang_getTokenSpelling(arg0: CXTranslationUnit?, arg1: CXToken, retValPlacement: NativePlacement): CXString { + val _arg0 = arg0.rawValue + val _arg1 = arg1.rawPtr + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_getTokenSpelling(_arg0, _arg1, _retValPlacement) - return NativePtr.byValue(res).asRef(CXString)!! + return interpretPointed(res) } -fun clang_getTokenLocation(arg0: CXTranslationUnitImpl?, arg1: CXToken, retValPlacement: Placement): CXSourceLocation { - val _arg0 = arg0.getNativePtr().asLong() - val _arg1 = arg1.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXSourceLocation.size).asLong() +fun clang_getTokenLocation(arg0: CXTranslationUnit?, arg1: CXToken, retValPlacement: NativePlacement): CXSourceLocation { + val _arg0 = arg0.rawValue + val _arg1 = arg1.rawPtr + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_getTokenLocation(_arg0, _arg1, _retValPlacement) - return NativePtr.byValue(res).asRef(CXSourceLocation)!! + return interpretPointed(res) } -fun clang_getTokenExtent(arg0: CXTranslationUnitImpl?, arg1: CXToken, retValPlacement: Placement): CXSourceRange { - val _arg0 = arg0.getNativePtr().asLong() - val _arg1 = arg1.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXSourceRange.size).asLong() +fun clang_getTokenExtent(arg0: CXTranslationUnit?, arg1: CXToken, retValPlacement: NativePlacement): CXSourceRange { + val _arg0 = arg0.rawValue + val _arg1 = arg1.rawPtr + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_getTokenExtent(_arg0, _arg1, _retValPlacement) - return NativePtr.byValue(res).asRef(CXSourceRange)!! + return interpretPointed(res) } -fun clang_tokenize(TU: CXTranslationUnitImpl?, Range: CXSourceRange, Tokens: RefBox?, NumTokens: Int32Box?): Unit { - val _TU = TU.getNativePtr().asLong() - val _Range = Range.getNativePtr().asLong() - val _Tokens = Tokens.getNativePtr().asLong() - val _NumTokens = NumTokens.getNativePtr().asLong() +fun clang_tokenize(TU: CXTranslationUnit?, Range: CXSourceRange, Tokens: CPointer>?, NumTokens: CPointer?): Unit { + val _TU = TU.rawValue + val _Range = Range.rawPtr + val _Tokens = Tokens.rawValue + val _NumTokens = NumTokens.rawValue val res = externals.clang_tokenize(_TU, _Range, _Tokens, _NumTokens) return res } -fun clang_annotateTokens(TU: CXTranslationUnitImpl?, Tokens: CXToken?, NumTokens: Int, Cursors: CXCursor?): Unit { - val _TU = TU.getNativePtr().asLong() - val _Tokens = Tokens.getNativePtr().asLong() - val _Cursors = Cursors.getNativePtr().asLong() - val res = externals.clang_annotateTokens(_TU, _Tokens, NumTokens, _Cursors) +fun clang_annotateTokens(TU: CXTranslationUnit?, Tokens: CPointer?, NumTokens: Int, Cursors: CPointer?): Unit { + val _TU = TU.rawValue + val _Tokens = Tokens.rawValue + val _NumTokens = NumTokens + val _Cursors = Cursors.rawValue + val res = externals.clang_annotateTokens(_TU, _Tokens, _NumTokens, _Cursors) return res } -fun clang_disposeTokens(TU: CXTranslationUnitImpl?, Tokens: CXToken?, NumTokens: Int): Unit { - val _TU = TU.getNativePtr().asLong() - val _Tokens = Tokens.getNativePtr().asLong() - val res = externals.clang_disposeTokens(_TU, _Tokens, NumTokens) +fun clang_disposeTokens(TU: CXTranslationUnit?, Tokens: CPointer?, NumTokens: Int): Unit { + val _TU = TU.rawValue + val _Tokens = Tokens.rawValue + val _NumTokens = NumTokens + val res = externals.clang_disposeTokens(_TU, _Tokens, _NumTokens) return res } -fun clang_getCursorKindSpelling(Kind: CXCursorKind, retValPlacement: Placement): CXString { +fun clang_getCursorKindSpelling(Kind: CXCursorKind, retValPlacement: NativePlacement): CXString { val _Kind = Kind.value - val _retValPlacement = retValPlacement.alloc(CXString.size).asLong() + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_getCursorKindSpelling(_Kind, _retValPlacement) - return NativePtr.byValue(res).asRef(CXString)!! + return interpretPointed(res) } -fun clang_getDefinitionSpellingAndExtent(arg0: CXCursor, startBuf: RefBox?, endBuf: RefBox?, startLine: Int32Box?, startColumn: Int32Box?, endLine: Int32Box?, endColumn: Int32Box?): Unit { - val _arg0 = arg0.getNativePtr().asLong() - val _startBuf = startBuf.getNativePtr().asLong() - val _endBuf = endBuf.getNativePtr().asLong() - val _startLine = startLine.getNativePtr().asLong() - val _startColumn = startColumn.getNativePtr().asLong() - val _endLine = endLine.getNativePtr().asLong() - val _endColumn = endColumn.getNativePtr().asLong() +fun clang_getDefinitionSpellingAndExtent(arg0: CXCursor, startBuf: CPointer>?, endBuf: CPointer>?, startLine: CPointer?, startColumn: CPointer?, endLine: CPointer?, endColumn: CPointer?): Unit { + val _arg0 = arg0.rawPtr + val _startBuf = startBuf.rawValue + val _endBuf = endBuf.rawValue + val _startLine = startLine.rawValue + val _startColumn = startColumn.rawValue + val _endLine = endLine.rawValue + val _endColumn = endColumn.rawValue val res = externals.clang_getDefinitionSpellingAndExtent(_arg0, _startBuf, _endBuf, _startLine, _startColumn, _endLine, _endColumn) return res } @@ -1636,82 +1735,87 @@ fun clang_enableStackTraces(): Unit { return res } -fun clang_executeOnThread(fn: ((NativePtr?) -> Unit)?, user_data: NativePtr?, stack_size: Int): Unit { - val _fn = fn?.staticAsNative(NativeFunctionType2).asLong() - val _user_data = user_data.asLong() - val res = externals.clang_executeOnThread(_fn, _user_data, stack_size) +fun clang_executeOnThread(fn: CFunctionPointer?, user_data: COpaquePointer?, stack_size: Int): Unit { + val _fn = fn.rawValue + val _user_data = user_data.rawValue + val _stack_size = stack_size + val res = externals.clang_executeOnThread(_fn, _user_data, _stack_size) return res } -fun clang_getCompletionChunkKind(completion_string: NativePtr?, chunk_number: Int): CXCompletionChunkKind { - val _completion_string = completion_string.asLong() - val res = externals.clang_getCompletionChunkKind(_completion_string, chunk_number) +fun clang_getCompletionChunkKind(completion_string: CXCompletionString?, chunk_number: Int): CXCompletionChunkKind { + val _completion_string = completion_string.rawValue + val _chunk_number = chunk_number + val res = externals.clang_getCompletionChunkKind(_completion_string, _chunk_number) return CXCompletionChunkKind.byValue(res) } -fun clang_getCompletionChunkText(completion_string: NativePtr?, chunk_number: Int, retValPlacement: Placement): CXString { - val _completion_string = completion_string.asLong() - val _retValPlacement = retValPlacement.alloc(CXString.size).asLong() - val res = externals.clang_getCompletionChunkText(_completion_string, chunk_number, _retValPlacement) - return NativePtr.byValue(res).asRef(CXString)!! +fun clang_getCompletionChunkText(completion_string: CXCompletionString?, chunk_number: Int, retValPlacement: NativePlacement): CXString { + val _completion_string = completion_string.rawValue + val _chunk_number = chunk_number + val _retValPlacement = retValPlacement.alloc().rawPtr + val res = externals.clang_getCompletionChunkText(_completion_string, _chunk_number, _retValPlacement) + return interpretPointed(res) } -fun clang_getCompletionChunkCompletionString(completion_string: NativePtr?, chunk_number: Int): NativePtr? { - val _completion_string = completion_string.asLong() - val res = externals.clang_getCompletionChunkCompletionString(_completion_string, chunk_number) - return NativePtr.byValue(res) +fun clang_getCompletionChunkCompletionString(completion_string: CXCompletionString?, chunk_number: Int): CXCompletionString? { + val _completion_string = completion_string.rawValue + val _chunk_number = chunk_number + val res = externals.clang_getCompletionChunkCompletionString(_completion_string, _chunk_number) + return CPointer.createNullable(res) } -fun clang_getNumCompletionChunks(completion_string: NativePtr?): Int { - val _completion_string = completion_string.asLong() +fun clang_getNumCompletionChunks(completion_string: CXCompletionString?): Int { + val _completion_string = completion_string.rawValue val res = externals.clang_getNumCompletionChunks(_completion_string) return res } -fun clang_getCompletionPriority(completion_string: NativePtr?): Int { - val _completion_string = completion_string.asLong() +fun clang_getCompletionPriority(completion_string: CXCompletionString?): Int { + val _completion_string = completion_string.rawValue val res = externals.clang_getCompletionPriority(_completion_string) return res } -fun clang_getCompletionAvailability(completion_string: NativePtr?): CXAvailabilityKind { - val _completion_string = completion_string.asLong() +fun clang_getCompletionAvailability(completion_string: CXCompletionString?): CXAvailabilityKind { + val _completion_string = completion_string.rawValue val res = externals.clang_getCompletionAvailability(_completion_string) return CXAvailabilityKind.byValue(res) } -fun clang_getCompletionNumAnnotations(completion_string: NativePtr?): Int { - val _completion_string = completion_string.asLong() +fun clang_getCompletionNumAnnotations(completion_string: CXCompletionString?): Int { + val _completion_string = completion_string.rawValue val res = externals.clang_getCompletionNumAnnotations(_completion_string) return res } -fun clang_getCompletionAnnotation(completion_string: NativePtr?, annotation_number: Int, retValPlacement: Placement): CXString { - val _completion_string = completion_string.asLong() - val _retValPlacement = retValPlacement.alloc(CXString.size).asLong() - val res = externals.clang_getCompletionAnnotation(_completion_string, annotation_number, _retValPlacement) - return NativePtr.byValue(res).asRef(CXString)!! +fun clang_getCompletionAnnotation(completion_string: CXCompletionString?, annotation_number: Int, retValPlacement: NativePlacement): CXString { + val _completion_string = completion_string.rawValue + val _annotation_number = annotation_number + val _retValPlacement = retValPlacement.alloc().rawPtr + val res = externals.clang_getCompletionAnnotation(_completion_string, _annotation_number, _retValPlacement) + return interpretPointed(res) } -fun clang_getCompletionParent(completion_string: NativePtr?, kind: CXCursorKind.ref?, retValPlacement: Placement): CXString { - val _completion_string = completion_string.asLong() - val _kind = kind.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXString.size).asLong() +fun clang_getCompletionParent(completion_string: CXCompletionString?, kind: CPointer?, retValPlacement: NativePlacement): CXString { + val _completion_string = completion_string.rawValue + val _kind = kind.rawValue + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_getCompletionParent(_completion_string, _kind, _retValPlacement) - return NativePtr.byValue(res).asRef(CXString)!! + return interpretPointed(res) } -fun clang_getCompletionBriefComment(completion_string: NativePtr?, retValPlacement: Placement): CXString { - val _completion_string = completion_string.asLong() - val _retValPlacement = retValPlacement.alloc(CXString.size).asLong() +fun clang_getCompletionBriefComment(completion_string: CXCompletionString?, retValPlacement: NativePlacement): CXString { + val _completion_string = completion_string.rawValue + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_getCompletionBriefComment(_completion_string, _retValPlacement) - return NativePtr.byValue(res).asRef(CXString)!! + return interpretPointed(res) } -fun clang_getCursorCompletionString(cursor: CXCursor): NativePtr? { - val _cursor = cursor.getNativePtr().asLong() +fun clang_getCursorCompletionString(cursor: CXCursor): CXCompletionString? { + val _cursor = cursor.rawPtr val res = externals.clang_getCursorCompletionString(_cursor) - return NativePtr.byValue(res) + return CPointer.createNullable(res) } fun clang_defaultCodeCompleteOptions(): Int { @@ -1719,130 +1823,141 @@ fun clang_defaultCodeCompleteOptions(): Int { return res } -fun clang_codeCompleteAt(TU: CXTranslationUnitImpl?, complete_filename: String?, complete_line: Int, complete_column: Int, unsaved_files: CXUnsavedFile?, num_unsaved_files: Int, options: Int): CXCodeCompleteResults? { - val _TU = TU.getNativePtr().asLong() - val _complete_filename = CString.fromString(complete_filename).getNativePtr().asLong() - val _unsaved_files = unsaved_files.getNativePtr().asLong() - val res = externals.clang_codeCompleteAt(_TU, _complete_filename, complete_line, complete_column, _unsaved_files, num_unsaved_files, options) - free(NativePtr.byValue(_complete_filename)) - return NativePtr.byValue(res).asRef(CXCodeCompleteResults) +fun clang_codeCompleteAt(TU: CXTranslationUnit?, complete_filename: String?, complete_line: Int, complete_column: Int, unsaved_files: CPointer?, num_unsaved_files: Int, options: Int): CPointer? { + memScoped { + val _TU = TU.rawValue + val _complete_filename = complete_filename?.toCString(memScope).rawPtr + val _complete_line = complete_line + val _complete_column = complete_column + val _unsaved_files = unsaved_files.rawValue + val _num_unsaved_files = num_unsaved_files + val _options = options + val res = externals.clang_codeCompleteAt(_TU, _complete_filename, _complete_line, _complete_column, _unsaved_files, _num_unsaved_files, _options) + return CPointer.createNullable(res) + } } -fun clang_sortCodeCompletionResults(Results: CXCompletionResult?, NumResults: Int): Unit { - val _Results = Results.getNativePtr().asLong() - val res = externals.clang_sortCodeCompletionResults(_Results, NumResults) +fun clang_sortCodeCompletionResults(Results: CPointer?, NumResults: Int): Unit { + val _Results = Results.rawValue + val _NumResults = NumResults + val res = externals.clang_sortCodeCompletionResults(_Results, _NumResults) return res } -fun clang_disposeCodeCompleteResults(Results: CXCodeCompleteResults?): Unit { - val _Results = Results.getNativePtr().asLong() +fun clang_disposeCodeCompleteResults(Results: CPointer?): Unit { + val _Results = Results.rawValue val res = externals.clang_disposeCodeCompleteResults(_Results) return res } -fun clang_codeCompleteGetNumDiagnostics(Results: CXCodeCompleteResults?): Int { - val _Results = Results.getNativePtr().asLong() +fun clang_codeCompleteGetNumDiagnostics(Results: CPointer?): Int { + val _Results = Results.rawValue val res = externals.clang_codeCompleteGetNumDiagnostics(_Results) return res } -fun clang_codeCompleteGetDiagnostic(Results: CXCodeCompleteResults?, Index: Int): NativePtr? { - val _Results = Results.getNativePtr().asLong() - val res = externals.clang_codeCompleteGetDiagnostic(_Results, Index) - return NativePtr.byValue(res) +fun clang_codeCompleteGetDiagnostic(Results: CPointer?, Index: Int): CXDiagnostic? { + val _Results = Results.rawValue + val _Index = Index + val res = externals.clang_codeCompleteGetDiagnostic(_Results, _Index) + return CPointer.createNullable(res) } -fun clang_codeCompleteGetContexts(Results: CXCodeCompleteResults?): Long { - val _Results = Results.getNativePtr().asLong() +fun clang_codeCompleteGetContexts(Results: CPointer?): Long { + val _Results = Results.rawValue val res = externals.clang_codeCompleteGetContexts(_Results) return res } -fun clang_codeCompleteGetContainerKind(Results: CXCodeCompleteResults?, IsIncomplete: Int32Box?): CXCursorKind { - val _Results = Results.getNativePtr().asLong() - val _IsIncomplete = IsIncomplete.getNativePtr().asLong() +fun clang_codeCompleteGetContainerKind(Results: CPointer?, IsIncomplete: CPointer?): CXCursorKind { + val _Results = Results.rawValue + val _IsIncomplete = IsIncomplete.rawValue val res = externals.clang_codeCompleteGetContainerKind(_Results, _IsIncomplete) return CXCursorKind.byValue(res) } -fun clang_codeCompleteGetContainerUSR(Results: CXCodeCompleteResults?, retValPlacement: Placement): CXString { - val _Results = Results.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXString.size).asLong() +fun clang_codeCompleteGetContainerUSR(Results: CPointer?, retValPlacement: NativePlacement): CXString { + val _Results = Results.rawValue + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_codeCompleteGetContainerUSR(_Results, _retValPlacement) - return NativePtr.byValue(res).asRef(CXString)!! + return interpretPointed(res) } -fun clang_codeCompleteGetObjCSelector(Results: CXCodeCompleteResults?, retValPlacement: Placement): CXString { - val _Results = Results.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXString.size).asLong() +fun clang_codeCompleteGetObjCSelector(Results: CPointer?, retValPlacement: NativePlacement): CXString { + val _Results = Results.rawValue + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_codeCompleteGetObjCSelector(_Results, _retValPlacement) - return NativePtr.byValue(res).asRef(CXString)!! + return interpretPointed(res) } -fun clang_getClangVersion(retValPlacement: Placement): CXString { - val _retValPlacement = retValPlacement.alloc(CXString.size).asLong() +fun clang_getClangVersion(retValPlacement: NativePlacement): CXString { + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_getClangVersion(_retValPlacement) - return NativePtr.byValue(res).asRef(CXString)!! + return interpretPointed(res) } fun clang_toggleCrashRecovery(isEnabled: Int): Unit { - val res = externals.clang_toggleCrashRecovery(isEnabled) + val _isEnabled = isEnabled + val res = externals.clang_toggleCrashRecovery(_isEnabled) return res } -fun clang_getInclusions(tu: CXTranslationUnitImpl?, visitor: ((NativePtr?, CXSourceLocation?, Int, NativePtr?) -> Unit)?, client_data: NativePtr?): Unit { - val _tu = tu.getNativePtr().asLong() - val _visitor = visitor?.staticAsNative(NativeFunctionType3).asLong() - val _client_data = client_data.asLong() +fun clang_getInclusions(tu: CXTranslationUnit?, visitor: CXInclusionVisitor?, client_data: CXClientData?): Unit { + val _tu = tu.rawValue + val _visitor = visitor.rawValue + val _client_data = client_data.rawValue val res = externals.clang_getInclusions(_tu, _visitor, _client_data) return res } -fun clang_getRemappings(path: String?): NativePtr? { - val _path = CString.fromString(path).getNativePtr().asLong() - val res = externals.clang_getRemappings(_path) - free(NativePtr.byValue(_path)) - return NativePtr.byValue(res) +fun clang_getRemappings(path: String?): CXRemapping? { + memScoped { + val _path = path?.toCString(memScope).rawPtr + val res = externals.clang_getRemappings(_path) + return CPointer.createNullable(res) + } } -fun clang_getRemappingsFromFileList(filePaths: RefBox?, numFiles: Int): NativePtr? { - val _filePaths = filePaths.getNativePtr().asLong() - val res = externals.clang_getRemappingsFromFileList(_filePaths, numFiles) - return NativePtr.byValue(res) +fun clang_getRemappingsFromFileList(filePaths: CPointer>?, numFiles: Int): CXRemapping? { + val _filePaths = filePaths.rawValue + val _numFiles = numFiles + val res = externals.clang_getRemappingsFromFileList(_filePaths, _numFiles) + return CPointer.createNullable(res) } -fun clang_remap_getNumFiles(arg0: NativePtr?): Int { - val _arg0 = arg0.asLong() +fun clang_remap_getNumFiles(arg0: CXRemapping?): Int { + val _arg0 = arg0.rawValue val res = externals.clang_remap_getNumFiles(_arg0) return res } -fun clang_remap_getFilenames(arg0: NativePtr?, index: Int, original: CXString?, transformed: CXString?): Unit { - val _arg0 = arg0.asLong() - val _original = original.getNativePtr().asLong() - val _transformed = transformed.getNativePtr().asLong() - val res = externals.clang_remap_getFilenames(_arg0, index, _original, _transformed) +fun clang_remap_getFilenames(arg0: CXRemapping?, index: Int, original: CPointer?, transformed: CPointer?): Unit { + val _arg0 = arg0.rawValue + val _index = index + val _original = original.rawValue + val _transformed = transformed.rawValue + val res = externals.clang_remap_getFilenames(_arg0, _index, _original, _transformed) return res } -fun clang_remap_dispose(arg0: NativePtr?): Unit { - val _arg0 = arg0.asLong() +fun clang_remap_dispose(arg0: CXRemapping?): Unit { + val _arg0 = arg0.rawValue val res = externals.clang_remap_dispose(_arg0) return res } -fun clang_findReferencesInFile(cursor: CXCursor, file: NativePtr?, visitor: CXCursorAndRangeVisitor): CXResult { - val _cursor = cursor.getNativePtr().asLong() - val _file = file.asLong() - val _visitor = visitor.getNativePtr().asLong() +fun clang_findReferencesInFile(cursor: CXCursor, file: CXFile?, visitor: CXCursorAndRangeVisitor): CXResult { + val _cursor = cursor.rawPtr + val _file = file.rawValue + val _visitor = visitor.rawPtr val res = externals.clang_findReferencesInFile(_cursor, _file, _visitor) return CXResult.byValue(res) } -fun clang_findIncludesInFile(TU: CXTranslationUnitImpl?, file: NativePtr?, visitor: CXCursorAndRangeVisitor): CXResult { - val _TU = TU.getNativePtr().asLong() - val _file = file.asLong() - val _visitor = visitor.getNativePtr().asLong() +fun clang_findIncludesInFile(TU: CXTranslationUnit?, file: CXFile?, visitor: CXCursorAndRangeVisitor): CXResult { + val _TU = TU.rawValue + val _file = file.rawValue + val _visitor = visitor.rawPtr val res = externals.clang_findIncludesInFile(_TU, _file, _visitor) return CXResult.byValue(res) } @@ -1853,607 +1968,952 @@ fun clang_index_isEntityObjCContainerKind(arg0: CXIdxEntityKind): Int { return res } -fun clang_index_getObjCContainerDeclInfo(arg0: CXIdxDeclInfo?): CXIdxObjCContainerDeclInfo? { - val _arg0 = arg0.getNativePtr().asLong() +fun clang_index_getObjCContainerDeclInfo(arg0: CPointer?): CPointer? { + val _arg0 = arg0.rawValue val res = externals.clang_index_getObjCContainerDeclInfo(_arg0) - return NativePtr.byValue(res).asRef(CXIdxObjCContainerDeclInfo) + return CPointer.createNullable(res) } -fun clang_index_getObjCInterfaceDeclInfo(arg0: CXIdxDeclInfo?): CXIdxObjCInterfaceDeclInfo? { - val _arg0 = arg0.getNativePtr().asLong() +fun clang_index_getObjCInterfaceDeclInfo(arg0: CPointer?): CPointer? { + val _arg0 = arg0.rawValue val res = externals.clang_index_getObjCInterfaceDeclInfo(_arg0) - return NativePtr.byValue(res).asRef(CXIdxObjCInterfaceDeclInfo) + return CPointer.createNullable(res) } -fun clang_index_getObjCCategoryDeclInfo(arg0: CXIdxDeclInfo?): CXIdxObjCCategoryDeclInfo? { - val _arg0 = arg0.getNativePtr().asLong() +fun clang_index_getObjCCategoryDeclInfo(arg0: CPointer?): CPointer? { + val _arg0 = arg0.rawValue val res = externals.clang_index_getObjCCategoryDeclInfo(_arg0) - return NativePtr.byValue(res).asRef(CXIdxObjCCategoryDeclInfo) + return CPointer.createNullable(res) } -fun clang_index_getObjCProtocolRefListInfo(arg0: CXIdxDeclInfo?): CXIdxObjCProtocolRefListInfo? { - val _arg0 = arg0.getNativePtr().asLong() +fun clang_index_getObjCProtocolRefListInfo(arg0: CPointer?): CPointer? { + val _arg0 = arg0.rawValue val res = externals.clang_index_getObjCProtocolRefListInfo(_arg0) - return NativePtr.byValue(res).asRef(CXIdxObjCProtocolRefListInfo) + return CPointer.createNullable(res) } -fun clang_index_getObjCPropertyDeclInfo(arg0: CXIdxDeclInfo?): CXIdxObjCPropertyDeclInfo? { - val _arg0 = arg0.getNativePtr().asLong() +fun clang_index_getObjCPropertyDeclInfo(arg0: CPointer?): CPointer? { + val _arg0 = arg0.rawValue val res = externals.clang_index_getObjCPropertyDeclInfo(_arg0) - return NativePtr.byValue(res).asRef(CXIdxObjCPropertyDeclInfo) + return CPointer.createNullable(res) } -fun clang_index_getIBOutletCollectionAttrInfo(arg0: CXIdxAttrInfo?): CXIdxIBOutletCollectionAttrInfo? { - val _arg0 = arg0.getNativePtr().asLong() +fun clang_index_getIBOutletCollectionAttrInfo(arg0: CPointer?): CPointer? { + val _arg0 = arg0.rawValue val res = externals.clang_index_getIBOutletCollectionAttrInfo(_arg0) - return NativePtr.byValue(res).asRef(CXIdxIBOutletCollectionAttrInfo) + return CPointer.createNullable(res) } -fun clang_index_getCXXClassDeclInfo(arg0: CXIdxDeclInfo?): CXIdxCXXClassDeclInfo? { - val _arg0 = arg0.getNativePtr().asLong() +fun clang_index_getCXXClassDeclInfo(arg0: CPointer?): CPointer? { + val _arg0 = arg0.rawValue val res = externals.clang_index_getCXXClassDeclInfo(_arg0) - return NativePtr.byValue(res).asRef(CXIdxCXXClassDeclInfo) + return CPointer.createNullable(res) } -fun clang_index_getClientContainer(arg0: CXIdxContainerInfo?): NativePtr? { - val _arg0 = arg0.getNativePtr().asLong() +fun clang_index_getClientContainer(arg0: CPointer?): CXIdxClientContainer? { + val _arg0 = arg0.rawValue val res = externals.clang_index_getClientContainer(_arg0) - return NativePtr.byValue(res) + return CPointer.createNullable(res) } -fun clang_index_setClientContainer(arg0: CXIdxContainerInfo?, arg1: NativePtr?): Unit { - val _arg0 = arg0.getNativePtr().asLong() - val _arg1 = arg1.asLong() +fun clang_index_setClientContainer(arg0: CPointer?, arg1: CXIdxClientContainer?): Unit { + val _arg0 = arg0.rawValue + val _arg1 = arg1.rawValue val res = externals.clang_index_setClientContainer(_arg0, _arg1) return res } -fun clang_index_getClientEntity(arg0: CXIdxEntityInfo?): NativePtr? { - val _arg0 = arg0.getNativePtr().asLong() +fun clang_index_getClientEntity(arg0: CPointer?): CXIdxClientEntity? { + val _arg0 = arg0.rawValue val res = externals.clang_index_getClientEntity(_arg0) - return NativePtr.byValue(res) + return CPointer.createNullable(res) } -fun clang_index_setClientEntity(arg0: CXIdxEntityInfo?, arg1: NativePtr?): Unit { - val _arg0 = arg0.getNativePtr().asLong() - val _arg1 = arg1.asLong() +fun clang_index_setClientEntity(arg0: CPointer?, arg1: CXIdxClientEntity?): Unit { + val _arg0 = arg0.rawValue + val _arg1 = arg1.rawValue val res = externals.clang_index_setClientEntity(_arg0, _arg1) return res } -fun clang_IndexAction_create(CIdx: NativePtr?): NativePtr? { - val _CIdx = CIdx.asLong() +fun clang_IndexAction_create(CIdx: CXIndex?): CXIndexAction? { + val _CIdx = CIdx.rawValue val res = externals.clang_IndexAction_create(_CIdx) - return NativePtr.byValue(res) + return CPointer.createNullable(res) } -fun clang_IndexAction_dispose(arg0: NativePtr?): Unit { - val _arg0 = arg0.asLong() +fun clang_IndexAction_dispose(arg0: CXIndexAction?): Unit { + val _arg0 = arg0.rawValue val res = externals.clang_IndexAction_dispose(_arg0) return res } -fun clang_indexSourceFile(arg0: NativePtr?, client_data: NativePtr?, index_callbacks: IndexerCallbacks?, index_callbacks_size: Int, index_options: Int, source_filename: String?, command_line_args: RefBox?, num_command_line_args: Int, unsaved_files: CXUnsavedFile?, num_unsaved_files: Int, out_TU: RefBox?, TU_options: Int): Int { - val _arg0 = arg0.asLong() - val _client_data = client_data.asLong() - val _index_callbacks = index_callbacks.getNativePtr().asLong() - val _source_filename = CString.fromString(source_filename).getNativePtr().asLong() - val _command_line_args = command_line_args.getNativePtr().asLong() - val _unsaved_files = unsaved_files.getNativePtr().asLong() - val _out_TU = out_TU.getNativePtr().asLong() - val res = externals.clang_indexSourceFile(_arg0, _client_data, _index_callbacks, index_callbacks_size, index_options, _source_filename, _command_line_args, num_command_line_args, _unsaved_files, num_unsaved_files, _out_TU, TU_options) - free(NativePtr.byValue(_source_filename)) +fun clang_indexSourceFile(arg0: CXIndexAction?, client_data: CXClientData?, index_callbacks: CPointer?, index_callbacks_size: Int, index_options: Int, source_filename: String?, command_line_args: CPointer>?, num_command_line_args: Int, unsaved_files: CPointer?, num_unsaved_files: Int, out_TU: CPointer?, TU_options: Int): Int { + memScoped { + val _arg0 = arg0.rawValue + val _client_data = client_data.rawValue + val _index_callbacks = index_callbacks.rawValue + val _index_callbacks_size = index_callbacks_size + val _index_options = index_options + val _source_filename = source_filename?.toCString(memScope).rawPtr + val _command_line_args = command_line_args.rawValue + val _num_command_line_args = num_command_line_args + val _unsaved_files = unsaved_files.rawValue + val _num_unsaved_files = num_unsaved_files + val _out_TU = out_TU.rawValue + val _TU_options = TU_options + val res = externals.clang_indexSourceFile(_arg0, _client_data, _index_callbacks, _index_callbacks_size, _index_options, _source_filename, _command_line_args, _num_command_line_args, _unsaved_files, _num_unsaved_files, _out_TU, _TU_options) + return res + } +} + +fun clang_indexSourceFileFullArgv(arg0: CXIndexAction?, client_data: CXClientData?, index_callbacks: CPointer?, index_callbacks_size: Int, index_options: Int, source_filename: String?, command_line_args: CPointer>?, num_command_line_args: Int, unsaved_files: CPointer?, num_unsaved_files: Int, out_TU: CPointer?, TU_options: Int): Int { + memScoped { + val _arg0 = arg0.rawValue + val _client_data = client_data.rawValue + val _index_callbacks = index_callbacks.rawValue + val _index_callbacks_size = index_callbacks_size + val _index_options = index_options + val _source_filename = source_filename?.toCString(memScope).rawPtr + val _command_line_args = command_line_args.rawValue + val _num_command_line_args = num_command_line_args + val _unsaved_files = unsaved_files.rawValue + val _num_unsaved_files = num_unsaved_files + val _out_TU = out_TU.rawValue + val _TU_options = TU_options + val res = externals.clang_indexSourceFileFullArgv(_arg0, _client_data, _index_callbacks, _index_callbacks_size, _index_options, _source_filename, _command_line_args, _num_command_line_args, _unsaved_files, _num_unsaved_files, _out_TU, _TU_options) + return res + } +} + +fun clang_indexTranslationUnit(arg0: CXIndexAction?, client_data: CXClientData?, index_callbacks: CPointer?, index_callbacks_size: Int, index_options: Int, arg5: CXTranslationUnit?): Int { + val _arg0 = arg0.rawValue + val _client_data = client_data.rawValue + val _index_callbacks = index_callbacks.rawValue + val _index_callbacks_size = index_callbacks_size + val _index_options = index_options + val _arg5 = arg5.rawValue + val res = externals.clang_indexTranslationUnit(_arg0, _client_data, _index_callbacks, _index_callbacks_size, _index_options, _arg5) return res } -fun clang_indexSourceFileFullArgv(arg0: NativePtr?, client_data: NativePtr?, index_callbacks: IndexerCallbacks?, index_callbacks_size: Int, index_options: Int, source_filename: String?, command_line_args: RefBox?, num_command_line_args: Int, unsaved_files: CXUnsavedFile?, num_unsaved_files: Int, out_TU: RefBox?, TU_options: Int): Int { - val _arg0 = arg0.asLong() - val _client_data = client_data.asLong() - val _index_callbacks = index_callbacks.getNativePtr().asLong() - val _source_filename = CString.fromString(source_filename).getNativePtr().asLong() - val _command_line_args = command_line_args.getNativePtr().asLong() - val _unsaved_files = unsaved_files.getNativePtr().asLong() - val _out_TU = out_TU.getNativePtr().asLong() - val res = externals.clang_indexSourceFileFullArgv(_arg0, _client_data, _index_callbacks, index_callbacks_size, index_options, _source_filename, _command_line_args, num_command_line_args, _unsaved_files, num_unsaved_files, _out_TU, TU_options) - free(NativePtr.byValue(_source_filename)) - return res -} - -fun clang_indexTranslationUnit(arg0: NativePtr?, client_data: NativePtr?, index_callbacks: IndexerCallbacks?, index_callbacks_size: Int, index_options: Int, arg5: CXTranslationUnitImpl?): Int { - val _arg0 = arg0.asLong() - val _client_data = client_data.asLong() - val _index_callbacks = index_callbacks.getNativePtr().asLong() - val _arg5 = arg5.getNativePtr().asLong() - val res = externals.clang_indexTranslationUnit(_arg0, _client_data, _index_callbacks, index_callbacks_size, index_options, _arg5) - return res -} - -fun clang_indexLoc_getFileLocation(loc: CXIdxLoc, indexFile: NativePtrBox?, file: NativePtrBox?, line: Int32Box?, column: Int32Box?, offset: Int32Box?): Unit { - val _loc = loc.getNativePtr().asLong() - val _indexFile = indexFile.getNativePtr().asLong() - val _file = file.getNativePtr().asLong() - val _line = line.getNativePtr().asLong() - val _column = column.getNativePtr().asLong() - val _offset = offset.getNativePtr().asLong() +fun clang_indexLoc_getFileLocation(loc: CXIdxLoc, indexFile: CPointer?, file: CPointer?, line: CPointer?, column: CPointer?, offset: CPointer?): Unit { + val _loc = loc.rawPtr + val _indexFile = indexFile.rawValue + val _file = file.rawValue + val _line = line.rawValue + val _column = column.rawValue + val _offset = offset.rawValue val res = externals.clang_indexLoc_getFileLocation(_loc, _indexFile, _file, _line, _column, _offset) return res } -fun clang_indexLoc_getCXSourceLocation(loc: CXIdxLoc, retValPlacement: Placement): CXSourceLocation { - val _loc = loc.getNativePtr().asLong() - val _retValPlacement = retValPlacement.alloc(CXSourceLocation.size).asLong() +fun clang_indexLoc_getCXSourceLocation(loc: CXIdxLoc, retValPlacement: NativePlacement): CXSourceLocation { + val _loc = loc.rawPtr + val _retValPlacement = retValPlacement.alloc().rawPtr val res = externals.clang_indexLoc_getCXSourceLocation(_loc, _retValPlacement) - return NativePtr.byValue(res).asRef(CXSourceLocation)!! + return interpretPointed(res) } -fun clang_Type_visitFields(T: CXType, visitor: ((CXCursor, NativePtr?) -> CXVisitorResult)?, client_data: NativePtr?): Int { - val _T = T.getNativePtr().asLong() - val _visitor = visitor?.staticAsNative(NativeFunctionType4).asLong() - val _client_data = client_data.asLong() +fun clang_Type_visitFields(T: CXType, visitor: CXFieldVisitor?, client_data: CXClientData?): Int { + val _T = T.rawPtr + val _visitor = visitor.rawValue + val _client_data = client_data.rawValue val res = externals.clang_Type_visitFields(_T, _visitor, _client_data) return res } -class __mbstate_t(ptr: NativePtr) : NativeStruct(ptr) { +class __mbstate_t(override val rawPtr: NativePtr) : CStructVar() { - companion object : Type<__mbstate_t>(128, ::__mbstate_t) + companion object : Type(128, 8) + + val __mbstate8: CArray + get() = memberAt(0) + + val _mbstateL: CInt64Var + get() = memberAt(0) - val __mbstate8 by array[128](Int8Box) at 0 - val _mbstateL by Int64Box at 0 } -class __darwin_pthread_handler_rec(ptr: NativePtr) : NativeStruct(ptr) { +class __darwin_pthread_handler_rec(override val rawPtr: NativePtr) : CStructVar() { - companion object : Type<__darwin_pthread_handler_rec>(24, ::__darwin_pthread_handler_rec) + companion object : Type(24, 8) + + val __routine: CFunctionPointerVar + get() = memberAt(0) + + val __arg: COpaquePointerVar + get() = memberAt(8) + + val __next: CPointerVar<__darwin_pthread_handler_rec> + get() = memberAt(16) - val __routine by NativeFunctionType2.ref at 0 - val __arg by NativePtrBox at 8 - val __next by __darwin_pthread_handler_rec.ref at 16 } -class _opaque_pthread_attr_t(ptr: NativePtr) : NativeStruct(ptr) { +class _opaque_pthread_attr_t(override val rawPtr: NativePtr) : CStructVar() { - companion object : Type<_opaque_pthread_attr_t>(64, ::_opaque_pthread_attr_t) + companion object : Type(64, 8) + + val __sig: CInt64Var + get() = memberAt(0) + + val __opaque: CArray + get() = memberAt(8) - val __sig by Int64Box at 0 - val __opaque by array[56](Int8Box) at 8 } -class _opaque_pthread_cond_t(ptr: NativePtr) : NativeStruct(ptr) { +class _opaque_pthread_cond_t(override val rawPtr: NativePtr) : CStructVar() { - companion object : Type<_opaque_pthread_cond_t>(48, ::_opaque_pthread_cond_t) + companion object : Type(48, 8) + + val __sig: CInt64Var + get() = memberAt(0) + + val __opaque: CArray + get() = memberAt(8) - val __sig by Int64Box at 0 - val __opaque by array[40](Int8Box) at 8 } -class _opaque_pthread_condattr_t(ptr: NativePtr) : NativeStruct(ptr) { +class _opaque_pthread_condattr_t(override val rawPtr: NativePtr) : CStructVar() { - companion object : Type<_opaque_pthread_condattr_t>(16, ::_opaque_pthread_condattr_t) + companion object : Type(16, 8) + + val __sig: CInt64Var + get() = memberAt(0) + + val __opaque: CArray + get() = memberAt(8) - val __sig by Int64Box at 0 - val __opaque by array[8](Int8Box) at 8 } -class _opaque_pthread_mutex_t(ptr: NativePtr) : NativeStruct(ptr) { +class _opaque_pthread_mutex_t(override val rawPtr: NativePtr) : CStructVar() { - companion object : Type<_opaque_pthread_mutex_t>(64, ::_opaque_pthread_mutex_t) + companion object : Type(64, 8) + + val __sig: CInt64Var + get() = memberAt(0) + + val __opaque: CArray + get() = memberAt(8) - val __sig by Int64Box at 0 - val __opaque by array[56](Int8Box) at 8 } -class _opaque_pthread_mutexattr_t(ptr: NativePtr) : NativeStruct(ptr) { +class _opaque_pthread_mutexattr_t(override val rawPtr: NativePtr) : CStructVar() { - companion object : Type<_opaque_pthread_mutexattr_t>(16, ::_opaque_pthread_mutexattr_t) + companion object : Type(16, 8) + + val __sig: CInt64Var + get() = memberAt(0) + + val __opaque: CArray + get() = memberAt(8) - val __sig by Int64Box at 0 - val __opaque by array[8](Int8Box) at 8 } -class _opaque_pthread_once_t(ptr: NativePtr) : NativeStruct(ptr) { +class _opaque_pthread_once_t(override val rawPtr: NativePtr) : CStructVar() { - companion object : Type<_opaque_pthread_once_t>(16, ::_opaque_pthread_once_t) + companion object : Type(16, 8) + + val __sig: CInt64Var + get() = memberAt(0) + + val __opaque: CArray + get() = memberAt(8) - val __sig by Int64Box at 0 - val __opaque by array[8](Int8Box) at 8 } -class _opaque_pthread_rwlock_t(ptr: NativePtr) : NativeStruct(ptr) { +class _opaque_pthread_rwlock_t(override val rawPtr: NativePtr) : CStructVar() { - companion object : Type<_opaque_pthread_rwlock_t>(200, ::_opaque_pthread_rwlock_t) + companion object : Type(200, 8) + + val __sig: CInt64Var + get() = memberAt(0) + + val __opaque: CArray + get() = memberAt(8) - val __sig by Int64Box at 0 - val __opaque by array[192](Int8Box) at 8 } -class _opaque_pthread_rwlockattr_t(ptr: NativePtr) : NativeStruct(ptr) { +class _opaque_pthread_rwlockattr_t(override val rawPtr: NativePtr) : CStructVar() { - companion object : Type<_opaque_pthread_rwlockattr_t>(24, ::_opaque_pthread_rwlockattr_t) + companion object : Type(24, 8) + + val __sig: CInt64Var + get() = memberAt(0) + + val __opaque: CArray + get() = memberAt(8) - val __sig by Int64Box at 0 - val __opaque by array[16](Int8Box) at 8 } -class _opaque_pthread_t(ptr: NativePtr) : NativeStruct(ptr) { +class _opaque_pthread_t(override val rawPtr: NativePtr) : CStructVar() { - companion object : Type<_opaque_pthread_t>(8192, ::_opaque_pthread_t) + companion object : Type(8192, 8) + + val __sig: CInt64Var + get() = memberAt(0) + + val __cleanup_stack: CPointerVar<__darwin_pthread_handler_rec> + get() = memberAt(8) + + val __opaque: CArray + get() = memberAt(16) - val __sig by Int64Box at 0 - val __cleanup_stack by __darwin_pthread_handler_rec.ref at 8 - val __opaque by array[8176](Int8Box) at 16 } -class timespec(ptr: NativePtr) : NativeStruct(ptr) { +class timespec(override val rawPtr: NativePtr) : CStructVar() { - companion object : Type(16, ::timespec) + companion object : Type(16, 8) + + val tv_sec: __darwin_time_tVar + get() = memberAt(0) + + val tv_nsec: CInt64Var + get() = memberAt(8) - val tv_sec by Int64Box at 0 - val tv_nsec by Int64Box at 8 } -class tm(ptr: NativePtr) : NativeStruct(ptr) { +class tm(override val rawPtr: NativePtr) : CStructVar() { - companion object : Type(56, ::tm) + companion object : Type(56, 8) + + val tm_sec: CInt32Var + get() = memberAt(0) + + val tm_min: CInt32Var + get() = memberAt(4) + + val tm_hour: CInt32Var + get() = memberAt(8) + + val tm_mday: CInt32Var + get() = memberAt(12) + + val tm_mon: CInt32Var + get() = memberAt(16) + + val tm_year: CInt32Var + get() = memberAt(20) + + val tm_wday: CInt32Var + get() = memberAt(24) + + val tm_yday: CInt32Var + get() = memberAt(28) + + val tm_isdst: CInt32Var + get() = memberAt(32) + + val tm_gmtoff: CInt64Var + get() = memberAt(40) + + val tm_zone: CPointerVar + get() = memberAt(48) - val tm_sec by Int32Box at 0 - val tm_min by Int32Box at 4 - val tm_hour by Int32Box at 8 - val tm_mday by Int32Box at 12 - val tm_mon by Int32Box at 16 - val tm_year by Int32Box at 20 - val tm_wday by Int32Box at 24 - val tm_yday by Int32Box at 28 - val tm_isdst by Int32Box at 32 - val tm_gmtoff by Int64Box at 40 - val tm_zone by Int8Box.ref at 48 } -class CXString(ptr: NativePtr) : NativeStruct(ptr) { +class CXString(override val rawPtr: NativePtr) : CStructVar() { - companion object : Type(16, ::CXString) + companion object : Type(16, 8) + + val data: COpaquePointerVar + get() = memberAt(0) + + val private_flags: CInt32Var + get() = memberAt(8) - val data by NativePtrBox at 0 - val private_flags by Int32Box at 8 } -class CXStringSet(ptr: NativePtr) : NativeStruct(ptr) { +class CXStringSet(override val rawPtr: NativePtr) : CStructVar() { - companion object : Type(16, ::CXStringSet) + companion object : Type(16, 8) + + val Strings: CPointerVar + get() = memberAt(0) + + val Count: CInt32Var + get() = memberAt(8) - val Strings by CXString.ref at 0 - val Count by Int32Box at 8 } -class CXVirtualFileOverlayImpl(ptr: NativePtr) : NativeRef(ptr) { - companion object : Type(::CXVirtualFileOverlayImpl) +class CXVirtualFileOverlayImpl(override val rawPtr: NativePtr) : COpaque + +class CXModuleMapDescriptorImpl(override val rawPtr: NativePtr) : COpaque + +class CXTranslationUnitImpl(override val rawPtr: NativePtr) : COpaque + +class CXUnsavedFile(override val rawPtr: NativePtr) : CStructVar() { + + companion object : Type(24, 8) + + val Filename: CPointerVar + get() = memberAt(0) + + val Contents: CPointerVar + get() = memberAt(8) + + val Length: CInt64Var + get() = memberAt(16) + } -class CXModuleMapDescriptorImpl(ptr: NativePtr) : NativeRef(ptr) { - companion object : Type(::CXModuleMapDescriptorImpl) +class CXVersion(override val rawPtr: NativePtr) : CStructVar() { + + companion object : Type(12, 4) + + val Major: CInt32Var + get() = memberAt(0) + + val Minor: CInt32Var + get() = memberAt(4) + + val Subminor: CInt32Var + get() = memberAt(8) + } -class CXTranslationUnitImpl(ptr: NativePtr) : NativeRef(ptr) { - companion object : Type(::CXTranslationUnitImpl) +class CXFileUniqueID(override val rawPtr: NativePtr) : CStructVar() { + + companion object : Type(24, 8) + + val data: CArray + get() = memberAt(0) + } -class CXUnsavedFile(ptr: NativePtr) : NativeStruct(ptr) { +class CXSourceLocation(override val rawPtr: NativePtr) : CStructVar() { - companion object : Type(24, ::CXUnsavedFile) + companion object : Type(24, 8) + + val ptr_data: CArray + get() = memberAt(0) + + val int_data: CInt32Var + get() = memberAt(16) - val Filename by Int8Box.ref at 0 - val Contents by Int8Box.ref at 8 - val Length by Int64Box at 16 } -class CXVersion(ptr: NativePtr) : NativeStruct(ptr) { +class CXSourceRange(override val rawPtr: NativePtr) : CStructVar() { - companion object : Type(12, ::CXVersion) + companion object : Type(24, 8) + + val ptr_data: CArray + get() = memberAt(0) + + val begin_int_data: CInt32Var + get() = memberAt(16) + + val end_int_data: CInt32Var + get() = memberAt(20) - val Major by Int32Box at 0 - val Minor by Int32Box at 4 - val Subminor by Int32Box at 8 } -class CXFileUniqueID(ptr: NativePtr) : NativeStruct(ptr) { +class CXSourceRangeList(override val rawPtr: NativePtr) : CStructVar() { - companion object : Type(24, ::CXFileUniqueID) + companion object : Type(16, 8) + + val count: CInt32Var + get() = memberAt(0) + + val ranges: CPointerVar + get() = memberAt(8) - val data by array[3](Int64Box) at 0 } -class CXSourceLocation(ptr: NativePtr) : NativeStruct(ptr) { +class CXTUResourceUsageEntry(override val rawPtr: NativePtr) : CStructVar() { - companion object : Type(24, ::CXSourceLocation) + companion object : Type(16, 8) + + val kind: CXTUResourceUsageKind.Var + get() = memberAt(0) + + val amount: CInt64Var + get() = memberAt(8) - val ptr_data by array[2](NativePtrBox) at 0 - val int_data by Int32Box at 16 } -class CXSourceRange(ptr: NativePtr) : NativeStruct(ptr) { +class CXTUResourceUsage(override val rawPtr: NativePtr) : CStructVar() { - companion object : Type(24, ::CXSourceRange) + companion object : Type(24, 8) + + val data: COpaquePointerVar + get() = memberAt(0) + + val numEntries: CInt32Var + get() = memberAt(8) + + val entries: CPointerVar + get() = memberAt(16) - val ptr_data by array[2](NativePtrBox) at 0 - val begin_int_data by Int32Box at 16 - val end_int_data by Int32Box at 20 } -class CXSourceRangeList(ptr: NativePtr) : NativeStruct(ptr) { +class CXCursor(override val rawPtr: NativePtr) : CStructVar() { - companion object : Type(16, ::CXSourceRangeList) + companion object : Type(32, 8) + + val kind: CXCursorKind.Var + get() = memberAt(0) + + val xdata: CInt32Var + get() = memberAt(4) + + val data: CArray + get() = memberAt(8) - val count by Int32Box at 0 - val ranges by CXSourceRange.ref at 8 } -class CXTUResourceUsageEntry(ptr: NativePtr) : NativeStruct(ptr) { +class CXPlatformAvailability(override val rawPtr: NativePtr) : CStructVar() { - companion object : Type(16, ::CXTUResourceUsageEntry) + companion object : Type(72, 8) + + val Platform: CXString + get() = memberAt(0) + + val Introduced: CXVersion + get() = memberAt(16) + + val Deprecated: CXVersion + get() = memberAt(28) + + val Obsoleted: CXVersion + get() = memberAt(40) + + val Unavailable: CInt32Var + get() = memberAt(52) + + val Message: CXString + get() = memberAt(56) - val kind by CXTUResourceUsageKind.ref at 0 - val amount by Int64Box at 8 } -class CXTUResourceUsage(ptr: NativePtr) : NativeStruct(ptr) { +class CXCursorSetImpl(override val rawPtr: NativePtr) : COpaque + +class CXType(override val rawPtr: NativePtr) : CStructVar() { - companion object : Type(24, ::CXTUResourceUsage) + companion object : Type(24, 8) + + val kind: CXTypeKind.Var + get() = memberAt(0) + + val data: CArray + get() = memberAt(8) - val data by NativePtrBox at 0 - val numEntries by Int32Box at 8 - val entries by CXTUResourceUsageEntry.ref at 16 } -class CXCursor(ptr: NativePtr) : NativeStruct(ptr) { +class CXToken(override val rawPtr: NativePtr) : CStructVar() { - companion object : Type(32, ::CXCursor) + companion object : Type(24, 8) + + val int_data: CArray + get() = memberAt(0) + + val ptr_data: COpaquePointerVar + get() = memberAt(16) - val kind by CXCursorKind.ref at 0 - val xdata by Int32Box at 4 - val data by array[3](NativePtrBox) at 8 } -class CXPlatformAvailability(ptr: NativePtr) : NativeStruct(ptr) { +class CXCompletionResult(override val rawPtr: NativePtr) : CStructVar() { - companion object : Type(72, ::CXPlatformAvailability) + companion object : Type(16, 8) + + val CursorKind: CXCursorKind.Var + get() = memberAt(0) + + val CompletionString: CXCompletionStringVar + get() = memberAt(8) - val Platform by CXString at 0 - val Introduced by CXVersion at 16 - val Deprecated by CXVersion at 28 - val Obsoleted by CXVersion at 40 - val Unavailable by Int32Box at 52 - val Message by CXString at 56 } -class CXCursorSetImpl(ptr: NativePtr) : NativeRef(ptr) { - companion object : Type(::CXCursorSetImpl) +class CXCodeCompleteResults(override val rawPtr: NativePtr) : CStructVar() { + + companion object : Type(16, 8) + + val Results: CPointerVar + get() = memberAt(0) + + val NumResults: CInt32Var + get() = memberAt(8) + } -class CXType(ptr: NativePtr) : NativeStruct(ptr) { +class CXCursorAndRangeVisitor(override val rawPtr: NativePtr) : CStructVar() { - companion object : Type(24, ::CXType) + companion object : Type(16, 8) + + val context: COpaquePointerVar + get() = memberAt(0) + + val visit: CFunctionPointerVar + get() = memberAt(8) - val kind by CXTypeKind.ref at 0 - val data by array[2](NativePtrBox) at 8 } -class CXToken(ptr: NativePtr) : NativeStruct(ptr) { +class CXIdxLoc(override val rawPtr: NativePtr) : CStructVar() { - companion object : Type(24, ::CXToken) + companion object : Type(24, 8) + + val ptr_data: CArray + get() = memberAt(0) + + val int_data: CInt32Var + get() = memberAt(16) - val int_data by array[4](Int32Box) at 0 - val ptr_data by NativePtrBox at 16 } -class CXCompletionResult(ptr: NativePtr) : NativeStruct(ptr) { +class CXIdxIncludedFileInfo(override val rawPtr: NativePtr) : CStructVar() { - companion object : Type(16, ::CXCompletionResult) + companion object : Type(56, 8) + + val hashLoc: CXIdxLoc + get() = memberAt(0) + + val filename: CPointerVar + get() = memberAt(24) + + val file: CXFileVar + get() = memberAt(32) + + val isImport: CInt32Var + get() = memberAt(40) + + val isAngled: CInt32Var + get() = memberAt(44) + + val isModuleImport: CInt32Var + get() = memberAt(48) - val CursorKind by CXCursorKind.ref at 0 - val CompletionString by NativePtrBox at 8 } -class CXCodeCompleteResults(ptr: NativePtr) : NativeStruct(ptr) { +class CXIdxImportedASTFileInfo(override val rawPtr: NativePtr) : CStructVar() { - companion object : Type(16, ::CXCodeCompleteResults) + companion object : Type(48, 8) + + val file: CXFileVar + get() = memberAt(0) + + val module: CXModuleVar + get() = memberAt(8) + + val loc: CXIdxLoc + get() = memberAt(16) + + val isImplicit: CInt32Var + get() = memberAt(40) - val Results by CXCompletionResult.ref at 0 - val NumResults by Int32Box at 8 } -class CXCursorAndRangeVisitor(ptr: NativePtr) : NativeStruct(ptr) { +class CXIdxAttrInfo(override val rawPtr: NativePtr) : CStructVar() { - companion object : Type(16, ::CXCursorAndRangeVisitor) + companion object : Type(64, 8) + + val kind: CXIdxAttrKind.Var + get() = memberAt(0) + + val cursor: CXCursor + get() = memberAt(8) + + val loc: CXIdxLoc + get() = memberAt(40) - val context by NativePtrBox at 0 - val visit by NativeFunctionType5.ref at 8 } -class CXIdxLoc(ptr: NativePtr) : NativeStruct(ptr) { +class CXIdxEntityInfo(override val rawPtr: NativePtr) : CStructVar() { - companion object : Type(24, ::CXIdxLoc) + companion object : Type(80, 8) + + val kind: CXIdxEntityKind.Var + get() = memberAt(0) + + val templateKind: CXIdxEntityCXXTemplateKind.Var + get() = memberAt(4) + + val lang: CXIdxEntityLanguage.Var + get() = memberAt(8) + + val name: CPointerVar + get() = memberAt(16) + + val USR: CPointerVar + get() = memberAt(24) + + val cursor: CXCursor + get() = memberAt(32) + + val attributes: CPointerVar> + get() = memberAt(64) + + val numAttributes: CInt32Var + get() = memberAt(72) - val ptr_data by array[2](NativePtrBox) at 0 - val int_data by Int32Box at 16 } -class CXIdxIncludedFileInfo(ptr: NativePtr) : NativeStruct(ptr) { +class CXIdxContainerInfo(override val rawPtr: NativePtr) : CStructVar() { - companion object : Type(56, ::CXIdxIncludedFileInfo) + companion object : Type(32, 8) + + val cursor: CXCursor + get() = memberAt(0) - val hashLoc by CXIdxLoc at 0 - val filename by Int8Box.ref at 24 - val file by NativePtrBox at 32 - val isImport by Int32Box at 40 - val isAngled by Int32Box at 44 - val isModuleImport by Int32Box at 48 } -class CXIdxImportedASTFileInfo(ptr: NativePtr) : NativeStruct(ptr) { +class CXIdxIBOutletCollectionAttrInfo(override val rawPtr: NativePtr) : CStructVar() { - companion object : Type(48, ::CXIdxImportedASTFileInfo) + companion object : Type(72, 8) + + val attrInfo: CPointerVar + get() = memberAt(0) + + val objcClass: CPointerVar + get() = memberAt(8) + + val classCursor: CXCursor + get() = memberAt(16) + + val classLoc: CXIdxLoc + get() = memberAt(48) - val file by NativePtrBox at 0 - val module by NativePtrBox at 8 - val loc by CXIdxLoc at 16 - val isImplicit by Int32Box at 40 } -class CXIdxAttrInfo(ptr: NativePtr) : NativeStruct(ptr) { +class CXIdxDeclInfo(override val rawPtr: NativePtr) : CStructVar() { - companion object : Type(64, ::CXIdxAttrInfo) + companion object : Type(128, 8) + + val entityInfo: CPointerVar + get() = memberAt(0) + + val cursor: CXCursor + get() = memberAt(8) + + val loc: CXIdxLoc + get() = memberAt(40) + + val semanticContainer: CPointerVar + get() = memberAt(64) + + val lexicalContainer: CPointerVar + get() = memberAt(72) + + val isRedeclaration: CInt32Var + get() = memberAt(80) + + val isDefinition: CInt32Var + get() = memberAt(84) + + val isContainer: CInt32Var + get() = memberAt(88) + + val declAsContainer: CPointerVar + get() = memberAt(96) + + val isImplicit: CInt32Var + get() = memberAt(104) + + val attributes: CPointerVar> + get() = memberAt(112) + + val numAttributes: CInt32Var + get() = memberAt(120) + + val flags: CInt32Var + get() = memberAt(124) - val kind by CXIdxAttrKind.ref at 0 - val cursor by CXCursor at 8 - val loc by CXIdxLoc at 40 } -class CXIdxEntityInfo(ptr: NativePtr) : NativeStruct(ptr) { +class CXIdxObjCContainerDeclInfo(override val rawPtr: NativePtr) : CStructVar() { - companion object : Type(80, ::CXIdxEntityInfo) + companion object : Type(16, 8) + + val declInfo: CPointerVar + get() = memberAt(0) + + val kind: CXIdxObjCContainerKind.Var + get() = memberAt(8) - val kind by CXIdxEntityKind.ref at 0 - val templateKind by CXIdxEntityCXXTemplateKind.ref at 4 - val lang by CXIdxEntityLanguage.ref at 8 - val name by Int8Box.ref at 16 - val USR by Int8Box.ref at 24 - val cursor by CXCursor at 32 - val attributes by CXIdxAttrInfo.ref.ref at 64 - val numAttributes by Int32Box at 72 } -class CXIdxContainerInfo(ptr: NativePtr) : NativeStruct(ptr) { +class CXIdxBaseClassInfo(override val rawPtr: NativePtr) : CStructVar() { - companion object : Type(32, ::CXIdxContainerInfo) + companion object : Type(64, 8) + + val base: CPointerVar + get() = memberAt(0) + + val cursor: CXCursor + get() = memberAt(8) + + val loc: CXIdxLoc + get() = memberAt(40) - val cursor by CXCursor at 0 } -class CXIdxIBOutletCollectionAttrInfo(ptr: NativePtr) : NativeStruct(ptr) { +class CXIdxObjCProtocolRefInfo(override val rawPtr: NativePtr) : CStructVar() { - companion object : Type(72, ::CXIdxIBOutletCollectionAttrInfo) + companion object : Type(64, 8) + + val protocol: CPointerVar + get() = memberAt(0) + + val cursor: CXCursor + get() = memberAt(8) + + val loc: CXIdxLoc + get() = memberAt(40) - val attrInfo by CXIdxAttrInfo.ref at 0 - val objcClass by CXIdxEntityInfo.ref at 8 - val classCursor by CXCursor at 16 - val classLoc by CXIdxLoc at 48 } -class CXIdxDeclInfo(ptr: NativePtr) : NativeStruct(ptr) { +class CXIdxObjCProtocolRefListInfo(override val rawPtr: NativePtr) : CStructVar() { - companion object : Type(128, ::CXIdxDeclInfo) + companion object : Type(16, 8) + + val protocols: CPointerVar> + get() = memberAt(0) + + val numProtocols: CInt32Var + get() = memberAt(8) - val entityInfo by CXIdxEntityInfo.ref at 0 - val cursor by CXCursor at 8 - val loc by CXIdxLoc at 40 - val semanticContainer by CXIdxContainerInfo.ref at 64 - val lexicalContainer by CXIdxContainerInfo.ref at 72 - val isRedeclaration by Int32Box at 80 - val isDefinition by Int32Box at 84 - val isContainer by Int32Box at 88 - val declAsContainer by CXIdxContainerInfo.ref at 96 - val isImplicit by Int32Box at 104 - val attributes by CXIdxAttrInfo.ref.ref at 112 - val numAttributes by Int32Box at 120 - val flags by Int32Box at 124 } -class CXIdxObjCContainerDeclInfo(ptr: NativePtr) : NativeStruct(ptr) { +class CXIdxObjCInterfaceDeclInfo(override val rawPtr: NativePtr) : CStructVar() { - companion object : Type(16, ::CXIdxObjCContainerDeclInfo) + companion object : Type(24, 8) + + val containerInfo: CPointerVar + get() = memberAt(0) + + val superInfo: CPointerVar + get() = memberAt(8) + + val protocols: CPointerVar + get() = memberAt(16) - val declInfo by CXIdxDeclInfo.ref at 0 - val kind by CXIdxObjCContainerKind.ref at 8 } -class CXIdxBaseClassInfo(ptr: NativePtr) : NativeStruct(ptr) { +class CXIdxObjCCategoryDeclInfo(override val rawPtr: NativePtr) : CStructVar() { - companion object : Type(64, ::CXIdxBaseClassInfo) + companion object : Type(80, 8) + + val containerInfo: CPointerVar + get() = memberAt(0) + + val objcClass: CPointerVar + get() = memberAt(8) + + val classCursor: CXCursor + get() = memberAt(16) + + val classLoc: CXIdxLoc + get() = memberAt(48) + + val protocols: CPointerVar + get() = memberAt(72) - val base by CXIdxEntityInfo.ref at 0 - val cursor by CXCursor at 8 - val loc by CXIdxLoc at 40 } -class CXIdxObjCProtocolRefInfo(ptr: NativePtr) : NativeStruct(ptr) { +class CXIdxObjCPropertyDeclInfo(override val rawPtr: NativePtr) : CStructVar() { - companion object : Type(64, ::CXIdxObjCProtocolRefInfo) + companion object : Type(24, 8) + + val declInfo: CPointerVar + get() = memberAt(0) + + val getter: CPointerVar + get() = memberAt(8) + + val setter: CPointerVar + get() = memberAt(16) - val protocol by CXIdxEntityInfo.ref at 0 - val cursor by CXCursor at 8 - val loc by CXIdxLoc at 40 } -class CXIdxObjCProtocolRefListInfo(ptr: NativePtr) : NativeStruct(ptr) { +class CXIdxCXXClassDeclInfo(override val rawPtr: NativePtr) : CStructVar() { - companion object : Type(16, ::CXIdxObjCProtocolRefListInfo) + companion object : Type(24, 8) + + val declInfo: CPointerVar + get() = memberAt(0) + + val bases: CPointerVar> + get() = memberAt(8) + + val numBases: CInt32Var + get() = memberAt(16) - val protocols by CXIdxObjCProtocolRefInfo.ref.ref at 0 - val numProtocols by Int32Box at 8 } -class CXIdxObjCInterfaceDeclInfo(ptr: NativePtr) : NativeStruct(ptr) { +class CXIdxEntityRefInfo(override val rawPtr: NativePtr) : CStructVar() { - companion object : Type(24, ::CXIdxObjCInterfaceDeclInfo) + companion object : Type(88, 8) + + val kind: CXIdxEntityRefKind.Var + get() = memberAt(0) + + val cursor: CXCursor + get() = memberAt(8) + + val loc: CXIdxLoc + get() = memberAt(40) + + val referencedEntity: CPointerVar + get() = memberAt(64) + + val parentEntity: CPointerVar + get() = memberAt(72) + + val container: CPointerVar + get() = memberAt(80) - val containerInfo by CXIdxObjCContainerDeclInfo.ref at 0 - val superInfo by CXIdxBaseClassInfo.ref at 8 - val protocols by CXIdxObjCProtocolRefListInfo.ref at 16 } -class CXIdxObjCCategoryDeclInfo(ptr: NativePtr) : NativeStruct(ptr) { +class IndexerCallbacks(override val rawPtr: NativePtr) : CStructVar() { - companion object : Type(80, ::CXIdxObjCCategoryDeclInfo) + companion object : Type(64, 8) + + val abortQuery: CFunctionPointerVar + get() = memberAt(0) + + val diagnostic: CFunctionPointerVar + get() = memberAt(8) + + val enteredMainFile: CFunctionPointerVar + get() = memberAt(16) + + val ppIncludedFile: CFunctionPointerVar + get() = memberAt(24) + + val importedASTFile: CFunctionPointerVar + get() = memberAt(32) + + val startedTranslationUnit: CFunctionPointerVar + get() = memberAt(40) + + val indexDeclaration: CFunctionPointerVar + get() = memberAt(48) + + val indexEntityReference: CFunctionPointerVar + get() = memberAt(56) - val containerInfo by CXIdxObjCContainerDeclInfo.ref at 0 - val objcClass by CXIdxEntityInfo.ref at 8 - val classCursor by CXCursor at 16 - val classLoc by CXIdxLoc at 48 - val protocols by CXIdxObjCProtocolRefListInfo.ref at 72 } -class CXIdxObjCPropertyDeclInfo(ptr: NativePtr) : NativeStruct(ptr) { +enum class clockid_t(val value: Int) { + _CLOCK_REALTIME(0), + _CLOCK_MONOTONIC(6), + _CLOCK_MONOTONIC_RAW(4), + _CLOCK_MONOTONIC_RAW_APPROX(5), + _CLOCK_UPTIME_RAW(8), + _CLOCK_UPTIME_RAW_APPROX(9), + _CLOCK_PROCESS_CPUTIME_ID(12), + _CLOCK_THREAD_CPUTIME_ID(16), + ; - companion object : Type(24, ::CXIdxObjCPropertyDeclInfo) + companion object { + fun byValue(value: Int) = clockid_t.values().find { it.value == value }!! + } - val declInfo by CXIdxDeclInfo.ref at 0 - val getter by CXIdxEntityInfo.ref at 8 - val setter by CXIdxEntityInfo.ref at 16 -} - -class CXIdxCXXClassDeclInfo(ptr: NativePtr) : NativeStruct(ptr) { - - companion object : Type(24, ::CXIdxCXXClassDeclInfo) - - val declInfo by CXIdxDeclInfo.ref at 0 - val bases by CXIdxBaseClassInfo.ref.ref at 8 - val numBases by Int32Box at 16 -} - -class CXIdxEntityRefInfo(ptr: NativePtr) : NativeStruct(ptr) { - - companion object : Type(88, ::CXIdxEntityRefInfo) - - val kind by CXIdxEntityRefKind.ref at 0 - val cursor by CXCursor at 8 - val loc by CXIdxLoc at 40 - val referencedEntity by CXIdxEntityInfo.ref at 64 - val parentEntity by CXIdxEntityInfo.ref at 72 - val container by CXIdxContainerInfo.ref at 80 -} - -class IndexerCallbacks(ptr: NativePtr) : NativeStruct(ptr) { - - companion object : Type(64, ::IndexerCallbacks) - - val abortQuery by NativeFunctionType6.ref at 0 - val diagnostic by NativeFunctionType7.ref at 8 - val enteredMainFile by NativeFunctionType8.ref at 16 - val ppIncludedFile by NativeFunctionType9.ref at 24 - val importedASTFile by NativeFunctionType10.ref at 32 - val startedTranslationUnit by NativeFunctionType11.ref at 40 - val indexDeclaration by NativeFunctionType12.ref at 48 - val indexEntityReference by NativeFunctionType13.ref at 56 + class Var(override val rawPtr: NativePtr) : CEnumVar() { + companion object : Type(CInt32Var.size.toInt()) + var value: clockid_t + get() = byValue(this.reinterpret().value) + set(value) { this.reinterpret().value = value.value } + } } enum class CXErrorCode(val value: Int) { @@ -2468,11 +2928,11 @@ enum class CXErrorCode(val value: Int) { fun byValue(value: Int) = CXErrorCode.values().find { it.value == value }!! } - class ref(ptr: NativePtr) : NativeRef(ptr) { - companion object : TypeWithSize(Int32Box.size, ::ref) + class Var(override val rawPtr: NativePtr) : CEnumVar() { + companion object : Type(CInt32Var.size.toInt()) var value: CXErrorCode - get() = byValue(Int32Box.byPtr(ptr).value) - set(value) { Int32Box.byPtr(ptr).value = value.value } + get() = byValue(this.reinterpret().value) + set(value) { this.reinterpret().value = value.value } } } @@ -2487,11 +2947,11 @@ enum class CXAvailabilityKind(val value: Int) { fun byValue(value: Int) = CXAvailabilityKind.values().find { it.value == value }!! } - class ref(ptr: NativePtr) : NativeRef(ptr) { - companion object : TypeWithSize(Int32Box.size, ::ref) + class Var(override val rawPtr: NativePtr) : CEnumVar() { + companion object : Type(CInt32Var.size.toInt()) var value: CXAvailabilityKind - get() = byValue(Int32Box.byPtr(ptr).value) - set(value) { Int32Box.byPtr(ptr).value = value.value } + get() = byValue(this.reinterpret().value) + set(value) { this.reinterpret().value = value.value } } } @@ -2506,11 +2966,11 @@ enum class CXGlobalOptFlags(val value: Int) { fun byValue(value: Int) = CXGlobalOptFlags.values().find { it.value == value }!! } - class ref(ptr: NativePtr) : NativeRef(ptr) { - companion object : TypeWithSize(Int32Box.size, ::ref) + class Var(override val rawPtr: NativePtr) : CEnumVar() { + companion object : Type(CInt32Var.size.toInt()) var value: CXGlobalOptFlags - get() = byValue(Int32Box.byPtr(ptr).value) - set(value) { Int32Box.byPtr(ptr).value = value.value } + get() = byValue(this.reinterpret().value) + set(value) { this.reinterpret().value = value.value } } } @@ -2526,11 +2986,11 @@ enum class CXDiagnosticSeverity(val value: Int) { fun byValue(value: Int) = CXDiagnosticSeverity.values().find { it.value == value }!! } - class ref(ptr: NativePtr) : NativeRef(ptr) { - companion object : TypeWithSize(Int32Box.size, ::ref) + class Var(override val rawPtr: NativePtr) : CEnumVar() { + companion object : Type(CInt32Var.size.toInt()) var value: CXDiagnosticSeverity - get() = byValue(Int32Box.byPtr(ptr).value) - set(value) { Int32Box.byPtr(ptr).value = value.value } + get() = byValue(this.reinterpret().value) + set(value) { this.reinterpret().value = value.value } } } @@ -2545,11 +3005,11 @@ enum class CXLoadDiag_Error(val value: Int) { fun byValue(value: Int) = CXLoadDiag_Error.values().find { it.value == value }!! } - class ref(ptr: NativePtr) : NativeRef(ptr) { - companion object : TypeWithSize(Int32Box.size, ::ref) + class Var(override val rawPtr: NativePtr) : CEnumVar() { + companion object : Type(CInt32Var.size.toInt()) var value: CXLoadDiag_Error - get() = byValue(Int32Box.byPtr(ptr).value) - set(value) { Int32Box.byPtr(ptr).value = value.value } + get() = byValue(this.reinterpret().value) + set(value) { this.reinterpret().value = value.value } } } @@ -2566,11 +3026,11 @@ enum class CXDiagnosticDisplayOptions(val value: Int) { fun byValue(value: Int) = CXDiagnosticDisplayOptions.values().find { it.value == value }!! } - class ref(ptr: NativePtr) : NativeRef(ptr) { - companion object : TypeWithSize(Int32Box.size, ::ref) + class Var(override val rawPtr: NativePtr) : CEnumVar() { + companion object : Type(CInt32Var.size.toInt()) var value: CXDiagnosticDisplayOptions - get() = byValue(Int32Box.byPtr(ptr).value) - set(value) { Int32Box.byPtr(ptr).value = value.value } + get() = byValue(this.reinterpret().value) + set(value) { this.reinterpret().value = value.value } } } @@ -2591,11 +3051,11 @@ enum class CXTranslationUnit_Flags(val value: Int) { fun byValue(value: Int) = CXTranslationUnit_Flags.values().find { it.value == value }!! } - class ref(ptr: NativePtr) : NativeRef(ptr) { - companion object : TypeWithSize(Int32Box.size, ::ref) + class Var(override val rawPtr: NativePtr) : CEnumVar() { + companion object : Type(CInt32Var.size.toInt()) var value: CXTranslationUnit_Flags - get() = byValue(Int32Box.byPtr(ptr).value) - set(value) { Int32Box.byPtr(ptr).value = value.value } + get() = byValue(this.reinterpret().value) + set(value) { this.reinterpret().value = value.value } } } @@ -2607,11 +3067,11 @@ enum class CXSaveTranslationUnit_Flags(val value: Int) { fun byValue(value: Int) = CXSaveTranslationUnit_Flags.values().find { it.value == value }!! } - class ref(ptr: NativePtr) : NativeRef(ptr) { - companion object : TypeWithSize(Int32Box.size, ::ref) + class Var(override val rawPtr: NativePtr) : CEnumVar() { + companion object : Type(CInt32Var.size.toInt()) var value: CXSaveTranslationUnit_Flags - get() = byValue(Int32Box.byPtr(ptr).value) - set(value) { Int32Box.byPtr(ptr).value = value.value } + get() = byValue(this.reinterpret().value) + set(value) { this.reinterpret().value = value.value } } } @@ -2626,11 +3086,11 @@ enum class CXSaveError(val value: Int) { fun byValue(value: Int) = CXSaveError.values().find { it.value == value }!! } - class ref(ptr: NativePtr) : NativeRef(ptr) { - companion object : TypeWithSize(Int32Box.size, ::ref) + class Var(override val rawPtr: NativePtr) : CEnumVar() { + companion object : Type(CInt32Var.size.toInt()) var value: CXSaveError - get() = byValue(Int32Box.byPtr(ptr).value) - set(value) { Int32Box.byPtr(ptr).value = value.value } + get() = byValue(this.reinterpret().value) + set(value) { this.reinterpret().value = value.value } } } @@ -2642,11 +3102,11 @@ enum class CXReparse_Flags(val value: Int) { fun byValue(value: Int) = CXReparse_Flags.values().find { it.value == value }!! } - class ref(ptr: NativePtr) : NativeRef(ptr) { - companion object : TypeWithSize(Int32Box.size, ::ref) + class Var(override val rawPtr: NativePtr) : CEnumVar() { + companion object : Type(CInt32Var.size.toInt()) var value: CXReparse_Flags - get() = byValue(Int32Box.byPtr(ptr).value) - set(value) { Int32Box.byPtr(ptr).value = value.value } + get() = byValue(this.reinterpret().value) + set(value) { this.reinterpret().value = value.value } } } @@ -2675,11 +3135,11 @@ enum class CXTUResourceUsageKind(val value: Int) { fun byValue(value: Int) = CXTUResourceUsageKind.values().find { it.value == value }!! } - class ref(ptr: NativePtr) : NativeRef(ptr) { - companion object : TypeWithSize(Int32Box.size, ::ref) + class Var(override val rawPtr: NativePtr) : CEnumVar() { + companion object : Type(CInt32Var.size.toInt()) var value: CXTUResourceUsageKind - get() = byValue(Int32Box.byPtr(ptr).value) - set(value) { Int32Box.byPtr(ptr).value = value.value } + get() = byValue(this.reinterpret().value) + set(value) { this.reinterpret().value = value.value } } } @@ -2899,11 +3359,11 @@ enum class CXCursorKind(val value: Int) { fun byValue(value: Int) = CXCursorKind.values().find { it.value == value }!! } - class ref(ptr: NativePtr) : NativeRef(ptr) { - companion object : TypeWithSize(Int32Box.size, ::ref) + class Var(override val rawPtr: NativePtr) : CEnumVar() { + companion object : Type(CInt32Var.size.toInt()) var value: CXCursorKind - get() = byValue(Int32Box.byPtr(ptr).value) - set(value) { Int32Box.byPtr(ptr).value = value.value } + get() = byValue(this.reinterpret().value) + set(value) { this.reinterpret().value = value.value } } } @@ -2919,11 +3379,11 @@ enum class CXLinkageKind(val value: Int) { fun byValue(value: Int) = CXLinkageKind.values().find { it.value == value }!! } - class ref(ptr: NativePtr) : NativeRef(ptr) { - companion object : TypeWithSize(Int32Box.size, ::ref) + class Var(override val rawPtr: NativePtr) : CEnumVar() { + companion object : Type(CInt32Var.size.toInt()) var value: CXLinkageKind - get() = byValue(Int32Box.byPtr(ptr).value) - set(value) { Int32Box.byPtr(ptr).value = value.value } + get() = byValue(this.reinterpret().value) + set(value) { this.reinterpret().value = value.value } } } @@ -2938,11 +3398,11 @@ enum class CXVisibilityKind(val value: Int) { fun byValue(value: Int) = CXVisibilityKind.values().find { it.value == value }!! } - class ref(ptr: NativePtr) : NativeRef(ptr) { - companion object : TypeWithSize(Int32Box.size, ::ref) + class Var(override val rawPtr: NativePtr) : CEnumVar() { + companion object : Type(CInt32Var.size.toInt()) var value: CXVisibilityKind - get() = byValue(Int32Box.byPtr(ptr).value) - set(value) { Int32Box.byPtr(ptr).value = value.value } + get() = byValue(this.reinterpret().value) + set(value) { this.reinterpret().value = value.value } } } @@ -2957,11 +3417,11 @@ enum class CXLanguageKind(val value: Int) { fun byValue(value: Int) = CXLanguageKind.values().find { it.value == value }!! } - class ref(ptr: NativePtr) : NativeRef(ptr) { - companion object : TypeWithSize(Int32Box.size, ::ref) + class Var(override val rawPtr: NativePtr) : CEnumVar() { + companion object : Type(CInt32Var.size.toInt()) var value: CXLanguageKind - get() = byValue(Int32Box.byPtr(ptr).value) - set(value) { Int32Box.byPtr(ptr).value = value.value } + get() = byValue(this.reinterpret().value) + set(value) { this.reinterpret().value = value.value } } } @@ -3023,11 +3483,11 @@ enum class CXTypeKind(val value: Int) { fun byValue(value: Int) = CXTypeKind.values().find { it.value == value }!! } - class ref(ptr: NativePtr) : NativeRef(ptr) { - companion object : TypeWithSize(Int32Box.size, ::ref) + class Var(override val rawPtr: NativePtr) : CEnumVar() { + companion object : Type(CInt32Var.size.toInt()) var value: CXTypeKind - get() = byValue(Int32Box.byPtr(ptr).value) - set(value) { Int32Box.byPtr(ptr).value = value.value } + get() = byValue(this.reinterpret().value) + set(value) { this.reinterpret().value = value.value } } } @@ -3052,11 +3512,11 @@ enum class CXCallingConv(val value: Int) { fun byValue(value: Int) = CXCallingConv.values().find { it.value == value }!! } - class ref(ptr: NativePtr) : NativeRef(ptr) { - companion object : TypeWithSize(Int32Box.size, ::ref) + class Var(override val rawPtr: NativePtr) : CEnumVar() { + companion object : Type(CInt32Var.size.toInt()) var value: CXCallingConv - get() = byValue(Int32Box.byPtr(ptr).value) - set(value) { Int32Box.byPtr(ptr).value = value.value } + get() = byValue(this.reinterpret().value) + set(value) { this.reinterpret().value = value.value } } } @@ -3077,11 +3537,11 @@ enum class CXTemplateArgumentKind(val value: Int) { fun byValue(value: Int) = CXTemplateArgumentKind.values().find { it.value == value }!! } - class ref(ptr: NativePtr) : NativeRef(ptr) { - companion object : TypeWithSize(Int32Box.size, ::ref) + class Var(override val rawPtr: NativePtr) : CEnumVar() { + companion object : Type(CInt32Var.size.toInt()) var value: CXTemplateArgumentKind - get() = byValue(Int32Box.byPtr(ptr).value) - set(value) { Int32Box.byPtr(ptr).value = value.value } + get() = byValue(this.reinterpret().value) + set(value) { this.reinterpret().value = value.value } } } @@ -3097,11 +3557,11 @@ enum class CXTypeLayoutError(val value: Int) { fun byValue(value: Int) = CXTypeLayoutError.values().find { it.value == value }!! } - class ref(ptr: NativePtr) : NativeRef(ptr) { - companion object : TypeWithSize(Int32Box.size, ::ref) + class Var(override val rawPtr: NativePtr) : CEnumVar() { + companion object : Type(CInt32Var.size.toInt()) var value: CXTypeLayoutError - get() = byValue(Int32Box.byPtr(ptr).value) - set(value) { Int32Box.byPtr(ptr).value = value.value } + get() = byValue(this.reinterpret().value) + set(value) { this.reinterpret().value = value.value } } } @@ -3115,11 +3575,11 @@ enum class CXRefQualifierKind(val value: Int) { fun byValue(value: Int) = CXRefQualifierKind.values().find { it.value == value }!! } - class ref(ptr: NativePtr) : NativeRef(ptr) { - companion object : TypeWithSize(Int32Box.size, ::ref) + class Var(override val rawPtr: NativePtr) : CEnumVar() { + companion object : Type(CInt32Var.size.toInt()) var value: CXRefQualifierKind - get() = byValue(Int32Box.byPtr(ptr).value) - set(value) { Int32Box.byPtr(ptr).value = value.value } + get() = byValue(this.reinterpret().value) + set(value) { this.reinterpret().value = value.value } } } @@ -3134,11 +3594,11 @@ enum class CX_CXXAccessSpecifier(val value: Int) { fun byValue(value: Int) = CX_CXXAccessSpecifier.values().find { it.value == value }!! } - class ref(ptr: NativePtr) : NativeRef(ptr) { - companion object : TypeWithSize(Int32Box.size, ::ref) + class Var(override val rawPtr: NativePtr) : CEnumVar() { + companion object : Type(CInt32Var.size.toInt()) var value: CX_CXXAccessSpecifier - get() = byValue(Int32Box.byPtr(ptr).value) - set(value) { Int32Box.byPtr(ptr).value = value.value } + get() = byValue(this.reinterpret().value) + set(value) { this.reinterpret().value = value.value } } } @@ -3157,11 +3617,11 @@ enum class CX_StorageClass(val value: Int) { fun byValue(value: Int) = CX_StorageClass.values().find { it.value == value }!! } - class ref(ptr: NativePtr) : NativeRef(ptr) { - companion object : TypeWithSize(Int32Box.size, ::ref) + class Var(override val rawPtr: NativePtr) : CEnumVar() { + companion object : Type(CInt32Var.size.toInt()) var value: CX_StorageClass - get() = byValue(Int32Box.byPtr(ptr).value) - set(value) { Int32Box.byPtr(ptr).value = value.value } + get() = byValue(this.reinterpret().value) + set(value) { this.reinterpret().value = value.value } } } @@ -3175,11 +3635,11 @@ enum class CXChildVisitResult(val value: Int) { fun byValue(value: Int) = CXChildVisitResult.values().find { it.value == value }!! } - class ref(ptr: NativePtr) : NativeRef(ptr) { - companion object : TypeWithSize(Int32Box.size, ::ref) + class Var(override val rawPtr: NativePtr) : CEnumVar() { + companion object : Type(CInt32Var.size.toInt()) var value: CXChildVisitResult - get() = byValue(Int32Box.byPtr(ptr).value) - set(value) { Int32Box.byPtr(ptr).value = value.value } + get() = byValue(this.reinterpret().value) + set(value) { this.reinterpret().value = value.value } } } @@ -3203,11 +3663,11 @@ enum class CXObjCPropertyAttrKind(val value: Int) { fun byValue(value: Int) = CXObjCPropertyAttrKind.values().find { it.value == value }!! } - class ref(ptr: NativePtr) : NativeRef(ptr) { - companion object : TypeWithSize(Int32Box.size, ::ref) + class Var(override val rawPtr: NativePtr) : CEnumVar() { + companion object : Type(CInt32Var.size.toInt()) var value: CXObjCPropertyAttrKind - get() = byValue(Int32Box.byPtr(ptr).value) - set(value) { Int32Box.byPtr(ptr).value = value.value } + get() = byValue(this.reinterpret().value) + set(value) { this.reinterpret().value = value.value } } } @@ -3225,11 +3685,11 @@ enum class CXObjCDeclQualifierKind(val value: Int) { fun byValue(value: Int) = CXObjCDeclQualifierKind.values().find { it.value == value }!! } - class ref(ptr: NativePtr) : NativeRef(ptr) { - companion object : TypeWithSize(Int32Box.size, ::ref) + class Var(override val rawPtr: NativePtr) : CEnumVar() { + companion object : Type(CInt32Var.size.toInt()) var value: CXObjCDeclQualifierKind - get() = byValue(Int32Box.byPtr(ptr).value) - set(value) { Int32Box.byPtr(ptr).value = value.value } + get() = byValue(this.reinterpret().value) + set(value) { this.reinterpret().value = value.value } } } @@ -3243,11 +3703,11 @@ enum class CXNameRefFlags(val value: Int) { fun byValue(value: Int) = CXNameRefFlags.values().find { it.value == value }!! } - class ref(ptr: NativePtr) : NativeRef(ptr) { - companion object : TypeWithSize(Int32Box.size, ::ref) + class Var(override val rawPtr: NativePtr) : CEnumVar() { + companion object : Type(CInt32Var.size.toInt()) var value: CXNameRefFlags - get() = byValue(Int32Box.byPtr(ptr).value) - set(value) { Int32Box.byPtr(ptr).value = value.value } + get() = byValue(this.reinterpret().value) + set(value) { this.reinterpret().value = value.value } } } @@ -3263,11 +3723,11 @@ enum class CXTokenKind(val value: Int) { fun byValue(value: Int) = CXTokenKind.values().find { it.value == value }!! } - class ref(ptr: NativePtr) : NativeRef(ptr) { - companion object : TypeWithSize(Int32Box.size, ::ref) + class Var(override val rawPtr: NativePtr) : CEnumVar() { + companion object : Type(CInt32Var.size.toInt()) var value: CXTokenKind - get() = byValue(Int32Box.byPtr(ptr).value) - set(value) { Int32Box.byPtr(ptr).value = value.value } + get() = byValue(this.reinterpret().value) + set(value) { this.reinterpret().value = value.value } } } @@ -3299,11 +3759,11 @@ enum class CXCompletionChunkKind(val value: Int) { fun byValue(value: Int) = CXCompletionChunkKind.values().find { it.value == value }!! } - class ref(ptr: NativePtr) : NativeRef(ptr) { - companion object : TypeWithSize(Int32Box.size, ::ref) + class Var(override val rawPtr: NativePtr) : CEnumVar() { + companion object : Type(CInt32Var.size.toInt()) var value: CXCompletionChunkKind - get() = byValue(Int32Box.byPtr(ptr).value) - set(value) { Int32Box.byPtr(ptr).value = value.value } + get() = byValue(this.reinterpret().value) + set(value) { this.reinterpret().value = value.value } } } @@ -3317,11 +3777,11 @@ enum class CXCodeComplete_Flags(val value: Int) { fun byValue(value: Int) = CXCodeComplete_Flags.values().find { it.value == value }!! } - class ref(ptr: NativePtr) : NativeRef(ptr) { - companion object : TypeWithSize(Int32Box.size, ::ref) + class Var(override val rawPtr: NativePtr) : CEnumVar() { + companion object : Type(CInt32Var.size.toInt()) var value: CXCodeComplete_Flags - get() = byValue(Int32Box.byPtr(ptr).value) - set(value) { Int32Box.byPtr(ptr).value = value.value } + get() = byValue(this.reinterpret().value) + set(value) { this.reinterpret().value = value.value } } } @@ -3356,11 +3816,11 @@ enum class CXCompletionContext(val value: Int) { fun byValue(value: Int) = CXCompletionContext.values().find { it.value == value }!! } - class ref(ptr: NativePtr) : NativeRef(ptr) { - companion object : TypeWithSize(Int32Box.size, ::ref) + class Var(override val rawPtr: NativePtr) : CEnumVar() { + companion object : Type(CInt32Var.size.toInt()) var value: CXCompletionContext - get() = byValue(Int32Box.byPtr(ptr).value) - set(value) { Int32Box.byPtr(ptr).value = value.value } + get() = byValue(this.reinterpret().value) + set(value) { this.reinterpret().value = value.value } } } @@ -3373,11 +3833,11 @@ enum class CXVisitorResult(val value: Int) { fun byValue(value: Int) = CXVisitorResult.values().find { it.value == value }!! } - class ref(ptr: NativePtr) : NativeRef(ptr) { - companion object : TypeWithSize(Int32Box.size, ::ref) + class Var(override val rawPtr: NativePtr) : CEnumVar() { + companion object : Type(CInt32Var.size.toInt()) var value: CXVisitorResult - get() = byValue(Int32Box.byPtr(ptr).value) - set(value) { Int32Box.byPtr(ptr).value = value.value } + get() = byValue(this.reinterpret().value) + set(value) { this.reinterpret().value = value.value } } } @@ -3391,11 +3851,11 @@ enum class CXResult(val value: Int) { fun byValue(value: Int) = CXResult.values().find { it.value == value }!! } - class ref(ptr: NativePtr) : NativeRef(ptr) { - companion object : TypeWithSize(Int32Box.size, ::ref) + class Var(override val rawPtr: NativePtr) : CEnumVar() { + companion object : Type(CInt32Var.size.toInt()) var value: CXResult - get() = byValue(Int32Box.byPtr(ptr).value) - set(value) { Int32Box.byPtr(ptr).value = value.value } + get() = byValue(this.reinterpret().value) + set(value) { this.reinterpret().value = value.value } } } @@ -3433,11 +3893,11 @@ enum class CXIdxEntityKind(val value: Int) { fun byValue(value: Int) = CXIdxEntityKind.values().find { it.value == value }!! } - class ref(ptr: NativePtr) : NativeRef(ptr) { - companion object : TypeWithSize(Int32Box.size, ::ref) + class Var(override val rawPtr: NativePtr) : CEnumVar() { + companion object : Type(CInt32Var.size.toInt()) var value: CXIdxEntityKind - get() = byValue(Int32Box.byPtr(ptr).value) - set(value) { Int32Box.byPtr(ptr).value = value.value } + get() = byValue(this.reinterpret().value) + set(value) { this.reinterpret().value = value.value } } } @@ -3452,11 +3912,11 @@ enum class CXIdxEntityLanguage(val value: Int) { fun byValue(value: Int) = CXIdxEntityLanguage.values().find { it.value == value }!! } - class ref(ptr: NativePtr) : NativeRef(ptr) { - companion object : TypeWithSize(Int32Box.size, ::ref) + class Var(override val rawPtr: NativePtr) : CEnumVar() { + companion object : Type(CInt32Var.size.toInt()) var value: CXIdxEntityLanguage - get() = byValue(Int32Box.byPtr(ptr).value) - set(value) { Int32Box.byPtr(ptr).value = value.value } + get() = byValue(this.reinterpret().value) + set(value) { this.reinterpret().value = value.value } } } @@ -3471,11 +3931,11 @@ enum class CXIdxEntityCXXTemplateKind(val value: Int) { fun byValue(value: Int) = CXIdxEntityCXXTemplateKind.values().find { it.value == value }!! } - class ref(ptr: NativePtr) : NativeRef(ptr) { - companion object : TypeWithSize(Int32Box.size, ::ref) + class Var(override val rawPtr: NativePtr) : CEnumVar() { + companion object : Type(CInt32Var.size.toInt()) var value: CXIdxEntityCXXTemplateKind - get() = byValue(Int32Box.byPtr(ptr).value) - set(value) { Int32Box.byPtr(ptr).value = value.value } + get() = byValue(this.reinterpret().value) + set(value) { this.reinterpret().value = value.value } } } @@ -3490,11 +3950,11 @@ enum class CXIdxAttrKind(val value: Int) { fun byValue(value: Int) = CXIdxAttrKind.values().find { it.value == value }!! } - class ref(ptr: NativePtr) : NativeRef(ptr) { - companion object : TypeWithSize(Int32Box.size, ::ref) + class Var(override val rawPtr: NativePtr) : CEnumVar() { + companion object : Type(CInt32Var.size.toInt()) var value: CXIdxAttrKind - get() = byValue(Int32Box.byPtr(ptr).value) - set(value) { Int32Box.byPtr(ptr).value = value.value } + get() = byValue(this.reinterpret().value) + set(value) { this.reinterpret().value = value.value } } } @@ -3506,11 +3966,11 @@ enum class CXIdxDeclInfoFlags(val value: Int) { fun byValue(value: Int) = CXIdxDeclInfoFlags.values().find { it.value == value }!! } - class ref(ptr: NativePtr) : NativeRef(ptr) { - companion object : TypeWithSize(Int32Box.size, ::ref) + class Var(override val rawPtr: NativePtr) : CEnumVar() { + companion object : Type(CInt32Var.size.toInt()) var value: CXIdxDeclInfoFlags - get() = byValue(Int32Box.byPtr(ptr).value) - set(value) { Int32Box.byPtr(ptr).value = value.value } + get() = byValue(this.reinterpret().value) + set(value) { this.reinterpret().value = value.value } } } @@ -3524,11 +3984,11 @@ enum class CXIdxObjCContainerKind(val value: Int) { fun byValue(value: Int) = CXIdxObjCContainerKind.values().find { it.value == value }!! } - class ref(ptr: NativePtr) : NativeRef(ptr) { - companion object : TypeWithSize(Int32Box.size, ::ref) + class Var(override val rawPtr: NativePtr) : CEnumVar() { + companion object : Type(CInt32Var.size.toInt()) var value: CXIdxObjCContainerKind - get() = byValue(Int32Box.byPtr(ptr).value) - set(value) { Int32Box.byPtr(ptr).value = value.value } + get() = byValue(this.reinterpret().value) + set(value) { this.reinterpret().value = value.value } } } @@ -3541,11 +4001,11 @@ enum class CXIdxEntityRefKind(val value: Int) { fun byValue(value: Int) = CXIdxEntityRefKind.values().find { it.value == value }!! } - class ref(ptr: NativePtr) : NativeRef(ptr) { - companion object : TypeWithSize(Int32Box.size, ::ref) + class Var(override val rawPtr: NativePtr) : CEnumVar() { + companion object : Type(CInt32Var.size.toInt()) var value: CXIdxEntityRefKind - get() = byValue(Int32Box.byPtr(ptr).value) - set(value) { Int32Box.byPtr(ptr).value = value.value } + get() = byValue(this.reinterpret().value) + set(value) { this.reinterpret().value = value.value } } } @@ -3562,97 +4022,175 @@ enum class CXIndexOptFlags(val value: Int) { fun byValue(value: Int) = CXIndexOptFlags.values().find { it.value == value }!! } - class ref(ptr: NativePtr) : NativeRef(ptr) { - companion object : TypeWithSize(Int32Box.size, ::ref) + class Var(override val rawPtr: NativePtr) : CEnumVar() { + companion object : Type(CInt32Var.size.toInt()) var value: CXIndexOptFlags - get() = byValue(Int32Box.byPtr(ptr).value) - set(value) { Int32Box.byPtr(ptr).value = value.value } + get() = byValue(this.reinterpret().value) + set(value) { this.reinterpret().value = value.value } } } -object NativeFunctionType1 : NativeFunctionType<(CXCursor, CXCursor, NativePtr?) -> CXChildVisitResult>(UInt32, Struct(UInt32, SInt32, Struct(Pointer, Pointer, Pointer)), Struct(UInt32, SInt32, Struct(Pointer, Pointer, Pointer)), Pointer) { - override fun invoke(function: (CXCursor, CXCursor, NativePtr?) -> CXChildVisitResult, args: NativeArray, ret: NativePtr) { - val res = function(args[0].value.asRef(CXCursor)!!, args[1].value.asRef(CXCursor)!!, args[2].value.asRef(NativePtrBox)!!.value) - CXChildVisitResult.ref.byPtr(ret).value = res +typealias __darwin_time_tVar = CInt64VarWithValueMappedTo<__darwin_time_t> +typealias __darwin_time_t = Long + +typealias __darwin_clock_tVar = CInt64VarWithValueMappedTo<__darwin_clock_t> +typealias __darwin_clock_t = Long + +typealias clock_tVar = CInt64VarWithValueMappedTo +typealias clock_t = __darwin_clock_t + +typealias time_tVar = CInt64VarWithValueMappedTo +typealias time_t = __darwin_time_t + +typealias __darwin_size_tVar = CInt64VarWithValueMappedTo<__darwin_size_t> +typealias __darwin_size_t = Long + +typealias size_tVar = CInt64VarWithValueMappedTo +typealias size_t = __darwin_size_t + +typealias __uint64_tVar = CInt64VarWithValueMappedTo<__uint64_t> +typealias __uint64_t = Long + +typealias CXVirtualFileOverlayVar = CPointerVarWithValueMappedTo +typealias CXVirtualFileOverlay = CPointer + +typealias CXModuleMapDescriptorVar = CPointerVarWithValueMappedTo +typealias CXModuleMapDescriptor = CPointer + +typealias CXIndexVar = CPointerVarWithValueMappedTo +typealias CXIndex = COpaquePointer + +typealias CXFileVar = CPointerVarWithValueMappedTo +typealias CXFile = COpaquePointer + +typealias CXTranslationUnitVar = CPointerVarWithValueMappedTo +typealias CXTranslationUnit = CPointer + +typealias CXDiagnosticSetVar = CPointerVarWithValueMappedTo +typealias CXDiagnosticSet = COpaquePointer + +typealias CXDiagnosticVar = CPointerVarWithValueMappedTo +typealias CXDiagnostic = COpaquePointer + +typealias CXCursorSetVar = CPointerVarWithValueMappedTo +typealias CXCursorSet = CPointer + +typealias CXCursorVisitorVar = CPointerVarWithValueMappedTo +typealias CXCursorVisitor = CFunctionPointer + +typealias CXClientDataVar = CPointerVarWithValueMappedTo +typealias CXClientData = COpaquePointer + +typealias CXModuleVar = CPointerVarWithValueMappedTo +typealias CXModule = COpaquePointer + +typealias CXCompletionStringVar = CPointerVarWithValueMappedTo +typealias CXCompletionString = COpaquePointer + +typealias CXInclusionVisitorVar = CPointerVarWithValueMappedTo +typealias CXInclusionVisitor = CFunctionPointer + +typealias CXRemappingVar = CPointerVarWithValueMappedTo +typealias CXRemapping = COpaquePointer + +typealias CXIdxClientContainerVar = CPointerVarWithValueMappedTo +typealias CXIdxClientContainer = COpaquePointer + +typealias CXIdxClientEntityVar = CPointerVarWithValueMappedTo +typealias CXIdxClientEntity = COpaquePointer + +typealias CXIndexActionVar = CPointerVarWithValueMappedTo +typealias CXIndexAction = COpaquePointer + +typealias CXIdxClientFileVar = CPointerVarWithValueMappedTo +typealias CXIdxClientFile = COpaquePointer + +typealias CXFieldVisitorVar = CPointerVarWithValueMappedTo +typealias CXFieldVisitor = CFunctionPointer + +object CFunctionType1 : CAdaptedFunctionTypeImpl<(CXCursor, CXCursor, COpaquePointer?) -> CXChildVisitResult>(UInt32, Struct(UInt32, SInt32, Struct(Pointer, Pointer, Pointer)), Struct(UInt32, SInt32, Struct(Pointer, Pointer, Pointer)), Pointer) { + override fun invoke(function: (CXCursor, CXCursor, COpaquePointer?) -> CXChildVisitResult, args: CArray, ret: COpaquePointer) { + val res = function(args[0].value!!.reinterpret().pointed, args[1].value!!.reinterpret().pointed, args[2].value!!.reinterpret().pointed.value) + ret.reinterpret().pointed.value = res } } -object NativeFunctionType2 : NativeFunctionType<(NativePtr?) -> Unit>(Void, Pointer) { - override fun invoke(function: (NativePtr?) -> Unit, args: NativeArray, ret: NativePtr) { - val res = function(args[0].value.asRef(NativePtrBox)!!.value) +object CFunctionType2 : CAdaptedFunctionTypeImpl<(COpaquePointer?) -> Unit>(Void, Pointer) { + override fun invoke(function: (COpaquePointer?) -> Unit, args: CArray, ret: COpaquePointer) { + val res = function(args[0].value!!.reinterpret().pointed.value) } } -object NativeFunctionType3 : NativeFunctionType<(NativePtr?, CXSourceLocation?, Int, NativePtr?) -> Unit>(Void, Pointer, Pointer, UInt32, Pointer) { - override fun invoke(function: (NativePtr?, CXSourceLocation?, Int, NativePtr?) -> Unit, args: NativeArray, ret: NativePtr) { - val res = function(args[0].value.asRef(NativePtrBox)!!.value, args[1].value.asRef(CXSourceLocation.ref)!!.value, args[2].value.asRef(Int32Box)!!.value, args[3].value.asRef(NativePtrBox)!!.value) +object CFunctionType3 : CAdaptedFunctionTypeImpl<(COpaquePointer?, CPointer?, Int, COpaquePointer?) -> Unit>(Void, Pointer, Pointer, UInt32, Pointer) { + override fun invoke(function: (COpaquePointer?, CPointer?, Int, COpaquePointer?) -> Unit, args: CArray, ret: COpaquePointer) { + val res = function(args[0].value!!.reinterpret().pointed.value, args[1].value!!.reinterpret>().pointed.value, args[2].value!!.reinterpret().pointed.value, args[3].value!!.reinterpret().pointed.value) } } -object NativeFunctionType4 : NativeFunctionType<(CXCursor, NativePtr?) -> CXVisitorResult>(UInt32, Struct(UInt32, SInt32, Struct(Pointer, Pointer, Pointer)), Pointer) { - override fun invoke(function: (CXCursor, NativePtr?) -> CXVisitorResult, args: NativeArray, ret: NativePtr) { - val res = function(args[0].value.asRef(CXCursor)!!, args[1].value.asRef(NativePtrBox)!!.value) - CXVisitorResult.ref.byPtr(ret).value = res +object CFunctionType4 : CAdaptedFunctionTypeImpl<(CXCursor, COpaquePointer?) -> CXVisitorResult>(UInt32, Struct(UInt32, SInt32, Struct(Pointer, Pointer, Pointer)), Pointer) { + override fun invoke(function: (CXCursor, COpaquePointer?) -> CXVisitorResult, args: CArray, ret: COpaquePointer) { + val res = function(args[0].value!!.reinterpret().pointed, args[1].value!!.reinterpret().pointed.value) + ret.reinterpret().pointed.value = res } } -object NativeFunctionType5 : NativeFunctionType<(NativePtr?, CXCursor, CXSourceRange) -> CXVisitorResult>(UInt32, Pointer, Struct(UInt32, SInt32, Struct(Pointer, Pointer, Pointer)), Struct(Struct(Pointer, Pointer), UInt32, UInt32)) { - override fun invoke(function: (NativePtr?, CXCursor, CXSourceRange) -> CXVisitorResult, args: NativeArray, ret: NativePtr) { - val res = function(args[0].value.asRef(NativePtrBox)!!.value, args[1].value.asRef(CXCursor)!!, args[2].value.asRef(CXSourceRange)!!) - CXVisitorResult.ref.byPtr(ret).value = res +object CFunctionType5 : CAdaptedFunctionTypeImpl<(COpaquePointer?, CXCursor, CXSourceRange) -> CXVisitorResult>(UInt32, Pointer, Struct(UInt32, SInt32, Struct(Pointer, Pointer, Pointer)), Struct(Struct(Pointer, Pointer), UInt32, UInt32)) { + override fun invoke(function: (COpaquePointer?, CXCursor, CXSourceRange) -> CXVisitorResult, args: CArray, ret: COpaquePointer) { + val res = function(args[0].value!!.reinterpret().pointed.value, args[1].value!!.reinterpret().pointed, args[2].value!!.reinterpret().pointed) + ret.reinterpret().pointed.value = res } } -object NativeFunctionType6 : NativeFunctionType<(NativePtr?, NativePtr?) -> Int>(SInt32, Pointer, Pointer) { - override fun invoke(function: (NativePtr?, NativePtr?) -> Int, args: NativeArray, ret: NativePtr) { - val res = function(args[0].value.asRef(NativePtrBox)!!.value, args[1].value.asRef(NativePtrBox)!!.value) - Int32Box.byPtr(ret).value = res +object CFunctionType6 : CAdaptedFunctionTypeImpl<(COpaquePointer?, COpaquePointer?) -> Int>(SInt32, Pointer, Pointer) { + override fun invoke(function: (COpaquePointer?, COpaquePointer?) -> Int, args: CArray, ret: COpaquePointer) { + val res = function(args[0].value!!.reinterpret().pointed.value, args[1].value!!.reinterpret().pointed.value) + ret.reinterpret().pointed.value = res } } -object NativeFunctionType7 : NativeFunctionType<(NativePtr?, NativePtr?, NativePtr?) -> Unit>(Void, Pointer, Pointer, Pointer) { - override fun invoke(function: (NativePtr?, NativePtr?, NativePtr?) -> Unit, args: NativeArray, ret: NativePtr) { - val res = function(args[0].value.asRef(NativePtrBox)!!.value, args[1].value.asRef(NativePtrBox)!!.value, args[2].value.asRef(NativePtrBox)!!.value) +object CFunctionType7 : CAdaptedFunctionTypeImpl<(COpaquePointer?, COpaquePointer?, COpaquePointer?) -> Unit>(Void, Pointer, Pointer, Pointer) { + override fun invoke(function: (COpaquePointer?, COpaquePointer?, COpaquePointer?) -> Unit, args: CArray, ret: COpaquePointer) { + val res = function(args[0].value!!.reinterpret().pointed.value, args[1].value!!.reinterpret().pointed.value, args[2].value!!.reinterpret().pointed.value) } } -object NativeFunctionType8 : NativeFunctionType<(NativePtr?, NativePtr?, NativePtr?) -> NativePtr?>(Pointer, Pointer, Pointer, Pointer) { - override fun invoke(function: (NativePtr?, NativePtr?, NativePtr?) -> NativePtr?, args: NativeArray, ret: NativePtr) { - val res = function(args[0].value.asRef(NativePtrBox)!!.value, args[1].value.asRef(NativePtrBox)!!.value, args[2].value.asRef(NativePtrBox)!!.value) - NativePtrBox.byPtr(ret).value = res +object CFunctionType8 : CAdaptedFunctionTypeImpl<(COpaquePointer?, COpaquePointer?, COpaquePointer?) -> COpaquePointer?>(Pointer, Pointer, Pointer, Pointer) { + override fun invoke(function: (COpaquePointer?, COpaquePointer?, COpaquePointer?) -> COpaquePointer?, args: CArray, ret: COpaquePointer) { + val res = function(args[0].value!!.reinterpret().pointed.value, args[1].value!!.reinterpret().pointed.value, args[2].value!!.reinterpret().pointed.value) + ret.reinterpret().pointed.value = res } } -object NativeFunctionType9 : NativeFunctionType<(NativePtr?, CXIdxIncludedFileInfo?) -> NativePtr?>(Pointer, Pointer, Pointer) { - override fun invoke(function: (NativePtr?, CXIdxIncludedFileInfo?) -> NativePtr?, args: NativeArray, ret: NativePtr) { - val res = function(args[0].value.asRef(NativePtrBox)!!.value, args[1].value.asRef(CXIdxIncludedFileInfo.ref)!!.value) - NativePtrBox.byPtr(ret).value = res +object CFunctionType9 : CAdaptedFunctionTypeImpl<(COpaquePointer?, CPointer?) -> COpaquePointer?>(Pointer, Pointer, Pointer) { + override fun invoke(function: (COpaquePointer?, CPointer?) -> COpaquePointer?, args: CArray, ret: COpaquePointer) { + val res = function(args[0].value!!.reinterpret().pointed.value, args[1].value!!.reinterpret>().pointed.value) + ret.reinterpret().pointed.value = res } } -object NativeFunctionType10 : NativeFunctionType<(NativePtr?, CXIdxImportedASTFileInfo?) -> NativePtr?>(Pointer, Pointer, Pointer) { - override fun invoke(function: (NativePtr?, CXIdxImportedASTFileInfo?) -> NativePtr?, args: NativeArray, ret: NativePtr) { - val res = function(args[0].value.asRef(NativePtrBox)!!.value, args[1].value.asRef(CXIdxImportedASTFileInfo.ref)!!.value) - NativePtrBox.byPtr(ret).value = res +object CFunctionType10 : CAdaptedFunctionTypeImpl<(COpaquePointer?, CPointer?) -> COpaquePointer?>(Pointer, Pointer, Pointer) { + override fun invoke(function: (COpaquePointer?, CPointer?) -> COpaquePointer?, args: CArray, ret: COpaquePointer) { + val res = function(args[0].value!!.reinterpret().pointed.value, args[1].value!!.reinterpret>().pointed.value) + ret.reinterpret().pointed.value = res } } -object NativeFunctionType11 : NativeFunctionType<(NativePtr?, NativePtr?) -> NativePtr?>(Pointer, Pointer, Pointer) { - override fun invoke(function: (NativePtr?, NativePtr?) -> NativePtr?, args: NativeArray, ret: NativePtr) { - val res = function(args[0].value.asRef(NativePtrBox)!!.value, args[1].value.asRef(NativePtrBox)!!.value) - NativePtrBox.byPtr(ret).value = res +object CFunctionType11 : CAdaptedFunctionTypeImpl<(COpaquePointer?, COpaquePointer?) -> COpaquePointer?>(Pointer, Pointer, Pointer) { + override fun invoke(function: (COpaquePointer?, COpaquePointer?) -> COpaquePointer?, args: CArray, ret: COpaquePointer) { + val res = function(args[0].value!!.reinterpret().pointed.value, args[1].value!!.reinterpret().pointed.value) + ret.reinterpret().pointed.value = res } } -object NativeFunctionType12 : NativeFunctionType<(NativePtr?, CXIdxDeclInfo?) -> Unit>(Void, Pointer, Pointer) { - override fun invoke(function: (NativePtr?, CXIdxDeclInfo?) -> Unit, args: NativeArray, ret: NativePtr) { - val res = function(args[0].value.asRef(NativePtrBox)!!.value, args[1].value.asRef(CXIdxDeclInfo.ref)!!.value) +object CFunctionType12 : CAdaptedFunctionTypeImpl<(COpaquePointer?, CPointer?) -> Unit>(Void, Pointer, Pointer) { + override fun invoke(function: (COpaquePointer?, CPointer?) -> Unit, args: CArray, ret: COpaquePointer) { + val res = function(args[0].value!!.reinterpret().pointed.value, args[1].value!!.reinterpret>().pointed.value) } } -object NativeFunctionType13 : NativeFunctionType<(NativePtr?, CXIdxEntityRefInfo?) -> Unit>(Void, Pointer, Pointer) { - override fun invoke(function: (NativePtr?, CXIdxEntityRefInfo?) -> Unit, args: NativeArray, ret: NativePtr) { - val res = function(args[0].value.asRef(NativePtrBox)!!.value, args[1].value.asRef(CXIdxEntityRefInfo.ref)!!.value) +object CFunctionType13 : CAdaptedFunctionTypeImpl<(COpaquePointer?, CPointer?) -> Unit>(Void, Pointer, Pointer) { + override fun invoke(function: (COpaquePointer?, CPointer?) -> Unit, args: CArray, ret: COpaquePointer) { + val res = function(args[0].value!!.reinterpret().pointed.value, args[1].value!!.reinterpret>().pointed.value) } } @@ -3698,7 +4236,15 @@ object externals { external fun timegm(arg0: Long): Long - external fun nanosleep(arg0: Long, arg1: Long): Int + external fun nanosleep(__rqtp: Long, __rmtp: Long): Int + + external fun clock_getres(__clock_id: Int, __res: Long): Int + + external fun clock_gettime(__clock_id: Int, __tp: Long): Int + + external fun clock_gettime_nsec_np(__clock_id: Int): Long + + external fun clock_settime(__clock_id: Int, __tp: Long): Int external fun clang_getCString(string: Long): Long diff --git a/Interop/Indexer/src/main/kotlin/org/jetbrains/kotlin/native/interop/indexer/Indexer.kt b/Interop/Indexer/src/main/kotlin/org/jetbrains/kotlin/native/interop/indexer/Indexer.kt index 4db3c86e6db..3f9d48b5613 100644 --- a/Interop/Indexer/src/main/kotlin/org/jetbrains/kotlin/native/interop/indexer/Indexer.kt +++ b/Interop/Indexer/src/main/kotlin/org/jetbrains/kotlin/native/interop/indexer/Indexer.kt @@ -3,7 +3,7 @@ package org.jetbrains.kotlin.native.interop.indexer import clang.* import clang.CXIdxEntityKind.* import clang.CXTypeKind.* -import kotlin_native.interop.* +import kotlin_.cinterop.* import java.io.File private class StructDeclImpl(spelling: String) : StructDecl(spelling) { @@ -135,11 +135,12 @@ private class NativeIndexImpl : NativeIndex() { CXCursorKind.CXCursor_UnionDecl -> return false CXCursorKind.CXCursor_StructDecl -> { - val hasAttributes = arena.alloc(Int32Box) + val hasAttributes = arena.alloc() hasAttributes.value = 0 - clang_visitChildren(structDefCursor, { cursor, parent, clientData -> + clang_visitChildren(structDefCursor, staticCFunction { cursor, parent, clientData -> if (clang_isAttribute(cursor.kind.value) != 0) { - clientData.asRef(Int32Box)!!.value = 1 + val hasAttributes = clientData!!.reinterpret().pointed + hasAttributes.value = 1 } CXChildVisitResult.CXChildVisit_Continue }, hasAttributes.ptr) @@ -220,7 +221,7 @@ private class NativeIndexImpl : NativeIndex() { fun indexDeclaration(info: CXIdxDeclInfo) { val cursor = info.cursor - val entityInfo = info.entityInfo.value!! + val entityInfo = info.entityInfo.pointed!! val entityName = entityInfo.name.value?.asCString()?.toString() val kind = entityInfo.kind.value @@ -230,7 +231,7 @@ private class NativeIndexImpl : NativeIndex() { val type = convertType(clang_getCursorType(cursor, arena)) val offset = clang_Cursor_getOffsetOfField(cursor) - val container = info.semanticContainer.value!! + val container = info.semanticContainer.pointed!! val structDef = getStructDeclAt(container.cursor).def!! structDef.fields.add(Field(name, type, offset)) } @@ -265,7 +266,7 @@ private class NativeIndexImpl : NativeIndex() { } CXIdxEntity_EnumConstant -> { - val container = info.semanticContainer.value!! + val container = info.semanticContainer.pointed!! val name = entityName!! val value = clang_getEnumConstantDeclValue(info.cursor) @@ -294,11 +295,11 @@ fun CXString.convertAndDispose(): String { fun buildNativeIndexImpl(headerFile: File, args: List): NativeIndex { // TODO: dispose all allocated memory and resources - val args1 = args.map { CString.fromString(it)!!.asCharPtr() }.toTypedArray() + val args1 = args.map { CString.fromString(it, nativeHeap)!!.asCharPtr() }.toTypedArray() val index = clang_createIndex(0, 0) val indexAction = clang_IndexAction_create(index) - val callbacks = malloc(IndexerCallbacks.Companion) + val callbacks = nativeHeap.alloc() val res = NativeIndexImpl() try { @@ -307,23 +308,23 @@ fun buildNativeIndexImpl(headerFile: File, args: List): NativeIndex { try { with(callbacks) { - abortQuery.setStatic(null) - diagnostic.setStatic(null) - enteredMainFile.setStatic(null) - ppIncludedFile.setStatic(null) - importedASTFile.setStatic(null) - startedTranslationUnit.setStatic(null) - indexDeclaration.setStatic { clientData, info -> + abortQuery.value = null + diagnostic.value = null + enteredMainFile.value = null + ppIncludedFile.value = null + importedASTFile.value = null + startedTranslationUnit.value = null + indexDeclaration.value = staticCFunction { clientData, info -> val index = StableObjPtr.fromValue(clientData!!).get() as NativeIndexImpl - index.indexDeclaration(info!!) + index.indexDeclaration(info!!.pointed) } - indexEntityReference.setStatic(null) + indexEntityReference.value = null } - val commandLineArgs = if (args1.size != 0) mallocNativeArrayOf(Int8Box.Companion, *args1)[0] else null + val commandLineArgs = if (args1.size != 0) nativeHeap.allocArrayOfPointersTo(*args1)[0].ptr else null - clang_indexSourceFile(indexAction, clientData, callbacks, IndexerCallbacks.size, 0, headerFile.path, - commandLineArgs, args1.size, null, 0, null, 0) + clang_indexSourceFile(indexAction, clientData, callbacks.ptr, IndexerCallbacks.size.toInt(), + 0, headerFile.path, commandLineArgs, args1.size, null, 0, null, 0) return res diff --git a/Interop/Runtime/src/callbacks/c/callbacks.c b/Interop/Runtime/src/callbacks/c/callbacks.c index 44f90608f65..eef64ee4ad5 100644 --- a/Interop/Runtime/src/callbacks/c/callbacks.c +++ b/Interop/Runtime/src/callbacks/c/callbacks.c @@ -4,101 +4,101 @@ #include /* - * Class: kotlin_native_interop_CallbacksKt + * Class: kotlin__cinterop_JvmCallbacksKt * Method: ffiTypeVoid * Signature: ()J */ -JNIEXPORT jlong JNICALL Java_kotlin_1native_interop_CallbacksKt_ffiTypeVoid(JNIEnv *env, jclass cls) { +JNIEXPORT jlong JNICALL Java_kotlin_1_cinterop_JvmCallbacksKt_ffiTypeVoid(JNIEnv *env, jclass cls) { return (jlong) &ffi_type_void; } /* - * Class: kotlin_native_interop_CallbacksKt + * Class: kotlin__cinterop_JvmCallbacksKt * Method: ffiTypeUInt8 * Signature: ()J */ -JNIEXPORT jlong JNICALL Java_kotlin_1native_interop_CallbacksKt_ffiTypeUInt8(JNIEnv *env, jclass cls) { +JNIEXPORT jlong JNICALL Java_kotlin_1_cinterop_JvmCallbacksKt_ffiTypeUInt8(JNIEnv *env, jclass cls) { return (jlong) &ffi_type_uint8; } /* - * Class: kotlin_native_interop_CallbacksKt + * Class: kotlin__cinterop_JvmCallbacksKt * Method: ffiTypeSInt8 * Signature: ()J */ -JNIEXPORT jlong JNICALL Java_kotlin_1native_interop_CallbacksKt_ffiTypeSInt8(JNIEnv *env, jclass cls) { +JNIEXPORT jlong JNICALL Java_kotlin_1_cinterop_JvmCallbacksKt_ffiTypeSInt8(JNIEnv *env, jclass cls) { return (jlong) &ffi_type_sint8; } /* - * Class: kotlin_native_interop_CallbacksKt + * Class: kotlin__cinterop_JvmCallbacksKt * Method: ffiTypeUInt16 * Signature: ()J */ -JNIEXPORT jlong JNICALL Java_kotlin_1native_interop_CallbacksKt_ffiTypeUInt16(JNIEnv *env, jclass cls) { +JNIEXPORT jlong JNICALL Java_kotlin_1_cinterop_JvmCallbacksKt_ffiTypeUInt16(JNIEnv *env, jclass cls) { return (jlong) &ffi_type_uint16; } /* - * Class: kotlin_native_interop_CallbacksKt + * Class: kotlin__cinterop_JvmCallbacksKt * Method: ffiTypeSInt16 * Signature: ()J */ -JNIEXPORT jlong JNICALL Java_kotlin_1native_interop_CallbacksKt_ffiTypeSInt16(JNIEnv *env, jclass cls) { +JNIEXPORT jlong JNICALL Java_kotlin_1_cinterop_JvmCallbacksKt_ffiTypeSInt16(JNIEnv *env, jclass cls) { return (jlong) &ffi_type_sint16; } /* - * Class: kotlin_native_interop_CallbacksKt + * Class: kotlin__cinterop_JvmCallbacksKt * Method: ffiTypeUInt32 * Signature: ()J */ -JNIEXPORT jlong JNICALL Java_kotlin_1native_interop_CallbacksKt_ffiTypeUInt32(JNIEnv *env, jclass cls) { +JNIEXPORT jlong JNICALL Java_kotlin_1_cinterop_JvmCallbacksKt_ffiTypeUInt32(JNIEnv *env, jclass cls) { return (jlong) &ffi_type_uint32; } /* - * Class: kotlin_native_interop_CallbacksKt + * Class: kotlin__cinterop_JvmCallbacksKt * Method: ffiTypeSInt32 * Signature: ()J */ -JNIEXPORT jlong JNICALL Java_kotlin_1native_interop_CallbacksKt_ffiTypeSInt32(JNIEnv *env, jclass cls) { +JNIEXPORT jlong JNICALL Java_kotlin_1_cinterop_JvmCallbacksKt_ffiTypeSInt32(JNIEnv *env, jclass cls) { return (jlong) &ffi_type_sint32; } /* - * Class: kotlin_native_interop_CallbacksKt + * Class: kotlin__cinterop_JvmCallbacksKt * Method: ffiTypeUInt64 * Signature: ()J */ -JNIEXPORT jlong JNICALL Java_kotlin_1native_interop_CallbacksKt_ffiTypeUInt64(JNIEnv *env, jclass cls) { +JNIEXPORT jlong JNICALL Java_kotlin_1_cinterop_JvmCallbacksKt_ffiTypeUInt64(JNIEnv *env, jclass cls) { return (jlong) &ffi_type_uint64; } /* - * Class: kotlin_native_interop_CallbacksKt + * Class: kotlin__cinterop_JvmCallbacksKt * Method: ffiTypeSInt64 * Signature: ()J */ -JNIEXPORT jlong JNICALL Java_kotlin_1native_interop_CallbacksKt_ffiTypeSInt64(JNIEnv *env, jclass cls) { +JNIEXPORT jlong JNICALL Java_kotlin_1_cinterop_JvmCallbacksKt_ffiTypeSInt64(JNIEnv *env, jclass cls) { return (jlong) &ffi_type_sint64; } /* - * Class: kotlin_native_interop_CallbacksKt + * Class: kotlin__cinterop_JvmCallbacksKt * Method: ffiTypePointer * Signature: ()J */ -JNIEXPORT jlong JNICALL Java_kotlin_1native_interop_CallbacksKt_ffiTypePointer(JNIEnv *env, jclass cls) { +JNIEXPORT jlong JNICALL Java_kotlin_1_cinterop_JvmCallbacksKt_ffiTypePointer(JNIEnv *env, jclass cls) { return (jlong) &ffi_type_pointer; } /* - * Class: kotlin_native_interop_CallbacksKt + * Class: kotlin__cinterop_JvmCallbacksKt * Method: ffiTypeStruct0 * Signature: (J)J */ -JNIEXPORT jlong JNICALL Java_kotlin_1native_interop_CallbacksKt_ffiTypeStruct0(JNIEnv *env, jclass cls, jlong elements) { +JNIEXPORT jlong JNICALL Java_kotlin_1_cinterop_JvmCallbacksKt_ffiTypeStruct0(JNIEnv *env, jclass cls, jlong elements) { ffi_type* res = malloc(sizeof(ffi_type)); if (res != NULL) { res->size = 0; @@ -110,11 +110,11 @@ JNIEXPORT jlong JNICALL Java_kotlin_1native_interop_CallbacksKt_ffiTypeStruct0(J } /* - * Class: kotlin_native_interop_CallbacksKt + * Class: kotlin__cinterop_JvmCallbacksKt * Method: ffiCreateCif0 * Signature: (IJJ)J */ -JNIEXPORT jlong JNICALL Java_kotlin_1native_interop_CallbacksKt_ffiCreateCif0(JNIEnv *env, jclass cls, jint nArgs, jlong rType, jlong argTypes) { +JNIEXPORT jlong JNICALL Java_kotlin_1_cinterop_JvmCallbacksKt_ffiCreateCif0(JNIEnv *env, jclass cls, jint nArgs, jlong rType, jlong argTypes) { ffi_cif* res = malloc(sizeof(ffi_cif)); if (res != NULL) { ffi_status status = ffi_prep_cif(res, FFI_DEFAULT_ABI, nArgs, (ffi_type*)rType, (ffi_type**)argTypes); @@ -166,7 +166,7 @@ static void ffi_fun(ffi_cif *cif, void *ret, void **args, void *user_data) { static jmethodID ffiFunImpl0 = NULL; static jclass cls = NULL; if (ffiFunImpl0 == NULL) { - jclass clsLocal = (*env)->FindClass(env, "kotlin_native/interop/CallbacksKt"); + jclass clsLocal = (*env)->FindClass(env, "kotlin_/cinterop/JvmCallbacksKt"); checkException(env); assert(clsLocal != NULL); @@ -184,11 +184,11 @@ static void ffi_fun(ffi_cif *cif, void *ret, void **args, void *user_data) { } /* - * Class: kotlin_native_interop_CallbacksKt + * Class: kotlin__cinterop_JvmCallbacksKt * Method: ffiCreateClosure0 * Signature: (JLjava/lang/Object;)J */ -JNIEXPORT jlong JNICALL Java_kotlin_1native_interop_CallbacksKt_ffiCreateClosure0(JNIEnv *env, jclass cls, jlong ffiCif, jobject userData) { +JNIEXPORT jlong JNICALL Java_kotlin_1_cinterop_JvmCallbacksKt_ffiCreateClosure0(JNIEnv *env, jclass cls, jlong ffiCif, jobject userData) { jobject userDataGlobalRef = (*env)->NewGlobalRef(env, userData); if (userDataGlobalRef == NULL) { return (jlong)0; @@ -211,29 +211,29 @@ JNIEXPORT jlong JNICALL Java_kotlin_1native_interop_CallbacksKt_ffiCreateClosure } /* - * Class: kotlin_native_interop_CallbacksKt + * Class: kotlin__cinterop_JvmCallbacksKt * Method: newGlobalRef * Signature: (Ljava/lang/Object;)J */ -JNIEXPORT jlong JNICALL Java_kotlin_1native_interop_CallbacksKt_newGlobalRef(JNIEnv *env, jclass cls, jobject obj) { +JNIEXPORT jlong JNICALL Java_kotlin_1_cinterop_JvmCallbacksKt_newGlobalRef(JNIEnv *env, jclass cls, jobject obj) { jobject res = (*env)->NewGlobalRef(env, obj); return (jlong) res; } /* - * Class: kotlin_native_interop_CallbacksKt + * Class: kotlin__cinterop_JvmCallbacksKt * Method: derefGlobalRef * Signature: (J)Ljava/lang/Object; */ -JNIEXPORT jobject JNICALL Java_kotlin_1native_interop_CallbacksKt_derefGlobalRef(JNIEnv *env, jclass cls, jlong ref) { +JNIEXPORT jobject JNICALL Java_kotlin_1_cinterop_JvmCallbacksKt_derefGlobalRef(JNIEnv *env, jclass cls, jlong ref) { return (jobject) ref; } /* - * Class: kotlin_native_interop_CallbacksKt + * Class: kotlin__cinterop_JvmCallbacksKt * Method: deleteGlobalRef * Signature: (J)V */ -JNIEXPORT void JNICALL Java_kotlin_1native_interop_CallbacksKt_deleteGlobalRef(JNIEnv *env, jclass cls, jlong ref) { +JNIEXPORT void JNICALL Java_kotlin_1_cinterop_JvmCallbacksKt_deleteGlobalRef(JNIEnv *env, jclass cls, jlong ref) { (*env)->DeleteGlobalRef(env, (jobject) ref); } From a58d682d405f219b481961d9d55ba8ec076211f4 Mon Sep 17 00:00:00 2001 From: Svyatoslav Scherbina Date: Tue, 22 Nov 2016 12:10:49 +0700 Subject: [PATCH 08/11] Interop: remove old version --- .../kotlin/kotlin_native/interop/Bridge.kt | 46 --- .../kotlin/kotlin_native/interop/Callbacks.kt | 287 ------------------ .../kotlin/kotlin_native/interop/Types.kt | 202 ------------ .../kotlin/kotlin_native/interop/Utils.kt | 76 ----- 4 files changed, 611 deletions(-) delete mode 100644 Interop/Runtime/src/main/kotlin/kotlin_native/interop/Bridge.kt delete mode 100644 Interop/Runtime/src/main/kotlin/kotlin_native/interop/Callbacks.kt delete mode 100644 Interop/Runtime/src/main/kotlin/kotlin_native/interop/Types.kt delete mode 100644 Interop/Runtime/src/main/kotlin/kotlin_native/interop/Utils.kt diff --git a/Interop/Runtime/src/main/kotlin/kotlin_native/interop/Bridge.kt b/Interop/Runtime/src/main/kotlin/kotlin_native/interop/Bridge.kt deleted file mode 100644 index 611202f6cdc..00000000000 --- a/Interop/Runtime/src/main/kotlin/kotlin_native/interop/Bridge.kt +++ /dev/null @@ -1,46 +0,0 @@ -package kotlin_native.interop - -import sun.misc.Unsafe - -data class NativePtr private constructor(internal val value: Long) { - - fun displacedBy(offset: Int) = NativePtr(value + offset) - - companion object { - fun byValue(value: Long): NativePtr? { - return if (value == 0L) { - null - } else { - NativePtr(value) - } - } - } -} - -fun NativePtr?.asLong() = if (this == null) 0L else value - -internal object bridge { - - fun malloc(size: Int): NativePtr = NativePtr.byValue(unsafe.allocateMemory(size.toLong()))!! - fun free(ptr: NativePtr) = unsafe.freeMemory(ptr.asLong()) - - fun getInt64(ptr: NativePtr): Long = unsafe.getLong(ptr.asLong()) - fun putInt64(ptr: NativePtr, value: Long) = unsafe.putLong(ptr.asLong(), value) - - fun getPtr(ptr: NativePtr): NativePtr? = NativePtr.byValue(unsafe.getLong(ptr.asLong())) - fun putPtr(ptr: NativePtr, value: NativePtr?) = unsafe.putLong(ptr.asLong(), value.asLong()) - - fun getInt32(ptr: NativePtr): Int = unsafe.getInt(ptr.asLong()) - fun putInt32(ptr: NativePtr, value: Int) = unsafe.putInt(ptr.asLong(), value) - - fun getInt16(ptr: NativePtr): Short = unsafe.getShort(ptr.asLong()) - fun putInt16(ptr: NativePtr, value: Short) = unsafe.putShort(ptr.asLong(), value) - - fun getInt8(ptr: NativePtr): Byte = unsafe.getByte(ptr.asLong()) - fun putInt8(ptr: NativePtr, value: Byte) = unsafe.putByte(ptr.asLong(), value) - - private val unsafe = with(Unsafe::class.java.getDeclaredField("theUnsafe")) { - isAccessible = true - return@with this.get(null) as Unsafe - } -} \ No newline at end of file diff --git a/Interop/Runtime/src/main/kotlin/kotlin_native/interop/Callbacks.kt b/Interop/Runtime/src/main/kotlin/kotlin_native/interop/Callbacks.kt deleted file mode 100644 index 15389fae432..00000000000 --- a/Interop/Runtime/src/main/kotlin/kotlin_native/interop/Callbacks.kt +++ /dev/null @@ -1,287 +0,0 @@ -package kotlin_native.interop - -/** - * This class provides a way to create a stable handle to any Kotlin object. - * Its [value] can be safely passed to native code e.g. to be received in a Kotlin callback. - * - * Any [StableObjPtr] should be manually [disposed][dispose] - */ -data class StableObjPtr private constructor(val value: NativePtr) { - - companion object { - - /** - * Creates a handle for given object. - */ - fun create(any: Any) = StableObjPtr(NativePtr.byValue(newGlobalRef(any))!!) - - /** - * Creates [StableObjPtr] from given raw value. - * - * @param value must be a [value] of some [StableObjPtr] - */ - fun fromValue(value: NativePtr) = StableObjPtr(value) - - init { - loadCallbacksLibrary() - } - } - - /** - * Disposes the handle. It must not be [used][get] after that. - */ - fun dispose() { - deleteGlobalRef(value.value) - } - - /** - * Returns the object this handle was [created][create] for. - */ - fun get(): Any = derefGlobalRef(value.value) - -} - -/** - * Describes the type of native function. - * - * The instances of this class are supposed to be Kotlin objects (singletons), - * because creating the instance implies allocating some amount of non-freeable memory for the instance itself - * and for any unique Kotlin function "converted" to this type. - * - * Native function type definition consists in the following: - * - Definitions of native function's parameter and return types to be passed into the constructor - * - Implementation of [invoke] method which describes how to convert between these types and Kotlin types used in [F] - * - * @param F Kotlin function type corresponding to given native function type -*/ -abstract class NativeFunctionType> protected constructor(returnType: CType, vararg paramTypes: CType) { - - /** - * Returns a native function of this type, which calls given Kotlin *static* function. - * - * Given function must be *static*, i.e. an (unbound) reference to a Kotlin function or - * a closure which doesn't capture any variable - */ - fun fromStatic(function: F): NativePtr { - // TODO: optimize synchronization - synchronized(cache) { - return cache.getOrPut(function, { createFromStatic(function) }) - } - } - - /** - * Describes the C type of a function's parameter or return value. - * It is supposed to be constructed using the primitive types (such as [SInt32]) and the [Struct] combinator. - * - * This description omits the details that are irrelevant for the ABI. - */ - protected open class CType internal constructor(val ffiType: ffi_type) { - internal constructor(ffiTypePtr: Long) : this(NativePtr.byValue(ffiTypePtr).asRef(ffi_type)!!) - } - - protected object Void : CType(ffiTypeVoid()) - protected object UInt8 : CType(ffiTypeUInt8()) - protected object SInt8 : CType(ffiTypeSInt8()) - protected object UInt16 : CType(ffiTypeUInt16()) - protected object SInt16 : CType(ffiTypeSInt16()) - protected object UInt32 : CType(ffiTypeUInt32()) - protected object SInt32 : CType(ffiTypeSInt32()) - protected object UInt64 : CType(ffiTypeUInt64()) - protected object SInt64 : CType(ffiTypeSInt64()) - protected object Pointer : CType(ffiTypePointer()) - - protected class Struct(vararg elementTypes: CType) : CType( - ffiTypeStruct( - elementTypes.map { it.ffiType } - ) - ) - - /** - * This method should invoke given Kotlin function. - * - * @param args array of pointers to arguments to be passed to [function] - * @param ret pointer to memory to be filled with return value of [function] - */ - protected abstract fun invoke(function: F, args: NativeArray, ret: NativePtr) - - companion object { - init { - loadCallbacksLibrary() - } - } - - private val ffiCif = ffiCreateCif(returnType.ffiType, paramTypes.map { it.ffiType }) - - /** - * Allocates a native function of this type for given Kotlin function. - */ - private fun createFromStatic(function: F): NativePtr { - if (!isStatic(function)) { - throw IllegalArgumentException() - } - - val impl = { ret: NativePtr, args: NativeArray -> - invoke(function, args, ret) - } - - return ffiCreateClosure(ffiCif, impl) - } - - /** - * Returns `true` if given function is *static* as defined in [fromStatic]. - */ - private fun isStatic(function: Function<*>): Boolean { - // TODO: revise - try { - with(function.javaClass.getDeclaredField("INSTANCE")) { - if (!java.lang.reflect.Modifier.isStatic(modifiers) || !java.lang.reflect.Modifier.isFinal(modifiers)) { - return false - } - - isAccessible = true // TODO: undo - - return get(null) == function - } - } catch (e: NoSuchFieldException) { - return false - } - } - - private val cache = mutableMapOf() -} - -/** - * @see NativeFunctionType.fromStatic - */ -fun > F.staticAsNative(type: NativeFunctionType) = type.fromStatic(this) - -/** - * Describes a "struct" with native function pointer field. - */ -class NativeFunctionBox>(ptr: NativePtr, private val type: NativeFunctionType) : NativeRef(ptr) { - - /** - * Sets the function pointer field to null or native function calling given Kotlin function. - */ - fun setStatic(function: F?) { - val nativeFunPtr = function?.staticAsNative(type) - bridge.putPtr(ptr, nativeFunPtr) - } -} - -val > NativeFunctionType.ref: NativeRef.TypeWithSize> - get() = NativeRef.TypeWithSize(8, { NativeFunctionBox(it, this) }) // TODO: 64-bit specific - - -private fun loadCallbacksLibrary() { - System.loadLibrary("callbacks") -} - - -/** - * Reference to `ffi_type` struct instance. - */ -internal class ffi_type (ptr: NativePtr) : NativeRef(ptr) { - companion object : Type(::ffi_type) -} - -/** - * Reference to `ffi_cif` struct instance. - */ -internal class ffi_cif (ptr: NativePtr) : NativeRef(ptr) { - companion object : Type(::ffi_cif) -} - -private external fun ffiTypeVoid(): Long -private external fun ffiTypeUInt8(): Long -private external fun ffiTypeSInt8(): Long -private external fun ffiTypeUInt16(): Long -private external fun ffiTypeSInt16(): Long -private external fun ffiTypeUInt32(): Long -private external fun ffiTypeSInt32(): Long -private external fun ffiTypeUInt64(): Long -private external fun ffiTypeSInt64(): Long -private external fun ffiTypePointer(): Long - -private external fun ffiTypeStruct0(elements: Long): Long - -/** - * Allocates and initializes `ffi_type` describing the struct. - * - * @param elements types of the struct elements - */ -private fun ffiTypeStruct(elementTypes: List): ffi_type { - val elements = mallocNativeArrayOf(ffi_type, *elementTypes.toTypedArray(), null).ptr - val res = ffiTypeStruct0(elements.value) - if (res == 0L) { - throw OutOfMemoryError() - } - return NativePtr.byValue(res).asRef(ffi_type)!! -} - -private external fun ffiCreateCif0(nArgs: Int, rType: Long, argTypes: Long): Long - -/** - * Creates and prepares an `ffi_cif`. - * - * @param returnType native function return value type - * @param paramTypes native function parameter types - * - * @return the initialized `ffi_cif` - */ -private fun ffiCreateCif(returnType: ffi_type, paramTypes: List): ffi_cif { - val nArgs = paramTypes.size - val rType = returnType.ptr - val argTypes = mallocNativeArrayOf(ffi_type, *paramTypes.toTypedArray(), null).ptr - val res = ffiCreateCif0(nArgs, rType.value, argTypes.value) - - when (res) { - 0L -> throw OutOfMemoryError() - -1L -> throw Error("FFI_BAD_TYPEDEF") - -2L -> throw Error("FFI_BAD_ABI") - -3L -> throw Error("libffi error occurred") - } - - return NativePtr.byValue(res).asRef(ffi_cif)!! -} - -private fun ffiFunImpl0(ffiCif: Long, ret: Long, args: Long, userData: Any) { - ffiFunImpl(NativePtr.byValue(ffiCif).asRef(ffi_cif)!!, - NativePtr.byValue(ret)!!, - NativePtr.byValue(args).asRef(array(NativePtrBox))!!, - userData as (ret: NativePtr, args: NativeArray) -> Unit) -} - -/** - * This function is called from native code when a native function created with [ffiCreateClosure] is invoked. - * - * @param ret pointer to memory to be filled with return value of the invoked native function - * @param args pointer to array of pointers to arguments passed to the invoked native function - */ -private fun ffiFunImpl(ffiCif: ffi_cif, ret: NativePtr, args: NativeArray, - userData: (NativePtr, NativeArray) -> Unit) { - - userData.invoke(ret, args) -} - -private external fun ffiCreateClosure0(ffiCif: Long, userData: Any): Long - -/** - * Uses libffi to allocate a native function which will call [ffiFunImpl] when invoked. - * - * @param ffiCif describes the type of the function to create - */ -private fun ffiCreateClosure(ffiCif: ffi_cif, userData: (NativePtr, NativeArray) -> Unit): NativePtr { - val res = ffiCreateClosure0(ffiCif.ptr.value, userData) - - when (res) { - 0L -> throw OutOfMemoryError() - -1L -> throw Error("libffi error occurred") - } - - return NativePtr.byValue(res)!! -} - -private external fun newGlobalRef(any: Any): Long -private external fun derefGlobalRef(ref: Long): Any -private external fun deleteGlobalRef(ref: Long) \ No newline at end of file diff --git a/Interop/Runtime/src/main/kotlin/kotlin_native/interop/Types.kt b/Interop/Runtime/src/main/kotlin/kotlin_native/interop/Types.kt deleted file mode 100644 index d51d41770c7..00000000000 --- a/Interop/Runtime/src/main/kotlin/kotlin_native/interop/Types.kt +++ /dev/null @@ -1,202 +0,0 @@ -package kotlin_native.interop - -import java.io.Closeable - -// TODO: what about equals/hashCode? - -open class NativeRef(val ptr: NativePtr) { - open class Type(val byPtr: (NativePtr) -> T) - open class TypeWithSize(val size: Int, byPtr: (NativePtr) -> T) : NativeRef.Type(byPtr) - - final override fun equals(other: Any?): Boolean{ - if (this === other) return true - if (other !is NativeRef) return false - - return ptr == other.ptr - } - - final override fun hashCode(): Int{ - return ptr.hashCode() - } -} - -fun NativePtr?.asRef(type: NativeRef.Type) = this?.let { type.byPtr(this) } -fun NativeRef?.getNativePtr() = this?.ptr - -class Int8Box(ptr: NativePtr) : NativeRef(ptr) { - companion object : NativeRef.TypeWithSize(1, ::Int8Box) - var value: Byte - get() = bridge.getInt8(ptr) - set(value) = bridge.putInt8(ptr, value) -} - -class Int16Box(ptr: NativePtr) : NativeRef(ptr) { - companion object : NativeRef.TypeWithSize(2, ::Int16Box) - var value: Short - get() = bridge.getInt16(ptr) - set(value) = bridge.putInt16(ptr, value) -} - -class Int32Box(ptr: NativePtr) : NativeRef(ptr) { - companion object : NativeRef.TypeWithSize(4, ::Int32Box) - var value: Int - get() = bridge.getInt32(ptr) - set(value) = bridge.putInt32(ptr, value) -} - -class NativePtrBox(ptr: NativePtr) : NativeRef(ptr) { - companion object : NativeRef.TypeWithSize(8, ::NativePtrBox) // TODO: 64-bit specific - var value: NativePtr? - get() = bridge.getPtr(ptr) - set(value) = bridge.putPtr(ptr, value) -} - -class Int64Box(ptr: NativePtr) : NativeRef(ptr) { - companion object : NativeRef.TypeWithSize(8, ::Int64Box) - var value: Long - get() = bridge.getInt64(ptr) - set(value) = bridge.putInt64(ptr, value) -} - -class RefBox(ptr: NativePtr, val referentType: NativeRef.Type) : NativeRef(ptr) { - companion object { - infix fun of(type: NativeRef.Type) = NativeRef.TypeWithSize>(8, { RefBox(it, type) }) // TODO: 64-bit specific - } - - var value: T? - get() = bridge.getPtr(ptr).asRef(referentType) - set(value) = bridge.putPtr(ptr, value.getNativePtr()) -} - -val NativeRef.Type.ref: NativeRef.TypeWithSize> - get() = Ref to this - -object Ref { - infix fun to(type: NativeRef.Type) = RefBox.Companion of type - infix fun to(type: Byte.Companion) = Int8Box.Companion - infix fun to(type: Short.Companion) = Int16Box.Companion - infix fun to(type: Int.Companion) = Int32Box.Companion - infix fun to(type: Long.Companion) = Int64Box.Companion -} - -open class NativeStruct(ptr: NativePtr) : NativeRef(ptr) { - open class Type(size: Int, byPtr: (NativePtr) -> T) : NativeRef.TypeWithSize(size, byPtr) - - companion object { - class FieldAt(val type: NativeRef.Type, val offset: Int) { - operator fun getValue(thisRef: NativeStruct, property: kotlin.reflect.KProperty<*>): T { - return type.byPtr(thisRef.ptr.displacedBy(offset)) - } - } - - infix fun NativeRef.Type.at(offset: Int) = NativeStruct.Companion.FieldAt(this, offset) - } -} - -class NativeArray(ptr: NativePtr, val elemType: NativeRef.TypeWithSize) : NativeRef(ptr) { - operator fun get(index: Int): T { - return elemType.byPtr(ptr.displacedBy(index * elemType.size)) - } - - companion object { - - class Type (val elemType: NativeRef.TypeWithSize) : - NativeRef.Type>({ ptr -> NativeArray(ptr, elemType) }) { - - infix fun length(length: Int) = - NativeRef.TypeWithSize(elemType.size * length, { ptr -> NativeArray(ptr, elemType) }) - } - - infix fun of(elemType: NativeRef.TypeWithSize) = NativeArray.Companion.Type(elemType) - - fun byRefToFirstElem(ref: T, refType: NativeRef.TypeWithSize) = NativeArray(ref.ptr, refType) - } -} - -operator fun NativeRef.TypeWithSize.get(length: Int) = NativeArray.Companion of this length length -object array { - - // array(type) - operator fun invoke(type: NativeRef.TypeWithSize) = NativeArray.Companion of type - - // array[length](type) - operator fun get(length: Int) = array.ArrayWithLength(length) - - class ArrayWithLength(val length: Int) { - infix fun of(type: NativeRef.TypeWithSize) = NativeArray.Companion of type length length - - operator fun invoke(type: NativeRef.TypeWithSize) = this of type - } - -} - - -class CString private constructor(internal val array: NativeArray) : NativeRef(array.ptr) { - companion object { - fun fromArray(array: NativeArray) = CString(array) - } - - fun length(): Int { - var res = 0 - while (array[res].value != 0.toByte()) { - ++res - } - return res - } - - override fun toString(): String { - val bytes = ByteArray(this.length()) - bytes.forEachIndexed { i, byte -> - bytes[i] = this.array[i].value - } - return String(bytes) // TODO: encoding - } - - fun asCharPtr() = array[0] -} - -class __va_list_tag(ptr: NativePtr) : NativeRef(ptr) // FIXME - -interface Placement { - fun alloc(size: Int): NativePtr -} - -object heap : Placement { - override fun alloc(size: Int) = bridge.malloc(size) - - fun free(ptr: NativePtr) = bridge.free(ptr) - - fun free(ref: NativeRef) = free(ref.ptr) -} - -// TODO: implement optimally -class Arena : Placement, Closeable { - - private val allocatedChunks = mutableListOf() - - override fun alloc(size: Int): NativePtr { - val res = heap.alloc(size) - try { - allocatedChunks.add(res) - return res - } catch (e: Throwable) { - heap.free(res) - throw e - } - } - - fun clear() { - allocatedChunks.forEach { - heap.free(it) - } - - allocatedChunks.clear() - } - - override fun close() = clear() - -} - -fun Placement.alloc(type: NativeRef.TypeWithSize): T { - return type.byPtr(this.alloc(type.size)) -} \ No newline at end of file diff --git a/Interop/Runtime/src/main/kotlin/kotlin_native/interop/Utils.kt b/Interop/Runtime/src/main/kotlin/kotlin_native/interop/Utils.kt deleted file mode 100644 index b5c9c5bc373..00000000000 --- a/Interop/Runtime/src/main/kotlin/kotlin_native/interop/Utils.kt +++ /dev/null @@ -1,76 +0,0 @@ -package kotlin_native.interop - -fun malloc(type: NativeRef.TypeWithSize) = type.byPtr(bridge.malloc(type.size)) - -fun free(ptr: NativePtr?) { - if (ptr != null) { - bridge.free(ptr) - } -} - -fun free(ref: NativeRef?) = free(ref.getNativePtr()) - -fun Placement.allocNativeArrayOf(elemType: NativeRef.Type, elements: List): NativeArray> { - val res = this.alloc(array[elements.size](elemType.ref)) - elements.forEachIndexed { i, element -> - res[i].value = element - } - return res -} - -fun Placement.allocNativeArrayOf(elemType: NativeRef.Type, vararg elements: T?) = - allocNativeArrayOf(elemType, elements.toList()) - -fun mallocNativeArrayOf(elemType: NativeRef.Type, vararg elements: T?) = heap.allocNativeArrayOf(elemType, *elements) - -fun Placement.allocNativeArrayOf(elements: ByteArray): NativeArray { - val res = this.alloc(array[elements.size](Int8Box)) - elements.forEachIndexed { i, element -> - res[i].value = element - } - return res -} - -fun CString.Companion.fromString(str: String?): CString? { - return str?.toCString(heap) -} - -fun Int8Box.asCString() = CString.fromArray(NativeArray.byRefToFirstElem(this, Int8Box)) - -fun String.toCString(retValPlacement: Placement): CString { - val bytes = this.toByteArray() // TODO: encoding - val len = bytes.size - val nativeBytes = retValPlacement.alloc(array[len + 1](Int8Box)) - - bytes.forEachIndexed { i, byte -> - nativeBytes[i].value = byte - } - nativeBytes[len].value = 0 - - return CString.fromArray(nativeBytes) -} - -class MemScope private constructor(private val arena: Arena) : Placement by arena { - val memScope: Placement - get() = this - - companion object { - internal inline fun use(block: MemScope.()->R): R { - val memScope = MemScope(Arena()) - try { - return memScope.block() - } finally { - memScope.arena.clear() - } - } - } -} - -/** - * Runs given [block] providing allocation of memory - * which will be automatically disposed at the end of this scope. - */ -inline fun memScoped(block: MemScope.()->R): R { - @Suppress("NON_PUBLIC_CALL_FROM_PUBLIC_INLINE") // TODO: it is a hack - return MemScope.use(block) -} \ No newline at end of file From 950bc62c7bc29f9d547ab2d26b7c14999ac92d0e Mon Sep 17 00:00:00 2001 From: Svyatoslav Scherbina Date: Tue, 22 Nov 2016 16:06:51 +0700 Subject: [PATCH 09/11] Review feedback, part 1 --- .../org/jetbrains/kotlin/native/interop/indexer/Indexer.kt | 4 +--- Interop/Runtime/src/main/kotlin/kotlin_/cinterop/Types.kt | 7 +++---- 2 files changed, 4 insertions(+), 7 deletions(-) diff --git a/Interop/Indexer/src/main/kotlin/org/jetbrains/kotlin/native/interop/indexer/Indexer.kt b/Interop/Indexer/src/main/kotlin/org/jetbrains/kotlin/native/interop/indexer/Indexer.kt index 3f9d48b5613..7444013972a 100644 --- a/Interop/Indexer/src/main/kotlin/org/jetbrains/kotlin/native/interop/indexer/Indexer.kt +++ b/Interop/Indexer/src/main/kotlin/org/jetbrains/kotlin/native/interop/indexer/Indexer.kt @@ -182,9 +182,7 @@ private class NativeIndexImpl : NativeIndex() { CXType_ULongLong -> UInt64Type CXType_LongLong -> Int64Type - CXType_Typedef -> { - getTypedef(type) - } + CXType_Typedef -> getTypedef(type) CXType_Record -> RecordType(getStructTypeDecl(type)) CXType_Enum -> EnumType(getEnumTypeDef(type)) diff --git a/Interop/Runtime/src/main/kotlin/kotlin_/cinterop/Types.kt b/Interop/Runtime/src/main/kotlin/kotlin_/cinterop/Types.kt index ff3ec8e7b84..353bd7791f1 100644 --- a/Interop/Runtime/src/main/kotlin/kotlin_/cinterop/Types.kt +++ b/Interop/Runtime/src/main/kotlin/kotlin_/cinterop/Types.kt @@ -84,8 +84,7 @@ class CPointer private constructor(val rawValue: NativePtr) { } override fun toString(): String { - val hex = "%x".format(rawValue) - return "CPointer(raw=0x$hex)" + return "CPointer(raw=0x%x)".format(rawValue) } } @@ -107,7 +106,7 @@ inline val CPointer.pointed: T val CPointer<*>?.rawValue: NativePtr get() = this?.rawValue ?: nativeNullPtr -fun CPointer<*>.reinterpret() = this as CPointer +fun CPointer<*>.reinterpret(): CPointer = CPointer.create(this.rawValue) /** * The [CPointed] without any specified interpretation. @@ -155,7 +154,7 @@ interface CVariable : CPointed { } /** - * The C data which is composed from number of members. + * The C data which is composed from several members. */ interface CAggregate : CPointed From 453a36070796556d2b6974cd5951870fbbde3eb0 Mon Sep 17 00:00:00 2001 From: Svyatoslav Scherbina Date: Tue, 22 Nov 2016 16:18:48 +0700 Subject: [PATCH 10/11] Interop/Runtime: add minor code improvements --- .../src/main/kotlin/kotlin_/cinterop/Utils.kt | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) diff --git a/Interop/Runtime/src/main/kotlin/kotlin_/cinterop/Utils.kt b/Interop/Runtime/src/main/kotlin/kotlin_/cinterop/Utils.kt index f1a255c5e49..94063f1763e 100644 --- a/Interop/Runtime/src/main/kotlin/kotlin_/cinterop/Utils.kt +++ b/Interop/Runtime/src/main/kotlin/kotlin_/cinterop/Utils.kt @@ -75,11 +75,11 @@ inline fun NativePlacement.allocArray(length: Int): CArr * @param T must not be abstract */ inline fun NativePlacement.allocArray(length: Long, - initializer: T.(Long)->Unit): CArray { + initializer: T.(index: Long)->Unit): CArray { val res = allocArray(length) - (0 until length).forEach { - res[it].initializer(it) + (0 until length).forEach { index -> + res[index].initializer(index) } return res @@ -90,8 +90,11 @@ inline fun NativePlacement.allocArray(length: Long, * * @param T must not be abstract */ -inline fun NativePlacement.allocArray(length: Int, initializer: T.(Long)->Unit) = - allocArray(length.toLong(), initializer) +inline fun NativePlacement.allocArray(length: Int, + initializer: T.(index: Int)->Unit): CArray = + allocArray(length.toLong()) { index -> + this.initializer(index.toInt()) + } /** From c9881754314b793159dec0daa0b08aa7b959c245 Mon Sep 17 00:00:00 2001 From: Svyatoslav Scherbina Date: Wed, 23 Nov 2016 11:34:51 +0700 Subject: [PATCH 11/11] Review feedback: move `kotlin_.cinterop` package to `kotlinx` --- .../nativeInteropStubs/kotlin/clang/Clang.kt | 2 +- .../kotlin/native/interop/indexer/Indexer.kt | 2 +- Interop/Runtime/src/callbacks/c/callbacks.c | 66 +++++++++---------- .../cinterop/JvmCallbacks.kt | 2 +- .../cinterop/JvmNativeMem.kt | 2 +- .../{kotlin_ => kotlinx}/cinterop/JvmTypes.kt | 2 +- .../src/main/kotlin/kotlin_/package-info.java | 4 -- .../{kotlin_ => kotlinx}/cinterop/Types.kt | 2 +- .../{kotlin_ => kotlinx}/cinterop/Utils.kt | 2 +- .../kotlin/kotlinx/cinterop/package-info.java | 6 ++ .../native/interop/gen/jvm/StubGenerator.kt | 2 +- InteropExample/src/main/kotlin/main.kt | 2 +- .../backend/konan/llvm/CodeGenerator.kt | 2 +- .../kotlin/backend/konan/llvm/ContextUtils.kt | 2 +- .../kotlin/backend/konan/llvm/HashUtils.kt | 2 +- .../kotlin/backend/konan/llvm/IrToBitcode.kt | 2 +- .../kotlin/backend/konan/llvm/LlvmUtils.kt | 2 +- .../kotlin/backend/konan/llvm/Logger.kt | 2 +- .../backend/konan/llvm/MetadataGenerator.kt | 2 +- .../backend/konan/llvm/RTTIGenerator.kt | 2 +- .../kotlin/backend/konan/llvm/Runtime.kt | 2 +- .../kotlin/backend/konan/llvm/hacks.kt | 4 +- 22 files changed, 59 insertions(+), 57 deletions(-) rename Interop/Runtime/src/jvm/kotlin/{kotlin_ => kotlinx}/cinterop/JvmCallbacks.kt (99%) rename Interop/Runtime/src/jvm/kotlin/{kotlin_ => kotlinx}/cinterop/JvmNativeMem.kt (98%) rename Interop/Runtime/src/jvm/kotlin/{kotlin_ => kotlinx}/cinterop/JvmTypes.kt (97%) delete mode 100644 Interop/Runtime/src/main/kotlin/kotlin_/package-info.java rename Interop/Runtime/src/main/kotlin/{kotlin_ => kotlinx}/cinterop/Types.kt (99%) rename Interop/Runtime/src/main/kotlin/{kotlin_ => kotlinx}/cinterop/Utils.kt (99%) create mode 100644 Interop/Runtime/src/main/kotlin/kotlinx/cinterop/package-info.java diff --git a/Interop/Indexer/prebuilt/nativeInteropStubs/kotlin/clang/Clang.kt b/Interop/Indexer/prebuilt/nativeInteropStubs/kotlin/clang/Clang.kt index ffbef74fc09..8dff8851951 100644 --- a/Interop/Indexer/prebuilt/nativeInteropStubs/kotlin/clang/Clang.kt +++ b/Interop/Indexer/prebuilt/nativeInteropStubs/kotlin/clang/Clang.kt @@ -1,6 +1,6 @@ package clang -import kotlin_.cinterop.* +import kotlinx.cinterop.* fun asctime(arg0: CPointer?): CPointer? { val _arg0 = arg0.rawValue diff --git a/Interop/Indexer/src/main/kotlin/org/jetbrains/kotlin/native/interop/indexer/Indexer.kt b/Interop/Indexer/src/main/kotlin/org/jetbrains/kotlin/native/interop/indexer/Indexer.kt index 7444013972a..81ab2e5513e 100644 --- a/Interop/Indexer/src/main/kotlin/org/jetbrains/kotlin/native/interop/indexer/Indexer.kt +++ b/Interop/Indexer/src/main/kotlin/org/jetbrains/kotlin/native/interop/indexer/Indexer.kt @@ -3,7 +3,7 @@ package org.jetbrains.kotlin.native.interop.indexer import clang.* import clang.CXIdxEntityKind.* import clang.CXTypeKind.* -import kotlin_.cinterop.* +import kotlinx.cinterop.* import java.io.File private class StructDeclImpl(spelling: String) : StructDecl(spelling) { diff --git a/Interop/Runtime/src/callbacks/c/callbacks.c b/Interop/Runtime/src/callbacks/c/callbacks.c index eef64ee4ad5..426ac7af7cf 100644 --- a/Interop/Runtime/src/callbacks/c/callbacks.c +++ b/Interop/Runtime/src/callbacks/c/callbacks.c @@ -4,101 +4,101 @@ #include /* - * Class: kotlin__cinterop_JvmCallbacksKt + * Class: kotlinx_cinterop_JvmCallbacksKt * Method: ffiTypeVoid * Signature: ()J */ -JNIEXPORT jlong JNICALL Java_kotlin_1_cinterop_JvmCallbacksKt_ffiTypeVoid(JNIEnv *env, jclass cls) { +JNIEXPORT jlong JNICALL Java_kotlinx_cinterop_JvmCallbacksKt_ffiTypeVoid(JNIEnv *env, jclass cls) { return (jlong) &ffi_type_void; } /* - * Class: kotlin__cinterop_JvmCallbacksKt + * Class: kotlinx_cinterop_JvmCallbacksKt * Method: ffiTypeUInt8 * Signature: ()J */ -JNIEXPORT jlong JNICALL Java_kotlin_1_cinterop_JvmCallbacksKt_ffiTypeUInt8(JNIEnv *env, jclass cls) { +JNIEXPORT jlong JNICALL Java_kotlinx_cinterop_JvmCallbacksKt_ffiTypeUInt8(JNIEnv *env, jclass cls) { return (jlong) &ffi_type_uint8; } /* - * Class: kotlin__cinterop_JvmCallbacksKt + * Class: kotlinx_cinterop_JvmCallbacksKt * Method: ffiTypeSInt8 * Signature: ()J */ -JNIEXPORT jlong JNICALL Java_kotlin_1_cinterop_JvmCallbacksKt_ffiTypeSInt8(JNIEnv *env, jclass cls) { +JNIEXPORT jlong JNICALL Java_kotlinx_cinterop_JvmCallbacksKt_ffiTypeSInt8(JNIEnv *env, jclass cls) { return (jlong) &ffi_type_sint8; } /* - * Class: kotlin__cinterop_JvmCallbacksKt + * Class: kotlinx_cinterop_JvmCallbacksKt * Method: ffiTypeUInt16 * Signature: ()J */ -JNIEXPORT jlong JNICALL Java_kotlin_1_cinterop_JvmCallbacksKt_ffiTypeUInt16(JNIEnv *env, jclass cls) { +JNIEXPORT jlong JNICALL Java_kotlinx_cinterop_JvmCallbacksKt_ffiTypeUInt16(JNIEnv *env, jclass cls) { return (jlong) &ffi_type_uint16; } /* - * Class: kotlin__cinterop_JvmCallbacksKt + * Class: kotlinx_cinterop_JvmCallbacksKt * Method: ffiTypeSInt16 * Signature: ()J */ -JNIEXPORT jlong JNICALL Java_kotlin_1_cinterop_JvmCallbacksKt_ffiTypeSInt16(JNIEnv *env, jclass cls) { +JNIEXPORT jlong JNICALL Java_kotlinx_cinterop_JvmCallbacksKt_ffiTypeSInt16(JNIEnv *env, jclass cls) { return (jlong) &ffi_type_sint16; } /* - * Class: kotlin__cinterop_JvmCallbacksKt + * Class: kotlinx_cinterop_JvmCallbacksKt * Method: ffiTypeUInt32 * Signature: ()J */ -JNIEXPORT jlong JNICALL Java_kotlin_1_cinterop_JvmCallbacksKt_ffiTypeUInt32(JNIEnv *env, jclass cls) { +JNIEXPORT jlong JNICALL Java_kotlinx_cinterop_JvmCallbacksKt_ffiTypeUInt32(JNIEnv *env, jclass cls) { return (jlong) &ffi_type_uint32; } /* - * Class: kotlin__cinterop_JvmCallbacksKt + * Class: kotlinx_cinterop_JvmCallbacksKt * Method: ffiTypeSInt32 * Signature: ()J */ -JNIEXPORT jlong JNICALL Java_kotlin_1_cinterop_JvmCallbacksKt_ffiTypeSInt32(JNIEnv *env, jclass cls) { +JNIEXPORT jlong JNICALL Java_kotlinx_cinterop_JvmCallbacksKt_ffiTypeSInt32(JNIEnv *env, jclass cls) { return (jlong) &ffi_type_sint32; } /* - * Class: kotlin__cinterop_JvmCallbacksKt + * Class: kotlinx_cinterop_JvmCallbacksKt * Method: ffiTypeUInt64 * Signature: ()J */ -JNIEXPORT jlong JNICALL Java_kotlin_1_cinterop_JvmCallbacksKt_ffiTypeUInt64(JNIEnv *env, jclass cls) { +JNIEXPORT jlong JNICALL Java_kotlinx_cinterop_JvmCallbacksKt_ffiTypeUInt64(JNIEnv *env, jclass cls) { return (jlong) &ffi_type_uint64; } /* - * Class: kotlin__cinterop_JvmCallbacksKt + * Class: kotlinx_cinterop_JvmCallbacksKt * Method: ffiTypeSInt64 * Signature: ()J */ -JNIEXPORT jlong JNICALL Java_kotlin_1_cinterop_JvmCallbacksKt_ffiTypeSInt64(JNIEnv *env, jclass cls) { +JNIEXPORT jlong JNICALL Java_kotlinx_cinterop_JvmCallbacksKt_ffiTypeSInt64(JNIEnv *env, jclass cls) { return (jlong) &ffi_type_sint64; } /* - * Class: kotlin__cinterop_JvmCallbacksKt + * Class: kotlinx_cinterop_JvmCallbacksKt * Method: ffiTypePointer * Signature: ()J */ -JNIEXPORT jlong JNICALL Java_kotlin_1_cinterop_JvmCallbacksKt_ffiTypePointer(JNIEnv *env, jclass cls) { +JNIEXPORT jlong JNICALL Java_kotlinx_cinterop_JvmCallbacksKt_ffiTypePointer(JNIEnv *env, jclass cls) { return (jlong) &ffi_type_pointer; } /* - * Class: kotlin__cinterop_JvmCallbacksKt + * Class: kotlinx_cinterop_JvmCallbacksKt * Method: ffiTypeStruct0 * Signature: (J)J */ -JNIEXPORT jlong JNICALL Java_kotlin_1_cinterop_JvmCallbacksKt_ffiTypeStruct0(JNIEnv *env, jclass cls, jlong elements) { +JNIEXPORT jlong JNICALL Java_kotlinx_cinterop_JvmCallbacksKt_ffiTypeStruct0(JNIEnv *env, jclass cls, jlong elements) { ffi_type* res = malloc(sizeof(ffi_type)); if (res != NULL) { res->size = 0; @@ -110,11 +110,11 @@ JNIEXPORT jlong JNICALL Java_kotlin_1_cinterop_JvmCallbacksKt_ffiTypeStruct0(JNI } /* - * Class: kotlin__cinterop_JvmCallbacksKt + * Class: kotlinx_cinterop_JvmCallbacksKt * Method: ffiCreateCif0 * Signature: (IJJ)J */ -JNIEXPORT jlong JNICALL Java_kotlin_1_cinterop_JvmCallbacksKt_ffiCreateCif0(JNIEnv *env, jclass cls, jint nArgs, jlong rType, jlong argTypes) { +JNIEXPORT jlong JNICALL Java_kotlinx_cinterop_JvmCallbacksKt_ffiCreateCif0(JNIEnv *env, jclass cls, jint nArgs, jlong rType, jlong argTypes) { ffi_cif* res = malloc(sizeof(ffi_cif)); if (res != NULL) { ffi_status status = ffi_prep_cif(res, FFI_DEFAULT_ABI, nArgs, (ffi_type*)rType, (ffi_type**)argTypes); @@ -166,7 +166,7 @@ static void ffi_fun(ffi_cif *cif, void *ret, void **args, void *user_data) { static jmethodID ffiFunImpl0 = NULL; static jclass cls = NULL; if (ffiFunImpl0 == NULL) { - jclass clsLocal = (*env)->FindClass(env, "kotlin_/cinterop/JvmCallbacksKt"); + jclass clsLocal = (*env)->FindClass(env, "kotlinx/cinterop/JvmCallbacksKt"); checkException(env); assert(clsLocal != NULL); @@ -184,11 +184,11 @@ static void ffi_fun(ffi_cif *cif, void *ret, void **args, void *user_data) { } /* - * Class: kotlin__cinterop_JvmCallbacksKt + * Class: kotlinx_cinterop_JvmCallbacksKt * Method: ffiCreateClosure0 * Signature: (JLjava/lang/Object;)J */ -JNIEXPORT jlong JNICALL Java_kotlin_1_cinterop_JvmCallbacksKt_ffiCreateClosure0(JNIEnv *env, jclass cls, jlong ffiCif, jobject userData) { +JNIEXPORT jlong JNICALL Java_kotlinx_cinterop_JvmCallbacksKt_ffiCreateClosure0(JNIEnv *env, jclass cls, jlong ffiCif, jobject userData) { jobject userDataGlobalRef = (*env)->NewGlobalRef(env, userData); if (userDataGlobalRef == NULL) { return (jlong)0; @@ -211,29 +211,29 @@ JNIEXPORT jlong JNICALL Java_kotlin_1_cinterop_JvmCallbacksKt_ffiCreateClosure0( } /* - * Class: kotlin__cinterop_JvmCallbacksKt + * Class: kotlinx_cinterop_JvmCallbacksKt * Method: newGlobalRef * Signature: (Ljava/lang/Object;)J */ -JNIEXPORT jlong JNICALL Java_kotlin_1_cinterop_JvmCallbacksKt_newGlobalRef(JNIEnv *env, jclass cls, jobject obj) { +JNIEXPORT jlong JNICALL Java_kotlinx_cinterop_JvmCallbacksKt_newGlobalRef(JNIEnv *env, jclass cls, jobject obj) { jobject res = (*env)->NewGlobalRef(env, obj); return (jlong) res; } /* - * Class: kotlin__cinterop_JvmCallbacksKt + * Class: kotlinx_cinterop_JvmCallbacksKt * Method: derefGlobalRef * Signature: (J)Ljava/lang/Object; */ -JNIEXPORT jobject JNICALL Java_kotlin_1_cinterop_JvmCallbacksKt_derefGlobalRef(JNIEnv *env, jclass cls, jlong ref) { +JNIEXPORT jobject JNICALL Java_kotlinx_cinterop_JvmCallbacksKt_derefGlobalRef(JNIEnv *env, jclass cls, jlong ref) { return (jobject) ref; } /* - * Class: kotlin__cinterop_JvmCallbacksKt + * Class: kotlinx_cinterop_JvmCallbacksKt * Method: deleteGlobalRef * Signature: (J)V */ -JNIEXPORT void JNICALL Java_kotlin_1_cinterop_JvmCallbacksKt_deleteGlobalRef(JNIEnv *env, jclass cls, jlong ref) { +JNIEXPORT void JNICALL Java_kotlinx_cinterop_JvmCallbacksKt_deleteGlobalRef(JNIEnv *env, jclass cls, jlong ref) { (*env)->DeleteGlobalRef(env, (jobject) ref); } diff --git a/Interop/Runtime/src/jvm/kotlin/kotlin_/cinterop/JvmCallbacks.kt b/Interop/Runtime/src/jvm/kotlin/kotlinx/cinterop/JvmCallbacks.kt similarity index 99% rename from Interop/Runtime/src/jvm/kotlin/kotlin_/cinterop/JvmCallbacks.kt rename to Interop/Runtime/src/jvm/kotlin/kotlinx/cinterop/JvmCallbacks.kt index 5827836e8e6..598fa97700b 100644 --- a/Interop/Runtime/src/jvm/kotlin/kotlin_/cinterop/JvmCallbacks.kt +++ b/Interop/Runtime/src/jvm/kotlin/kotlinx/cinterop/JvmCallbacks.kt @@ -1,4 +1,4 @@ -package kotlin_.cinterop +package kotlinx.cinterop /** * This class provides a way to create a stable handle to any Kotlin object. diff --git a/Interop/Runtime/src/jvm/kotlin/kotlin_/cinterop/JvmNativeMem.kt b/Interop/Runtime/src/jvm/kotlin/kotlinx/cinterop/JvmNativeMem.kt similarity index 98% rename from Interop/Runtime/src/jvm/kotlin/kotlin_/cinterop/JvmNativeMem.kt rename to Interop/Runtime/src/jvm/kotlin/kotlinx/cinterop/JvmNativeMem.kt index 048ded7c1cd..41ddc6e58e1 100644 --- a/Interop/Runtime/src/jvm/kotlin/kotlin_/cinterop/JvmNativeMem.kt +++ b/Interop/Runtime/src/jvm/kotlin/kotlinx/cinterop/JvmNativeMem.kt @@ -1,4 +1,4 @@ -package kotlin_.cinterop +package kotlinx.cinterop import sun.misc.Unsafe diff --git a/Interop/Runtime/src/jvm/kotlin/kotlin_/cinterop/JvmTypes.kt b/Interop/Runtime/src/jvm/kotlin/kotlinx/cinterop/JvmTypes.kt similarity index 97% rename from Interop/Runtime/src/jvm/kotlin/kotlin_/cinterop/JvmTypes.kt rename to Interop/Runtime/src/jvm/kotlin/kotlinx/cinterop/JvmTypes.kt index ecf369bc997..f4665fefe3f 100644 --- a/Interop/Runtime/src/jvm/kotlin/kotlin_/cinterop/JvmTypes.kt +++ b/Interop/Runtime/src/jvm/kotlin/kotlinx/cinterop/JvmTypes.kt @@ -1,4 +1,4 @@ -package kotlin_.cinterop +package kotlinx.cinterop import kotlin.reflect.companionObjectInstance import kotlin.reflect.primaryConstructor diff --git a/Interop/Runtime/src/main/kotlin/kotlin_/package-info.java b/Interop/Runtime/src/main/kotlin/kotlin_/package-info.java deleted file mode 100644 index 8729a26605b..00000000000 --- a/Interop/Runtime/src/main/kotlin/kotlin_/package-info.java +++ /dev/null @@ -1,4 +0,0 @@ -/** - * TODO: rename to kotlin - */ -package kotlin_; \ No newline at end of file diff --git a/Interop/Runtime/src/main/kotlin/kotlin_/cinterop/Types.kt b/Interop/Runtime/src/main/kotlin/kotlinx/cinterop/Types.kt similarity index 99% rename from Interop/Runtime/src/main/kotlin/kotlin_/cinterop/Types.kt rename to Interop/Runtime/src/main/kotlin/kotlinx/cinterop/Types.kt index 353bd7791f1..5bcba74cc31 100644 --- a/Interop/Runtime/src/main/kotlin/kotlin_/cinterop/Types.kt +++ b/Interop/Runtime/src/main/kotlin/kotlinx/cinterop/Types.kt @@ -1,4 +1,4 @@ -package kotlin_.cinterop +package kotlinx.cinterop /** * The entity which has an associated native pointer. diff --git a/Interop/Runtime/src/main/kotlin/kotlin_/cinterop/Utils.kt b/Interop/Runtime/src/main/kotlin/kotlinx/cinterop/Utils.kt similarity index 99% rename from Interop/Runtime/src/main/kotlin/kotlin_/cinterop/Utils.kt rename to Interop/Runtime/src/main/kotlin/kotlinx/cinterop/Utils.kt index 94063f1763e..a97d1fa3a70 100644 --- a/Interop/Runtime/src/main/kotlin/kotlin_/cinterop/Utils.kt +++ b/Interop/Runtime/src/main/kotlin/kotlinx/cinterop/Utils.kt @@ -1,4 +1,4 @@ -package kotlin_.cinterop +package kotlinx.cinterop interface NativePlacement { diff --git a/Interop/Runtime/src/main/kotlin/kotlinx/cinterop/package-info.java b/Interop/Runtime/src/main/kotlin/kotlinx/cinterop/package-info.java new file mode 100644 index 00000000000..a98e94a8be8 --- /dev/null +++ b/Interop/Runtime/src/main/kotlin/kotlinx/cinterop/package-info.java @@ -0,0 +1,6 @@ +/** + * This package contains API and runtime support for calling C code from Kotlin (aka Kotlin C interop). + * + * TODO: decide about package location. + */ +package kotlinx.cinterop; \ No newline at end of file diff --git a/Interop/StubGenerator/src/main/kotlin/org/jetbrains/kotlin/native/interop/gen/jvm/StubGenerator.kt b/Interop/StubGenerator/src/main/kotlin/org/jetbrains/kotlin/native/interop/gen/jvm/StubGenerator.kt index 97e981b405b..02b02fcddc9 100644 --- a/Interop/StubGenerator/src/main/kotlin/org/jetbrains/kotlin/native/interop/gen/jvm/StubGenerator.kt +++ b/Interop/StubGenerator/src/main/kotlin/org/jetbrains/kotlin/native/interop/gen/jvm/StubGenerator.kt @@ -750,7 +750,7 @@ class StubGenerator( out("package $pkgName") out("") } - out("import kotlin_.cinterop.*") + out("import kotlinx.cinterop.*") out("") functionsToBind.forEach { diff --git a/InteropExample/src/main/kotlin/main.kt b/InteropExample/src/main/kotlin/main.kt index a617122187a..a000c9359d7 100644 --- a/InteropExample/src/main/kotlin/main.kt +++ b/InteropExample/src/main/kotlin/main.kt @@ -1,4 +1,4 @@ -import kotlin_.cinterop.* +import kotlinx.cinterop.* import llvm.* fun main(args: Array) = memScoped { diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/CodeGenerator.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/CodeGenerator.kt index 7e77b66de05..b3b3a422b9e 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/CodeGenerator.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/CodeGenerator.kt @@ -1,7 +1,7 @@ package org.jetbrains.kotlin.backend.konan.llvm -import kotlin_.cinterop.* +import kotlinx.cinterop.* import llvm.* import org.jetbrains.kotlin.descriptors.ClassConstructorDescriptor import org.jetbrains.kotlin.descriptors.ClassDescriptor diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/ContextUtils.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/ContextUtils.kt index 1b870f6b58c..f3d9e9e696c 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/ContextUtils.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/ContextUtils.kt @@ -1,6 +1,6 @@ package org.jetbrains.kotlin.backend.konan.llvm -import kotlin_.cinterop.* +import kotlinx.cinterop.* import llvm.* import org.jetbrains.kotlin.backend.konan.hash.GlobalHash import org.jetbrains.kotlin.descriptors.ClassDescriptor diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/HashUtils.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/HashUtils.kt index c1b4f3e99df..59f47e1b49c 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/HashUtils.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/HashUtils.kt @@ -1,6 +1,6 @@ package org.jetbrains.kotlin.backend.konan.llvm -import kotlin_.cinterop.* +import kotlinx.cinterop.* import org.jetbrains.kotlin.backend.konan.hash.* internal fun localHash(data: ByteArray): Long { diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/IrToBitcode.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/IrToBitcode.kt index 964f1a6f291..7cd632490b8 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/IrToBitcode.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/IrToBitcode.kt @@ -1,6 +1,6 @@ package org.jetbrains.kotlin.backend.konan.llvm -import kotlin_.cinterop.* +import kotlinx.cinterop.* import llvm.* import org.jetbrains.kotlin.backend.konan.* import org.jetbrains.kotlin.builtins.KotlinBuiltIns diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/LlvmUtils.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/LlvmUtils.kt index d10721d3922..effa55a0629 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/LlvmUtils.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/LlvmUtils.kt @@ -1,6 +1,6 @@ package org.jetbrains.kotlin.backend.konan.llvm -import kotlin_.cinterop.* +import kotlinx.cinterop.* import llvm.* import org.jetbrains.kotlin.descriptors.ClassConstructorDescriptor import org.jetbrains.kotlin.descriptors.FunctionDescriptor diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/Logger.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/Logger.kt index 68d30c2bd31..f435a1f7248 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/Logger.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/Logger.kt @@ -1,6 +1,6 @@ package org.jetbrains.kotlin.backend.konan.llvm -import kotlin_.cinterop.* +import kotlinx.cinterop.* import llvm.* import org.jetbrains.kotlin.ir.IrElement import org.jetbrains.kotlin.ir.util.DumpIrTreeVisitor diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/MetadataGenerator.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/MetadataGenerator.kt index e4921051b5a..4a6361b3957 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/MetadataGenerator.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/MetadataGenerator.kt @@ -1,7 +1,7 @@ package org.jetbrains.kotlin.backend.konan.llvm -import kotlin_.cinterop.* +import kotlinx.cinterop.* import llvm.* import org.jetbrains.kotlin.ir.declarations.IrFunction import org.jetbrains.kotlin.ir.declarations.IrModuleFragment diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/RTTIGenerator.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/RTTIGenerator.kt index 37d3898e950..6687ebc45ce 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/RTTIGenerator.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/RTTIGenerator.kt @@ -1,7 +1,7 @@ package org.jetbrains.kotlin.backend.konan.llvm -import kotlin_.cinterop.* +import kotlinx.cinterop.* import llvm.* import org.jetbrains.kotlin.backend.konan.implementation import org.jetbrains.kotlin.backend.konan.implementedInterfaces diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/Runtime.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/Runtime.kt index e1bca6c09a5..76a351126eb 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/Runtime.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/Runtime.kt @@ -1,6 +1,6 @@ package org.jetbrains.kotlin.backend.konan.llvm -import kotlin_.cinterop.* +import kotlinx.cinterop.* import llvm.* class Runtime(private val bitcodeFile: String) { diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/hacks.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/hacks.kt index 61ae7f895cc..d06c0355cdd 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/hacks.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/hacks.kt @@ -1,7 +1,7 @@ package org.jetbrains.kotlin.backend.konan.llvm -import kotlin_.cinterop.CPointer -import kotlin_.cinterop.CPointerVarWithValueMappedTo +import kotlinx.cinterop.CPointer +import kotlinx.cinterop.CPointerVarWithValueMappedTo // TODO: the definitions below are required to perform smooth migration to new interop; // remove after replacing with LLVM*Ref typedefs