├── adder
    ├── zig
    │   ├── add.zig
    │   └── make.sh
    ├── rust
    │   ├── add.rs
    │   └── make.sh
    ├── swift
    │   ├── add.swift
    │   └── make.sh
    ├── c
    │   ├── add.c
    │   └── make.sh
    ├── src
    │   ├── commonMain
    │   │   └── kotlin
    │   │   │   └── com
    │   │   │       └── example
    │   │   │           └── adder
    │   │   │               └── Math.kt
    │   ├── jvmMain
    │   │   ├── kotlin
    │   │   │   └── com
    │   │   │   │   └── example
    │   │   │   │       └── adder
    │   │   │   │           └── Math.kt
    │   │   ├── c
    │   │   │   └── com_example_adder_Jni.c
    │   │   ├── java
    │   │   │   └── com
    │   │   │   │   └── example
    │   │   │   │       └── adder
    │   │   │   │           ├── Jni.java
    │   │   │   │           └── NativeLibrary.java
    │   │   └── include
    │   │   │   ├── windows
    │   │   │       └── jni_md.h
    │   │   │   ├── unix
    │   │   │       └── jni_md.h
    │   │   │   ├── LICENSE
    │   │   │   └── share
    │   │   │       └── jni.h
    │   ├── nativeMain
    │   │   └── kotlin
    │   │   │   └── com
    │   │   │       └── example
    │   │   │           └── adder
    │   │   │               └── Math.kt
    │   ├── jvmJdk22
    │   │   └── kotlin
    │   │   │   └── com
    │   │   │       └── example
    │   │   │           └── adder
    │   │   │               └── Math.kt
    │   └── commonTest
    │   │   └── kotlin
    │   │       └── com
    │   │           └── example
    │   │               └── adder
    │   │                   └── AdderTest.kt
    ├── cpp
    │   ├── add.cpp
    │   └── make.sh
    ├── include
    │   └── add.h
    ├── gradle.properties
    ├── make-jni.sh
    └── build.gradle
├── gradle
    ├── wrapper
    │   ├── gradle-wrapper.jar
    │   └── gradle-wrapper.properties
    └── libs.versions.toml
├── app-gui
    ├── src
    │   ├── androidMain
    │   │   ├── res
    │   │   │   ├── values-night
    │   │   │   │   └── themes.xml
    │   │   │   └── values
    │   │   │   │   └── themes.xml
    │   │   ├── kotlin
    │   │   │   └── com
    │   │   │   │   └── example
    │   │   │   │       └── gui
    │   │   │   │           └── MainActivity.kt
    │   │   └── AndroidManifest.xml
    │   ├── jvmMain
    │   │   └── kotlin
    │   │   │   └── com
    │   │   │       └── example
    │   │   │           └── gui
    │   │   │               └── Main.kt
    │   ├── commonTest
    │   │   └── kotlin
    │   │   │   └── com
    │   │   │       └── example
    │   │   │           └── gui
    │   │   │               └── GuiTest.kt
    │   └── commonMain
    │   │   └── kotlin
    │   │       └── com
    │   │           └── example
    │   │               └── gui
    │   │                   └── Adder.kt
    └── build.gradle
├── .gitignore
├── settings.gradle
├── .editorconfig
├── app-cli
    ├── src
    │   └── commonMain
    │   │   └── kotlin
    │   │       └── com
    │   │           └── example
    │   │               └── cli
    │   │                   └── Main.kt
    └── build.gradle
├── gradle.properties
├── README.md
├── gradlew.bat
├── gradlew
└── LICENSE.txt


/adder/zig/add.zig:
--------------------------------------------------------------------------------
1 | export fn kmp_add(a: i32, b: i32) i32 {
2 | 	return a + b;
3 | }
4 | 


--------------------------------------------------------------------------------
/adder/rust/add.rs:
--------------------------------------------------------------------------------
1 | #[no_mangle]
2 | pub extern "C" fn kmp_add(a: i32, b: i32) -> i32 {
3 | 	a + b
4 | }
5 | 


--------------------------------------------------------------------------------
/adder/swift/add.swift:
--------------------------------------------------------------------------------
1 | @_cdecl("kmp_add")
2 | public func add(a: Int32, b: Int32) -> Int32 {
3 | 	return a + b
4 | }
5 | 


--------------------------------------------------------------------------------
/adder/c/add.c:
--------------------------------------------------------------------------------
1 | #include <stdint.h>
2 | #include "add.h"
3 | 
4 | int32_t kmp_add(int32_t a, int32_t b) {
5 | 	return a + b;
6 | }
7 | 


--------------------------------------------------------------------------------
/adder/src/commonMain/kotlin/com/example/adder/Math.kt:
--------------------------------------------------------------------------------
1 | package com.example.adder
2 | 
3 | public expect fun add(a: Int, b: Int): Int
4 | 


--------------------------------------------------------------------------------
/gradle/wrapper/gradle-wrapper.jar:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/JakeWharton/kmp-other-languages-sample/HEAD/gradle/wrapper/gradle-wrapper.jar


--------------------------------------------------------------------------------
/adder/src/jvmMain/kotlin/com/example/adder/Math.kt:
--------------------------------------------------------------------------------
1 | package com.example.adder
2 | 
3 | public actual fun add(a: Int, b: Int): Int {
4 | 	return Jni.add(a, b)
5 | }
6 | 


--------------------------------------------------------------------------------
/adder/src/nativeMain/kotlin/com/example/adder/Math.kt:
--------------------------------------------------------------------------------
1 | package com.example.adder
2 | 
3 | public actual fun add(a: Int, b: Int): Int {
4 | 	return kmp_add(a, b)
5 | }
6 | 


--------------------------------------------------------------------------------
/adder/cpp/add.cpp:
--------------------------------------------------------------------------------
 1 | #include <stdint.h>
 2 | #include "add.h"
 3 | 
 4 | extern "C" {
 5 | 
 6 | int32_t kmp_add(int32_t a, int32_t b) {
 7 | 	return a + b;
 8 | }
 9 | 
10 | }
11 | 


--------------------------------------------------------------------------------
/app-gui/src/androidMain/res/values-night/themes.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <resources>
3 | 	<style name="BaseTheme.Adder" parent="android:Theme.Material.NoActionBar" />
4 | </resources>
5 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # IntelliJ
 2 | .idea
 3 | 
 4 | # Gradle
 5 | .gradle
 6 | build
 7 | 
 8 | # Kotlin
 9 | .kotlin
10 | 
11 | # Android
12 | local.properties
13 | 
14 | # Native binaries
15 | *.a
16 | *.dylib
17 | *.o
18 | *.so
19 | 


--------------------------------------------------------------------------------
/app-gui/src/androidMain/res/values/themes.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <resources>
3 | 	<style name="BaseTheme.Adder" parent="android:Theme.Material.Light.NoActionBar" />
4 | 	<style name="Theme.Adder" parent="BaseTheme.Adder" />
5 | </resources>
6 | 


--------------------------------------------------------------------------------
/adder/include/add.h:
--------------------------------------------------------------------------------
 1 | #ifndef KMP_ADD_H
 2 | #define KMP_ADD_H
 3 | 
 4 | #include <stdint.h>
 5 | 
 6 | #ifdef __cplusplus
 7 | extern "C" {
 8 | #endif
 9 | 
10 | int32_t kmp_add(int32_t a, int32_t b);
11 | 
12 | #ifdef __cplusplus
13 | } // extern "C"
14 | #endif
15 | 
16 | #endif // KMP_ADD_H
17 | 


--------------------------------------------------------------------------------
/adder/src/jvmMain/c/com_example_adder_Jni.c:
--------------------------------------------------------------------------------
1 | #include "com_example_adder_Jni.h"
2 | 
3 | #include "../../../include/add.h"
4 | #include "../include/share/jni.h"
5 | 
6 | JNIEXPORT jint JNICALL Java_com_example_adder_Jni_add(JNIEnv *env, jclass clazz, jint a, jint b) {
7 | 	return kmp_add(a, b);
8 | }
9 | 


--------------------------------------------------------------------------------
/adder/src/jvmJdk22/kotlin/com/example/adder/Math.kt:
--------------------------------------------------------------------------------
 1 | package com.example.adder
 2 | 
 3 | private val nativeLibraryLoader by lazy {
 4 | 	NativeLibrary.loadEmbeddedNativeLibrary("add")
 5 | }
 6 | 
 7 | public fun add(a: Int, b: Int): Int {
 8 | 	nativeLibraryLoader
 9 | 
10 | 	return Libadd.kmp_add(a, b)
11 | }
12 | 


--------------------------------------------------------------------------------
/settings.gradle:
--------------------------------------------------------------------------------
 1 | rootProject.name = 'kmp-other-languages-sample'
 2 | 
 3 | include ':adder'
 4 | include ':app-gui'
 5 | include ':app-cli'
 6 | 
 7 | enableFeaturePreview('TYPESAFE_PROJECT_ACCESSORS')
 8 | 
 9 | dependencyResolutionManagement {
10 | 	repositories {
11 | 		mavenCentral()
12 | 		google()
13 | 	}
14 | }
15 | 


--------------------------------------------------------------------------------
/adder/src/jvmMain/java/com/example/adder/Jni.java:
--------------------------------------------------------------------------------
 1 | package com.example.adder;
 2 | 
 3 | final class Jni {
 4 | 	static {
 5 | 		NativeLibrary.loadEmbeddedNativeLibrary("add");
 6 | 		NativeLibrary.loadEmbeddedNativeLibrary("add-jni");
 7 | 	}
 8 | 
 9 | 	static native int add(int a, int b);
10 | 
11 | 	private Jni() {}
12 | }
13 | 


--------------------------------------------------------------------------------
/.editorconfig:
--------------------------------------------------------------------------------
 1 | root = true
 2 | 
 3 | [*]
 4 | indent_style = tab
 5 | indent_size = 2
 6 | end_of_line = lf
 7 | charset = utf-8
 8 | trim_trailing_whitespace = true
 9 | insert_final_newline = true
10 | 
11 | [*.yaml]
12 | indent_style = space
13 | 
14 | [*.md]
15 | indent_style = space
16 | 
17 | [*.{kt,kts}]
18 | ij_kotlin_imports_layout=*
19 | 


--------------------------------------------------------------------------------
/adder/src/commonTest/kotlin/com/example/adder/AdderTest.kt:
--------------------------------------------------------------------------------
 1 | package com.example.adder
 2 | 
 3 | import kotlin.test.Test
 4 | import kotlin.test.assertEquals
 5 | 
 6 | class AddTest {
 7 | 	@Test fun simple() {
 8 | 		assertEquals(3, add(1, 2))
 9 | 		assertEquals(-1, add(1, -2))
10 | 		assertEquals(1, add(-1, 2))
11 | 		assertEquals(-3, add(-1, -2))
12 | 	}
13 | }
14 | 


--------------------------------------------------------------------------------
/gradle/wrapper/gradle-wrapper.properties:
--------------------------------------------------------------------------------
1 | distributionBase=GRADLE_USER_HOME
2 | distributionPath=wrapper/dists
3 | distributionSha256Sum=7197a12f450794931532469d4ff21a59ea2c1cd59a3ec3f89c035c3c420a6999
4 | distributionUrl=https\://services.gradle.org/distributions/gradle-8.14.2-bin.zip
5 | networkTimeout=10000
6 | validateDistributionUrl=true
7 | zipStoreBase=GRADLE_USER_HOME
8 | zipStorePath=wrapper/dists
9 | 


--------------------------------------------------------------------------------
/app-gui/src/androidMain/kotlin/com/example/gui/MainActivity.kt:
--------------------------------------------------------------------------------
 1 | package com.example.gui
 2 | 
 3 | import android.os.Bundle
 4 | import androidx.activity.ComponentActivity
 5 | import androidx.activity.compose.setContent
 6 | 
 7 | class MainActivity : ComponentActivity() {
 8 | 	override fun onCreate(savedInstanceState: Bundle?) {
 9 | 		super.onCreate(savedInstanceState)
10 | 		setContent { Adder() }
11 | 	}
12 | }
13 | 


--------------------------------------------------------------------------------
/adder/gradle.properties:
--------------------------------------------------------------------------------
1 | # By default, creating an additional Kotlin compilation and calling associateWith(mainCompilation)
2 | # will produce a dependency on the jar task. We want to copy the output of the new compilation
3 | # into the jar, though, so we need to disable this behavior to avoid a cyclic task dependency.
4 | # See https://youtrack.jetbrains.com/issue/KT-78269
5 | kotlin.build.archivesTaskOutputAsFriendModule=false
6 | 


--------------------------------------------------------------------------------
/app-cli/src/commonMain/kotlin/com/example/cli/Main.kt:
--------------------------------------------------------------------------------
 1 | @file:JvmName("Main")
 2 | 
 3 | package com.example.cli
 4 | 
 5 | import com.example.adder.add
 6 | import kotlin.jvm.JvmName
 7 | 
 8 | fun main() {
 9 | 	print("Enter first integer: ")
10 | 	val a = readln().toInt()
11 | 
12 | 	print("Enter second integer: ")
13 | 	val b = readln().toInt()
14 | 
15 | 	val sum = add(a, b)
16 | 	println()
17 | 	println("$a + $b = $sum")
18 | }
19 | 


--------------------------------------------------------------------------------
/gradle.properties:
--------------------------------------------------------------------------------
 1 | org.gradle.caching=true
 2 | org.gradle.jvmargs=-Xmx4096m
 3 | org.gradle.parallel=true
 4 | 
 5 | android.useAndroidX=true
 6 | android.enableJetifier=false
 7 | android.defaults.buildfeatures.resvalues=false
 8 | android.defaults.buildfeatures.shaders=false
 9 | android.library.defaults.buildfeatures.androidresources=false
10 | 
11 | kotlin.mpp.enableCInteropCommonization=true
12 | kotlin.native.cacheKind=none
13 | 


--------------------------------------------------------------------------------
/adder/zig/make.sh:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | 
 3 | set -ex
 4 | 
 5 | cd -- "$(dirname -- "${BASH_SOURCE[0]}")" &> /dev/null
 6 | 
 7 | zig build-lib add.zig
 8 | zig build-lib add.zig -dynamic
 9 | 
10 | mkdir -p ../src/nativeMain/binaries/aarch64
11 | mkdir -p ../src/jvmMain/resources/com/example/adder/aarch64
12 | 
13 | cp libadd.a ../src/nativeMain/binaries/aarch64
14 | cp libadd.dylib ../src/jvmMain/resources/com/example/adder/aarch64
15 | 


--------------------------------------------------------------------------------
/adder/rust/make.sh:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | 
 3 | set -ex
 4 | 
 5 | cd -- "$(dirname -- "${BASH_SOURCE[0]}")" &> /dev/null
 6 | 
 7 | rustc --crate-type dylib add.rs
 8 | rustc --crate-type staticlib add.rs
 9 | 
10 | mkdir -p ../src/nativeMain/binaries/aarch64
11 | mkdir -p ../src/jvmMain/resources/com/example/adder/aarch64
12 | 
13 | cp libadd.a ../src/nativeMain/binaries/aarch64
14 | cp libadd.dylib ../src/jvmMain/resources/com/example/adder/aarch64
15 | 


--------------------------------------------------------------------------------
/adder/swift/make.sh:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | 
 3 | set -ex
 4 | 
 5 | cd -- "$(dirname -- "${BASH_SOURCE[0]}")" &> /dev/null
 6 | 
 7 | swiftc -emit-library add.swift
 8 | swiftc -emit-library -static add.swift
 9 | 
10 | mkdir -p ../src/nativeMain/binaries/aarch64
11 | mkdir -p ../src/jvmMain/resources/com/example/adder/aarch64
12 | 
13 | cp libadd.a ../src/nativeMain/binaries/aarch64
14 | cp libadd.dylib ../src/jvmMain/resources/com/example/adder/aarch64
15 | 


--------------------------------------------------------------------------------
/adder/c/make.sh:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | 
 3 | set -ex
 4 | 
 5 | cd -- "$(dirname -- "${BASH_SOURCE[0]}")" &> /dev/null
 6 | 
 7 | gcc -dynamiclib -I ../include add.c -o libadd.dylib
 8 | gcc -c -I ../include add.c -o libadd.o
 9 | ar rvs libadd.a libadd.o
10 | 
11 | mkdir -p ../src/nativeMain/binaries/aarch64
12 | mkdir -p ../src/jvmMain/resources/com/example/adder/aarch64
13 | 
14 | cp libadd.a ../src/nativeMain/binaries/aarch64
15 | cp libadd.dylib ../src/jvmMain/resources/com/example/adder/aarch64
16 | 


--------------------------------------------------------------------------------
/adder/cpp/make.sh:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | 
 3 | set -ex
 4 | 
 5 | cd -- "$(dirname -- "${BASH_SOURCE[0]}")" &> /dev/null
 6 | 
 7 | g++ -dynamiclib -I ../include add.cpp -o libadd.dylib
 8 | g++ -c -I ../include add.cpp -o libadd.o
 9 | ar rvs libadd.a libadd.o
10 | 
11 | mkdir -p ../src/nativeMain/binaries/aarch64
12 | mkdir -p ../src/jvmMain/resources/com/example/adder/aarch64
13 | 
14 | cp libadd.a ../src/nativeMain/binaries/aarch64
15 | cp libadd.dylib ../src/jvmMain/resources/com/example/adder/aarch64
16 | 


--------------------------------------------------------------------------------
/app-gui/src/jvmMain/kotlin/com/example/gui/Main.kt:
--------------------------------------------------------------------------------
 1 | @file:JvmName("Main")
 2 | 
 3 | package com.example.gui
 4 | 
 5 | import androidx.compose.ui.unit.dp
 6 | import androidx.compose.ui.window.Window
 7 | import androidx.compose.ui.window.application
 8 | import androidx.compose.ui.window.rememberWindowState
 9 | 
10 | fun main() = application {
11 | 	Window(
12 | 		onCloseRequest = ::exitApplication,
13 | 		title = "Adder",
14 | 		state = rememberWindowState(width = 300.dp, height = 300.dp),
15 | 	) {
16 | 		Adder()
17 | 	}
18 | }
19 | 


--------------------------------------------------------------------------------
/adder/make-jni.sh:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | 
 3 | set -e
 4 | 
 5 | cd -- "$(dirname -- "${BASH_SOURCE[0]}")" &> /dev/null
 6 | 
 7 | ../gradlew -q :adder:compileJvmMainJava
 8 | 
 9 | zig build-lib \
10 |   -dynamic \
11 |   --name add-jni \
12 |   -I include \
13 |   -I src/jvmMain/include/share \
14 |   -I src/jvmMain/include/unix \
15 |   -I build/generated/sources/headers/java/jvmMain \
16 |   src/jvmMain/resources/com/example/adder/aarch64/libadd.dylib \
17 |   src/jvmMain/c/com_example_adder_Jni.c
18 | 
19 | mv libadd-jni.dylib src/jvmMain/resources/com/example/adder/aarch64
20 | 


--------------------------------------------------------------------------------
/app-cli/build.gradle:
--------------------------------------------------------------------------------
 1 | import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTarget
 2 | 
 3 | apply plugin: 'org.jetbrains.kotlin.multiplatform'
 4 | 
 5 | kotlin {
 6 | 	jvm {
 7 | 		binaries {
 8 | 			executable {
 9 | 				mainClass = 'com.example.cli.Main'
10 | 			}
11 | 		}
12 | 	}
13 | 
14 | 	macosArm64()
15 | 
16 | 	sourceSets {
17 | 		commonMain {
18 | 			dependencies {
19 | 				implementation projects.adder
20 | 			}
21 | 		}
22 | 	}
23 | 
24 | 	targets.withType(KotlinNativeTarget).configureEach {
25 | 		binaries {
26 | 			executable {
27 | 				entryPoint = 'com.example.cli.main'
28 | 			}
29 | 		}
30 | 	}
31 | }
32 | 


--------------------------------------------------------------------------------
/app-gui/src/androidMain/AndroidManifest.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <manifest xmlns:android="http://schemas.android.com/apk/res/android">
 3 | 	<application
 4 | 		android:label="Adder"
 5 | 		android:theme="@style/Theme.Adder">
 6 | 		<activity
 7 | 			android:name=".MainActivity"
 8 | 			android:exported="true"
 9 | 		>
10 | 			<intent-filter>
11 | 				<action android:name="android.intent.action.MAIN"/>
12 | 				<category android:name="android.intent.category.LAUNCHER"/>
13 | 				<category android:name="android.intent.category.DEFAULT"/>
14 | 			</intent-filter>
15 | 		</activity>
16 | 	</application>
17 | </manifest>
18 | 


--------------------------------------------------------------------------------
/app-gui/src/commonTest/kotlin/com/example/gui/GuiTest.kt:
--------------------------------------------------------------------------------
 1 | package com.example.gui
 2 | 
 3 | import androidx.compose.ui.test.assert
 4 | import androidx.compose.ui.test.hasText
 5 | import androidx.compose.ui.test.onNodeWithText
 6 | import androidx.compose.ui.test.performTextInput
 7 | import androidx.compose.ui.test.runComposeUiTest
 8 | import kotlin.test.Test
 9 | 
10 | class GuiTest {
11 | 	@Test fun add() = runComposeUiTest {
12 | 		setContent { Adder() }
13 | 
14 | 		onNodeWithText("First integer")
15 | 			.performTextInput("34")
16 | 		onNodeWithText("Second integer")
17 | 			.performTextInput("45")
18 | 
19 | 		onNodeWithText("34 + 45", substring = true)
20 | 			.assert(hasText("= 79", substring = true))
21 | 	}
22 | }
23 | 


--------------------------------------------------------------------------------
/app-gui/src/commonMain/kotlin/com/example/gui/Adder.kt:
--------------------------------------------------------------------------------
 1 | package com.example.gui
 2 | 
 3 | import androidx.compose.foundation.layout.Arrangement
 4 | import androidx.compose.foundation.layout.Column
 5 | import androidx.compose.foundation.layout.fillMaxWidth
 6 | import androidx.compose.foundation.layout.padding
 7 | import androidx.compose.foundation.text.input.rememberTextFieldState
 8 | import androidx.compose.material3.Text
 9 | import androidx.compose.material3.TextField
10 | import androidx.compose.runtime.Composable
11 | import androidx.compose.ui.Modifier
12 | import androidx.compose.ui.unit.dp
13 | import androidx.compose.ui.unit.sp
14 | import com.example.adder.add
15 | 
16 | @Composable
17 | fun Adder() {
18 | 	Column(
19 | 		modifier = Modifier.padding(16.dp),
20 | 		verticalArrangement = Arrangement.spacedBy(8.dp),
21 | 	) {
22 | 		val aState = rememberTextFieldState("")
23 | 		TextField(
24 | 			state = aState,
25 | 			label = { Text("First integer") },
26 | 			modifier = Modifier.fillMaxWidth(),
27 | 		)
28 | 
29 | 		val bState = rememberTextFieldState("")
30 | 		TextField(
31 | 			state = bState,
32 | 			label = { Text("Second integer") },
33 | 			modifier = Modifier.fillMaxWidth(),
34 | 		)
35 | 
36 | 		val a = aState.text.toString().toIntOrNull()
37 | 		val b = bState.text.toString().toIntOrNull()
38 | 		if (a != null && b != null) {
39 | 			val sum = add(a, b)
40 | 			Text(
41 | 				text = "$a + $b = $sum",
42 | 				modifier = Modifier.padding(top = 8.dp),
43 | 				fontSize = 30.sp,
44 | 			)
45 | 		}
46 | 	}
47 | }
48 | 


--------------------------------------------------------------------------------
/app-gui/build.gradle:
--------------------------------------------------------------------------------
 1 | import org.jetbrains.kotlin.gradle.plugin.KotlinSourceSetTree
 2 | 
 3 | apply plugin: 'org.jetbrains.kotlin.multiplatform'
 4 | apply plugin: 'org.jetbrains.kotlin.plugin.compose'
 5 | apply plugin: 'org.jetbrains.compose'
 6 | apply plugin: 'com.android.application'
 7 | 
 8 | kotlin {
 9 | 	androidTarget {
10 | 		instrumentedTestVariant.sourceSetTree.set(KotlinSourceSetTree.test)
11 | 	}
12 | 
13 | 	jvm {
14 | 		binaries {
15 | 			executable {
16 | 				mainClass = 'com.example.gui.Main'
17 | 			}
18 | 		}
19 | 	}
20 | 
21 | 	sourceSets {
22 | 		commonMain {
23 | 			dependencies {
24 | 				implementation projects.adder
25 | 				implementation compose.material3
26 | 			}
27 | 		}
28 | 		commonTest {
29 | 			dependencies {
30 | 				implementation libs.kotlin.test
31 | 				implementation compose.uiTest
32 | 			}
33 | 		}
34 | 		androidMain {
35 | 			dependencies {
36 | 				implementation libs.androidx.activity.compose
37 | 			}
38 | 		}
39 | 		jvmMain {
40 | 			dependencies {
41 | 				implementation compose.desktop.currentOs
42 | 			}
43 | 		}
44 | 
45 | 		configureEach {
46 | 			languageSettings {
47 | 				optIn('androidx.compose.ui.test.ExperimentalTestApi')
48 | 			}
49 | 		}
50 | 	}
51 | }
52 | 
53 | android {
54 | 	namespace = 'com.example.gui'
55 | 	compileSdk = 36
56 | 
57 | 	defaultConfig {
58 | 		minSdk = 26
59 | 		testInstrumentationRunner = 'androidx.test.runner.AndroidJUnitRunner'
60 | 	}
61 | }
62 | 
63 | dependencies {
64 | 	androidTestImplementation(libs.androidx.compose.ui.test.junit4)
65 | 	debugImplementation(libs.androidx.compose.ui.test.manifest)
66 | }
67 | 


--------------------------------------------------------------------------------
/gradle/libs.versions.toml:
--------------------------------------------------------------------------------
 1 | [versions]
 2 | kotlin = "2.1.21"
 3 | androidx-compose-ui-test = "1.8.3"
 4 | 
 5 | [libraries]
 6 | android-plugin = 'com.android.tools.build:gradle:8.10.1'
 7 | 
 8 | androidx-activity-compose = "androidx.activity:activity-compose:1.10.1"
 9 | androidx-compose-ui-test-junit4 = { module = "androidx.compose.ui:ui-test-junit4-android", version.ref = "androidx-compose-ui-test" }
10 | androidx-compose-ui-test-manifest = { module = "androidx.compose.ui:ui-test-manifest", version.ref = "androidx-compose-ui-test" }
11 | 
12 | kotlin-plugin = { module = "org.jetbrains.kotlin:kotlin-gradle-plugin", version.ref = "kotlin" }
13 | kotlin-plugin-compose = { module = "org.jetbrains.kotlin:compose-compiler-gradle-plugin", version.ref = "kotlin" }
14 | kotlin-test = { module = "org.jetbrains.kotlin:kotlin-test", version.ref = "kotlin" }
15 | kotlin-test-junit = { module = "org.jetbrains.kotlin:kotlin-test-junit", version.ref = "kotlin" }
16 | 
17 | jetbrains-compose-gradlePlugin = "org.jetbrains.compose:compose-gradle-plugin:1.9.0-alpha02"
18 | 
19 | binary-compatibility-validator-gradlePlugin = "org.jetbrains.kotlinx:binary-compatibility-validator:0.17.0"
20 | cklib-gradlePlugin = "co.touchlab:cklib-gradle-plugin:0.3.4"
21 | jextract-gradlePlugin = "de.infolektuell:gradle-plugin-jextract:0.5.0"
22 | 
23 | spotless-gradlePlugin = "com.diffplug.spotless:spotless-plugin-gradle:7.0.4"
24 | ktlint-core = "com.pinterest.ktlint:ktlint-cli:1.6.0"
25 | ktlint-composeRules = "io.nlopez.compose.rules:ktlint:0.4.22"
26 | 
27 | junit4 = "junit:junit:4.13.2"
28 | assertk = "com.willowtreeapps.assertk:assertk:0.28.1"
29 | 


--------------------------------------------------------------------------------
/adder/src/jvmMain/include/windows/jni_md.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 1996, 2023, Oracle and/or its affiliates. All rights reserved.
 3 |  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 4 |  *
 5 |  * This code is free software; you can redistribute it and/or modify it
 6 |  * under the terms of the GNU General Public License version 2 only, as
 7 |  * published by the Free Software Foundation.  Oracle designates this
 8 |  * particular file as subject to the "Classpath" exception as provided
 9 |  * by Oracle in the LICENSE file that accompanied this code.
10 |  *
11 |  * This code is distributed in the hope that it will be useful, but WITHOUT
12 |  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 |  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14 |  * version 2 for more details (a copy is included in the LICENSE file that
15 |  * accompanied this code).
16 |  *
17 |  * You should have received a copy of the GNU General Public License version
18 |  * 2 along with this work; if not, write to the Free Software Foundation,
19 |  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 |  *
21 |  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 |  * or visit www.oracle.com if you need additional information or have any
23 |  * questions.
24 |  */
25 | 
26 | #ifndef _JAVASOFT_JNI_MD_H_
27 | #define _JAVASOFT_JNI_MD_H_
28 | 
29 | #ifndef JNIEXPORT
30 |   #define JNIEXPORT __declspec(dllexport)
31 | #endif
32 | #define JNIIMPORT __declspec(dllimport)
33 | #define JNICALL __stdcall
34 | 
35 | typedef int jint;
36 | typedef long long jlong;
37 | typedef signed char jbyte;
38 | 
39 | #endif /* !_JAVASOFT_JNI_MD_H_ */
40 | 


--------------------------------------------------------------------------------
/adder/src/jvmMain/java/com/example/adder/NativeLibrary.java:
--------------------------------------------------------------------------------
 1 | package com.example.adder;
 2 | 
 3 | import static java.nio.file.StandardCopyOption.REPLACE_EXISTING;
 4 | import static java.util.Locale.US;
 5 | 
 6 | import java.io.IOException;
 7 | import java.io.InputStream;
 8 | import java.io.UncheckedIOException;
 9 | import java.net.URL;
10 | import java.nio.file.Files;
11 | import java.nio.file.Path;
12 | 
13 | final class NativeLibrary {
14 | 	@SuppressWarnings("SameParameterValue") // Preserving copy/paste!
15 | 	static void loadEmbeddedNativeLibrary(String library) {
16 | 		String osName = System.getProperty("os.name").toLowerCase(US);
17 | 		String osArch = System.getProperty("os.arch").toLowerCase(US);
18 | 		StringBuilder nativeLibraryJarPathBuilder = new StringBuilder(50)
19 | 			.append(osArch)
20 | 			.append('/');
21 | 		if (osName.contains("linux")) {
22 | 			nativeLibraryJarPathBuilder.append("lib")
23 | 				.append(library)
24 | 				.append(".so");
25 | 		} else if (osName.contains("mac")) {
26 | 			nativeLibraryJarPathBuilder.append("lib")
27 | 				.append(library)
28 | 				.append(".dylib");
29 | 		} else if (osName.contains("windows")) {
30 | 			nativeLibraryJarPathBuilder.append(library)
31 | 				.append(".dll");
32 | 		} else {
33 | 			throw new IllegalStateException("Unsupported OS: " + osName + ' ' + osArch);
34 | 		}
35 | 		String nativeLibraryJarPath = nativeLibraryJarPathBuilder.toString();
36 | 		URL nativeLibraryUrl = NativeLibrary.class.getResource(nativeLibraryJarPath);
37 | 		if (nativeLibraryUrl == null) {
38 | 			throw new IllegalStateException("Unable to read ".concat(nativeLibraryJarPath));
39 | 		}
40 | 
41 | 		Path nativeLibraryFile;
42 | 		try {
43 | 			nativeLibraryFile = Files.createTempFile(library, null);
44 | 
45 | 			// File-based deleteOnExit() uses a special internal shutdown hook that always runs last.
46 | 			nativeLibraryFile.toFile().deleteOnExit();
47 | 			try (InputStream nativeLibrary = nativeLibraryUrl.openStream()) {
48 | 				Files.copy(nativeLibrary, nativeLibraryFile, REPLACE_EXISTING);
49 | 			}
50 | 		} catch (IOException e) {
51 | 			throw new UncheckedIOException("Unable to extract native library from JAR", e);
52 | 		}
53 | 		System.load(nativeLibraryFile.toAbsolutePath().toString());
54 | 	}
55 | 
56 | 	private NativeLibrary() {}
57 | }
58 | 


--------------------------------------------------------------------------------
/adder/src/jvmMain/include/unix/jni_md.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 1996, 2020, Oracle and/or its affiliates. All rights reserved.
 3 |  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 4 |  *
 5 |  * This code is free software; you can redistribute it and/or modify it
 6 |  * under the terms of the GNU General Public License version 2 only, as
 7 |  * published by the Free Software Foundation.  Oracle designates this
 8 |  * particular file as subject to the "Classpath" exception as provided
 9 |  * by Oracle in the LICENSE file that accompanied this code.
10 |  *
11 |  * This code is distributed in the hope that it will be useful, but WITHOUT
12 |  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 |  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14 |  * version 2 for more details (a copy is included in the LICENSE file that
15 |  * accompanied this code).
16 |  *
17 |  * You should have received a copy of the GNU General Public License version
18 |  * 2 along with this work; if not, write to the Free Software Foundation,
19 |  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 |  *
21 |  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 |  * or visit www.oracle.com if you need additional information or have any
23 |  * questions.
24 |  */
25 | 
26 | #ifndef _JAVASOFT_JNI_MD_H_
27 | #define _JAVASOFT_JNI_MD_H_
28 | 
29 | #ifndef __has_attribute
30 |   #define __has_attribute(x) 0
31 | #endif
32 | 
33 | #ifndef JNIEXPORT
34 |   #if (defined(__GNUC__) && ((__GNUC__ > 4) || (__GNUC__ == 4) && (__GNUC_MINOR__ > 2))) || __has_attribute(visibility)
35 |     #ifdef ARM
36 |       #define JNIEXPORT     __attribute__((externally_visible,visibility("default")))
37 |     #else
38 |       #define JNIEXPORT     __attribute__((visibility("default")))
39 |     #endif
40 |   #else
41 |     #define JNIEXPORT
42 |   #endif
43 | #endif
44 | 
45 | #if (defined(__GNUC__) && ((__GNUC__ > 4) || (__GNUC__ == 4) && (__GNUC_MINOR__ > 2))) || __has_attribute(visibility)
46 |   #ifdef ARM
47 |     #define JNIIMPORT     __attribute__((externally_visible,visibility("default")))
48 |   #else
49 |     #define JNIIMPORT     __attribute__((visibility("default")))
50 |   #endif
51 | #else
52 |   #define JNIIMPORT
53 | #endif
54 | 
55 | #define JNICALL
56 | 
57 | typedef int jint;
58 | #ifdef _LP64
59 | typedef long jlong;
60 | #else
61 | typedef long long jlong;
62 | #endif
63 | 
64 | typedef signed char jbyte;
65 | 
66 | #endif /* !_JAVASOFT_JNI_MD_H_ */
67 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # KMP with other languages sample
 2 | 
 3 | This sample begins to demonstrate how to ship code written in non-Kotlin languages
 4 | behind a Kotlin multiplatform API. It focuses on leveraging tooling such as Kotlin's
 5 | cinterop to produce type-safe native APIs, Java's header generation to produce type-safe
 6 | JNI headers, and Java's jextract to produce type-safe JVM APIs (for JDK 22 and newer).
 7 | 
 8 | Spoiler alert: the mechanism which makes all this work is the C ABI. If you have something
 9 | which exposes or can expose C ABI-compatible functions then you can use it from just about
10 | any Kotlin target with a little work.
11 | 
12 | Shipping a comprehensive abstraction of a rich native library based on these principles
13 | is possible, but as the native code gets more complex so will your integration. This
14 | sample deliberately ignores the nuances of full-fledged build systems and dependency
15 | management for the native languages. It also does not use tools designed to simplify the
16 | interaction of a large API surface in each language across a C-compatible boundary.
17 | 
18 | If you choose to productionize a Kotlin multiplatform solution based around a native library
19 | written in a non-Kotlin language, you will need to design a tighter integration at the build
20 | system layer. This is very much an exercise left to the reader since it otherwise would drown
21 | this sample in complexity but also that it has an element of taste to it.
22 | 
23 | 
24 | ## Languages
25 | 
26 | You **must** choose a language and build its shared library before anything will work!
27 | 
28 | ### C
29 | 
30 | ```
31 | $ adder/c/make.sh
32 | ```
33 | 
34 | ### C++
35 | 
36 | ```
37 | $ adder/cpp/make.sh
38 | ```
39 | 
40 | ### Rust
41 | 
42 | ```
43 | $ adder/rust/make.sh
44 | ```
45 | 
46 | ### Swift
47 | 
48 | ```
49 | $ adder/swift/make.sh
50 | ```
51 | 
52 | ### Zig
53 | 
54 | ```
55 | $ adder/zig/make.sh
56 | ```
57 | 
58 | ### JNI
59 | 
60 | Once language binaries are built, the JNI binary needs to be built.
61 | 
62 | ```
63 | $ adder/make-jni.sh
64 | ```
65 | 
66 | 
67 | # License
68 | 
69 |     Copyright 2025 Jake Wharton
70 | 
71 |     Licensed under the Apache License, Version 2.0 (the "License");
72 |     you may not use this file except in compliance with the License.
73 |     You may obtain a copy of the License at
74 | 
75 |        http://www.apache.org/licenses/LICENSE-2.0
76 | 
77 |     Unless required by applicable law or agreed to in writing, software
78 |     distributed under the License is distributed on an "AS IS" BASIS,
79 |     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
80 |     See the License for the specific language governing permissions and
81 |     limitations under the License.
82 | 


--------------------------------------------------------------------------------
/adder/build.gradle:
--------------------------------------------------------------------------------
  1 | import org.jetbrains.kotlin.gradle.dsl.JvmTarget
  2 | import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTarget
  3 | import org.jetbrains.kotlin.gradle.targets.jvm.KotlinJvmTarget
  4 | 
  5 | apply plugin: 'org.jetbrains.kotlin.multiplatform'
  6 | apply plugin: 'de.infolektuell.jextract'
  7 | 
  8 | jextract.libraries.create('add') {
  9 | 	header = file('include/add.h')
 10 | 	headerClassName = 'Libadd'
 11 | 	targetPackage = 'com.example.adder'
 12 | }
 13 | 
 14 | kotlin {
 15 | 	jvm()
 16 | 
 17 | 	macosArm64 {
 18 | 		compilations.configureEach {
 19 | 			kotlinOptions {
 20 | 				freeCompilerArgs += [
 21 | 					"-include-binary",
 22 | 					file('src/nativeMain/binaries/aarch64/libadd.a').absolutePath,
 23 | 					"-linker-option",
 24 | 					"-ladd",
 25 | 				]
 26 | 			}
 27 | 		}
 28 | 	}
 29 | 
 30 | 	// TODO The other targets...
 31 | 	//  androidTarget() (via https://ziggit.dev/t/targeting-android/4101)
 32 | 	//  linuxArm64()
 33 | 	//  linuxX64()
 34 | 	//  macosX64()
 35 | 	//  mingwX64()
 36 | 
 37 | 	applyDefaultHierarchyTemplate()
 38 | 	explicitApi()
 39 | 
 40 | 	sourceSets {
 41 | 		commonTest {
 42 | 			dependencies {
 43 | 				implementation libs.kotlin.test
 44 | 			}
 45 | 		}
 46 | 
 47 | 		configureEach {
 48 | 			languageSettings {
 49 | 				optIn('kotlinx.cinterop.ExperimentalForeignApi')
 50 | 			}
 51 | 		}
 52 | 	}
 53 | 
 54 | 	targets.withType(KotlinJvmTarget).configureEach {
 55 | 		def mainCompilation = compilations.named('main')
 56 | 
 57 | 		def jdk22Compilation = compilations.create('jdk22') {
 58 | 			// I can't find a way to add a Java srcDir, so we have to add it both to Kotlin task so its
 59 | 			// sources can link and to Java task so the files are actually compiled to classes.
 60 | 			def mosaicFfmJava = tasks.named('jextract')
 61 | 			defaultSourceSet.kotlin.srcDir(mosaicFfmJava)
 62 | 			compileJavaTaskProvider.configure { task ->
 63 | 				task.source(mosaicFfmJava)
 64 | 			}
 65 | 
 66 | 			compileTaskProvider.configure { task ->
 67 | 				task.compilerOptions { options ->
 68 | 					options.jvmTarget = JvmTarget.JVM_22
 69 | 					options.freeCompilerArgs.add('-Xexplicit-api=strict')
 70 | 				}
 71 | 			}
 72 | 			compileJavaTaskProvider.configure { task ->
 73 | 				task.sourceCompatibility = '22'
 74 | 				task.targetCompatibility = '22'
 75 | 			}
 76 | 			associateWith(mainCompilation.get())
 77 | 		}
 78 | 
 79 | 		tasks.named(artifactsTaskName, Jar) {
 80 | 			from(jdk22Compilation.output) {
 81 | 				into('META-INF/versions/22')
 82 | 				// Don't add a nested .kotlin_module file.
 83 | 				exclude('META-INF')
 84 | 				// Empty class noise produced by jextract.
 85 | 				exclude('**/_*.class')
 86 | 			}
 87 | 			manifest {
 88 | 				attributes(['Multi-Release': 'true'])
 89 | 			}
 90 | 		}
 91 | 	}
 92 | 
 93 | 	targets.withType(KotlinNativeTarget).configureEach {
 94 | 		compilations.named('main').configure {
 95 | 			cinterops.create('add') {
 96 | 				header(file('include/add.h'))
 97 | 				packageName('com.example.adder')
 98 | 			}
 99 | 		}
100 | 	}
101 | }
102 | 


--------------------------------------------------------------------------------
/gradlew.bat:
--------------------------------------------------------------------------------
 1 | @rem
 2 | @rem Copyright 2015 the original author or authors.
 3 | @rem
 4 | @rem Licensed under the Apache License, Version 2.0 (the "License");
 5 | @rem you may not use this file except in compliance with the License.
 6 | @rem You may obtain a copy of the License at
 7 | @rem
 8 | @rem      https://www.apache.org/licenses/LICENSE-2.0
 9 | @rem
10 | @rem Unless required by applicable law or agreed to in writing, software
11 | @rem distributed under the License is distributed on an "AS IS" BASIS,
12 | @rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | @rem See the License for the specific language governing permissions and
14 | @rem limitations under the License.
15 | @rem
16 | @rem SPDX-License-Identifier: Apache-2.0
17 | @rem
18 | 
19 | @if "%DEBUG%"=="" @echo off
20 | @rem ##########################################################################
21 | @rem
22 | @rem  Gradle startup script for Windows
23 | @rem
24 | @rem ##########################################################################
25 | 
26 | @rem Set local scope for the variables with windows NT shell
27 | if "%OS%"=="Windows_NT" setlocal
28 | 
29 | set DIRNAME=%~dp0
30 | if "%DIRNAME%"=="" set DIRNAME=.
31 | @rem This is normally unused
32 | set APP_BASE_NAME=%~n0
33 | set APP_HOME=%DIRNAME%
34 | 
35 | @rem Resolve any "." and ".." in APP_HOME to make it shorter.
36 | for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
37 | 
38 | @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
39 | set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
40 | 
41 | @rem Find java.exe
42 | if defined JAVA_HOME goto findJavaFromJavaHome
43 | 
44 | set JAVA_EXE=java.exe
45 | %JAVA_EXE% -version >NUL 2>&1
46 | if %ERRORLEVEL% equ 0 goto execute
47 | 
48 | echo. 1>&2
49 | echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
50 | echo. 1>&2
51 | echo Please set the JAVA_HOME variable in your environment to match the 1>&2
52 | echo location of your Java installation. 1>&2
53 | 
54 | goto fail
55 | 
56 | :findJavaFromJavaHome
57 | set JAVA_HOME=%JAVA_HOME:"=%
58 | set JAVA_EXE=%JAVA_HOME%/bin/java.exe
59 | 
60 | if exist "%JAVA_EXE%" goto execute
61 | 
62 | echo. 1>&2
63 | echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
64 | echo. 1>&2
65 | echo Please set the JAVA_HOME variable in your environment to match the 1>&2
66 | echo location of your Java installation. 1>&2
67 | 
68 | goto fail
69 | 
70 | :execute
71 | @rem Setup the command line
72 | 
73 | set CLASSPATH=
74 | 
75 | 
76 | @rem Execute Gradle
77 | "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %*
78 | 
79 | :end
80 | @rem End local scope for the variables with windows NT shell
81 | if %ERRORLEVEL% equ 0 goto mainEnd
82 | 
83 | :fail
84 | rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
85 | rem the _cmd.exe /c_ return code!
86 | set EXIT_CODE=%ERRORLEVEL%
87 | if %EXIT_CODE% equ 0 set EXIT_CODE=1
88 | if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
89 | exit /b %EXIT_CODE%
90 | 
91 | :mainEnd
92 | if "%OS%"=="Windows_NT" endlocal
93 | 
94 | :omega
95 | 


--------------------------------------------------------------------------------
/gradlew:
--------------------------------------------------------------------------------
  1 | #!/bin/sh
  2 | 
  3 | #
  4 | # Copyright © 2015-2021 the original authors.
  5 | #
  6 | # Licensed under the Apache License, Version 2.0 (the "License");
  7 | # you may not use this file except in compliance with the License.
  8 | # You may obtain a copy of the License at
  9 | #
 10 | #      https://www.apache.org/licenses/LICENSE-2.0
 11 | #
 12 | # Unless required by applicable law or agreed to in writing, software
 13 | # distributed under the License is distributed on an "AS IS" BASIS,
 14 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 15 | # See the License for the specific language governing permissions and
 16 | # limitations under the License.
 17 | #
 18 | # SPDX-License-Identifier: Apache-2.0
 19 | #
 20 | 
 21 | ##############################################################################
 22 | #
 23 | #   Gradle start up script for POSIX generated by Gradle.
 24 | #
 25 | #   Important for running:
 26 | #
 27 | #   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
 28 | #       noncompliant, but you have some other compliant shell such as ksh or
 29 | #       bash, then to run this script, type that shell name before the whole
 30 | #       command line, like:
 31 | #
 32 | #           ksh Gradle
 33 | #
 34 | #       Busybox and similar reduced shells will NOT work, because this script
 35 | #       requires all of these POSIX shell features:
 36 | #         * functions;
 37 | #         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
 38 | #           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
 39 | #         * compound commands having a testable exit status, especially «case»;
 40 | #         * various built-in commands including «command», «set», and «ulimit».
 41 | #
 42 | #   Important for patching:
 43 | #
 44 | #   (2) This script targets any POSIX shell, so it avoids extensions provided
 45 | #       by Bash, Ksh, etc; in particular arrays are avoided.
 46 | #
 47 | #       The "traditional" practice of packing multiple parameters into a
 48 | #       space-separated string is a well documented source of bugs and security
 49 | #       problems, so this is (mostly) avoided, by progressively accumulating
 50 | #       options in "$@", and eventually passing that to Java.
 51 | #
 52 | #       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
 53 | #       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
 54 | #       see the in-line comments for details.
 55 | #
 56 | #       There are tweaks for specific operating systems such as AIX, CygWin,
 57 | #       Darwin, MinGW, and NonStop.
 58 | #
 59 | #   (3) This script is generated from the Groovy template
 60 | #       https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
 61 | #       within the Gradle project.
 62 | #
 63 | #       You can find Gradle at https://github.com/gradle/gradle/.
 64 | #
 65 | ##############################################################################
 66 | 
 67 | # Attempt to set APP_HOME
 68 | 
 69 | # Resolve links: $0 may be a link
 70 | app_path=$0
 71 | 
 72 | # Need this for daisy-chained symlinks.
 73 | while
 74 |     APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
 75 |     [ -h "$app_path" ]
 76 | do
 77 |     ls=$( ls -ld "$app_path" )
 78 |     link=${ls#*' -> '}
 79 |     case $link in             #(
 80 |       /*)   app_path=$link ;; #(
 81 |       *)    app_path=$APP_HOME$link ;;
 82 |     esac
 83 | done
 84 | 
 85 | # This is normally unused
 86 | # shellcheck disable=SC2034
 87 | APP_BASE_NAME=${0##*/}
 88 | # Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
 89 | APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit
 90 | 
 91 | # Use the maximum available, or set MAX_FD != -1 to use that value.
 92 | MAX_FD=maximum
 93 | 
 94 | warn () {
 95 |     echo "$*"
 96 | } >&2
 97 | 
 98 | die () {
 99 |     echo
100 |     echo "$*"
101 |     echo
102 |     exit 1
103 | } >&2
104 | 
105 | # OS specific support (must be 'true' or 'false').
106 | cygwin=false
107 | msys=false
108 | darwin=false
109 | nonstop=false
110 | case "$( uname )" in                #(
111 |   CYGWIN* )         cygwin=true  ;; #(
112 |   Darwin* )         darwin=true  ;; #(
113 |   MSYS* | MINGW* )  msys=true    ;; #(
114 |   NONSTOP* )        nonstop=true ;;
115 | esac
116 | 
117 | CLASSPATH="\\\"\\\""
118 | 
119 | 
120 | # Determine the Java command to use to start the JVM.
121 | if [ -n "$JAVA_HOME" ] ; then
122 |     if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
123 |         # IBM's JDK on AIX uses strange locations for the executables
124 |         JAVACMD=$JAVA_HOME/jre/sh/java
125 |     else
126 |         JAVACMD=$JAVA_HOME/bin/java
127 |     fi
128 |     if [ ! -x "$JAVACMD" ] ; then
129 |         die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
130 | 
131 | Please set the JAVA_HOME variable in your environment to match the
132 | location of your Java installation."
133 |     fi
134 | else
135 |     JAVACMD=java
136 |     if ! command -v java >/dev/null 2>&1
137 |     then
138 |         die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
139 | 
140 | Please set the JAVA_HOME variable in your environment to match the
141 | location of your Java installation."
142 |     fi
143 | fi
144 | 
145 | # Increase the maximum file descriptors if we can.
146 | if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
147 |     case $MAX_FD in #(
148 |       max*)
149 |         # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
150 |         # shellcheck disable=SC2039,SC3045
151 |         MAX_FD=$( ulimit -H -n ) ||
152 |             warn "Could not query maximum file descriptor limit"
153 |     esac
154 |     case $MAX_FD in  #(
155 |       '' | soft) :;; #(
156 |       *)
157 |         # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
158 |         # shellcheck disable=SC2039,SC3045
159 |         ulimit -n "$MAX_FD" ||
160 |             warn "Could not set maximum file descriptor limit to $MAX_FD"
161 |     esac
162 | fi
163 | 
164 | # Collect all arguments for the java command, stacking in reverse order:
165 | #   * args from the command line
166 | #   * the main class name
167 | #   * -classpath
168 | #   * -D...appname settings
169 | #   * --module-path (only if needed)
170 | #   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
171 | 
172 | # For Cygwin or MSYS, switch paths to Windows format before running java
173 | if "$cygwin" || "$msys" ; then
174 |     APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
175 |     CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
176 | 
177 |     JAVACMD=$( cygpath --unix "$JAVACMD" )
178 | 
179 |     # Now convert the arguments - kludge to limit ourselves to /bin/sh
180 |     for arg do
181 |         if
182 |             case $arg in                                #(
183 |               -*)   false ;;                            # don't mess with options #(
184 |               /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
185 |                     [ -e "$t" ] ;;                      #(
186 |               *)    false ;;
187 |             esac
188 |         then
189 |             arg=$( cygpath --path --ignore --mixed "$arg" )
190 |         fi
191 |         # Roll the args list around exactly as many times as the number of
192 |         # args, so each arg winds up back in the position where it started, but
193 |         # possibly modified.
194 |         #
195 |         # NB: a `for` loop captures its iteration list before it begins, so
196 |         # changing the positional parameters here affects neither the number of
197 |         # iterations, nor the values presented in `arg`.
198 |         shift                   # remove old arg
199 |         set -- "$@" "$arg"      # push replacement arg
200 |     done
201 | fi
202 | 
203 | 
204 | # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
205 | DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
206 | 
207 | # Collect all arguments for the java command:
208 | #   * DEFAULT_JVM_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
209 | #     and any embedded shellness will be escaped.
210 | #   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
211 | #     treated as '${Hostname}' itself on the command line.
212 | 
213 | set -- \
214 |         "-Dorg.gradle.appname=$APP_BASE_NAME" \
215 |         -classpath "$CLASSPATH" \
216 |         -jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \
217 |         "$@"
218 | 
219 | # Stop when "xargs" is not available.
220 | if ! command -v xargs >/dev/null 2>&1
221 | then
222 |     die "xargs is not available"
223 | fi
224 | 
225 | # Use "xargs" to parse quoted args.
226 | #
227 | # With -n1 it outputs one arg per line, with the quotes and backslashes removed.
228 | #
229 | # In Bash we could simply go:
230 | #
231 | #   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
232 | #   set -- "${ARGS[@]}" "$@"
233 | #
234 | # but POSIX shell has neither arrays nor command substitution, so instead we
235 | # post-process each arg (as a line of input to sed) to backslash-escape any
236 | # character that might be a shell metacharacter, then use eval to reverse
237 | # that process (while maintaining the separation between arguments), and wrap
238 | # the whole thing up as a single "set" statement.
239 | #
240 | # This will of course break if any of these variables contains a newline or
241 | # an unmatched quote.
242 | #
243 | 
244 | eval "set -- $(
245 |         printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
246 |         xargs -n1 |
247 |         sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
248 |         tr '\n' ' '
249 |     )" '"$@"'
250 | 
251 | exec "$JAVACMD" "$@"
252 | 


--------------------------------------------------------------------------------
/LICENSE.txt:
--------------------------------------------------------------------------------
  1 | 
  2 |                                  Apache License
  3 |                            Version 2.0, January 2004
  4 |                         http://www.apache.org/licenses/
  5 | 
  6 |    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
  7 | 
  8 |    1. Definitions.
  9 | 
 10 |       "License" shall mean the terms and conditions for use, reproduction,
 11 |       and distribution as defined by Sections 1 through 9 of this document.
 12 | 
 13 |       "Licensor" shall mean the copyright owner or entity authorized by
 14 |       the copyright owner that is granting the License.
 15 | 
 16 |       "Legal Entity" shall mean the union of the acting entity and all
 17 |       other entities that control, are controlled by, or are under common
 18 |       control with that entity. For the purposes of this definition,
 19 |       "control" means (i) the power, direct or indirect, to cause the
 20 |       direction or management of such entity, whether by contract or
 21 |       otherwise, or (ii) ownership of fifty percent (50%) or more of the
 22 |       outstanding shares, or (iii) beneficial ownership of such entity.
 23 | 
 24 |       "You" (or "Your") shall mean an individual or Legal Entity
 25 |       exercising permissions granted by this License.
 26 | 
 27 |       "Source" form shall mean the preferred form for making modifications,
 28 |       including but not limited to software source code, documentation
 29 |       source, and configuration files.
 30 | 
 31 |       "Object" form shall mean any form resulting from mechanical
 32 |       transformation or translation of a Source form, including but
 33 |       not limited to compiled object code, generated documentation,
 34 |       and conversions to other media types.
 35 | 
 36 |       "Work" shall mean the work of authorship, whether in Source or
 37 |       Object form, made available under the License, as indicated by a
 38 |       copyright notice that is included in or attached to the work
 39 |       (an example is provided in the Appendix below).
 40 | 
 41 |       "Derivative Works" shall mean any work, whether in Source or Object
 42 |       form, that is based on (or derived from) the Work and for which the
 43 |       editorial revisions, annotations, elaborations, or other modifications
 44 |       represent, as a whole, an original work of authorship. For the purposes
 45 |       of this License, Derivative Works shall not include works that remain
 46 |       separable from, or merely link (or bind by name) to the interfaces of,
 47 |       the Work and Derivative Works thereof.
 48 | 
 49 |       "Contribution" shall mean any work of authorship, including
 50 |       the original version of the Work and any modifications or additions
 51 |       to that Work or Derivative Works thereof, that is intentionally
 52 |       submitted to Licensor for inclusion in the Work by the copyright owner
 53 |       or by an individual or Legal Entity authorized to submit on behalf of
 54 |       the copyright owner. For the purposes of this definition, "submitted"
 55 |       means any form of electronic, verbal, or written communication sent
 56 |       to the Licensor or its representatives, including but not limited to
 57 |       communication on electronic mailing lists, source code control systems,
 58 |       and issue tracking systems that are managed by, or on behalf of, the
 59 |       Licensor for the purpose of discussing and improving the Work, but
 60 |       excluding communication that is conspicuously marked or otherwise
 61 |       designated in writing by the copyright owner as "Not a Contribution."
 62 | 
 63 |       "Contributor" shall mean Licensor and any individual or Legal Entity
 64 |       on behalf of whom a Contribution has been received by Licensor and
 65 |       subsequently incorporated within the Work.
 66 | 
 67 |    2. Grant of Copyright License. Subject to the terms and conditions of
 68 |       this License, each Contributor hereby grants to You a perpetual,
 69 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 70 |       copyright license to reproduce, prepare Derivative Works of,
 71 |       publicly display, publicly perform, sublicense, and distribute the
 72 |       Work and such Derivative Works in Source or Object form.
 73 | 
 74 |    3. Grant of Patent License. Subject to the terms and conditions of
 75 |       this License, each Contributor hereby grants to You a perpetual,
 76 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 77 |       (except as stated in this section) patent license to make, have made,
 78 |       use, offer to sell, sell, import, and otherwise transfer the Work,
 79 |       where such license applies only to those patent claims licensable
 80 |       by such Contributor that are necessarily infringed by their
 81 |       Contribution(s) alone or by combination of their Contribution(s)
 82 |       with the Work to which such Contribution(s) was submitted. If You
 83 |       institute patent litigation against any entity (including a
 84 |       cross-claim or counterclaim in a lawsuit) alleging that the Work
 85 |       or a Contribution incorporated within the Work constitutes direct
 86 |       or contributory patent infringement, then any patent licenses
 87 |       granted to You under this License for that Work shall terminate
 88 |       as of the date such litigation is filed.
 89 | 
 90 |    4. Redistribution. You may reproduce and distribute copies of the
 91 |       Work or Derivative Works thereof in any medium, with or without
 92 |       modifications, and in Source or Object form, provided that You
 93 |       meet the following conditions:
 94 | 
 95 |       (a) You must give any other recipients of the Work or
 96 |           Derivative Works a copy of this License; and
 97 | 
 98 |       (b) You must cause any modified files to carry prominent notices
 99 |           stating that You changed the files; and
100 | 
101 |       (c) You must retain, in the Source form of any Derivative Works
102 |           that You distribute, all copyright, patent, trademark, and
103 |           attribution notices from the Source form of the Work,
104 |           excluding those notices that do not pertain to any part of
105 |           the Derivative Works; and
106 | 
107 |       (d) If the Work includes a "NOTICE" text file as part of its
108 |           distribution, then any Derivative Works that You distribute must
109 |           include a readable copy of the attribution notices contained
110 |           within such NOTICE file, excluding those notices that do not
111 |           pertain to any part of the Derivative Works, in at least one
112 |           of the following places: within a NOTICE text file distributed
113 |           as part of the Derivative Works; within the Source form or
114 |           documentation, if provided along with the Derivative Works; or,
115 |           within a display generated by the Derivative Works, if and
116 |           wherever such third-party notices normally appear. The contents
117 |           of the NOTICE file are for informational purposes only and
118 |           do not modify the License. You may add Your own attribution
119 |           notices within Derivative Works that You distribute, alongside
120 |           or as an addendum to the NOTICE text from the Work, provided
121 |           that such additional attribution notices cannot be construed
122 |           as modifying the License.
123 | 
124 |       You may add Your own copyright statement to Your modifications and
125 |       may provide additional or different license terms and conditions
126 |       for use, reproduction, or distribution of Your modifications, or
127 |       for any such Derivative Works as a whole, provided Your use,
128 |       reproduction, and distribution of the Work otherwise complies with
129 |       the conditions stated in this License.
130 | 
131 |    5. Submission of Contributions. Unless You explicitly state otherwise,
132 |       any Contribution intentionally submitted for inclusion in the Work
133 |       by You to the Licensor shall be under the terms and conditions of
134 |       this License, without any additional terms or conditions.
135 |       Notwithstanding the above, nothing herein shall supersede or modify
136 |       the terms of any separate license agreement you may have executed
137 |       with Licensor regarding such Contributions.
138 | 
139 |    6. Trademarks. This License does not grant permission to use the trade
140 |       names, trademarks, service marks, or product names of the Licensor,
141 |       except as required for reasonable and customary use in describing the
142 |       origin of the Work and reproducing the content of the NOTICE file.
143 | 
144 |    7. Disclaimer of Warranty. Unless required by applicable law or
145 |       agreed to in writing, Licensor provides the Work (and each
146 |       Contributor provides its Contributions) on an "AS IS" BASIS,
147 |       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
148 |       implied, including, without limitation, any warranties or conditions
149 |       of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
150 |       PARTICULAR PURPOSE. You are solely responsible for determining the
151 |       appropriateness of using or redistributing the Work and assume any
152 |       risks associated with Your exercise of permissions under this License.
153 | 
154 |    8. Limitation of Liability. In no event and under no legal theory,
155 |       whether in tort (including negligence), contract, or otherwise,
156 |       unless required by applicable law (such as deliberate and grossly
157 |       negligent acts) or agreed to in writing, shall any Contributor be
158 |       liable to You for damages, including any direct, indirect, special,
159 |       incidental, or consequential damages of any character arising as a
160 |       result of this License or out of the use or inability to use the
161 |       Work (including but not limited to damages for loss of goodwill,
162 |       work stoppage, computer failure or malfunction, or any and all
163 |       other commercial damages or losses), even if such Contributor
164 |       has been advised of the possibility of such damages.
165 | 
166 |    9. Accepting Warranty or Additional Liability. While redistributing
167 |       the Work or Derivative Works thereof, You may choose to offer,
168 |       and charge a fee for, acceptance of support, warranty, indemnity,
169 |       or other liability obligations and/or rights consistent with this
170 |       License. However, in accepting such obligations, You may act only
171 |       on Your own behalf and on Your sole responsibility, not on behalf
172 |       of any other Contributor, and only if You agree to indemnify,
173 |       defend, and hold each Contributor harmless for any liability
174 |       incurred by, or claims asserted against, such Contributor by reason
175 |       of your accepting any such warranty or additional liability.
176 | 
177 |    END OF TERMS AND CONDITIONS
178 | 
179 |    APPENDIX: How to apply the Apache License to your work.
180 | 
181 |       To apply the Apache License to your work, attach the following
182 |       boilerplate notice, with the fields enclosed by brackets "[]"
183 |       replaced with your own identifying information. (Don't include
184 |       the brackets!)  The text should be enclosed in the appropriate
185 |       comment syntax for the file format. We also recommend that a
186 |       file or class name and description of purpose be included on the
187 |       same "printed page" as the copyright notice for easier
188 |       identification within third-party archives.
189 | 
190 |    Copyright [yyyy] [name of copyright owner]
191 | 
192 |    Licensed under the Apache License, Version 2.0 (the "License");
193 |    you may not use this file except in compliance with the License.
194 |    You may obtain a copy of the License at
195 | 
196 |        http://www.apache.org/licenses/LICENSE-2.0
197 | 
198 |    Unless required by applicable law or agreed to in writing, software
199 |    distributed under the License is distributed on an "AS IS" BASIS,
200 |    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
201 |    See the License for the specific language governing permissions and
202 |    limitations under the License.
203 | 


--------------------------------------------------------------------------------
/adder/src/jvmMain/include/LICENSE:
--------------------------------------------------------------------------------
  1 | The GNU General Public License (GPL)
  2 | 
  3 | Version 2, June 1991
  4 | 
  5 | Copyright (C) 1989, 1991 Free Software Foundation, Inc.
  6 | 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  7 | 
  8 | Everyone is permitted to copy and distribute verbatim copies of this license
  9 | document, but changing it is not allowed.
 10 | 
 11 | Preamble
 12 | 
 13 | The licenses for most software are designed to take away your freedom to share
 14 | and change it.  By contrast, the GNU General Public License is intended to
 15 | guarantee your freedom to share and change free software--to make sure the
 16 | software is free for all its users.  This General Public License applies to
 17 | most of the Free Software Foundation's software and to any other program whose
 18 | authors commit to using it.  (Some other Free Software Foundation software is
 19 | covered by the GNU Library General Public License instead.) You can apply it to
 20 | your programs, too.
 21 | 
 22 | When we speak of free software, we are referring to freedom, not price.  Our
 23 | General Public Licenses are designed to make sure that you have the freedom to
 24 | distribute copies of free software (and charge for this service if you wish),
 25 | that you receive source code or can get it if you want it, that you can change
 26 | the software or use pieces of it in new free programs; and that you know you
 27 | can do these things.
 28 | 
 29 | To protect your rights, we need to make restrictions that forbid anyone to deny
 30 | you these rights or to ask you to surrender the rights.  These restrictions
 31 | translate to certain responsibilities for you if you distribute copies of the
 32 | software, or if you modify it.
 33 | 
 34 | For example, if you distribute copies of such a program, whether gratis or for
 35 | a fee, you must give the recipients all the rights that you have.  You must
 36 | make sure that they, too, receive or can get the source code.  And you must
 37 | show them these terms so they know their rights.
 38 | 
 39 | We protect your rights with two steps: (1) copyright the software, and (2)
 40 | offer you this license which gives you legal permission to copy, distribute
 41 | and/or modify the software.
 42 | 
 43 | Also, for each author's protection and ours, we want to make certain that
 44 | everyone understands that there is no warranty for this free software.  If the
 45 | software is modified by someone else and passed on, we want its recipients to
 46 | know that what they have is not the original, so that any problems introduced
 47 | by others will not reflect on the original authors' reputations.
 48 | 
 49 | Finally, any free program is threatened constantly by software patents.  We
 50 | wish to avoid the danger that redistributors of a free program will
 51 | individually obtain patent licenses, in effect making the program proprietary.
 52 | To prevent this, we have made it clear that any patent must be licensed for
 53 | everyone's free use or not licensed at all.
 54 | 
 55 | The precise terms and conditions for copying, distribution and modification
 56 | follow.
 57 | 
 58 | TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
 59 | 
 60 | 0. This License applies to any program or other work which contains a notice
 61 | placed by the copyright holder saying it may be distributed under the terms of
 62 | this General Public License.  The "Program", below, refers to any such program
 63 | or work, and a "work based on the Program" means either the Program or any
 64 | derivative work under copyright law: that is to say, a work containing the
 65 | Program or a portion of it, either verbatim or with modifications and/or
 66 | translated into another language.  (Hereinafter, translation is included
 67 | without limitation in the term "modification".) Each licensee is addressed as
 68 | "you".
 69 | 
 70 | Activities other than copying, distribution and modification are not covered by
 71 | this License; they are outside its scope.  The act of running the Program is
 72 | not restricted, and the output from the Program is covered only if its contents
 73 | constitute a work based on the Program (independent of having been made by
 74 | running the Program).  Whether that is true depends on what the Program does.
 75 | 
 76 | 1. You may copy and distribute verbatim copies of the Program's source code as
 77 | you receive it, in any medium, provided that you conspicuously and
 78 | appropriately publish on each copy an appropriate copyright notice and
 79 | disclaimer of warranty; keep intact all the notices that refer to this License
 80 | and to the absence of any warranty; and give any other recipients of the
 81 | Program a copy of this License along with the Program.
 82 | 
 83 | You may charge a fee for the physical act of transferring a copy, and you may
 84 | at your option offer warranty protection in exchange for a fee.
 85 | 
 86 | 2. You may modify your copy or copies of the Program or any portion of it, thus
 87 | forming a work based on the Program, and copy and distribute such modifications
 88 | or work under the terms of Section 1 above, provided that you also meet all of
 89 | these conditions:
 90 | 
 91 |     a) You must cause the modified files to carry prominent notices stating
 92 |     that you changed the files and the date of any change.
 93 | 
 94 |     b) You must cause any work that you distribute or publish, that in whole or
 95 |     in part contains or is derived from the Program or any part thereof, to be
 96 |     licensed as a whole at no charge to all third parties under the terms of
 97 |     this License.
 98 | 
 99 |     c) If the modified program normally reads commands interactively when run,
100 |     you must cause it, when started running for such interactive use in the
101 |     most ordinary way, to print or display an announcement including an
102 |     appropriate copyright notice and a notice that there is no warranty (or
103 |     else, saying that you provide a warranty) and that users may redistribute
104 |     the program under these conditions, and telling the user how to view a copy
105 |     of this License.  (Exception: if the Program itself is interactive but does
106 |     not normally print such an announcement, your work based on the Program is
107 |     not required to print an announcement.)
108 | 
109 | These requirements apply to the modified work as a whole.  If identifiable
110 | sections of that work are not derived from the Program, and can be reasonably
111 | considered independent and separate works in themselves, then this License, and
112 | its terms, do not apply to those sections when you distribute them as separate
113 | works.  But when you distribute the same sections as part of a whole which is a
114 | work based on the Program, the distribution of the whole must be on the terms
115 | of this License, whose permissions for other licensees extend to the entire
116 | whole, and thus to each and every part regardless of who wrote it.
117 | 
118 | Thus, it is not the intent of this section to claim rights or contest your
119 | rights to work written entirely by you; rather, the intent is to exercise the
120 | right to control the distribution of derivative or collective works based on
121 | the Program.
122 | 
123 | In addition, mere aggregation of another work not based on the Program with the
124 | Program (or with a work based on the Program) on a volume of a storage or
125 | distribution medium does not bring the other work under the scope of this
126 | License.
127 | 
128 | 3. You may copy and distribute the Program (or a work based on it, under
129 | Section 2) in object code or executable form under the terms of Sections 1 and
130 | 2 above provided that you also do one of the following:
131 | 
132 |     a) Accompany it with the complete corresponding machine-readable source
133 |     code, which must be distributed under the terms of Sections 1 and 2 above
134 |     on a medium customarily used for software interchange; or,
135 | 
136 |     b) Accompany it with a written offer, valid for at least three years, to
137 |     give any third party, for a charge no more than your cost of physically
138 |     performing source distribution, a complete machine-readable copy of the
139 |     corresponding source code, to be distributed under the terms of Sections 1
140 |     and 2 above on a medium customarily used for software interchange; or,
141 | 
142 |     c) Accompany it with the information you received as to the offer to
143 |     distribute corresponding source code.  (This alternative is allowed only
144 |     for noncommercial distribution and only if you received the program in
145 |     object code or executable form with such an offer, in accord with
146 |     Subsection b above.)
147 | 
148 | The source code for a work means the preferred form of the work for making
149 | modifications to it.  For an executable work, complete source code means all
150 | the source code for all modules it contains, plus any associated interface
151 | definition files, plus the scripts used to control compilation and installation
152 | of the executable.  However, as a special exception, the source code
153 | distributed need not include anything that is normally distributed (in either
154 | source or binary form) with the major components (compiler, kernel, and so on)
155 | of the operating system on which the executable runs, unless that component
156 | itself accompanies the executable.
157 | 
158 | If distribution of executable or object code is made by offering access to copy
159 | from a designated place, then offering equivalent access to copy the source
160 | code from the same place counts as distribution of the source code, even though
161 | third parties are not compelled to copy the source along with the object code.
162 | 
163 | 4. You may not copy, modify, sublicense, or distribute the Program except as
164 | expressly provided under this License.  Any attempt otherwise to copy, modify,
165 | sublicense or distribute the Program is void, and will automatically terminate
166 | your rights under this License.  However, parties who have received copies, or
167 | rights, from you under this License will not have their licenses terminated so
168 | long as such parties remain in full compliance.
169 | 
170 | 5. You are not required to accept this License, since you have not signed it.
171 | However, nothing else grants you permission to modify or distribute the Program
172 | or its derivative works.  These actions are prohibited by law if you do not
173 | accept this License.  Therefore, by modifying or distributing the Program (or
174 | any work based on the Program), you indicate your acceptance of this License to
175 | do so, and all its terms and conditions for copying, distributing or modifying
176 | the Program or works based on it.
177 | 
178 | 6. Each time you redistribute the Program (or any work based on the Program),
179 | the recipient automatically receives a license from the original licensor to
180 | copy, distribute or modify the Program subject to these terms and conditions.
181 | You may not impose any further restrictions on the recipients' exercise of the
182 | rights granted herein.  You are not responsible for enforcing compliance by
183 | third parties to this License.
184 | 
185 | 7. If, as a consequence of a court judgment or allegation of patent
186 | infringement or for any other reason (not limited to patent issues), conditions
187 | are imposed on you (whether by court order, agreement or otherwise) that
188 | contradict the conditions of this License, they do not excuse you from the
189 | conditions of this License.  If you cannot distribute so as to satisfy
190 | simultaneously your obligations under this License and any other pertinent
191 | obligations, then as a consequence you may not distribute the Program at all.
192 | For example, if a patent license would not permit royalty-free redistribution
193 | of the Program by all those who receive copies directly or indirectly through
194 | you, then the only way you could satisfy both it and this License would be to
195 | refrain entirely from distribution of the Program.
196 | 
197 | If any portion of this section is held invalid or unenforceable under any
198 | particular circumstance, the balance of the section is intended to apply and
199 | the section as a whole is intended to apply in other circumstances.
200 | 
201 | It is not the purpose of this section to induce you to infringe any patents or
202 | other property right claims or to contest validity of any such claims; this
203 | section has the sole purpose of protecting the integrity of the free software
204 | distribution system, which is implemented by public license practices.  Many
205 | people have made generous contributions to the wide range of software
206 | distributed through that system in reliance on consistent application of that
207 | system; it is up to the author/donor to decide if he or she is willing to
208 | distribute software through any other system and a licensee cannot impose that
209 | choice.
210 | 
211 | This section is intended to make thoroughly clear what is believed to be a
212 | consequence of the rest of this License.
213 | 
214 | 8. If the distribution and/or use of the Program is restricted in certain
215 | countries either by patents or by copyrighted interfaces, the original
216 | copyright holder who places the Program under this License may add an explicit
217 | geographical distribution limitation excluding those countries, so that
218 | distribution is permitted only in or among countries not thus excluded.  In
219 | such case, this License incorporates the limitation as if written in the body
220 | of this License.
221 | 
222 | 9. The Free Software Foundation may publish revised and/or new versions of the
223 | General Public License from time to time.  Such new versions will be similar in
224 | spirit to the present version, but may differ in detail to address new problems
225 | or concerns.
226 | 
227 | Each version is given a distinguishing version number.  If the Program
228 | specifies a version number of this License which applies to it and "any later
229 | version", you have the option of following the terms and conditions either of
230 | that version or of any later version published by the Free Software Foundation.
231 | If the Program does not specify a version number of this License, you may
232 | choose any version ever published by the Free Software Foundation.
233 | 
234 | 10. If you wish to incorporate parts of the Program into other free programs
235 | whose distribution conditions are different, write to the author to ask for
236 | permission.  For software which is copyrighted by the Free Software Foundation,
237 | write to the Free Software Foundation; we sometimes make exceptions for this.
238 | Our decision will be guided by the two goals of preserving the free status of
239 | all derivatives of our free software and of promoting the sharing and reuse of
240 | software generally.
241 | 
242 | NO WARRANTY
243 | 
244 | 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR
245 | THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN OTHERWISE
246 | STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE
247 | PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED,
248 | INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
249 | FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND
250 | PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE,
251 | YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
252 | 
253 | 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL
254 | ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE
255 | PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
256 | GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR
257 | INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA
258 | BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
259 | FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER
260 | OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
261 | 
262 | END OF TERMS AND CONDITIONS
263 | 
264 | How to Apply These Terms to Your New Programs
265 | 
266 | If you develop a new program, and you want it to be of the greatest possible
267 | use to the public, the best way to achieve this is to make it free software
268 | which everyone can redistribute and change under these terms.
269 | 
270 | To do so, attach the following notices to the program.  It is safest to attach
271 | them to the start of each source file to most effectively convey the exclusion
272 | of warranty; and each file should have at least the "copyright" line and a
273 | pointer to where the full notice is found.
274 | 
275 |     One line to give the program's name and a brief idea of what it does.
276 | 
277 |     Copyright (C) <year> <name of author>
278 | 
279 |     This program is free software; you can redistribute it and/or modify it
280 |     under the terms of the GNU General Public License as published by the Free
281 |     Software Foundation; either version 2 of the License, or (at your option)
282 |     any later version.
283 | 
284 |     This program is distributed in the hope that it will be useful, but WITHOUT
285 |     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
286 |     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
287 |     more details.
288 | 
289 |     You should have received a copy of the GNU General Public License along
290 |     with this program; if not, write to the Free Software Foundation, Inc.,
291 |     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
292 | 
293 | Also add information on how to contact you by electronic and paper mail.
294 | 
295 | If the program is interactive, make it output a short notice like this when it
296 | starts in an interactive mode:
297 | 
298 |     Gnomovision version 69, Copyright (C) year name of author Gnomovision comes
299 |     with ABSOLUTELY NO WARRANTY; for details type 'show w'.  This is free
300 |     software, and you are welcome to redistribute it under certain conditions;
301 |     type 'show c' for details.
302 | 
303 | The hypothetical commands 'show w' and 'show c' should show the appropriate
304 | parts of the General Public License.  Of course, the commands you use may be
305 | called something other than 'show w' and 'show c'; they could even be
306 | mouse-clicks or menu items--whatever suits your program.
307 | 
308 | You should also get your employer (if you work as a programmer) or your school,
309 | if any, to sign a "copyright disclaimer" for the program, if necessary.  Here
310 | is a sample; alter the names:
311 | 
312 |     Yoyodyne, Inc., hereby disclaims all copyright interest in the program
313 |     'Gnomovision' (which makes passes at compilers) written by James Hacker.
314 | 
315 |     signature of Ty Coon, 1 April 1989
316 | 
317 |     Ty Coon, President of Vice
318 | 
319 | This General Public License does not permit incorporating your program into
320 | proprietary programs.  If your program is a subroutine library, you may
321 | consider it more useful to permit linking proprietary applications with the
322 | library.  If this is what you want to do, use the GNU Library General Public
323 | License instead of this License.
324 | 
325 | 
326 | "CLASSPATH" EXCEPTION TO THE GPL
327 | 
328 | Certain source files distributed by Oracle America and/or its affiliates are
329 | subject to the following clarification and special exception to the GPL, but
330 | only where Oracle has expressly included in the particular source file's header
331 | the words "Oracle designates this particular file as subject to the "Classpath"
332 | exception as provided by Oracle in the LICENSE file that accompanied this code."
333 | 
334 |     Linking this library statically or dynamically with other modules is making
335 |     a combined work based on this library.  Thus, the terms and conditions of
336 |     the GNU General Public License cover the whole combination.
337 | 
338 |     As a special exception, the copyright holders of this library give you
339 |     permission to link this library with independent modules to produce an
340 |     executable, regardless of the license terms of these independent modules,
341 |     and to copy and distribute the resulting executable under terms of your
342 |     choice, provided that you also meet, for each linked independent module,
343 |     the terms and conditions of the license of that module.  An independent
344 |     module is a module which is not derived from or based on this library.  If
345 |     you modify this library, you may extend this exception to your version of
346 |     the library, but you are not obligated to do so.  If you do not wish to do
347 |     so, delete this exception statement from your version.
348 | 


--------------------------------------------------------------------------------
/adder/src/jvmMain/include/share/jni.h:
--------------------------------------------------------------------------------
   1 | /*
   2 |  * Copyright (c) 1996, 2023, Oracle and/or its affiliates. All rights reserved.
   3 |  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4 |  *
   5 |  * This code is free software; you can redistribute it and/or modify it
   6 |  * under the terms of the GNU General Public License version 2 only, as
   7 |  * published by the Free Software Foundation.  Oracle designates this
   8 |  * particular file as subject to the "Classpath" exception as provided
   9 |  * by Oracle in the LICENSE file that accompanied this code.
  10 |  *
  11 |  * This code is distributed in the hope that it will be useful, but WITHOUT
  12 |  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 |  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14 |  * version 2 for more details (a copy is included in the LICENSE file that
  15 |  * accompanied this code).
  16 |  *
  17 |  * You should have received a copy of the GNU General Public License version
  18 |  * 2 along with this work; if not, write to the Free Software Foundation,
  19 |  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20 |  *
  21 |  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22 |  * or visit www.oracle.com if you need additional information or have any
  23 |  * questions.
  24 |  */
  25 | 
  26 | /*
  27 |  * We used part of Netscape's Java Runtime Interface (JRI) as the starting
  28 |  * point of our design and implementation.
  29 |  */
  30 | 
  31 | /******************************************************************************
  32 |  * Java Runtime Interface
  33 |  * Copyright (c) 1996 Netscape Communications Corporation. All rights reserved.
  34 |  *****************************************************************************/
  35 | 
  36 | #ifndef _JAVASOFT_JNI_H_
  37 | #define _JAVASOFT_JNI_H_
  38 | 
  39 | #include <stdio.h>
  40 | #include <stdarg.h>
  41 | 
  42 | /* jni_md.h contains the machine-dependent typedefs for jbyte, jint
  43 |    and jlong */
  44 | 
  45 | #include "../unix/jni_md.h"
  46 | 
  47 | #ifdef __cplusplus
  48 | extern "C" {
  49 | #endif
  50 | 
  51 | /*
  52 |  * JNI Types
  53 |  */
  54 | 
  55 | #ifndef JNI_TYPES_ALREADY_DEFINED_IN_JNI_MD_H
  56 | 
  57 | typedef unsigned char   jboolean;
  58 | typedef unsigned short  jchar;
  59 | typedef short           jshort;
  60 | typedef float           jfloat;
  61 | typedef double          jdouble;
  62 | 
  63 | typedef jint            jsize;
  64 | 
  65 | #ifdef __cplusplus
  66 | 
  67 | class _jobject {};
  68 | class _jclass : public _jobject {};
  69 | class _jthrowable : public _jobject {};
  70 | class _jstring : public _jobject {};
  71 | class _jarray : public _jobject {};
  72 | class _jbooleanArray : public _jarray {};
  73 | class _jbyteArray : public _jarray {};
  74 | class _jcharArray : public _jarray {};
  75 | class _jshortArray : public _jarray {};
  76 | class _jintArray : public _jarray {};
  77 | class _jlongArray : public _jarray {};
  78 | class _jfloatArray : public _jarray {};
  79 | class _jdoubleArray : public _jarray {};
  80 | class _jobjectArray : public _jarray {};
  81 | 
  82 | typedef _jobject *jobject;
  83 | typedef _jclass *jclass;
  84 | typedef _jthrowable *jthrowable;
  85 | typedef _jstring *jstring;
  86 | typedef _jarray *jarray;
  87 | typedef _jbooleanArray *jbooleanArray;
  88 | typedef _jbyteArray *jbyteArray;
  89 | typedef _jcharArray *jcharArray;
  90 | typedef _jshortArray *jshortArray;
  91 | typedef _jintArray *jintArray;
  92 | typedef _jlongArray *jlongArray;
  93 | typedef _jfloatArray *jfloatArray;
  94 | typedef _jdoubleArray *jdoubleArray;
  95 | typedef _jobjectArray *jobjectArray;
  96 | 
  97 | #else
  98 | 
  99 | struct _jobject;
 100 | 
 101 | typedef struct _jobject *jobject;
 102 | typedef jobject jclass;
 103 | typedef jobject jthrowable;
 104 | typedef jobject jstring;
 105 | typedef jobject jarray;
 106 | typedef jarray jbooleanArray;
 107 | typedef jarray jbyteArray;
 108 | typedef jarray jcharArray;
 109 | typedef jarray jshortArray;
 110 | typedef jarray jintArray;
 111 | typedef jarray jlongArray;
 112 | typedef jarray jfloatArray;
 113 | typedef jarray jdoubleArray;
 114 | typedef jarray jobjectArray;
 115 | 
 116 | #endif
 117 | 
 118 | typedef jobject jweak;
 119 | 
 120 | typedef union jvalue {
 121 |     jboolean z;
 122 |     jbyte    b;
 123 |     jchar    c;
 124 |     jshort   s;
 125 |     jint     i;
 126 |     jlong    j;
 127 |     jfloat   f;
 128 |     jdouble  d;
 129 |     jobject  l;
 130 | } jvalue;
 131 | 
 132 | struct _jfieldID;
 133 | typedef struct _jfieldID *jfieldID;
 134 | 
 135 | struct _jmethodID;
 136 | typedef struct _jmethodID *jmethodID;
 137 | 
 138 | /* Return values from jobjectRefType */
 139 | typedef enum _jobjectType {
 140 |      JNIInvalidRefType    = 0,
 141 |      JNILocalRefType      = 1,
 142 |      JNIGlobalRefType     = 2,
 143 |      JNIWeakGlobalRefType = 3
 144 | } jobjectRefType;
 145 | 
 146 | 
 147 | #endif /* JNI_TYPES_ALREADY_DEFINED_IN_JNI_MD_H */
 148 | 
 149 | /*
 150 |  * jboolean constants
 151 |  */
 152 | 
 153 | #define JNI_FALSE 0
 154 | #define JNI_TRUE 1
 155 | 
 156 | /*
 157 |  * possible return values for JNI functions.
 158 |  */
 159 | 
 160 | #define JNI_OK           0                 /* success */
 161 | #define JNI_ERR          (-1)              /* unknown error */
 162 | #define JNI_EDETACHED    (-2)              /* thread detached from the VM */
 163 | #define JNI_EVERSION     (-3)              /* JNI version error */
 164 | #define JNI_ENOMEM       (-4)              /* not enough memory */
 165 | #define JNI_EEXIST       (-5)              /* VM already created */
 166 | #define JNI_EINVAL       (-6)              /* invalid arguments */
 167 | 
 168 | /*
 169 |  * used in ReleaseScalarArrayElements
 170 |  */
 171 | 
 172 | #define JNI_COMMIT 1
 173 | #define JNI_ABORT 2
 174 | 
 175 | /*
 176 |  * used in RegisterNatives to describe native method name, signature,
 177 |  * and function pointer.
 178 |  */
 179 | 
 180 | typedef struct {
 181 |     char *name;
 182 |     char *signature;
 183 |     void *fnPtr;
 184 | } JNINativeMethod;
 185 | 
 186 | /*
 187 |  * JNI Native Method Interface.
 188 |  */
 189 | 
 190 | struct JNINativeInterface_;
 191 | 
 192 | struct JNIEnv_;
 193 | 
 194 | #ifdef __cplusplus
 195 | typedef JNIEnv_ JNIEnv;
 196 | #else
 197 | typedef const struct JNINativeInterface_ *JNIEnv;
 198 | #endif
 199 | 
 200 | /*
 201 |  * JNI Invocation Interface.
 202 |  */
 203 | 
 204 | struct JNIInvokeInterface_;
 205 | 
 206 | struct JavaVM_;
 207 | 
 208 | #ifdef __cplusplus
 209 | typedef JavaVM_ JavaVM;
 210 | #else
 211 | typedef const struct JNIInvokeInterface_ *JavaVM;
 212 | #endif
 213 | 
 214 | struct JNINativeInterface_ {
 215 |     void *reserved0;
 216 |     void *reserved1;
 217 |     void *reserved2;
 218 | 
 219 |     void *reserved3;
 220 |     jint (JNICALL *GetVersion)(JNIEnv *env);
 221 | 
 222 |     jclass (JNICALL *DefineClass)
 223 |       (JNIEnv *env, const char *name, jobject loader, const jbyte *buf,
 224 |        jsize len);
 225 |     jclass (JNICALL *FindClass)
 226 |       (JNIEnv *env, const char *name);
 227 | 
 228 |     jmethodID (JNICALL *FromReflectedMethod)
 229 |       (JNIEnv *env, jobject method);
 230 |     jfieldID (JNICALL *FromReflectedField)
 231 |       (JNIEnv *env, jobject field);
 232 | 
 233 |     jobject (JNICALL *ToReflectedMethod)
 234 |       (JNIEnv *env, jclass cls, jmethodID methodID, jboolean isStatic);
 235 | 
 236 |     jclass (JNICALL *GetSuperclass)
 237 |       (JNIEnv *env, jclass sub);
 238 |     jboolean (JNICALL *IsAssignableFrom)
 239 |       (JNIEnv *env, jclass sub, jclass sup);
 240 | 
 241 |     jobject (JNICALL *ToReflectedField)
 242 |       (JNIEnv *env, jclass cls, jfieldID fieldID, jboolean isStatic);
 243 | 
 244 |     jint (JNICALL *Throw)
 245 |       (JNIEnv *env, jthrowable obj);
 246 |     jint (JNICALL *ThrowNew)
 247 |       (JNIEnv *env, jclass clazz, const char *msg);
 248 |     jthrowable (JNICALL *ExceptionOccurred)
 249 |       (JNIEnv *env);
 250 |     void (JNICALL *ExceptionDescribe)
 251 |       (JNIEnv *env);
 252 |     void (JNICALL *ExceptionClear)
 253 |       (JNIEnv *env);
 254 |     void (JNICALL *FatalError)
 255 |       (JNIEnv *env, const char *msg);
 256 | 
 257 |     jint (JNICALL *PushLocalFrame)
 258 |       (JNIEnv *env, jint capacity);
 259 |     jobject (JNICALL *PopLocalFrame)
 260 |       (JNIEnv *env, jobject result);
 261 | 
 262 |     jobject (JNICALL *NewGlobalRef)
 263 |       (JNIEnv *env, jobject lobj);
 264 |     void (JNICALL *DeleteGlobalRef)
 265 |       (JNIEnv *env, jobject gref);
 266 |     void (JNICALL *DeleteLocalRef)
 267 |       (JNIEnv *env, jobject obj);
 268 |     jboolean (JNICALL *IsSameObject)
 269 |       (JNIEnv *env, jobject obj1, jobject obj2);
 270 |     jobject (JNICALL *NewLocalRef)
 271 |       (JNIEnv *env, jobject ref);
 272 |     jint (JNICALL *EnsureLocalCapacity)
 273 |       (JNIEnv *env, jint capacity);
 274 | 
 275 |     jobject (JNICALL *AllocObject)
 276 |       (JNIEnv *env, jclass clazz);
 277 |     jobject (JNICALL *NewObject)
 278 |       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
 279 |     jobject (JNICALL *NewObjectV)
 280 |       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
 281 |     jobject (JNICALL *NewObjectA)
 282 |       (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);
 283 | 
 284 |     jclass (JNICALL *GetObjectClass)
 285 |       (JNIEnv *env, jobject obj);
 286 |     jboolean (JNICALL *IsInstanceOf)
 287 |       (JNIEnv *env, jobject obj, jclass clazz);
 288 | 
 289 |     jmethodID (JNICALL *GetMethodID)
 290 |       (JNIEnv *env, jclass clazz, const char *name, const char *sig);
 291 | 
 292 |     jobject (JNICALL *CallObjectMethod)
 293 |       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
 294 |     jobject (JNICALL *CallObjectMethodV)
 295 |       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
 296 |     jobject (JNICALL *CallObjectMethodA)
 297 |       (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue * args);
 298 | 
 299 |     jboolean (JNICALL *CallBooleanMethod)
 300 |       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
 301 |     jboolean (JNICALL *CallBooleanMethodV)
 302 |       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
 303 |     jboolean (JNICALL *CallBooleanMethodA)
 304 |       (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue * args);
 305 | 
 306 |     jbyte (JNICALL *CallByteMethod)
 307 |       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
 308 |     jbyte (JNICALL *CallByteMethodV)
 309 |       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
 310 |     jbyte (JNICALL *CallByteMethodA)
 311 |       (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args);
 312 | 
 313 |     jchar (JNICALL *CallCharMethod)
 314 |       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
 315 |     jchar (JNICALL *CallCharMethodV)
 316 |       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
 317 |     jchar (JNICALL *CallCharMethodA)
 318 |       (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args);
 319 | 
 320 |     jshort (JNICALL *CallShortMethod)
 321 |       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
 322 |     jshort (JNICALL *CallShortMethodV)
 323 |       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
 324 |     jshort (JNICALL *CallShortMethodA)
 325 |       (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args);
 326 | 
 327 |     jint (JNICALL *CallIntMethod)
 328 |       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
 329 |     jint (JNICALL *CallIntMethodV)
 330 |       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
 331 |     jint (JNICALL *CallIntMethodA)
 332 |       (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args);
 333 | 
 334 |     jlong (JNICALL *CallLongMethod)
 335 |       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
 336 |     jlong (JNICALL *CallLongMethodV)
 337 |       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
 338 |     jlong (JNICALL *CallLongMethodA)
 339 |       (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args);
 340 | 
 341 |     jfloat (JNICALL *CallFloatMethod)
 342 |       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
 343 |     jfloat (JNICALL *CallFloatMethodV)
 344 |       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
 345 |     jfloat (JNICALL *CallFloatMethodA)
 346 |       (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args);
 347 | 
 348 |     jdouble (JNICALL *CallDoubleMethod)
 349 |       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
 350 |     jdouble (JNICALL *CallDoubleMethodV)
 351 |       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
 352 |     jdouble (JNICALL *CallDoubleMethodA)
 353 |       (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args);
 354 | 
 355 |     void (JNICALL *CallVoidMethod)
 356 |       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
 357 |     void (JNICALL *CallVoidMethodV)
 358 |       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
 359 |     void (JNICALL *CallVoidMethodA)
 360 |       (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue * args);
 361 | 
 362 |     jobject (JNICALL *CallNonvirtualObjectMethod)
 363 |       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
 364 |     jobject (JNICALL *CallNonvirtualObjectMethodV)
 365 |       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
 366 |        va_list args);
 367 |     jobject (JNICALL *CallNonvirtualObjectMethodA)
 368 |       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
 369 |        const jvalue * args);
 370 | 
 371 |     jboolean (JNICALL *CallNonvirtualBooleanMethod)
 372 |       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
 373 |     jboolean (JNICALL *CallNonvirtualBooleanMethodV)
 374 |       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
 375 |        va_list args);
 376 |     jboolean (JNICALL *CallNonvirtualBooleanMethodA)
 377 |       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
 378 |        const jvalue * args);
 379 | 
 380 |     jbyte (JNICALL *CallNonvirtualByteMethod)
 381 |       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
 382 |     jbyte (JNICALL *CallNonvirtualByteMethodV)
 383 |       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
 384 |        va_list args);
 385 |     jbyte (JNICALL *CallNonvirtualByteMethodA)
 386 |       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
 387 |        const jvalue *args);
 388 | 
 389 |     jchar (JNICALL *CallNonvirtualCharMethod)
 390 |       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
 391 |     jchar (JNICALL *CallNonvirtualCharMethodV)
 392 |       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
 393 |        va_list args);
 394 |     jchar (JNICALL *CallNonvirtualCharMethodA)
 395 |       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
 396 |        const jvalue *args);
 397 | 
 398 |     jshort (JNICALL *CallNonvirtualShortMethod)
 399 |       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
 400 |     jshort (JNICALL *CallNonvirtualShortMethodV)
 401 |       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
 402 |        va_list args);
 403 |     jshort (JNICALL *CallNonvirtualShortMethodA)
 404 |       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
 405 |        const jvalue *args);
 406 | 
 407 |     jint (JNICALL *CallNonvirtualIntMethod)
 408 |       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
 409 |     jint (JNICALL *CallNonvirtualIntMethodV)
 410 |       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
 411 |        va_list args);
 412 |     jint (JNICALL *CallNonvirtualIntMethodA)
 413 |       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
 414 |        const jvalue *args);
 415 | 
 416 |     jlong (JNICALL *CallNonvirtualLongMethod)
 417 |       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
 418 |     jlong (JNICALL *CallNonvirtualLongMethodV)
 419 |       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
 420 |        va_list args);
 421 |     jlong (JNICALL *CallNonvirtualLongMethodA)
 422 |       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
 423 |        const jvalue *args);
 424 | 
 425 |     jfloat (JNICALL *CallNonvirtualFloatMethod)
 426 |       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
 427 |     jfloat (JNICALL *CallNonvirtualFloatMethodV)
 428 |       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
 429 |        va_list args);
 430 |     jfloat (JNICALL *CallNonvirtualFloatMethodA)
 431 |       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
 432 |        const jvalue *args);
 433 | 
 434 |     jdouble (JNICALL *CallNonvirtualDoubleMethod)
 435 |       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
 436 |     jdouble (JNICALL *CallNonvirtualDoubleMethodV)
 437 |       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
 438 |        va_list args);
 439 |     jdouble (JNICALL *CallNonvirtualDoubleMethodA)
 440 |       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
 441 |        const jvalue *args);
 442 | 
 443 |     void (JNICALL *CallNonvirtualVoidMethod)
 444 |       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
 445 |     void (JNICALL *CallNonvirtualVoidMethodV)
 446 |       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
 447 |        va_list args);
 448 |     void (JNICALL *CallNonvirtualVoidMethodA)
 449 |       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
 450 |        const jvalue * args);
 451 | 
 452 |     jfieldID (JNICALL *GetFieldID)
 453 |       (JNIEnv *env, jclass clazz, const char *name, const char *sig);
 454 | 
 455 |     jobject (JNICALL *GetObjectField)
 456 |       (JNIEnv *env, jobject obj, jfieldID fieldID);
 457 |     jboolean (JNICALL *GetBooleanField)
 458 |       (JNIEnv *env, jobject obj, jfieldID fieldID);
 459 |     jbyte (JNICALL *GetByteField)
 460 |       (JNIEnv *env, jobject obj, jfieldID fieldID);
 461 |     jchar (JNICALL *GetCharField)
 462 |       (JNIEnv *env, jobject obj, jfieldID fieldID);
 463 |     jshort (JNICALL *GetShortField)
 464 |       (JNIEnv *env, jobject obj, jfieldID fieldID);
 465 |     jint (JNICALL *GetIntField)
 466 |       (JNIEnv *env, jobject obj, jfieldID fieldID);
 467 |     jlong (JNICALL *GetLongField)
 468 |       (JNIEnv *env, jobject obj, jfieldID fieldID);
 469 |     jfloat (JNICALL *GetFloatField)
 470 |       (JNIEnv *env, jobject obj, jfieldID fieldID);
 471 |     jdouble (JNICALL *GetDoubleField)
 472 |       (JNIEnv *env, jobject obj, jfieldID fieldID);
 473 | 
 474 |     void (JNICALL *SetObjectField)
 475 |       (JNIEnv *env, jobject obj, jfieldID fieldID, jobject val);
 476 |     void (JNICALL *SetBooleanField)
 477 |       (JNIEnv *env, jobject obj, jfieldID fieldID, jboolean val);
 478 |     void (JNICALL *SetByteField)
 479 |       (JNIEnv *env, jobject obj, jfieldID fieldID, jbyte val);
 480 |     void (JNICALL *SetCharField)
 481 |       (JNIEnv *env, jobject obj, jfieldID fieldID, jchar val);
 482 |     void (JNICALL *SetShortField)
 483 |       (JNIEnv *env, jobject obj, jfieldID fieldID, jshort val);
 484 |     void (JNICALL *SetIntField)
 485 |       (JNIEnv *env, jobject obj, jfieldID fieldID, jint val);
 486 |     void (JNICALL *SetLongField)
 487 |       (JNIEnv *env, jobject obj, jfieldID fieldID, jlong val);
 488 |     void (JNICALL *SetFloatField)
 489 |       (JNIEnv *env, jobject obj, jfieldID fieldID, jfloat val);
 490 |     void (JNICALL *SetDoubleField)
 491 |       (JNIEnv *env, jobject obj, jfieldID fieldID, jdouble val);
 492 | 
 493 |     jmethodID (JNICALL *GetStaticMethodID)
 494 |       (JNIEnv *env, jclass clazz, const char *name, const char *sig);
 495 | 
 496 |     jobject (JNICALL *CallStaticObjectMethod)
 497 |       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
 498 |     jobject (JNICALL *CallStaticObjectMethodV)
 499 |       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
 500 |     jobject (JNICALL *CallStaticObjectMethodA)
 501 |       (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);
 502 | 
 503 |     jboolean (JNICALL *CallStaticBooleanMethod)
 504 |       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
 505 |     jboolean (JNICALL *CallStaticBooleanMethodV)
 506 |       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
 507 |     jboolean (JNICALL *CallStaticBooleanMethodA)
 508 |       (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);
 509 | 
 510 |     jbyte (JNICALL *CallStaticByteMethod)
 511 |       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
 512 |     jbyte (JNICALL *CallStaticByteMethodV)
 513 |       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
 514 |     jbyte (JNICALL *CallStaticByteMethodA)
 515 |       (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);
 516 | 
 517 |     jchar (JNICALL *CallStaticCharMethod)
 518 |       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
 519 |     jchar (JNICALL *CallStaticCharMethodV)
 520 |       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
 521 |     jchar (JNICALL *CallStaticCharMethodA)
 522 |       (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);
 523 | 
 524 |     jshort (JNICALL *CallStaticShortMethod)
 525 |       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
 526 |     jshort (JNICALL *CallStaticShortMethodV)
 527 |       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
 528 |     jshort (JNICALL *CallStaticShortMethodA)
 529 |       (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);
 530 | 
 531 |     jint (JNICALL *CallStaticIntMethod)
 532 |       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
 533 |     jint (JNICALL *CallStaticIntMethodV)
 534 |       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
 535 |     jint (JNICALL *CallStaticIntMethodA)
 536 |       (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);
 537 | 
 538 |     jlong (JNICALL *CallStaticLongMethod)
 539 |       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
 540 |     jlong (JNICALL *CallStaticLongMethodV)
 541 |       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
 542 |     jlong (JNICALL *CallStaticLongMethodA)
 543 |       (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);
 544 | 
 545 |     jfloat (JNICALL *CallStaticFloatMethod)
 546 |       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
 547 |     jfloat (JNICALL *CallStaticFloatMethodV)
 548 |       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
 549 |     jfloat (JNICALL *CallStaticFloatMethodA)
 550 |       (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);
 551 | 
 552 |     jdouble (JNICALL *CallStaticDoubleMethod)
 553 |       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
 554 |     jdouble (JNICALL *CallStaticDoubleMethodV)
 555 |       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
 556 |     jdouble (JNICALL *CallStaticDoubleMethodA)
 557 |       (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);
 558 | 
 559 |     void (JNICALL *CallStaticVoidMethod)
 560 |       (JNIEnv *env, jclass cls, jmethodID methodID, ...);
 561 |     void (JNICALL *CallStaticVoidMethodV)
 562 |       (JNIEnv *env, jclass cls, jmethodID methodID, va_list args);
 563 |     void (JNICALL *CallStaticVoidMethodA)
 564 |       (JNIEnv *env, jclass cls, jmethodID methodID, const jvalue * args);
 565 | 
 566 |     jfieldID (JNICALL *GetStaticFieldID)
 567 |       (JNIEnv *env, jclass clazz, const char *name, const char *sig);
 568 |     jobject (JNICALL *GetStaticObjectField)
 569 |       (JNIEnv *env, jclass clazz, jfieldID fieldID);
 570 |     jboolean (JNICALL *GetStaticBooleanField)
 571 |       (JNIEnv *env, jclass clazz, jfieldID fieldID);
 572 |     jbyte (JNICALL *GetStaticByteField)
 573 |       (JNIEnv *env, jclass clazz, jfieldID fieldID);
 574 |     jchar (JNICALL *GetStaticCharField)
 575 |       (JNIEnv *env, jclass clazz, jfieldID fieldID);
 576 |     jshort (JNICALL *GetStaticShortField)
 577 |       (JNIEnv *env, jclass clazz, jfieldID fieldID);
 578 |     jint (JNICALL *GetStaticIntField)
 579 |       (JNIEnv *env, jclass clazz, jfieldID fieldID);
 580 |     jlong (JNICALL *GetStaticLongField)
 581 |       (JNIEnv *env, jclass clazz, jfieldID fieldID);
 582 |     jfloat (JNICALL *GetStaticFloatField)
 583 |       (JNIEnv *env, jclass clazz, jfieldID fieldID);
 584 |     jdouble (JNICALL *GetStaticDoubleField)
 585 |       (JNIEnv *env, jclass clazz, jfieldID fieldID);
 586 | 
 587 |     void (JNICALL *SetStaticObjectField)
 588 |       (JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value);
 589 |     void (JNICALL *SetStaticBooleanField)
 590 |       (JNIEnv *env, jclass clazz, jfieldID fieldID, jboolean value);
 591 |     void (JNICALL *SetStaticByteField)
 592 |       (JNIEnv *env, jclass clazz, jfieldID fieldID, jbyte value);
 593 |     void (JNICALL *SetStaticCharField)
 594 |       (JNIEnv *env, jclass clazz, jfieldID fieldID, jchar value);
 595 |     void (JNICALL *SetStaticShortField)
 596 |       (JNIEnv *env, jclass clazz, jfieldID fieldID, jshort value);
 597 |     void (JNICALL *SetStaticIntField)
 598 |       (JNIEnv *env, jclass clazz, jfieldID fieldID, jint value);
 599 |     void (JNICALL *SetStaticLongField)
 600 |       (JNIEnv *env, jclass clazz, jfieldID fieldID, jlong value);
 601 |     void (JNICALL *SetStaticFloatField)
 602 |       (JNIEnv *env, jclass clazz, jfieldID fieldID, jfloat value);
 603 |     void (JNICALL *SetStaticDoubleField)
 604 |       (JNIEnv *env, jclass clazz, jfieldID fieldID, jdouble value);
 605 | 
 606 |     jstring (JNICALL *NewString)
 607 |       (JNIEnv *env, const jchar *unicode, jsize len);
 608 |     jsize (JNICALL *GetStringLength)
 609 |       (JNIEnv *env, jstring str);
 610 |     const jchar *(JNICALL *GetStringChars)
 611 |       (JNIEnv *env, jstring str, jboolean *isCopy);
 612 |     void (JNICALL *ReleaseStringChars)
 613 |       (JNIEnv *env, jstring str, const jchar *chars);
 614 | 
 615 |     jstring (JNICALL *NewStringUTF)
 616 |       (JNIEnv *env, const char *utf);
 617 |     jsize (JNICALL *GetStringUTFLength)
 618 |       (JNIEnv *env, jstring str);
 619 |     const char* (JNICALL *GetStringUTFChars)
 620 |       (JNIEnv *env, jstring str, jboolean *isCopy);
 621 |     void (JNICALL *ReleaseStringUTFChars)
 622 |       (JNIEnv *env, jstring str, const char* chars);
 623 | 
 624 | 
 625 |     jsize (JNICALL *GetArrayLength)
 626 |       (JNIEnv *env, jarray array);
 627 | 
 628 |     jobjectArray (JNICALL *NewObjectArray)
 629 |       (JNIEnv *env, jsize len, jclass clazz, jobject init);
 630 |     jobject (JNICALL *GetObjectArrayElement)
 631 |       (JNIEnv *env, jobjectArray array, jsize index);
 632 |     void (JNICALL *SetObjectArrayElement)
 633 |       (JNIEnv *env, jobjectArray array, jsize index, jobject val);
 634 | 
 635 |     jbooleanArray (JNICALL *NewBooleanArray)
 636 |       (JNIEnv *env, jsize len);
 637 |     jbyteArray (JNICALL *NewByteArray)
 638 |       (JNIEnv *env, jsize len);
 639 |     jcharArray (JNICALL *NewCharArray)
 640 |       (JNIEnv *env, jsize len);
 641 |     jshortArray (JNICALL *NewShortArray)
 642 |       (JNIEnv *env, jsize len);
 643 |     jintArray (JNICALL *NewIntArray)
 644 |       (JNIEnv *env, jsize len);
 645 |     jlongArray (JNICALL *NewLongArray)
 646 |       (JNIEnv *env, jsize len);
 647 |     jfloatArray (JNICALL *NewFloatArray)
 648 |       (JNIEnv *env, jsize len);
 649 |     jdoubleArray (JNICALL *NewDoubleArray)
 650 |       (JNIEnv *env, jsize len);
 651 | 
 652 |     jboolean * (JNICALL *GetBooleanArrayElements)
 653 |       (JNIEnv *env, jbooleanArray array, jboolean *isCopy);
 654 |     jbyte * (JNICALL *GetByteArrayElements)
 655 |       (JNIEnv *env, jbyteArray array, jboolean *isCopy);
 656 |     jchar * (JNICALL *GetCharArrayElements)
 657 |       (JNIEnv *env, jcharArray array, jboolean *isCopy);
 658 |     jshort * (JNICALL *GetShortArrayElements)
 659 |       (JNIEnv *env, jshortArray array, jboolean *isCopy);
 660 |     jint * (JNICALL *GetIntArrayElements)
 661 |       (JNIEnv *env, jintArray array, jboolean *isCopy);
 662 |     jlong * (JNICALL *GetLongArrayElements)
 663 |       (JNIEnv *env, jlongArray array, jboolean *isCopy);
 664 |     jfloat * (JNICALL *GetFloatArrayElements)
 665 |       (JNIEnv *env, jfloatArray array, jboolean *isCopy);
 666 |     jdouble * (JNICALL *GetDoubleArrayElements)
 667 |       (JNIEnv *env, jdoubleArray array, jboolean *isCopy);
 668 | 
 669 |     void (JNICALL *ReleaseBooleanArrayElements)
 670 |       (JNIEnv *env, jbooleanArray array, jboolean *elems, jint mode);
 671 |     void (JNICALL *ReleaseByteArrayElements)
 672 |       (JNIEnv *env, jbyteArray array, jbyte *elems, jint mode);
 673 |     void (JNICALL *ReleaseCharArrayElements)
 674 |       (JNIEnv *env, jcharArray array, jchar *elems, jint mode);
 675 |     void (JNICALL *ReleaseShortArrayElements)
 676 |       (JNIEnv *env, jshortArray array, jshort *elems, jint mode);
 677 |     void (JNICALL *ReleaseIntArrayElements)
 678 |       (JNIEnv *env, jintArray array, jint *elems, jint mode);
 679 |     void (JNICALL *ReleaseLongArrayElements)
 680 |       (JNIEnv *env, jlongArray array, jlong *elems, jint mode);
 681 |     void (JNICALL *ReleaseFloatArrayElements)
 682 |       (JNIEnv *env, jfloatArray array, jfloat *elems, jint mode);
 683 |     void (JNICALL *ReleaseDoubleArrayElements)
 684 |       (JNIEnv *env, jdoubleArray array, jdouble *elems, jint mode);
 685 | 
 686 |     void (JNICALL *GetBooleanArrayRegion)
 687 |       (JNIEnv *env, jbooleanArray array, jsize start, jsize l, jboolean *buf);
 688 |     void (JNICALL *GetByteArrayRegion)
 689 |       (JNIEnv *env, jbyteArray array, jsize start, jsize len, jbyte *buf);
 690 |     void (JNICALL *GetCharArrayRegion)
 691 |       (JNIEnv *env, jcharArray array, jsize start, jsize len, jchar *buf);
 692 |     void (JNICALL *GetShortArrayRegion)
 693 |       (JNIEnv *env, jshortArray array, jsize start, jsize len, jshort *buf);
 694 |     void (JNICALL *GetIntArrayRegion)
 695 |       (JNIEnv *env, jintArray array, jsize start, jsize len, jint *buf);
 696 |     void (JNICALL *GetLongArrayRegion)
 697 |       (JNIEnv *env, jlongArray array, jsize start, jsize len, jlong *buf);
 698 |     void (JNICALL *GetFloatArrayRegion)
 699 |       (JNIEnv *env, jfloatArray array, jsize start, jsize len, jfloat *buf);
 700 |     void (JNICALL *GetDoubleArrayRegion)
 701 |       (JNIEnv *env, jdoubleArray array, jsize start, jsize len, jdouble *buf);
 702 | 
 703 |     void (JNICALL *SetBooleanArrayRegion)
 704 |       (JNIEnv *env, jbooleanArray array, jsize start, jsize l, const jboolean *buf);
 705 |     void (JNICALL *SetByteArrayRegion)
 706 |       (JNIEnv *env, jbyteArray array, jsize start, jsize len, const jbyte *buf);
 707 |     void (JNICALL *SetCharArrayRegion)
 708 |       (JNIEnv *env, jcharArray array, jsize start, jsize len, const jchar *buf);
 709 |     void (JNICALL *SetShortArrayRegion)
 710 |       (JNIEnv *env, jshortArray array, jsize start, jsize len, const jshort *buf);
 711 |     void (JNICALL *SetIntArrayRegion)
 712 |       (JNIEnv *env, jintArray array, jsize start, jsize len, const jint *buf);
 713 |     void (JNICALL *SetLongArrayRegion)
 714 |       (JNIEnv *env, jlongArray array, jsize start, jsize len, const jlong *buf);
 715 |     void (JNICALL *SetFloatArrayRegion)
 716 |       (JNIEnv *env, jfloatArray array, jsize start, jsize len, const jfloat *buf);
 717 |     void (JNICALL *SetDoubleArrayRegion)
 718 |       (JNIEnv *env, jdoubleArray array, jsize start, jsize len, const jdouble *buf);
 719 | 
 720 |     jint (JNICALL *RegisterNatives)
 721 |       (JNIEnv *env, jclass clazz, const JNINativeMethod *methods,
 722 |        jint nMethods);
 723 |     jint (JNICALL *UnregisterNatives)
 724 |       (JNIEnv *env, jclass clazz);
 725 | 
 726 |     jint (JNICALL *MonitorEnter)
 727 |       (JNIEnv *env, jobject obj);
 728 |     jint (JNICALL *MonitorExit)
 729 |       (JNIEnv *env, jobject obj);
 730 | 
 731 |     jint (JNICALL *GetJavaVM)
 732 |       (JNIEnv *env, JavaVM **vm);
 733 | 
 734 |     void (JNICALL *GetStringRegion)
 735 |       (JNIEnv *env, jstring str, jsize start, jsize len, jchar *buf);
 736 |     void (JNICALL *GetStringUTFRegion)
 737 |       (JNIEnv *env, jstring str, jsize start, jsize len, char *buf);
 738 | 
 739 |     void * (JNICALL *GetPrimitiveArrayCritical)
 740 |       (JNIEnv *env, jarray array, jboolean *isCopy);
 741 |     void (JNICALL *ReleasePrimitiveArrayCritical)
 742 |       (JNIEnv *env, jarray array, void *carray, jint mode);
 743 | 
 744 |     const jchar * (JNICALL *GetStringCritical)
 745 |       (JNIEnv *env, jstring string, jboolean *isCopy);
 746 |     void (JNICALL *ReleaseStringCritical)
 747 |       (JNIEnv *env, jstring string, const jchar *cstring);
 748 | 
 749 |     jweak (JNICALL *NewWeakGlobalRef)
 750 |        (JNIEnv *env, jobject obj);
 751 |     void (JNICALL *DeleteWeakGlobalRef)
 752 |        (JNIEnv *env, jweak ref);
 753 | 
 754 |     jboolean (JNICALL *ExceptionCheck)
 755 |        (JNIEnv *env);
 756 | 
 757 |     jobject (JNICALL *NewDirectByteBuffer)
 758 |        (JNIEnv* env, void* address, jlong capacity);
 759 |     void* (JNICALL *GetDirectBufferAddress)
 760 |        (JNIEnv* env, jobject buf);
 761 |     jlong (JNICALL *GetDirectBufferCapacity)
 762 |        (JNIEnv* env, jobject buf);
 763 | 
 764 |     /* New JNI 1.6 Features */
 765 | 
 766 |     jobjectRefType (JNICALL *GetObjectRefType)
 767 |         (JNIEnv* env, jobject obj);
 768 | 
 769 |     /* Module Features */
 770 | 
 771 |     jobject (JNICALL *GetModule)
 772 |        (JNIEnv* env, jclass clazz);
 773 | 
 774 |     /* Virtual threads */
 775 | 
 776 |     jboolean (JNICALL *IsVirtualThread)
 777 |        (JNIEnv* env, jobject obj);
 778 | };
 779 | 
 780 | /*
 781 |  * We use inlined functions for C++ so that programmers can write:
 782 |  *
 783 |  *    env->FindClass("java/lang/String")
 784 |  *
 785 |  * in C++ rather than:
 786 |  *
 787 |  *    (*env)->FindClass(env, "java/lang/String")
 788 |  *
 789 |  * in C.
 790 |  */
 791 | 
 792 | struct JNIEnv_ {
 793 |     const struct JNINativeInterface_ *functions;
 794 | #ifdef __cplusplus
 795 | 
 796 |     jint GetVersion() {
 797 |         return functions->GetVersion(this);
 798 |     }
 799 |     jclass DefineClass(const char *name, jobject loader, const jbyte *buf,
 800 |                        jsize len) {
 801 |         return functions->DefineClass(this, name, loader, buf, len);
 802 |     }
 803 |     jclass FindClass(const char *name) {
 804 |         return functions->FindClass(this, name);
 805 |     }
 806 |     jmethodID FromReflectedMethod(jobject method) {
 807 |         return functions->FromReflectedMethod(this,method);
 808 |     }
 809 |     jfieldID FromReflectedField(jobject field) {
 810 |         return functions->FromReflectedField(this,field);
 811 |     }
 812 | 
 813 |     jobject ToReflectedMethod(jclass cls, jmethodID methodID, jboolean isStatic) {
 814 |         return functions->ToReflectedMethod(this, cls, methodID, isStatic);
 815 |     }
 816 | 
 817 |     jclass GetSuperclass(jclass sub) {
 818 |         return functions->GetSuperclass(this, sub);
 819 |     }
 820 |     jboolean IsAssignableFrom(jclass sub, jclass sup) {
 821 |         return functions->IsAssignableFrom(this, sub, sup);
 822 |     }
 823 | 
 824 |     jobject ToReflectedField(jclass cls, jfieldID fieldID, jboolean isStatic) {
 825 |         return functions->ToReflectedField(this,cls,fieldID,isStatic);
 826 |     }
 827 | 
 828 |     jint Throw(jthrowable obj) {
 829 |         return functions->Throw(this, obj);
 830 |     }
 831 |     jint ThrowNew(jclass clazz, const char *msg) {
 832 |         return functions->ThrowNew(this, clazz, msg);
 833 |     }
 834 |     jthrowable ExceptionOccurred() {
 835 |         return functions->ExceptionOccurred(this);
 836 |     }
 837 |     void ExceptionDescribe() {
 838 |         functions->ExceptionDescribe(this);
 839 |     }
 840 |     void ExceptionClear() {
 841 |         functions->ExceptionClear(this);
 842 |     }
 843 |     void FatalError(const char *msg) {
 844 |         functions->FatalError(this, msg);
 845 |     }
 846 | 
 847 |     jint PushLocalFrame(jint capacity) {
 848 |         return functions->PushLocalFrame(this,capacity);
 849 |     }
 850 |     jobject PopLocalFrame(jobject result) {
 851 |         return functions->PopLocalFrame(this,result);
 852 |     }
 853 | 
 854 |     jobject NewGlobalRef(jobject lobj) {
 855 |         return functions->NewGlobalRef(this,lobj);
 856 |     }
 857 |     void DeleteGlobalRef(jobject gref) {
 858 |         functions->DeleteGlobalRef(this,gref);
 859 |     }
 860 |     void DeleteLocalRef(jobject obj) {
 861 |         functions->DeleteLocalRef(this, obj);
 862 |     }
 863 | 
 864 |     jboolean IsSameObject(jobject obj1, jobject obj2) {
 865 |         return functions->IsSameObject(this,obj1,obj2);
 866 |     }
 867 | 
 868 |     jobject NewLocalRef(jobject ref) {
 869 |         return functions->NewLocalRef(this,ref);
 870 |     }
 871 |     jint EnsureLocalCapacity(jint capacity) {
 872 |         return functions->EnsureLocalCapacity(this,capacity);
 873 |     }
 874 | 
 875 |     jobject AllocObject(jclass clazz) {
 876 |         return functions->AllocObject(this,clazz);
 877 |     }
 878 |     jobject NewObject(jclass clazz, jmethodID methodID, ...) {
 879 |         va_list args;
 880 |         jobject result;
 881 |         va_start(args, methodID);
 882 |         result = functions->NewObjectV(this,clazz,methodID,args);
 883 |         va_end(args);
 884 |         return result;
 885 |     }
 886 |     jobject NewObjectV(jclass clazz, jmethodID methodID,
 887 |                        va_list args) {
 888 |         return functions->NewObjectV(this,clazz,methodID,args);
 889 |     }
 890 |     jobject NewObjectA(jclass clazz, jmethodID methodID,
 891 |                        const jvalue *args) {
 892 |         return functions->NewObjectA(this,clazz,methodID,args);
 893 |     }
 894 | 
 895 |     jclass GetObjectClass(jobject obj) {
 896 |         return functions->GetObjectClass(this,obj);
 897 |     }
 898 |     jboolean IsInstanceOf(jobject obj, jclass clazz) {
 899 |         return functions->IsInstanceOf(this,obj,clazz);
 900 |     }
 901 | 
 902 |     jmethodID GetMethodID(jclass clazz, const char *name,
 903 |                           const char *sig) {
 904 |         return functions->GetMethodID(this,clazz,name,sig);
 905 |     }
 906 | 
 907 |     jobject CallObjectMethod(jobject obj, jmethodID methodID, ...) {
 908 |         va_list args;
 909 |         jobject result;
 910 |         va_start(args,methodID);
 911 |         result = functions->CallObjectMethodV(this,obj,methodID,args);
 912 |         va_end(args);
 913 |         return result;
 914 |     }
 915 |     jobject CallObjectMethodV(jobject obj, jmethodID methodID,
 916 |                         va_list args) {
 917 |         return functions->CallObjectMethodV(this,obj,methodID,args);
 918 |     }
 919 |     jobject CallObjectMethodA(jobject obj, jmethodID methodID,
 920 |                         const jvalue * args) {
 921 |         return functions->CallObjectMethodA(this,obj,methodID,args);
 922 |     }
 923 | 
 924 |     jboolean CallBooleanMethod(jobject obj,
 925 |                                jmethodID methodID, ...) {
 926 |         va_list args;
 927 |         jboolean result;
 928 |         va_start(args,methodID);
 929 |         result = functions->CallBooleanMethodV(this,obj,methodID,args);
 930 |         va_end(args);
 931 |         return result;
 932 |     }
 933 |     jboolean CallBooleanMethodV(jobject obj, jmethodID methodID,
 934 |                                 va_list args) {
 935 |         return functions->CallBooleanMethodV(this,obj,methodID,args);
 936 |     }
 937 |     jboolean CallBooleanMethodA(jobject obj, jmethodID methodID,
 938 |                                 const jvalue * args) {
 939 |         return functions->CallBooleanMethodA(this,obj,methodID, args);
 940 |     }
 941 | 
 942 |     jbyte CallByteMethod(jobject obj, jmethodID methodID, ...) {
 943 |         va_list args;
 944 |         jbyte result;
 945 |         va_start(args,methodID);
 946 |         result = functions->CallByteMethodV(this,obj,methodID,args);
 947 |         va_end(args);
 948 |         return result;
 949 |     }
 950 |     jbyte CallByteMethodV(jobject obj, jmethodID methodID,
 951 |                           va_list args) {
 952 |         return functions->CallByteMethodV(this,obj,methodID,args);
 953 |     }
 954 |     jbyte CallByteMethodA(jobject obj, jmethodID methodID,
 955 |                           const jvalue * args) {
 956 |         return functions->CallByteMethodA(this,obj,methodID,args);
 957 |     }
 958 | 
 959 |     jchar CallCharMethod(jobject obj, jmethodID methodID, ...) {
 960 |         va_list args;
 961 |         jchar result;
 962 |         va_start(args,methodID);
 963 |         result = functions->CallCharMethodV(this,obj,methodID,args);
 964 |         va_end(args);
 965 |         return result;
 966 |     }
 967 |     jchar CallCharMethodV(jobject obj, jmethodID methodID,
 968 |                           va_list args) {
 969 |         return functions->CallCharMethodV(this,obj,methodID,args);
 970 |     }
 971 |     jchar CallCharMethodA(jobject obj, jmethodID methodID,
 972 |                           const jvalue * args) {
 973 |         return functions->CallCharMethodA(this,obj,methodID,args);
 974 |     }
 975 | 
 976 |     jshort CallShortMethod(jobject obj, jmethodID methodID, ...) {
 977 |         va_list args;
 978 |         jshort result;
 979 |         va_start(args,methodID);
 980 |         result = functions->CallShortMethodV(this,obj,methodID,args);
 981 |         va_end(args);
 982 |         return result;
 983 |     }
 984 |     jshort CallShortMethodV(jobject obj, jmethodID methodID,
 985 |                             va_list args) {
 986 |         return functions->CallShortMethodV(this,obj,methodID,args);
 987 |     }
 988 |     jshort CallShortMethodA(jobject obj, jmethodID methodID,
 989 |                             const jvalue * args) {
 990 |         return functions->CallShortMethodA(this,obj,methodID,args);
 991 |     }
 992 | 
 993 |     jint CallIntMethod(jobject obj, jmethodID methodID, ...) {
 994 |         va_list args;
 995 |         jint result;
 996 |         va_start(args,methodID);
 997 |         result = functions->CallIntMethodV(this,obj,methodID,args);
 998 |         va_end(args);
 999 |         return result;
1000 |     }
1001 |     jint CallIntMethodV(jobject obj, jmethodID methodID,
1002 |                         va_list args) {
1003 |         return functions->CallIntMethodV(this,obj,methodID,args);
1004 |     }
1005 |     jint CallIntMethodA(jobject obj, jmethodID methodID,
1006 |                         const jvalue * args) {
1007 |         return functions->CallIntMethodA(this,obj,methodID,args);
1008 |     }
1009 | 
1010 |     jlong CallLongMethod(jobject obj, jmethodID methodID, ...) {
1011 |         va_list args;
1012 |         jlong result;
1013 |         va_start(args,methodID);
1014 |         result = functions->CallLongMethodV(this,obj,methodID,args);
1015 |         va_end(args);
1016 |         return result;
1017 |     }
1018 |     jlong CallLongMethodV(jobject obj, jmethodID methodID,
1019 |                           va_list args) {
1020 |         return functions->CallLongMethodV(this,obj,methodID,args);
1021 |     }
1022 |     jlong CallLongMethodA(jobject obj, jmethodID methodID,
1023 |                           const jvalue * args) {
1024 |         return functions->CallLongMethodA(this,obj,methodID,args);
1025 |     }
1026 | 
1027 |     jfloat CallFloatMethod(jobject obj, jmethodID methodID, ...) {
1028 |         va_list args;
1029 |         jfloat result;
1030 |         va_start(args,methodID);
1031 |         result = functions->CallFloatMethodV(this,obj,methodID,args);
1032 |         va_end(args);
1033 |         return result;
1034 |     }
1035 |     jfloat CallFloatMethodV(jobject obj, jmethodID methodID,
1036 |                             va_list args) {
1037 |         return functions->CallFloatMethodV(this,obj,methodID,args);
1038 |     }
1039 |     jfloat CallFloatMethodA(jobject obj, jmethodID methodID,
1040 |                             const jvalue * args) {
1041 |         return functions->CallFloatMethodA(this,obj,methodID,args);
1042 |     }
1043 | 
1044 |     jdouble CallDoubleMethod(jobject obj, jmethodID methodID, ...) {
1045 |         va_list args;
1046 |         jdouble result;
1047 |         va_start(args,methodID);
1048 |         result = functions->CallDoubleMethodV(this,obj,methodID,args);
1049 |         va_end(args);
1050 |         return result;
1051 |     }
1052 |     jdouble CallDoubleMethodV(jobject obj, jmethodID methodID,
1053 |                         va_list args) {
1054 |         return functions->CallDoubleMethodV(this,obj,methodID,args);
1055 |     }
1056 |     jdouble CallDoubleMethodA(jobject obj, jmethodID methodID,
1057 |                         const jvalue * args) {
1058 |         return functions->CallDoubleMethodA(this,obj,methodID,args);
1059 |     }
1060 | 
1061 |     void CallVoidMethod(jobject obj, jmethodID methodID, ...) {
1062 |         va_list args;
1063 |         va_start(args,methodID);
1064 |         functions->CallVoidMethodV(this,obj,methodID,args);
1065 |         va_end(args);
1066 |     }
1067 |     void CallVoidMethodV(jobject obj, jmethodID methodID,
1068 |                          va_list args) {
1069 |         functions->CallVoidMethodV(this,obj,methodID,args);
1070 |     }
1071 |     void CallVoidMethodA(jobject obj, jmethodID methodID,
1072 |                          const jvalue * args) {
1073 |         functions->CallVoidMethodA(this,obj,methodID,args);
1074 |     }
1075 | 
1076 |     jobject CallNonvirtualObjectMethod(jobject obj, jclass clazz,
1077 |                                        jmethodID methodID, ...) {
1078 |         va_list args;
1079 |         jobject result;
1080 |         va_start(args,methodID);
1081 |         result = functions->CallNonvirtualObjectMethodV(this,obj,clazz,
1082 |                                                         methodID,args);
1083 |         va_end(args);
1084 |         return result;
1085 |     }
1086 |     jobject CallNonvirtualObjectMethodV(jobject obj, jclass clazz,
1087 |                                         jmethodID methodID, va_list args) {
1088 |         return functions->CallNonvirtualObjectMethodV(this,obj,clazz,
1089 |                                                       methodID,args);
1090 |     }
1091 |     jobject CallNonvirtualObjectMethodA(jobject obj, jclass clazz,
1092 |                                         jmethodID methodID, const jvalue * args) {
1093 |         return functions->CallNonvirtualObjectMethodA(this,obj,clazz,
1094 |                                                       methodID,args);
1095 |     }
1096 | 
1097 |     jboolean CallNonvirtualBooleanMethod(jobject obj, jclass clazz,
1098 |                                          jmethodID methodID, ...) {
1099 |         va_list args;
1100 |         jboolean result;
1101 |         va_start(args,methodID);
1102 |         result = functions->CallNonvirtualBooleanMethodV(this,obj,clazz,
1103 |                                                          methodID,args);
1104 |         va_end(args);
1105 |         return result;
1106 |     }
1107 |     jboolean CallNonvirtualBooleanMethodV(jobject obj, jclass clazz,
1108 |                                           jmethodID methodID, va_list args) {
1109 |         return functions->CallNonvirtualBooleanMethodV(this,obj,clazz,
1110 |                                                        methodID,args);
1111 |     }
1112 |     jboolean CallNonvirtualBooleanMethodA(jobject obj, jclass clazz,
1113 |                                           jmethodID methodID, const jvalue * args) {
1114 |         return functions->CallNonvirtualBooleanMethodA(this,obj,clazz,
1115 |                                                        methodID, args);
1116 |     }
1117 | 
1118 |     jbyte CallNonvirtualByteMethod(jobject obj, jclass clazz,
1119 |                                    jmethodID methodID, ...) {
1120 |         va_list args;
1121 |         jbyte result;
1122 |         va_start(args,methodID);
1123 |         result = functions->CallNonvirtualByteMethodV(this,obj,clazz,
1124 |                                                       methodID,args);
1125 |         va_end(args);
1126 |         return result;
1127 |     }
1128 |     jbyte CallNonvirtualByteMethodV(jobject obj, jclass clazz,
1129 |                                     jmethodID methodID, va_list args) {
1130 |         return functions->CallNonvirtualByteMethodV(this,obj,clazz,
1131 |                                                     methodID,args);
1132 |     }
1133 |     jbyte CallNonvirtualByteMethodA(jobject obj, jclass clazz,
1134 |                                     jmethodID methodID, const jvalue * args) {
1135 |         return functions->CallNonvirtualByteMethodA(this,obj,clazz,
1136 |                                                     methodID,args);
1137 |     }
1138 | 
1139 |     jchar CallNonvirtualCharMethod(jobject obj, jclass clazz,
1140 |                                    jmethodID methodID, ...) {
1141 |         va_list args;
1142 |         jchar result;
1143 |         va_start(args,methodID);
1144 |         result = functions->CallNonvirtualCharMethodV(this,obj,clazz,
1145 |                                                       methodID,args);
1146 |         va_end(args);
1147 |         return result;
1148 |     }
1149 |     jchar CallNonvirtualCharMethodV(jobject obj, jclass clazz,
1150 |                                     jmethodID methodID, va_list args) {
1151 |         return functions->CallNonvirtualCharMethodV(this,obj,clazz,
1152 |                                                     methodID,args);
1153 |     }
1154 |     jchar CallNonvirtualCharMethodA(jobject obj, jclass clazz,
1155 |                                     jmethodID methodID, const jvalue * args) {
1156 |         return functions->CallNonvirtualCharMethodA(this,obj,clazz,
1157 |                                                     methodID,args);
1158 |     }
1159 | 
1160 |     jshort CallNonvirtualShortMethod(jobject obj, jclass clazz,
1161 |                                      jmethodID methodID, ...) {
1162 |         va_list args;
1163 |         jshort result;
1164 |         va_start(args,methodID);
1165 |         result = functions->CallNonvirtualShortMethodV(this,obj,clazz,
1166 |                                                        methodID,args);
1167 |         va_end(args);
1168 |         return result;
1169 |     }
1170 |     jshort CallNonvirtualShortMethodV(jobject obj, jclass clazz,
1171 |                                       jmethodID methodID, va_list args) {
1172 |         return functions->CallNonvirtualShortMethodV(this,obj,clazz,
1173 |                                                      methodID,args);
1174 |     }
1175 |     jshort CallNonvirtualShortMethodA(jobject obj, jclass clazz,
1176 |                                       jmethodID methodID, const jvalue * args) {
1177 |         return functions->CallNonvirtualShortMethodA(this,obj,clazz,
1178 |                                                      methodID,args);
1179 |     }
1180 | 
1181 |     jint CallNonvirtualIntMethod(jobject obj, jclass clazz,
1182 |                                  jmethodID methodID, ...) {
1183 |         va_list args;
1184 |         jint result;
1185 |         va_start(args,methodID);
1186 |         result = functions->CallNonvirtualIntMethodV(this,obj,clazz,
1187 |                                                      methodID,args);
1188 |         va_end(args);
1189 |         return result;
1190 |     }
1191 |     jint CallNonvirtualIntMethodV(jobject obj, jclass clazz,
1192 |                                   jmethodID methodID, va_list args) {
1193 |         return functions->CallNonvirtualIntMethodV(this,obj,clazz,
1194 |                                                    methodID,args);
1195 |     }
1196 |     jint CallNonvirtualIntMethodA(jobject obj, jclass clazz,
1197 |                                   jmethodID methodID, const jvalue * args) {
1198 |         return functions->CallNonvirtualIntMethodA(this,obj,clazz,
1199 |                                                    methodID,args);
1200 |     }
1201 | 
1202 |     jlong CallNonvirtualLongMethod(jobject obj, jclass clazz,
1203 |                                    jmethodID methodID, ...) {
1204 |         va_list args;
1205 |         jlong result;
1206 |         va_start(args,methodID);
1207 |         result = functions->CallNonvirtualLongMethodV(this,obj,clazz,
1208 |                                                       methodID,args);
1209 |         va_end(args);
1210 |         return result;
1211 |     }
1212 |     jlong CallNonvirtualLongMethodV(jobject obj, jclass clazz,
1213 |                                     jmethodID methodID, va_list args) {
1214 |         return functions->CallNonvirtualLongMethodV(this,obj,clazz,
1215 |                                                     methodID,args);
1216 |     }
1217 |     jlong CallNonvirtualLongMethodA(jobject obj, jclass clazz,
1218 |                                     jmethodID methodID, const jvalue * args) {
1219 |         return functions->CallNonvirtualLongMethodA(this,obj,clazz,
1220 |                                                     methodID,args);
1221 |     }
1222 | 
1223 |     jfloat CallNonvirtualFloatMethod(jobject obj, jclass clazz,
1224 |                                      jmethodID methodID, ...) {
1225 |         va_list args;
1226 |         jfloat result;
1227 |         va_start(args,methodID);
1228 |         result = functions->CallNonvirtualFloatMethodV(this,obj,clazz,
1229 |                                                        methodID,args);
1230 |         va_end(args);
1231 |         return result;
1232 |     }
1233 |     jfloat CallNonvirtualFloatMethodV(jobject obj, jclass clazz,
1234 |                                       jmethodID methodID,
1235 |                                       va_list args) {
1236 |         return functions->CallNonvirtualFloatMethodV(this,obj,clazz,
1237 |                                                      methodID,args);
1238 |     }
1239 |     jfloat CallNonvirtualFloatMethodA(jobject obj, jclass clazz,
1240 |                                       jmethodID methodID,
1241 |                                       const jvalue * args) {
1242 |         return functions->CallNonvirtualFloatMethodA(this,obj,clazz,
1243 |                                                      methodID,args);
1244 |     }
1245 | 
1246 |     jdouble CallNonvirtualDoubleMethod(jobject obj, jclass clazz,
1247 |                                        jmethodID methodID, ...) {
1248 |         va_list args;
1249 |         jdouble result;
1250 |         va_start(args,methodID);
1251 |         result = functions->CallNonvirtualDoubleMethodV(this,obj,clazz,
1252 |                                                         methodID,args);
1253 |         va_end(args);
1254 |         return result;
1255 |     }
1256 |     jdouble CallNonvirtualDoubleMethodV(jobject obj, jclass clazz,
1257 |                                         jmethodID methodID,
1258 |                                         va_list args) {
1259 |         return functions->CallNonvirtualDoubleMethodV(this,obj,clazz,
1260 |                                                       methodID,args);
1261 |     }
1262 |     jdouble CallNonvirtualDoubleMethodA(jobject obj, jclass clazz,
1263 |                                         jmethodID methodID,
1264 |                                         const jvalue * args) {
1265 |         return functions->CallNonvirtualDoubleMethodA(this,obj,clazz,
1266 |                                                       methodID,args);
1267 |     }
1268 | 
1269 |     void CallNonvirtualVoidMethod(jobject obj, jclass clazz,
1270 |                                   jmethodID methodID, ...) {
1271 |         va_list args;
1272 |         va_start(args,methodID);
1273 |         functions->CallNonvirtualVoidMethodV(this,obj,clazz,methodID,args);
1274 |         va_end(args);
1275 |     }
1276 |     void CallNonvirtualVoidMethodV(jobject obj, jclass clazz,
1277 |                                    jmethodID methodID,
1278 |                                    va_list args) {
1279 |         functions->CallNonvirtualVoidMethodV(this,obj,clazz,methodID,args);
1280 |     }
1281 |     void CallNonvirtualVoidMethodA(jobject obj, jclass clazz,
1282 |                                    jmethodID methodID,
1283 |                                    const jvalue * args) {
1284 |         functions->CallNonvirtualVoidMethodA(this,obj,clazz,methodID,args);
1285 |     }
1286 | 
1287 |     jfieldID GetFieldID(jclass clazz, const char *name,
1288 |                         const char *sig) {
1289 |         return functions->GetFieldID(this,clazz,name,sig);
1290 |     }
1291 | 
1292 |     jobject GetObjectField(jobject obj, jfieldID fieldID) {
1293 |         return functions->GetObjectField(this,obj,fieldID);
1294 |     }
1295 |     jboolean GetBooleanField(jobject obj, jfieldID fieldID) {
1296 |         return functions->GetBooleanField(this,obj,fieldID);
1297 |     }
1298 |     jbyte GetByteField(jobject obj, jfieldID fieldID) {
1299 |         return functions->GetByteField(this,obj,fieldID);
1300 |     }
1301 |     jchar GetCharField(jobject obj, jfieldID fieldID) {
1302 |         return functions->GetCharField(this,obj,fieldID);
1303 |     }
1304 |     jshort GetShortField(jobject obj, jfieldID fieldID) {
1305 |         return functions->GetShortField(this,obj,fieldID);
1306 |     }
1307 |     jint GetIntField(jobject obj, jfieldID fieldID) {
1308 |         return functions->GetIntField(this,obj,fieldID);
1309 |     }
1310 |     jlong GetLongField(jobject obj, jfieldID fieldID) {
1311 |         return functions->GetLongField(this,obj,fieldID);
1312 |     }
1313 |     jfloat GetFloatField(jobject obj, jfieldID fieldID) {
1314 |         return functions->GetFloatField(this,obj,fieldID);
1315 |     }
1316 |     jdouble GetDoubleField(jobject obj, jfieldID fieldID) {
1317 |         return functions->GetDoubleField(this,obj,fieldID);
1318 |     }
1319 | 
1320 |     void SetObjectField(jobject obj, jfieldID fieldID, jobject val) {
1321 |         functions->SetObjectField(this,obj,fieldID,val);
1322 |     }
1323 |     void SetBooleanField(jobject obj, jfieldID fieldID,
1324 |                          jboolean val) {
1325 |         functions->SetBooleanField(this,obj,fieldID,val);
1326 |     }
1327 |     void SetByteField(jobject obj, jfieldID fieldID,
1328 |                       jbyte val) {
1329 |         functions->SetByteField(this,obj,fieldID,val);
1330 |     }
1331 |     void SetCharField(jobject obj, jfieldID fieldID,
1332 |                       jchar val) {
1333 |         functions->SetCharField(this,obj,fieldID,val);
1334 |     }
1335 |     void SetShortField(jobject obj, jfieldID fieldID,
1336 |                        jshort val) {
1337 |         functions->SetShortField(this,obj,fieldID,val);
1338 |     }
1339 |     void SetIntField(jobject obj, jfieldID fieldID,
1340 |                      jint val) {
1341 |         functions->SetIntField(this,obj,fieldID,val);
1342 |     }
1343 |     void SetLongField(jobject obj, jfieldID fieldID,
1344 |                       jlong val) {
1345 |         functions->SetLongField(this,obj,fieldID,val);
1346 |     }
1347 |     void SetFloatField(jobject obj, jfieldID fieldID,
1348 |                        jfloat val) {
1349 |         functions->SetFloatField(this,obj,fieldID,val);
1350 |     }
1351 |     void SetDoubleField(jobject obj, jfieldID fieldID,
1352 |                         jdouble val) {
1353 |         functions->SetDoubleField(this,obj,fieldID,val);
1354 |     }
1355 | 
1356 |     jmethodID GetStaticMethodID(jclass clazz, const char *name,
1357 |                                 const char *sig) {
1358 |         return functions->GetStaticMethodID(this,clazz,name,sig);
1359 |     }
1360 | 
1361 |     jobject CallStaticObjectMethod(jclass clazz, jmethodID methodID,
1362 |                              ...) {
1363 |         va_list args;
1364 |         jobject result;
1365 |         va_start(args,methodID);
1366 |         result = functions->CallStaticObjectMethodV(this,clazz,methodID,args);
1367 |         va_end(args);
1368 |         return result;
1369 |     }
1370 |     jobject CallStaticObjectMethodV(jclass clazz, jmethodID methodID,
1371 |                               va_list args) {
1372 |         return functions->CallStaticObjectMethodV(this,clazz,methodID,args);
1373 |     }
1374 |     jobject CallStaticObjectMethodA(jclass clazz, jmethodID methodID,
1375 |                               const jvalue *args) {
1376 |         return functions->CallStaticObjectMethodA(this,clazz,methodID,args);
1377 |     }
1378 | 
1379 |     jboolean CallStaticBooleanMethod(jclass clazz,
1380 |                                      jmethodID methodID, ...) {
1381 |         va_list args;
1382 |         jboolean result;
1383 |         va_start(args,methodID);
1384 |         result = functions->CallStaticBooleanMethodV(this,clazz,methodID,args);
1385 |         va_end(args);
1386 |         return result;
1387 |     }
1388 |     jboolean CallStaticBooleanMethodV(jclass clazz,
1389 |                                       jmethodID methodID, va_list args) {
1390 |         return functions->CallStaticBooleanMethodV(this,clazz,methodID,args);
1391 |     }
1392 |     jboolean CallStaticBooleanMethodA(jclass clazz,
1393 |                                       jmethodID methodID, const jvalue *args) {
1394 |         return functions->CallStaticBooleanMethodA(this,clazz,methodID,args);
1395 |     }
1396 | 
1397 |     jbyte CallStaticByteMethod(jclass clazz,
1398 |                                jmethodID methodID, ...) {
1399 |         va_list args;
1400 |         jbyte result;
1401 |         va_start(args,methodID);
1402 |         result = functions->CallStaticByteMethodV(this,clazz,methodID,args);
1403 |         va_end(args);
1404 |         return result;
1405 |     }
1406 |     jbyte CallStaticByteMethodV(jclass clazz,
1407 |                                 jmethodID methodID, va_list args) {
1408 |         return functions->CallStaticByteMethodV(this,clazz,methodID,args);
1409 |     }
1410 |     jbyte CallStaticByteMethodA(jclass clazz,
1411 |                                 jmethodID methodID, const jvalue *args) {
1412 |         return functions->CallStaticByteMethodA(this,clazz,methodID,args);
1413 |     }
1414 | 
1415 |     jchar CallStaticCharMethod(jclass clazz,
1416 |                                jmethodID methodID, ...) {
1417 |         va_list args;
1418 |         jchar result;
1419 |         va_start(args,methodID);
1420 |         result = functions->CallStaticCharMethodV(this,clazz,methodID,args);
1421 |         va_end(args);
1422 |         return result;
1423 |     }
1424 |     jchar CallStaticCharMethodV(jclass clazz,
1425 |                                 jmethodID methodID, va_list args) {
1426 |         return functions->CallStaticCharMethodV(this,clazz,methodID,args);
1427 |     }
1428 |     jchar CallStaticCharMethodA(jclass clazz,
1429 |                                 jmethodID methodID, const jvalue *args) {
1430 |         return functions->CallStaticCharMethodA(this,clazz,methodID,args);
1431 |     }
1432 | 
1433 |     jshort CallStaticShortMethod(jclass clazz,
1434 |                                  jmethodID methodID, ...) {
1435 |         va_list args;
1436 |         jshort result;
1437 |         va_start(args,methodID);
1438 |         result = functions->CallStaticShortMethodV(this,clazz,methodID,args);
1439 |         va_end(args);
1440 |         return result;
1441 |     }
1442 |     jshort CallStaticShortMethodV(jclass clazz,
1443 |                                   jmethodID methodID, va_list args) {
1444 |         return functions->CallStaticShortMethodV(this,clazz,methodID,args);
1445 |     }
1446 |     jshort CallStaticShortMethodA(jclass clazz,
1447 |                                   jmethodID methodID, const jvalue *args) {
1448 |         return functions->CallStaticShortMethodA(this,clazz,methodID,args);
1449 |     }
1450 | 
1451 |     jint CallStaticIntMethod(jclass clazz,
1452 |                              jmethodID methodID, ...) {
1453 |         va_list args;
1454 |         jint result;
1455 |         va_start(args,methodID);
1456 |         result = functions->CallStaticIntMethodV(this,clazz,methodID,args);
1457 |         va_end(args);
1458 |         return result;
1459 |     }
1460 |     jint CallStaticIntMethodV(jclass clazz,
1461 |                               jmethodID methodID, va_list args) {
1462 |         return functions->CallStaticIntMethodV(this,clazz,methodID,args);
1463 |     }
1464 |     jint CallStaticIntMethodA(jclass clazz,
1465 |                               jmethodID methodID, const jvalue *args) {
1466 |         return functions->CallStaticIntMethodA(this,clazz,methodID,args);
1467 |     }
1468 | 
1469 |     jlong CallStaticLongMethod(jclass clazz,
1470 |                                jmethodID methodID, ...) {
1471 |         va_list args;
1472 |         jlong result;
1473 |         va_start(args,methodID);
1474 |         result = functions->CallStaticLongMethodV(this,clazz,methodID,args);
1475 |         va_end(args);
1476 |         return result;
1477 |     }
1478 |     jlong CallStaticLongMethodV(jclass clazz,
1479 |                                 jmethodID methodID, va_list args) {
1480 |         return functions->CallStaticLongMethodV(this,clazz,methodID,args);
1481 |     }
1482 |     jlong CallStaticLongMethodA(jclass clazz,
1483 |                                 jmethodID methodID, const jvalue *args) {
1484 |         return functions->CallStaticLongMethodA(this,clazz,methodID,args);
1485 |     }
1486 | 
1487 |     jfloat CallStaticFloatMethod(jclass clazz,
1488 |                                  jmethodID methodID, ...) {
1489 |         va_list args;
1490 |         jfloat result;
1491 |         va_start(args,methodID);
1492 |         result = functions->CallStaticFloatMethodV(this,clazz,methodID,args);
1493 |         va_end(args);
1494 |         return result;
1495 |     }
1496 |     jfloat CallStaticFloatMethodV(jclass clazz,
1497 |                                   jmethodID methodID, va_list args) {
1498 |         return functions->CallStaticFloatMethodV(this,clazz,methodID,args);
1499 |     }
1500 |     jfloat CallStaticFloatMethodA(jclass clazz,
1501 |                                   jmethodID methodID, const jvalue *args) {
1502 |         return functions->CallStaticFloatMethodA(this,clazz,methodID,args);
1503 |     }
1504 | 
1505 |     jdouble CallStaticDoubleMethod(jclass clazz,
1506 |                                    jmethodID methodID, ...) {
1507 |         va_list args;
1508 |         jdouble result;
1509 |         va_start(args,methodID);
1510 |         result = functions->CallStaticDoubleMethodV(this,clazz,methodID,args);
1511 |         va_end(args);
1512 |         return result;
1513 |     }
1514 |     jdouble CallStaticDoubleMethodV(jclass clazz,
1515 |                                     jmethodID methodID, va_list args) {
1516 |         return functions->CallStaticDoubleMethodV(this,clazz,methodID,args);
1517 |     }
1518 |     jdouble CallStaticDoubleMethodA(jclass clazz,
1519 |                                     jmethodID methodID, const jvalue *args) {
1520 |         return functions->CallStaticDoubleMethodA(this,clazz,methodID,args);
1521 |     }
1522 | 
1523 |     void CallStaticVoidMethod(jclass cls, jmethodID methodID, ...) {
1524 |         va_list args;
1525 |         va_start(args,methodID);
1526 |         functions->CallStaticVoidMethodV(this,cls,methodID,args);
1527 |         va_end(args);
1528 |     }
1529 |     void CallStaticVoidMethodV(jclass cls, jmethodID methodID,
1530 |                                va_list args) {
1531 |         functions->CallStaticVoidMethodV(this,cls,methodID,args);
1532 |     }
1533 |     void CallStaticVoidMethodA(jclass cls, jmethodID methodID,
1534 |                                const jvalue * args) {
1535 |         functions->CallStaticVoidMethodA(this,cls,methodID,args);
1536 |     }
1537 | 
1538 |     jfieldID GetStaticFieldID(jclass clazz, const char *name,
1539 |                               const char *sig) {
1540 |         return functions->GetStaticFieldID(this,clazz,name,sig);
1541 |     }
1542 |     jobject GetStaticObjectField(jclass clazz, jfieldID fieldID) {
1543 |         return functions->GetStaticObjectField(this,clazz,fieldID);
1544 |     }
1545 |     jboolean GetStaticBooleanField(jclass clazz, jfieldID fieldID) {
1546 |         return functions->GetStaticBooleanField(this,clazz,fieldID);
1547 |     }
1548 |     jbyte GetStaticByteField(jclass clazz, jfieldID fieldID) {
1549 |         return functions->GetStaticByteField(this,clazz,fieldID);
1550 |     }
1551 |     jchar GetStaticCharField(jclass clazz, jfieldID fieldID) {
1552 |         return functions->GetStaticCharField(this,clazz,fieldID);
1553 |     }
1554 |     jshort GetStaticShortField(jclass clazz, jfieldID fieldID) {
1555 |         return functions->GetStaticShortField(this,clazz,fieldID);
1556 |     }
1557 |     jint GetStaticIntField(jclass clazz, jfieldID fieldID) {
1558 |         return functions->GetStaticIntField(this,clazz,fieldID);
1559 |     }
1560 |     jlong GetStaticLongField(jclass clazz, jfieldID fieldID) {
1561 |         return functions->GetStaticLongField(this,clazz,fieldID);
1562 |     }
1563 |     jfloat GetStaticFloatField(jclass clazz, jfieldID fieldID) {
1564 |         return functions->GetStaticFloatField(this,clazz,fieldID);
1565 |     }
1566 |     jdouble GetStaticDoubleField(jclass clazz, jfieldID fieldID) {
1567 |         return functions->GetStaticDoubleField(this,clazz,fieldID);
1568 |     }
1569 | 
1570 |     void SetStaticObjectField(jclass clazz, jfieldID fieldID,
1571 |                         jobject value) {
1572 |       functions->SetStaticObjectField(this,clazz,fieldID,value);
1573 |     }
1574 |     void SetStaticBooleanField(jclass clazz, jfieldID fieldID,
1575 |                         jboolean value) {
1576 |       functions->SetStaticBooleanField(this,clazz,fieldID,value);
1577 |     }
1578 |     void SetStaticByteField(jclass clazz, jfieldID fieldID,
1579 |                         jbyte value) {
1580 |       functions->SetStaticByteField(this,clazz,fieldID,value);
1581 |     }
1582 |     void SetStaticCharField(jclass clazz, jfieldID fieldID,
1583 |                         jchar value) {
1584 |       functions->SetStaticCharField(this,clazz,fieldID,value);
1585 |     }
1586 |     void SetStaticShortField(jclass clazz, jfieldID fieldID,
1587 |                         jshort value) {
1588 |       functions->SetStaticShortField(this,clazz,fieldID,value);
1589 |     }
1590 |     void SetStaticIntField(jclass clazz, jfieldID fieldID,
1591 |                         jint value) {
1592 |       functions->SetStaticIntField(this,clazz,fieldID,value);
1593 |     }
1594 |     void SetStaticLongField(jclass clazz, jfieldID fieldID,
1595 |                         jlong value) {
1596 |       functions->SetStaticLongField(this,clazz,fieldID,value);
1597 |     }
1598 |     void SetStaticFloatField(jclass clazz, jfieldID fieldID,
1599 |                         jfloat value) {
1600 |       functions->SetStaticFloatField(this,clazz,fieldID,value);
1601 |     }
1602 |     void SetStaticDoubleField(jclass clazz, jfieldID fieldID,
1603 |                         jdouble value) {
1604 |       functions->SetStaticDoubleField(this,clazz,fieldID,value);
1605 |     }
1606 | 
1607 |     jstring NewString(const jchar *unicode, jsize len) {
1608 |         return functions->NewString(this,unicode,len);
1609 |     }
1610 |     jsize GetStringLength(jstring str) {
1611 |         return functions->GetStringLength(this,str);
1612 |     }
1613 |     const jchar *GetStringChars(jstring str, jboolean *isCopy) {
1614 |         return functions->GetStringChars(this,str,isCopy);
1615 |     }
1616 |     void ReleaseStringChars(jstring str, const jchar *chars) {
1617 |         functions->ReleaseStringChars(this,str,chars);
1618 |     }
1619 | 
1620 |     jstring NewStringUTF(const char *utf) {
1621 |         return functions->NewStringUTF(this,utf);
1622 |     }
1623 |     jsize GetStringUTFLength(jstring str) {
1624 |         return functions->GetStringUTFLength(this,str);
1625 |     }
1626 |     const char* GetStringUTFChars(jstring str, jboolean *isCopy) {
1627 |         return functions->GetStringUTFChars(this,str,isCopy);
1628 |     }
1629 |     void ReleaseStringUTFChars(jstring str, const char* chars) {
1630 |         functions->ReleaseStringUTFChars(this,str,chars);
1631 |     }
1632 | 
1633 |     jsize GetArrayLength(jarray array) {
1634 |         return functions->GetArrayLength(this,array);
1635 |     }
1636 | 
1637 |     jobjectArray NewObjectArray(jsize len, jclass clazz,
1638 |                                 jobject init) {
1639 |         return functions->NewObjectArray(this,len,clazz,init);
1640 |     }
1641 |     jobject GetObjectArrayElement(jobjectArray array, jsize index) {
1642 |         return functions->GetObjectArrayElement(this,array,index);
1643 |     }
1644 |     void SetObjectArrayElement(jobjectArray array, jsize index,
1645 |                                jobject val) {
1646 |         functions->SetObjectArrayElement(this,array,index,val);
1647 |     }
1648 | 
1649 |     jbooleanArray NewBooleanArray(jsize len) {
1650 |         return functions->NewBooleanArray(this,len);
1651 |     }
1652 |     jbyteArray NewByteArray(jsize len) {
1653 |         return functions->NewByteArray(this,len);
1654 |     }
1655 |     jcharArray NewCharArray(jsize len) {
1656 |         return functions->NewCharArray(this,len);
1657 |     }
1658 |     jshortArray NewShortArray(jsize len) {
1659 |         return functions->NewShortArray(this,len);
1660 |     }
1661 |     jintArray NewIntArray(jsize len) {
1662 |         return functions->NewIntArray(this,len);
1663 |     }
1664 |     jlongArray NewLongArray(jsize len) {
1665 |         return functions->NewLongArray(this,len);
1666 |     }
1667 |     jfloatArray NewFloatArray(jsize len) {
1668 |         return functions->NewFloatArray(this,len);
1669 |     }
1670 |     jdoubleArray NewDoubleArray(jsize len) {
1671 |         return functions->NewDoubleArray(this,len);
1672 |     }
1673 | 
1674 |     jboolean * GetBooleanArrayElements(jbooleanArray array, jboolean *isCopy) {
1675 |         return functions->GetBooleanArrayElements(this,array,isCopy);
1676 |     }
1677 |     jbyte * GetByteArrayElements(jbyteArray array, jboolean *isCopy) {
1678 |         return functions->GetByteArrayElements(this,array,isCopy);
1679 |     }
1680 |     jchar * GetCharArrayElements(jcharArray array, jboolean *isCopy) {
1681 |         return functions->GetCharArrayElements(this,array,isCopy);
1682 |     }
1683 |     jshort * GetShortArrayElements(jshortArray array, jboolean *isCopy) {
1684 |         return functions->GetShortArrayElements(this,array,isCopy);
1685 |     }
1686 |     jint * GetIntArrayElements(jintArray array, jboolean *isCopy) {
1687 |         return functions->GetIntArrayElements(this,array,isCopy);
1688 |     }
1689 |     jlong * GetLongArrayElements(jlongArray array, jboolean *isCopy) {
1690 |         return functions->GetLongArrayElements(this,array,isCopy);
1691 |     }
1692 |     jfloat * GetFloatArrayElements(jfloatArray array, jboolean *isCopy) {
1693 |         return functions->GetFloatArrayElements(this,array,isCopy);
1694 |     }
1695 |     jdouble * GetDoubleArrayElements(jdoubleArray array, jboolean *isCopy) {
1696 |         return functions->GetDoubleArrayElements(this,array,isCopy);
1697 |     }
1698 | 
1699 |     void ReleaseBooleanArrayElements(jbooleanArray array,
1700 |                                      jboolean *elems,
1701 |                                      jint mode) {
1702 |         functions->ReleaseBooleanArrayElements(this,array,elems,mode);
1703 |     }
1704 |     void ReleaseByteArrayElements(jbyteArray array,
1705 |                                   jbyte *elems,
1706 |                                   jint mode) {
1707 |         functions->ReleaseByteArrayElements(this,array,elems,mode);
1708 |     }
1709 |     void ReleaseCharArrayElements(jcharArray array,
1710 |                                   jchar *elems,
1711 |                                   jint mode) {
1712 |         functions->ReleaseCharArrayElements(this,array,elems,mode);
1713 |     }
1714 |     void ReleaseShortArrayElements(jshortArray array,
1715 |                                    jshort *elems,
1716 |                                    jint mode) {
1717 |         functions->ReleaseShortArrayElements(this,array,elems,mode);
1718 |     }
1719 |     void ReleaseIntArrayElements(jintArray array,
1720 |                                  jint *elems,
1721 |                                  jint mode) {
1722 |         functions->ReleaseIntArrayElements(this,array,elems,mode);
1723 |     }
1724 |     void ReleaseLongArrayElements(jlongArray array,
1725 |                                   jlong *elems,
1726 |                                   jint mode) {
1727 |         functions->ReleaseLongArrayElements(this,array,elems,mode);
1728 |     }
1729 |     void ReleaseFloatArrayElements(jfloatArray array,
1730 |                                    jfloat *elems,
1731 |                                    jint mode) {
1732 |         functions->ReleaseFloatArrayElements(this,array,elems,mode);
1733 |     }
1734 |     void ReleaseDoubleArrayElements(jdoubleArray array,
1735 |                                     jdouble *elems,
1736 |                                     jint mode) {
1737 |         functions->ReleaseDoubleArrayElements(this,array,elems,mode);
1738 |     }
1739 | 
1740 |     void GetBooleanArrayRegion(jbooleanArray array,
1741 |                                jsize start, jsize len, jboolean *buf) {
1742 |         functions->GetBooleanArrayRegion(this,array,start,len,buf);
1743 |     }
1744 |     void GetByteArrayRegion(jbyteArray array,
1745 |                             jsize start, jsize len, jbyte *buf) {
1746 |         functions->GetByteArrayRegion(this,array,start,len,buf);
1747 |     }
1748 |     void GetCharArrayRegion(jcharArray array,
1749 |                             jsize start, jsize len, jchar *buf) {
1750 |         functions->GetCharArrayRegion(this,array,start,len,buf);
1751 |     }
1752 |     void GetShortArrayRegion(jshortArray array,
1753 |                              jsize start, jsize len, jshort *buf) {
1754 |         functions->GetShortArrayRegion(this,array,start,len,buf);
1755 |     }
1756 |     void GetIntArrayRegion(jintArray array,
1757 |                            jsize start, jsize len, jint *buf) {
1758 |         functions->GetIntArrayRegion(this,array,start,len,buf);
1759 |     }
1760 |     void GetLongArrayRegion(jlongArray array,
1761 |                             jsize start, jsize len, jlong *buf) {
1762 |         functions->GetLongArrayRegion(this,array,start,len,buf);
1763 |     }
1764 |     void GetFloatArrayRegion(jfloatArray array,
1765 |                              jsize start, jsize len, jfloat *buf) {
1766 |         functions->GetFloatArrayRegion(this,array,start,len,buf);
1767 |     }
1768 |     void GetDoubleArrayRegion(jdoubleArray array,
1769 |                               jsize start, jsize len, jdouble *buf) {
1770 |         functions->GetDoubleArrayRegion(this,array,start,len,buf);
1771 |     }
1772 | 
1773 |     void SetBooleanArrayRegion(jbooleanArray array, jsize start, jsize len,
1774 |                                const jboolean *buf) {
1775 |         functions->SetBooleanArrayRegion(this,array,start,len,buf);
1776 |     }
1777 |     void SetByteArrayRegion(jbyteArray array, jsize start, jsize len,
1778 |                             const jbyte *buf) {
1779 |         functions->SetByteArrayRegion(this,array,start,len,buf);
1780 |     }
1781 |     void SetCharArrayRegion(jcharArray array, jsize start, jsize len,
1782 |                             const jchar *buf) {
1783 |         functions->SetCharArrayRegion(this,array,start,len,buf);
1784 |     }
1785 |     void SetShortArrayRegion(jshortArray array, jsize start, jsize len,
1786 |                              const jshort *buf) {
1787 |         functions->SetShortArrayRegion(this,array,start,len,buf);
1788 |     }
1789 |     void SetIntArrayRegion(jintArray array, jsize start, jsize len,
1790 |                            const jint *buf) {
1791 |         functions->SetIntArrayRegion(this,array,start,len,buf);
1792 |     }
1793 |     void SetLongArrayRegion(jlongArray array, jsize start, jsize len,
1794 |                             const jlong *buf) {
1795 |         functions->SetLongArrayRegion(this,array,start,len,buf);
1796 |     }
1797 |     void SetFloatArrayRegion(jfloatArray array, jsize start, jsize len,
1798 |                              const jfloat *buf) {
1799 |         functions->SetFloatArrayRegion(this,array,start,len,buf);
1800 |     }
1801 |     void SetDoubleArrayRegion(jdoubleArray array, jsize start, jsize len,
1802 |                               const jdouble *buf) {
1803 |         functions->SetDoubleArrayRegion(this,array,start,len,buf);
1804 |     }
1805 | 
1806 |     jint RegisterNatives(jclass clazz, const JNINativeMethod *methods,
1807 |                          jint nMethods) {
1808 |         return functions->RegisterNatives(this,clazz,methods,nMethods);
1809 |     }
1810 |     jint UnregisterNatives(jclass clazz) {
1811 |         return functions->UnregisterNatives(this,clazz);
1812 |     }
1813 | 
1814 |     jint MonitorEnter(jobject obj) {
1815 |         return functions->MonitorEnter(this,obj);
1816 |     }
1817 |     jint MonitorExit(jobject obj) {
1818 |         return functions->MonitorExit(this,obj);
1819 |     }
1820 | 
1821 |     jint GetJavaVM(JavaVM **vm) {
1822 |         return functions->GetJavaVM(this,vm);
1823 |     }
1824 | 
1825 |     void GetStringRegion(jstring str, jsize start, jsize len, jchar *buf) {
1826 |         functions->GetStringRegion(this,str,start,len,buf);
1827 |     }
1828 |     void GetStringUTFRegion(jstring str, jsize start, jsize len, char *buf) {
1829 |         functions->GetStringUTFRegion(this,str,start,len,buf);
1830 |     }
1831 | 
1832 |     void * GetPrimitiveArrayCritical(jarray array, jboolean *isCopy) {
1833 |         return functions->GetPrimitiveArrayCritical(this,array,isCopy);
1834 |     }
1835 |     void ReleasePrimitiveArrayCritical(jarray array, void *carray, jint mode) {
1836 |         functions->ReleasePrimitiveArrayCritical(this,array,carray,mode);
1837 |     }
1838 | 
1839 |     const jchar * GetStringCritical(jstring string, jboolean *isCopy) {
1840 |         return functions->GetStringCritical(this,string,isCopy);
1841 |     }
1842 |     void ReleaseStringCritical(jstring string, const jchar *cstring) {
1843 |         functions->ReleaseStringCritical(this,string,cstring);
1844 |     }
1845 | 
1846 |     jweak NewWeakGlobalRef(jobject obj) {
1847 |         return functions->NewWeakGlobalRef(this,obj);
1848 |     }
1849 |     void DeleteWeakGlobalRef(jweak ref) {
1850 |         functions->DeleteWeakGlobalRef(this,ref);
1851 |     }
1852 | 
1853 |     jboolean ExceptionCheck() {
1854 |         return functions->ExceptionCheck(this);
1855 |     }
1856 | 
1857 |     jobject NewDirectByteBuffer(void* address, jlong capacity) {
1858 |         return functions->NewDirectByteBuffer(this, address, capacity);
1859 |     }
1860 |     void* GetDirectBufferAddress(jobject buf) {
1861 |         return functions->GetDirectBufferAddress(this, buf);
1862 |     }
1863 |     jlong GetDirectBufferCapacity(jobject buf) {
1864 |         return functions->GetDirectBufferCapacity(this, buf);
1865 |     }
1866 |     jobjectRefType GetObjectRefType(jobject obj) {
1867 |         return functions->GetObjectRefType(this, obj);
1868 |     }
1869 | 
1870 |     /* Module Features */
1871 | 
1872 |     jobject GetModule(jclass clazz) {
1873 |         return functions->GetModule(this, clazz);
1874 |     }
1875 | 
1876 |     /* Virtual threads */
1877 | 
1878 |     jboolean IsVirtualThread(jobject obj) {
1879 |         return functions->IsVirtualThread(this, obj);
1880 |     }
1881 | 
1882 | #endif /* __cplusplus */
1883 | };
1884 | 
1885 | /*
1886 |  * optionString may be any option accepted by the JVM, or one of the
1887 |  * following:
1888 |  *
1889 |  * -D<name>=<value>          Set a system property.
1890 |  * -verbose[:class|gc|jni]   Enable verbose output, comma-separated. E.g.
1891 |  *                           "-verbose:class" or "-verbose:gc,class"
1892 |  *                           Standard names include: gc, class, and jni.
1893 |  *                           All nonstandard (VM-specific) names must begin
1894 |  *                           with "X".
1895 |  * vfprintf                  extraInfo is a pointer to the vfprintf hook.
1896 |  * exit                      extraInfo is a pointer to the exit hook.
1897 |  * abort                     extraInfo is a pointer to the abort hook.
1898 |  */
1899 | typedef struct JavaVMOption {
1900 |     char *optionString;
1901 |     void *extraInfo;
1902 | } JavaVMOption;
1903 | 
1904 | typedef struct JavaVMInitArgs {
1905 |     jint version;
1906 | 
1907 |     jint nOptions;
1908 |     JavaVMOption *options;
1909 |     jboolean ignoreUnrecognized;
1910 | } JavaVMInitArgs;
1911 | 
1912 | typedef struct JavaVMAttachArgs {
1913 |     jint version;
1914 | 
1915 |     char *name;
1916 |     jobject group;
1917 | } JavaVMAttachArgs;
1918 | 
1919 | /* These will be VM-specific. */
1920 | 
1921 | #define JDK1_2
1922 | #define JDK1_4
1923 | 
1924 | /* End VM-specific. */
1925 | 
1926 | struct JNIInvokeInterface_ {
1927 |     void *reserved0;
1928 |     void *reserved1;
1929 |     void *reserved2;
1930 | 
1931 |     jint (JNICALL *DestroyJavaVM)(JavaVM *vm);
1932 | 
1933 |     jint (JNICALL *AttachCurrentThread)(JavaVM *vm, void **penv, void *args);
1934 | 
1935 |     jint (JNICALL *DetachCurrentThread)(JavaVM *vm);
1936 | 
1937 |     jint (JNICALL *GetEnv)(JavaVM *vm, void **penv, jint version);
1938 | 
1939 |     jint (JNICALL *AttachCurrentThreadAsDaemon)(JavaVM *vm, void **penv, void *args);
1940 | };
1941 | 
1942 | struct JavaVM_ {
1943 |     const struct JNIInvokeInterface_ *functions;
1944 | #ifdef __cplusplus
1945 | 
1946 |     jint DestroyJavaVM() {
1947 |         return functions->DestroyJavaVM(this);
1948 |     }
1949 |     jint AttachCurrentThread(void **penv, void *args) {
1950 |         return functions->AttachCurrentThread(this, penv, args);
1951 |     }
1952 |     jint DetachCurrentThread() {
1953 |         return functions->DetachCurrentThread(this);
1954 |     }
1955 | 
1956 |     jint GetEnv(void **penv, jint version) {
1957 |         return functions->GetEnv(this, penv, version);
1958 |     }
1959 |     jint AttachCurrentThreadAsDaemon(void **penv, void *args) {
1960 |         return functions->AttachCurrentThreadAsDaemon(this, penv, args);
1961 |     }
1962 | #endif
1963 | };
1964 | 
1965 | #ifdef _JNI_IMPLEMENTATION_
1966 | #define _JNI_IMPORT_OR_EXPORT_ JNIEXPORT
1967 | #else
1968 | #define _JNI_IMPORT_OR_EXPORT_ JNIIMPORT
1969 | #endif
1970 | _JNI_IMPORT_OR_EXPORT_ jint JNICALL
1971 | JNI_GetDefaultJavaVMInitArgs(void *args);
1972 | 
1973 | _JNI_IMPORT_OR_EXPORT_ jint JNICALL
1974 | JNI_CreateJavaVM(JavaVM **pvm, void **penv, void *args);
1975 | 
1976 | _JNI_IMPORT_OR_EXPORT_ jint JNICALL
1977 | JNI_GetCreatedJavaVMs(JavaVM **, jsize, jsize *);
1978 | 
1979 | /* Defined by native libraries. */
1980 | JNIEXPORT jint JNICALL
1981 | JNI_OnLoad(JavaVM *vm, void *reserved);
1982 | 
1983 | JNIEXPORT void JNICALL
1984 | JNI_OnUnload(JavaVM *vm, void *reserved);
1985 | 
1986 | #define JNI_VERSION_1_1 0x00010001
1987 | #define JNI_VERSION_1_2 0x00010002
1988 | #define JNI_VERSION_1_4 0x00010004
1989 | #define JNI_VERSION_1_6 0x00010006
1990 | #define JNI_VERSION_1_8 0x00010008
1991 | #define JNI_VERSION_9   0x00090000
1992 | #define JNI_VERSION_10  0x000a0000
1993 | #define JNI_VERSION_19  0x00130000
1994 | #define JNI_VERSION_20  0x00140000
1995 | #define JNI_VERSION_21  0x00150000
1996 | 
1997 | #ifdef __cplusplus
1998 | } /* extern "C" */
1999 | #endif /* __cplusplus */
2000 | 
2001 | #endif /* !_JAVASOFT_JNI_H_ */
2002 | 


--------------------------------------------------------------------------------