Test` containing product and test sources for this platform. Common for all
+platforms sources are located in `commonMain` and `commonTest` source sets created by default. More information about source sets can be found
+[here](https://kotlinlang.org/docs/reference/building-mpp-with-gradle.html#configuring-source-sets).
+
+
+
+```groovy
+kotlin {
+ sourceSets {
+ // Adding target-independent sources.
+ commonMain.kotlin.srcDirs += file("src/main/mySources")
+
+ // Adding Linux-specific code.
+ linuxX64Main.kotlin.srcDirs += file("src/main/linux")
+ }
+}
+```
+
+
+
+### Managing dependencies
+
+With the `kotlin-platform-native` plugin dependencies are configured in a traditional for Gradle way by grouping them into configurations
+using the project `dependencies` block:
+
+
+
+```groovy
+dependencies {
+ implementation 'org.sample.test:mylibrary:1.0'
+ testImplementation 'org.sample.test:testlibrary:1.0'
+}
+```
+
+
+
+The `kotlin-multiplatform` plugin also uses configurations under the hood but it also provides a `dependencies` block for each source set
+allowing configuring dependencies of this sources set:
+
+
+
+```groovy
+kotlin.sourceSets {
+ commonMain {
+ dependencies {
+ implementation("org.sample.test:mylibrary:1.0")
+ }
+ }
+
+ commonTest {
+ dependencies {
+ implementation("org.sample.test:testlibrary:1.0")
+ }
+ }
+}
+```
+
+
+
+Note that a module referenced by a dependency declared for `commonMain` or `commonTest` source set must be published using the `kotlin-multiplatform` plugin.
+If you want to use libraries published by the `kotlin-platform-native` plugin, you need to declare a separate source set for common native sources.
+
+
+
+```groovy
+kotlin.sourceSets {
+ // Create a common source set used by native targets only.
+ nativeMain {
+ dependsOn(commonMain)
+ dependencies {
+ // Depend on a library published by the kotlin-platform-naive plugin.
+ implementation("org.sample.test:mylibrary:1.0")
+ }
+ }
+
+ // Configure all native platform sources sets to use it as a common one.
+ linuxX64Main.dependsOn(nativeMain)
+ macosX64Main.dependsOn(nativeMain)
+ // ...
+}
+```
+
+
+
+See more info about dependencies at the [corresponding page](https://kotlinlang.org/docs/reference/building-mpp-with-gradle.html#adding-dependencies).
+
+### Output kinds
+
+With the `kotlin-platform-native` plugin output kinds are specified as a list in properties of a component:
+
+
+
+```groovy
+components.main {
+ // Compile the component into an executable and a Kotlin/Native library.
+ outputKinds = [EXECUTABLE, KLIBRARY]
+}
+```
+
+
+
+With the `kotlin-multiplatform` plugin a compilation always produces a `*.klib` file. A separate `binaries` block is used to configure what
+final native binaries should be produced by each target. Each binary can be configured independently including linker options, executable entry point etc.
+
+
+
+```groovy
+kotlin {
+ macosX64 {
+ binaries {
+ executable {
+ // Binary configuration: linker options, name, etc.
+ }
+ framework {
+ // ...
+ }
+
+ }
+ }
+}
+```
+
+
+
+See more about native binaries declaration at the [corresponding page](https://kotlinlang.org/docs/reference/building-mpp-with-gradle.html#building-final-native-binaries).
+
+
+### Publishing
+
+Both `kotlin-platform-native` and `kotlin-multiplatform` plugins automatically set up artifact publication when the
+`maven-publish` plugin is applied. See details about publication at the [corresponding page](https://kotlinlang.org/docs/reference/building-mpp-with-gradle.html#publishing-a-multiplatform-library).
+Note that currently only Kotlin/Native libraries (`*.klib`) can be published for native targets.
+
+### Cinterop support
+
+With the `kotlin-platform-native` plugin interop with a native library can be declared in component dependencies:
+
+
+
+```groovy
+components.main {
+ dependencies {
+ cinterop('mystdio') {
+ // Cinterop configuration.
+ }
+ }
+}
+```
+
+
+
+With the `kotlin-multiplatform` plugin interops are configured as a part of a compilation (see details [here](https://kotlinlang.org/docs/reference/building-mpp-with-gradle.html#cinterop-support)).
+The rest of an interop configuration is the same as for the `kotlin-platform-native` plugin.
+
+
+
+```groovy
+kotlin {
+ macosX64 {
+ compilations.main.cinterops {
+ mystdio {
+ // Cinterop configuration.
+ }
+ }
+ }
+}
+```
+
+
+
+## `kotlin-platform-native` reference
+
+### Overview
+
+You may use the Gradle plugin to build _Kotlin/Native_ projects. Builds of the plugin are
+[available](https://plugins.gradle.org/plugin/org.jetbrains.kotlin.platform.native) at the Gradle plugin portal, so you can apply it
+using Gradle plugin DSL:
+
+
+
+```groovy
+plugins {
+ id "org.jetbrains.kotlin.platform.native" version "1.3.0-rc-146"
+}
+```
+
+
+
+You also can get the plugin from a Bintray repository. In addition to releases, this repo contains old and development
+versions of the plugin which are not available at the plugin portal. To get the plugin from the Bintray repo, include
+the following snippet in your build script:
+
+
+
+```groovy
+buildscript {
+ repositories {
+ mavenCentral()
+ maven {
+ url "https://dl.bintray.com/jetbrains/kotlin-native-dependencies"
+ }
+ }
+
+ dependencies {
+ classpath "org.jetbrains.kotlin:kotlin-native-gradle-plugin:1.3.0-rc-146"
+ }
+}
+
+apply plugin: 'org.jetbrains.kotlin.platform.native'
+```
+
+
+
+By default the plugin downloads the Kotlin/Native compiler during the first run. If you have already downloaded the compiler
+manually you can specify the path to its root directory using `org.jetbrains.kotlin.native.home` project property (e.g. in `gradle.properties`).
+
+
+
+```groovy
+org.jetbrains.kotlin.native.home=/home/user/kotlin-native-0.8
+```
+
+
+
+In this case the compiler will not be downloaded by the plugin.
+
+### Source management
+
+Source management in the `kotlin.platform.native` plugin is uniform with other Kotlin plugins and is based on source sets.
+A source set is a group of Kotlin/Native source which may contain both common and platform-specific code. The plugin
+provides a top-level script block `sourceSets` allowing you to configure source sets. Also it creates the default
+source sets `main` and `test` (for production and test code respectively).
+
+By default the production sources are located in `src/main/kotlin` and the test sources - in `src/test/kotlin`.
+
+
+
+```groovy
+sourceSets {
+ // Adding target-independent sources.
+ main.kotlin.srcDirs += 'src/main/mySources'
+
+ // Adding Linux-specific code. It will be compiled in Linux binaries only.
+ main.target('linux_x64').srcDirs += 'src/main/linux'
+}
+```
+
+
+
+### Targets and output kinds
+
+By default the plugin creates software components for the main and test source sets. You can access them via the
+`components` container provided by Gradle or via the `component` property of a corresponding source set:
+
+
+
+```groovy
+// Main component.
+components.main
+sourceSets.main.component
+
+// Test component.
+components.test
+sourceSets.test.component
+```
+
+
+
+Components allow you to specify:
+
+* Targets (e.g. Linux/x64 or iOS/arm64 etc)
+* Output kinds (e.g. executable, library, framework etc)
+* Dependencies (including interop ones)
+
+Targets can be specified by setting a corresponding component property:
+
+
+
+```groovy
+components.main {
+ // Compile this component for 64-bit MacOS, Linux and Windows.
+ targets = ['macos_x64', 'linux_x64', 'mingw_x64']
+}
+```
+
+
+
+The plugin uses the same notation as the compiler. By default, test component uses the same targets as specified for the main one.
+
+Output kinds can also be specified using a special property:
+
+
+
+```groovy
+components.main {
+ // Compile the component into an executable and a Kotlin/Native library.
+ outputKinds = [EXECUTABLE, KLIBRARY]
+}
+```
+
+
+
+All constants used here are available inside a component configuration script block.
+The plugin supports producing binaries of the following kinds:
+
+* `EXECUTABLE` - an executable file;
+* `KLIBRARY` - a Kotlin/Native library (*.klib);
+* `FRAMEWORK` - an Objective-C framework;
+* `DYNAMIC` - shared native library;
+* `STATIC` - static native library.
+
+Also each native binary is built in two variants (build types): `debug` (debuggable, not optimized) and `release` (not debuggable, optimized).
+Note that Kotlin/Native libraries have only `debug` variant because optimizations are preformed only during compilation
+of a final binary (executable, static lib etc) and affect all libraries used to build it.
+
+### Compile tasks
+
+The plugin creates a compilation task for each combination of the target, output kind, and build type. The tasks have the following naming convention:
+
+ compileKotlinNative
+
+For example `compileDebugKlibraryMacos_x64KotlinNative`, `compileTestDebugKotlinNative`.
+
+The name contains the following parts (some of them may be empty):
+
+* `` - name of a component. Empty for the main component.
+* `` - `Debug` or `Release`.
+* `` - output kind name, e.g. `Executabe` or `Dynamic`. Empty if the component has only one output kind.
+* `` - target the component is built for, e.g. `Macos_x64` or `Wasm32`. Empty if the component is built only for one target.
+
+Also the plugin creates a number of aggregate tasks allowing you to build all the binaries for a build type (e.g.
+`assembleAllDebug`) or all the binaries for a particular target (e.g. `assembleAllWasm32`).
+
+Basic lifecycle tasks like `assemble`, `build`, and `clean` are also available.
+
+### Running tests
+
+The plugin builds a test executable for all the targets specified for the `test` component. If the current host platform is
+included in this list the test running tasks are also created. To run tests, execute the standard lifecycle `check` task:
+
+
+
+```bash
+./gradlew check
+```
+
+
+
+### Dependencies
+
+The plugin allows you to declare dependencies on files and other projects using traditional Gradle's mechanism of
+configurations. The plugin supports Kotlin multiplatform projects allowing you to declare the `expectedBy` dependencies
+
+
+
+```groovy
+dependencies {
+ implementation files('path/to/file/dependencies')
+ implementation project('library')
+ testImplementation project('testLibrary')
+ expectedBy project('common')
+}
+```
+
+
+
+It's possible to depend on a Kotlin/Native library published earlier in a maven repo. The plugin relies on Gradle's
+[metadata](https://github.com/gradle/gradle/blob/master/subprojects/docs/src/docs/design/gradle-module-metadata-latest-specification.md)
+support so the corresponding feature must be enabled. Add the following line in your `settings.gradle`:
+
+
+
+```groovy
+enableFeaturePreview('GRADLE_METADATA')
+```
+
+
+
+
+Now you can declare a dependency on a Kotlin/Native library in the traditional `group:artifact:version` notation:
+
+
+
+```groovy
+dependencies {
+ implementation 'org.sample.test:mylibrary:1.0'
+ testImplementation 'org.sample.test:testlibrary:1.0'
+}
+```
+
+
+
+Dependency declaration is also possible in the component block:
+
+
+
+```groovy
+components.main {
+ dependencies {
+ implementation 'org.sample.test:mylibrary:1.0'
+ }
+}
+
+components.test {
+ dependencies {
+ implementation 'org.sample.test:testlibrary:1.0'
+ }
+}
+```
+
+
+
+
+### Using cinterop
+
+It's possible to declare a cinterop dependency for a component:
+
+
+
+```groovy
+components.main {
+ dependencies {
+ cinterop('mystdio') {
+ // src/main/c_interop/mystdio.def is used as a def file.
+
+ // Set up compiler options
+ compilerOpts '-I/my/include/path'
+
+ // It's possible to set up different options for different targets
+ target('linux') {
+ compilerOpts '-I/linux/include/path'
+ }
+ }
+ }
+}
+```
+
+
+
+Here an interop library will be built and added in the component dependencies.
+
+Often it's necessary to specify target-specific linker options for a Kotlin/Native binary using an interop. It can be
+done using the `target` script block:
+
+
+
+```groovy
+components.main {
+ target('linux') {
+ linkerOpts '-L/path/to/linux/libs'
+ }
+}
+```
+
+
+
+Also the `allTargets` block is available.
+
+
+
+```groovy
+components.main {
+ // Configure all targets.
+ allTargets {
+ linkerOpts '-L/path/to/libs'
+ }
+}
+```
+
+
+
+
+### Publishing
+
+In the presence of `maven-publish` plugin the publications for all the binaries built are created. The plugin uses Gradle
+metadata to publish the artifacts so this feature must be enabled (see the [dependencies](#dependencies) section).
+
+Now you can publish the artifacts with the standard Gradle `publish` task:
+
+
+
+```bash
+./gradlew publish
+```
+
+
+
+Only `EXECUTABLE` and `KLIBRARY` binaries are published currently.
+
+The plugin allows you to customize the pom generated for the publication with the `pom` code block available for every component:
+
+
+
+```groovy
+components.main {
+ pom {
+ withXml {
+ def root = asNode()
+ root.appendNode('name', 'My library')
+ root.appendNode('description', 'A Kotlin/Native library')
+ }
+ }
+}
+```
+
+
+
+### Serialization plugin
+
+The plugin is shipped with a customized version of the `kotlinx.serialization` plugin. To use it you don't have to
+add new buildscript dependencies, just apply the plugins and add a dependency on the serialization library:
+
+
+
+```groovy
+apply plugin: 'org.jetbrains.kotlin.platform.native'
+apply plugin: 'kotlinx-serialization-native'
+
+dependencies {
+ implementation 'org.jetbrains.kotlinx:kotlinx-serialization-runtime-native'
+}
+```
+
+
+
+The [example project](https://github.com/ilmat192/kotlin-native-serialization-sample) for details.
+
+### DSL example
+
+In this section a commented DSL is shown.
+See also the example projects that use this plugin, e.g.
+[Kotlinx.coroutines](https://github.com/Kotlin/kotlinx.coroutines),
+[MPP http client](https://github.com/e5l/http-client-common/tree/master/samples/ios-test-application)
+
+
+
+```groovy
+plugins {
+ id "org.jetbrains.kotlin.platform.native" version "1.3.0-rc-146"
+}
+
+sourceSets.main {
+ // Plugin uses Gradle's source directory sets here,
+ // so all the DSL methods available in SourceDirectorySet can be called here.
+ // Platform independent sources.
+ kotlin.srcDirs += 'src/main/customDir'
+
+ // Linux-specific sources
+ target('linux').srcDirs += 'src/main/linux'
+}
+
+components.main {
+
+ // Set up targets
+ targets = ['linux_x64', 'macos_x64', 'mingw_x64']
+
+ // Set up output kinds
+ outputKinds = [EXECUTABLE, KLIBRARY, FRAMEWORK, DYNAMIC, STATIC]
+
+ // Specify custom entry point for executables
+ entryPoint = "org.test.myMain"
+
+ // Target-specific options
+ target('linux_x64') {
+ linkerOpts '-L/linux/lib/path'
+ }
+
+ // Targets independent options
+ allTargets {
+ linkerOpts '-L/common/lib/path'
+ }
+
+ dependencies {
+
+ // Dependency on a published Kotlin/Native library.
+ implementation 'org.test:mylib:1.0'
+
+ // Dependency on a project
+ implementation project('library')
+
+ // Cinterop dependency
+ cinterop('interop-name') {
+ // Def-file describing the native API.
+ // The default path is src/main/c_interop/
.def
+ defFile project.file("deffile.def")
+
+ // Package to place the Kotlin API generated.
+ packageName 'org.sample'
+
+ // Options to be passed to compiler and linker by cinterop tool.
+ compilerOpts 'Options for native stubs compilation'
+ linkerOpts 'Options for native stubs'
+
+ // Additional headers to parse.
+ headers project.files('header1.h', 'header2.h')
+
+ // Directories to look for headers.
+ includeDirs {
+ // All objects accepted by the Project.file method may be used with both options.
+
+ // Directories for header search (an analogue of the -I compiler option).
+ allHeaders 'path1', 'path2'
+
+ // Additional directories to search headers listed in the 'headerFilter' def-file option.
+ // -headerFilterAdditionalSearchPrefix command line option analogue.
+ headerFilterOnly 'path1', 'path2'
+ }
+ // A shortcut for includeDirs.allHeaders.
+ includeDirs "include/directory" "another/directory"
+
+ // Pass additional command line options to the cinterop tool.
+ extraOpts '-verbose'
+
+ // Additional configuration for Linux.
+ target('linux') {
+ compilerOpts 'Linux-specific options'
+ }
+ }
+ }
+
+ // Additional pom settings for publication.
+ pom {
+ withXml {
+ def root = asNode()
+ root.appendNode('name', 'My library')
+ root.appendNode('description', 'A Kotlin/Native library')
+ }
+ }
+
+ // Additional options passed to the compiler.
+ extraOpts '--time'
+}
+```
+
+
+
+* **-Pfilter** allows one to choose test files to run.
+
+ ./gradlew -Pfilter=overflowLong.kt run_external
+
+* **-Pprefix** allows one to choose external test directories to run. Only tests from directories with given prefix will be executed.
+
+ ./gradlew -Pprefix=build_external_compiler_codegen_box_cast run_external
+
+* **-Ptest_flags** passes flags to the compiler used to compile tests
+
+ ./gradlew -Ptest_flags="--time" backend.native:tests:array0
+
+* **-Ptest_target** specifies cross target for a test run.
+
+ ./gradlew -Ptest_target=raspberrypi backend.native:tests:array0
+
+* **-Premote=user@host** sets remote test execution login/hostname. Good for cross compiled tests.
+
+ ./gradlew -Premote=kotlin@111.22.33.444 backend.native:tests:run
+
+* **-Ptest_verbose** enables printing compiler args and other helpful information during a test execution.
+
+ ./gradlew -Ptest_verbose :backend.native:tests:mpp_optional_expectation
+
+* **-Ptest_two_stage** enables two-stage compilation of tests. If two-stage compilation is enabled, test sources are compiled into a klibrary
+and then a final native binary is produced from this klibrary using the -Xinclude compiler flag.
+
+ ./gradlew -Ptest_two_stage backend.native:tests:array0
+
+* **-Ptest_with_cache_kind=static|dynamic** enables using caches during testing.
+
+ ### Runtime unit tests
+
+To run runtime unit tests on the host machine for both mimalloc and the standard allocator:
+
+ ./gradlew hostRuntimeTests
+
+To run tests for only one of these two allocators, run `hostStdAllocRuntimeTests` or `hostMimallocRuntimeTests`.
+
+We use [Google Test](https://github.com/google/googletest) to execute the runtime unit tests. The build automatically fetches
+the specified Google Test revision to `runtime/googletest`. It is possible to manually modify the downloaded GTest sources for debug
+purposes; the build will not overwrite them by default.
+
+To forcibly redownload Google Test when running tests, use the corresponding project property:
+
+ ./gradlew hostRuntimeTests -Prefresh-gtest
+
+or run the `downloadGTest` task directly with the `--refresh` CLI key:
+
+ ./gradlew downloadGTest --refresh
+
+To use a local GTest copy instead of the downloaded one, add the following line to `runtime/build.gradle.kts`:
+
+ googletest.useLocalSources("")
+
+ ## Performance measurement
+
+ Firstly, it's necessary to build analyzer tool to have opportunity to compare different performance results:
+
+ cd tools/benchmarksAnalyzer
+ ../../gradlew build
+
+ To measure performance of Kotlin/Native compiler on existing benchmarks:
+
+ cd performance
+ ../gradlew :konanRun
+
+ **NOTE**: **konanRun** task needs built compiler and libs. To test against working tree make sure to run
+
+ ./gradlew dist distPlatformLibs
+
+ before **konanRun**
+
+ **konanRun** task can be run separately for one/several benchmark applications:
+
+ cd performance
+ ../gradlew :cinterop:konanRun
+
+ **konanRun** task has parameter `filter` which allows to run only some subset of benchmarks:
+
+ cd performance
+ ../gradlew :cinterop:konanRun --filter=struct,macros
+
+ Or you can use `filterRegex` if you want to specify the filter as regexes:
+
+ cd performance
+ ../gradlew :ring:konanRun --filterRegex=String.*,Loop.*
+
+ There us also verbose mode to follow progress of running benchmarks
+
+ cd performance
+ ../gradlew :cinterop:konanRun --verbose
+
+ > Task :performance:cinterop:konanRun
+ [DEBUG] Warm up iterations for benchmark macros
+ [DEBUG] Running benchmark macros
+ ...
+
+ There are also tasks for running benchmarks on JVM (pay attention, some benchmarks e.g. cinterop benchmarks can't be run on JVM)
+
+ cd performance
+ ../gradlew :jvmRun
+
+ Files with results of benchmarks run are saved in `performance/build/nativeReport.json` for konanRun and `jvmReport.json` for jvmRun.
+ You can change the output filename by setting the `nativeJson` property for konanRun and `jvmJson` for jvmRun:
+
+ cd performance
+ ../gradlew :ring:konanRun --filter=String.*,Loop.* -PnativeJson=stringsAndLoops.json
+
+ You can use the `compilerArgs` property to pass flags to the compiler used to compile the benchmarks:
+
+ cd performance
+ ../gradlew :konanRun -PcompilerArgs="--time -g"
+
+ To compare different results run benchmarksAnalyzer tool:
+
+ cd tools/benchmarksAnalyzer/build/bin//benchmarksAnalyzerReleaseExecutable/
+ ./benchmarksAnalyzer.kexe
+
+ Tool has several renders which allow produce output report in different forms (text, html, etc.). To set up render use flag `--render/-r`.
+ Output can be redirected to file with flag `--output/-o`.
+ To get detailed information about supported options, please use `--help/-h`.
+
+ Analyzer tool can compare both local files and files placed on Artifactory/TeamCity.
+
+ File description stored on Artifactory
+
+ artifactory:::
+
+ Example
+
+ artifactory:1.2-dev-7942:Windows10:nativeReport.json
+
+ File description stored on TeamCity
+
+ teamcity::
+
+ Example
+
+ teamcity:id:42491947:nativeReport.json
+
+ Pay attention, user and password information(with flag `-u :`) should be provided to get data from TeamCity.
+
+## Composite build and testing
+
+If you have a fix spanning both Kotlin and Kotlin/native workspaces you need to be able to test Kotlin/Native composite build. Here's how to do it manually:
+
+### Have a composite build with the proper Kotlin tag.
+
+Find the version of Kotlin the current native is guaranteed to build with.
+The version is specified in `kotlin-native/gradle.properties`. For example:
+```
+kotlinVersion=1.3.70-dev-1526
+```
+Checkout `kotlin` workspace to tag `build-1.3.70-dev-1526`. Make sure its path ends with `.../kotlin`.
+Otherwise issues will arise.
+Direct `kotlin-native` build to the kotlin with `kotlinProjectPath` in native's `gradle.properties`.
+
+Now you have the kotlin + kotlin-native combination that is known to build.
+Apply your fix on top of both workspaces and run
+```
+$ ./gradlew dist
+```
+
+in `kotlin-native` to check the buildability.
+
+### Testing native
+
+For a quick check use:
+```
+$ ./gradlew sanity 2>&1 | tee log
+```
+
+For a longer, more thorough testing build the complete build. Make sure you are running it on a macOS.
+
+
+Have a complete build:
+
+```
+$ ./gradlew bundle # includes dist as its part
+```
+
+then run two test sets:
+
+```
+$ ./gradlew backend.native:tests:run 2>&1 | tee log
+
+$ ./gradlew backend.native:tests:runExternal -Ptest_two_stage=true 2>&1 | tee log
+
+```
+
+## LLVM
+
+See [BUILDING_LLVM.md](BUILDING_LLVM.md) if you want to build and use your own LLVM distribution
+instead of provided one.
+
+### Using different LLVM distributions as part of Kotlin/Native compilation pipeline.
+
+`llvmHome.` variable in `/konan/konan.properties` controls
+which LLVM distribution Kotlin/Native will use in its compilation pipeline.
+You can replace its value with either `$llvm..{dev, user}` to use one of predefined distributions
+or pass an absolute to your own distribution.
+Don't forget to set `llvmVersion.` to the version of your LLVM distribution.
+
+#### Example. Using LLVM from an absolute path.
+Assuming LLVM distribution is installed at `/usr` path, one can specify a path to it
+with the `-Xoverride-konan-properties` option:
+```
+konanc main.kt -Xoverride-konan-properties=llvmHome.linux_x64=/usr
+```
+
+### Playing with compilation pipeline.
+
+Following compiler phases control different parts of LLVM pipeline:
+1. `LinkBitcodeDependencies`. Linkage of produced bitcode with runtime and some other dependencies.
+2. `BitcodeOptimization`. Running LLVM optimization pipeline.
+3. `ObjectFiles`. Compilation of bitcode with Clang.
+
+For example, pass `-Xdisable-phases=BitcodeOptimization` to skip optimization pipeline.
+Note that disabling `LinkBitcodeDependencies` or `ObjectFiles` will break compilation pipeline.
+
+Compiler takes options for Clang from [konan.properties](konan/konan.properties) file
+by combining `clangFlags.` and `clangFlags.` properties.
+Use `-Xoverride-konan-properties=` flag to override default values.
+
+Please note:
+1. Kotlin Native passes bitcode files to Clang instead of C or C++, so many flags won't work.
+2. `-cc1 -emit-obj` should be passed because Kotlin/Native calls linker by itself.
+3. Use `clang -cc1 -help` to see a list of available options.
+
+Another useful compiler option is `-Xtemporary-files-dir=` which allows
+to specify a directory for intermediate compiler artifacts like bitcode and object files.
+
+#### Example 1. Bitcode right after IR to Bitcode translation.
+```shell script
+konanc main.kt -produce bitcode -o bitcode.bc
+```
+
+#### Example 2. Bitcode after LLVM optimizations.
+```shell script
+konanc main.kt -Xtemporary-files-dir= -o
+```
+`/.kt.bc` will contain bitcode after LLVM optimization pipeline.
+
+#### Example 3. Replace predefined LLVM pipeline with Clang options.
+```shell script
+CLANG_FLAGS="clangFlags.macos_x64=-cc1 -emit-obj;clangNooptFlags.macos_x64=-O2"
+konanc main.kt -Xdisable-phases=BitcodeOptimization -Xoverride-konan-properties="$CLANG_FLAGS"
+```
+
+## Running Clang the same way Kotlin/Native compiler does
+
+Kotlin/Native compiler (including `cinterop` tool) has machinery that manages LLVM, Clang and native SDKs for supported targets
+and runs bundled Clang with proper arguments.
+To utilize this machinery, use `$dist/bin/run_konan clang $tool $target $arguments`, e.g.
+```
+$dist/bin/run_konan clang clang ios_arm64 1.c
+```
+will print and run the following command:
+```
+~/.konan/dependencies/clang-llvm-apple-8.0.0-darwin-macos/bin/clang \
+ -B/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin \
+ -fno-stack-protector -stdlib=libc++ -arch arm64 \
+ -isysroot /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS13.5.sdk \
+ -miphoneos-version-min=9.0 1.c
+```
+
+The similar helper is available for LLVM tools, `$dist/bin/run_konan llvm $tool $arguments`.
diff --git a/kotlin-native/IMMUTABILITY.md b/kotlin-native/IMMUTABILITY.md
new file mode 100644
index 00000000000..b20185485cb
--- /dev/null
+++ b/kotlin-native/IMMUTABILITY.md
@@ -0,0 +1,3 @@
+# Immutability in Kotlin/Native
+
+The content of this page is moved to https://kotlinlang.org/docs/native-immutability.html
\ No newline at end of file
diff --git a/kotlin-native/INTEROP.md b/kotlin-native/INTEROP.md
new file mode 100644
index 00000000000..83c9b604420
--- /dev/null
+++ b/kotlin-native/INTEROP.md
@@ -0,0 +1,3 @@
+# _Kotlin/Native_ interoperability #
+
+The content of this page is moved to https://kotlinlang.org/docs/native-c-interop.html
\ No newline at end of file
diff --git a/kotlin-native/IOS_SYMBOLICATION.md b/kotlin-native/IOS_SYMBOLICATION.md
new file mode 100644
index 00000000000..cb0153fa577
--- /dev/null
+++ b/kotlin-native/IOS_SYMBOLICATION.md
@@ -0,0 +1,3 @@
+# Symbolicating iOS crash reports
+
+The content of this page is moved to https://kotlinlang.org/docs/native-ios-symbolication.html
\ No newline at end of file
diff --git a/kotlin-native/Interop/.idea/compiler.xml b/kotlin-native/Interop/.idea/compiler.xml
new file mode 100644
index 00000000000..96cc43efa6a
--- /dev/null
+++ b/kotlin-native/Interop/.idea/compiler.xml
@@ -0,0 +1,22 @@
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/kotlin-native/Interop/.idea/gradle.xml b/kotlin-native/Interop/.idea/gradle.xml
new file mode 100644
index 00000000000..712ec676d10
--- /dev/null
+++ b/kotlin-native/Interop/.idea/gradle.xml
@@ -0,0 +1,23 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/kotlin-native/Interop/.idea/libraries/Gradle__org_jetbrains_kotlin_kotlin_runtime_1_0_3.xml b/kotlin-native/Interop/.idea/libraries/Gradle__org_jetbrains_kotlin_kotlin_runtime_1_0_3.xml
new file mode 100644
index 00000000000..0eb057374b0
--- /dev/null
+++ b/kotlin-native/Interop/.idea/libraries/Gradle__org_jetbrains_kotlin_kotlin_runtime_1_0_3.xml
@@ -0,0 +1,11 @@
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/kotlin-native/Interop/.idea/libraries/Gradle__org_jetbrains_kotlin_kotlin_stdlib_1_0_3.xml b/kotlin-native/Interop/.idea/libraries/Gradle__org_jetbrains_kotlin_kotlin_stdlib_1_0_3.xml
new file mode 100644
index 00000000000..ae3ca477567
--- /dev/null
+++ b/kotlin-native/Interop/.idea/libraries/Gradle__org_jetbrains_kotlin_kotlin_stdlib_1_0_3.xml
@@ -0,0 +1,11 @@
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/kotlin-native/Interop/.idea/modules.xml b/kotlin-native/Interop/.idea/modules.xml
new file mode 100644
index 00000000000..9013d797b60
--- /dev/null
+++ b/kotlin-native/Interop/.idea/modules.xml
@@ -0,0 +1,10 @@
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/kotlin-native/Interop/.idea/modules/Indexer/Indexer.iml b/kotlin-native/Interop/.idea/modules/Indexer/Indexer.iml
new file mode 100644
index 00000000000..556176b4b39
--- /dev/null
+++ b/kotlin-native/Interop/.idea/modules/Indexer/Indexer.iml
@@ -0,0 +1,24 @@
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/kotlin-native/Interop/.idea/modules/Runtime/Runtime.iml b/kotlin-native/Interop/.idea/modules/Runtime/Runtime.iml
new file mode 100644
index 00000000000..91162e21499
--- /dev/null
+++ b/kotlin-native/Interop/.idea/modules/Runtime/Runtime.iml
@@ -0,0 +1,22 @@
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/kotlin-native/Interop/.idea/modules/StubGenerator/StubGenerator.iml b/kotlin-native/Interop/.idea/modules/StubGenerator/StubGenerator.iml
new file mode 100644
index 00000000000..79b649856d6
--- /dev/null
+++ b/kotlin-native/Interop/.idea/modules/StubGenerator/StubGenerator.iml
@@ -0,0 +1,24 @@
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/kotlin-native/Interop/Indexer/build.gradle.kts b/kotlin-native/Interop/Indexer/build.gradle.kts
new file mode 100644
index 00000000000..8c84f87a824
--- /dev/null
+++ b/kotlin-native/Interop/Indexer/build.gradle.kts
@@ -0,0 +1,194 @@
+/*
+ * Copyright 2010-2017 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import org.jetbrains.gradle.plugins.tools.lib
+import org.jetbrains.gradle.plugins.tools.solib
+import org.jetbrains.kotlin.*
+import org.jetbrains.kotlin.konan.target.*
+import org.jetbrains.kotlin.konan.target.ClangArgs
+import org.jetbrains.kotlin.konan.target.Family.*
+import org.jetbrains.kotlin.konan.target.HostManager.Companion.hostIsMac
+
+plugins {
+ `kotlin`
+ `native-interop-plugin`
+ `native`
+}
+
+
+val libclangextProject = project(":kotlin-native:libclangext")
+val libclangextTask = libclangextProject.path + ":build"
+val libclangextDir = libclangextProject.buildDir
+val libclangextIsEnabled = libclangextProject.findProperty("isEnabled")!! as Boolean
+val llvmDir = project.findProperty("llvmDir")
+
+
+val libclang =
+ if (HostManager.hostIsMingw) {
+ "bin/libclang.dll"
+ } else {
+ "lib/${System.mapLibraryName("clang")}"
+ }
+
+val cflags = mutableListOf( "-I$llvmDir/include",
+ "-I${project(":kotlin-native:libclangext").projectDir.absolutePath}/src/main/include",
+ *platformManager.hostPlatform.clang.hostCompilerArgsForJni)
+if (!HostManager.hostIsMingw) {
+ cflags += "-fPIC"
+}
+
+val ldflags = mutableListOf("$llvmDir/$libclang", "-L${libclangextDir.absolutePath}", "-lclangext")
+
+if (libclangextIsEnabled) {
+ assert(HostManager.hostIsMac)
+ ldflags.addAll(listOf("-Wl,--no-demangle", "-Wl,-search_paths_first", "-Wl,-headerpad_max_install_names", "-Wl,-U,_futimens",
+ "-Wl,-U,__ZN4llvm7remarks11parseFormatENS_9StringRefE",
+ "-Wl,-U,__ZN4llvm7remarks22createRemarkSerializerENS0_6FormatENS0_14SerializerModeERNS_11raw_ostreamE",
+ "-Wl,-U,__ZN4llvm7remarks14YAMLSerializerC1ERNS_11raw_ostreamENS0_14UseStringTableE"))
+
+ val llvmLibs = listOf(
+ "clangAST", "clangASTMatchers", "clangAnalysis", "clangBasic", "clangDriver", "clangEdit",
+ "clangFrontend", "clangFrontendTool", "clangLex", "clangParse", "clangSema", "clangEdit",
+ "clangRewrite", "clangRewriteFrontend", "clangStaticAnalyzerFrontend",
+ "clangStaticAnalyzerCheckers", "clangStaticAnalyzerCore", "clangSerialization",
+ "clangToolingCore",
+ "clangTooling", "clangFormat", "LLVMTarget", "LLVMMC", "LLVMLinker", "LLVMTransformUtils",
+ "LLVMBitWriter", "LLVMBitReader", "LLVMAnalysis", "LLVMProfileData", "LLVMCore",
+ "LLVMSupport", "LLVMBinaryFormat", "LLVMDemangle"
+ ).map { "$llvmDir/lib/lib${it}.a" }
+
+ ldflags.addAll(llvmLibs)
+ ldflags.addAll(listOf("-lpthread", "-lz", "-lm", "-lcurses"))
+}
+
+val solib = when{
+ HostManager.hostIsMingw -> "dll"
+ HostManager.hostIsMac -> "dylib"
+ else -> "so"
+}
+val lib = if (HostManager.hostIsMingw) "lib" else "a"
+
+
+native {
+ val obj = if (HostManager.hostIsMingw) "obj" else "o"
+ val host = rootProject.project(":kotlin-native").extra["hostName"]
+ val hostLibffiDir = rootProject.project(":kotlin-native").extra["${host}LibffiDir"]
+ val cxxflags = listOf("-std=c++11", *cflags.toTypedArray())
+ suffixes {
+ (".c" to ".$obj") {
+ tool(*platformManager.hostPlatform.clang.clangC("").toTypedArray())
+ flags(*cflags.toTypedArray(),
+ "-c", "-o", ruleOut(), ruleInFirst())
+ }
+ (".cpp" to ".$obj") {
+ tool(*platformManager.hostPlatform.clang.clangCXX("").toTypedArray())
+ flags(*cxxflags.toTypedArray(), "-c", "-o", ruleOut(), ruleInFirst())
+ }
+
+ }
+ sourceSet {
+ "main-c" {
+ dir("prebuilt/nativeInteropStubs/c")
+ }
+ "main-cpp" {
+ dir("src/nativeInteropStubs/cpp")
+ }
+ }
+ val objSet = arrayOf(sourceSets["main-c"]!!.transform(".c" to ".$obj"),
+ sourceSets["main-cpp"]!!.transform(".cpp" to ".$obj"))
+
+ target(solib("clangstubs"), *objSet) {
+ tool(*platformManager.hostPlatform.clang.clangCXX("").toTypedArray())
+ flags(
+ "-shared",
+ "-o", ruleOut(), *ruleInAll(),
+ *ldflags.toTypedArray())
+ }
+}
+
+tasks.named(solib("clangstubs")).configure {
+ dependsOn(":kotlin-native:libclangext:${lib("clangext")}")
+}
+
+sourceSets {
+ "main" {
+ java {
+ srcDirs("prebuilt/nativeInteropStubs/kotlin")
+ }
+ kotlin{
+
+ target {
+
+ }
+ }
+ }
+}
+
+
+dependencies {
+ compile(project(":kotlin-stdlib"))
+ compile(project(":kotlin-native:Interop:Runtime"))
+}
+
+val nativelibs = project.tasks.create("nativelibs") {
+ dependsOn(solib("clangstubs"))
+
+ from("$buildDir/")
+ into("$buildDir/nativelibs/")
+}
+
+kotlinNativeInterop {
+ this.create("clang") {
+ defFile("clang.def")
+ compilerOpts(cflags)
+ linkerOpts = ldflags
+ genTask.dependsOn(libclangextTask)
+ genTask.inputs.dir(libclangextDir)
+ }
+}
+val compileKotlin: org.jetbrains.kotlin.gradle.tasks.KotlinCompile by tasks
+
+tasks.withType().configureEach {
+ kotlinOptions {
+ allWarningsAsErrors = true
+ freeCompilerArgs = listOf("-Xskip-prerelease-check")
+ }
+}
+
+tasks.matching { it.name == "linkClangstubsSharedLibrary" }.all {
+ dependsOn(libclangextTask)
+ inputs.dir(libclangextDir)
+}
+
+tasks.create("updatePrebuilt") {
+ dependsOn("genClangInteropStubs")
+
+ doLast {
+ copy {
+ from("$buildDir/nativeInteropStubs/clang/kotlin") {
+ include("clang/clang.kt")
+ }
+ into("prebuilt/nativeInteropStubs/kotlin")
+ }
+
+ copy {
+ from("$buildDir/interopTemp") {
+ include("clangstubs.c")
+ }
+ into("prebuilt/nativeInteropStubs/c")
+ }
+ }
+}
diff --git a/kotlin-native/Interop/Indexer/clang.def b/kotlin-native/Interop/Indexer/clang.def
new file mode 100644
index 00000000000..9bbd52a7b1d
--- /dev/null
+++ b/kotlin-native/Interop/Indexer/clang.def
@@ -0,0 +1,16 @@
+headers = clang-c/Index.h clang-c/ext.h clang-c/ExtVector.h
+
+headerFilter = clang-c/**
+
+compiler = clang
+
+compilerOpts = -std=c99 -fPIC
+linkerOpts.linux = -Wl,-z,noexecstack
+
+linker = clang++
+
+linkerOpts = -fPIC
+
+strictEnums = CXErrorCode CXCursorKind CXTypeKind CXDiagnosticSeverity CXLoadDiag_Error CXSaveError \
+ CXTUResourceUsageKind CXLinkageKind CXVisibilityKind CXLanguageKind CXCallingConv CXChildVisitResult \
+ CXTokenKind CXEvalResultKind CXVisitorResult CXResult CXIdxEntityKind
diff --git a/kotlin-native/Interop/Indexer/prebuilt/nativeInteropStubs/c/clangstubs.c b/kotlin-native/Interop/Indexer/prebuilt/nativeInteropStubs/c/clangstubs.c
new file mode 100644
index 00000000000..bddeac54ac7
--- /dev/null
+++ b/kotlin-native/Interop/Indexer/prebuilt/nativeInteropStubs/c/clangstubs.c
@@ -0,0 +1,1125 @@
+#include
+#include
+#include
+#include
+#include
+#include
+
+// NOTE THIS FILE IS AUTO-GENERATED
+
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge0 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jlong)clang_getCString(*(CXString*)p0);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge1 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ clang_disposeString(*(CXString*)p0);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge2 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ clang_disposeStringSet((CXStringSet*)p0);
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge3 (JNIEnv* jniEnv, jclass jclss) {
+ return (jlong)clang_getBuildSessionTimestamp();
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge4 (JNIEnv* jniEnv, jclass jclss, jint p0) {
+ return (jlong)clang_VirtualFileOverlay_create(p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge5 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1, jlong p2) {
+ return (jint)clang_VirtualFileOverlay_addFileMapping((struct CXVirtualFileOverlayImpl*)p0, (char*)p1, (char*)p2);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge6 (JNIEnv* jniEnv, jclass jclss, jlong p0, jint p1) {
+ return (jint)clang_VirtualFileOverlay_setCaseSensitivity((struct CXVirtualFileOverlayImpl*)p0, p1);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge7 (JNIEnv* jniEnv, jclass jclss, jlong p0, jint p1, jlong p2, jlong p3) {
+ return (jint)clang_VirtualFileOverlay_writeToBuffer((struct CXVirtualFileOverlayImpl*)p0, p1, (char**)p2, (unsigned int*)p3);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge8 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ clang_free((void*)p0);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge9 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ clang_VirtualFileOverlay_dispose((struct CXVirtualFileOverlayImpl*)p0);
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge10 (JNIEnv* jniEnv, jclass jclss, jint p0) {
+ return (jlong)clang_ModuleMapDescriptor_create(p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge11 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ return (jint)clang_ModuleMapDescriptor_setFrameworkModuleName((struct CXModuleMapDescriptorImpl*)p0, (char*)p1);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge12 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ return (jint)clang_ModuleMapDescriptor_setUmbrellaHeader((struct CXModuleMapDescriptorImpl*)p0, (char*)p1);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge13 (JNIEnv* jniEnv, jclass jclss, jlong p0, jint p1, jlong p2, jlong p3) {
+ return (jint)clang_ModuleMapDescriptor_writeToBuffer((struct CXModuleMapDescriptorImpl*)p0, p1, (char**)p2, (unsigned int*)p3);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge14 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ clang_ModuleMapDescriptor_dispose((struct CXModuleMapDescriptorImpl*)p0);
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge15 (JNIEnv* jniEnv, jclass jclss, jint p0, jint p1) {
+ return (jlong)clang_createIndex(p0, p1);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge16 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ clang_disposeIndex((void*)p0);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge17 (JNIEnv* jniEnv, jclass jclss, jlong p0, jint p1) {
+ clang_CXIndex_setGlobalOptions((void*)p0, p1);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge18 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_CXIndex_getGlobalOptions((void*)p0);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge19 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ clang_CXIndex_setInvocationEmissionPathOption((void*)p0, (char*)p1);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge20 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXString kniStructResult = clang_getFileName((void*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge21 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jlong)clang_getFileTime((void*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge22 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ return (jint)clang_getFileUniqueID((void*)p0, (CXFileUniqueID*)p1);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge23 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ return (jint)clang_isFileMultipleIncludeGuarded((struct CXTranslationUnitImpl*)p0, (void*)p1);
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge24 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ return (jlong)clang_getFile((struct CXTranslationUnitImpl*)p0, (char*)p1);
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge25 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1, jlong p2) {
+ return (jlong)clang_getFileContents((struct CXTranslationUnitImpl*)p0, (void*)p1, (unsigned long*)p2);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge26 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ return (jint)clang_File_isEqual((void*)p0, (void*)p1);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge27 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXString kniStructResult = clang_File_tryGetRealPathName((void*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge28 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ CXSourceLocation kniStructResult = clang_getNullLocation();
+ memcpy(p0, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge29 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ return (jint)clang_equalLocations(*(CXSourceLocation*)p0, *(CXSourceLocation*)p1);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge30 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1, jint p2, jint p3, jlong p4) {
+ CXSourceLocation kniStructResult = clang_getLocation((struct CXTranslationUnitImpl*)p0, (void*)p1, p2, p3);
+ memcpy(p4, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge31 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1, jint p2, jlong p3) {
+ CXSourceLocation kniStructResult = clang_getLocationForOffset((struct CXTranslationUnitImpl*)p0, (void*)p1, p2);
+ memcpy(p3, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge32 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_Location_isInSystemHeader(*(CXSourceLocation*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge33 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_Location_isFromMainFile(*(CXSourceLocation*)p0);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge34 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ CXSourceRange kniStructResult = clang_getNullRange();
+ memcpy(p0, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge35 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1, jlong p2) {
+ CXSourceRange kniStructResult = clang_getRange(*(CXSourceLocation*)p0, *(CXSourceLocation*)p1);
+ memcpy(p2, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge36 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ return (jint)clang_equalRanges(*(CXSourceRange*)p0, *(CXSourceRange*)p1);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge37 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_Range_isNull(*(CXSourceRange*)p0);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge38 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1, jlong p2, jlong p3, jlong p4) {
+ clang_getExpansionLocation(*(CXSourceLocation*)p0, (void*)p1, (unsigned int*)p2, (unsigned int*)p3, (unsigned int*)p4);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge39 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1, jlong p2, jlong p3) {
+ clang_getPresumedLocation(*(CXSourceLocation*)p0, (CXString*)p1, (unsigned int*)p2, (unsigned int*)p3);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge40 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1, jlong p2, jlong p3, jlong p4) {
+ clang_getInstantiationLocation(*(CXSourceLocation*)p0, (void*)p1, (unsigned int*)p2, (unsigned int*)p3, (unsigned int*)p4);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge41 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1, jlong p2, jlong p3, jlong p4) {
+ clang_getSpellingLocation(*(CXSourceLocation*)p0, (void*)p1, (unsigned int*)p2, (unsigned int*)p3, (unsigned int*)p4);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge42 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1, jlong p2, jlong p3, jlong p4) {
+ clang_getFileLocation(*(CXSourceLocation*)p0, (void*)p1, (unsigned int*)p2, (unsigned int*)p3, (unsigned int*)p4);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge43 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXSourceLocation kniStructResult = clang_getRangeStart(*(CXSourceRange*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge44 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXSourceLocation kniStructResult = clang_getRangeEnd(*(CXSourceRange*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge45 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ return (jlong)clang_getSkippedRanges((struct CXTranslationUnitImpl*)p0, (void*)p1);
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge46 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jlong)clang_getAllSkippedRanges((struct CXTranslationUnitImpl*)p0);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge47 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ clang_disposeSourceRangeList((CXSourceRangeList*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge48 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_getNumDiagnosticsInSet((void*)p0);
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge49 (JNIEnv* jniEnv, jclass jclss, jlong p0, jint p1) {
+ return (jlong)clang_getDiagnosticInSet((void*)p0, p1);
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge50 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1, jlong p2) {
+ return (jlong)clang_loadDiagnostics((char*)p0, (void*)p1, (CXString*)p2);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge51 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ clang_disposeDiagnosticSet((void*)p0);
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge52 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jlong)clang_getChildDiagnostics((void*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge53 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_getNumDiagnostics((struct CXTranslationUnitImpl*)p0);
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge54 (JNIEnv* jniEnv, jclass jclss, jlong p0, jint p1) {
+ return (jlong)clang_getDiagnostic((struct CXTranslationUnitImpl*)p0, p1);
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge55 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jlong)clang_getDiagnosticSetFromTU((struct CXTranslationUnitImpl*)p0);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge56 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ clang_disposeDiagnostic((void*)p0);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge57 (JNIEnv* jniEnv, jclass jclss, jlong p0, jint p1, jlong p2) {
+ CXString kniStructResult = clang_formatDiagnostic((void*)p0, p1);
+ memcpy(p2, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge58 (JNIEnv* jniEnv, jclass jclss) {
+ return (jint)clang_defaultDiagnosticDisplayOptions();
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge59 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_getDiagnosticSeverity((void*)p0);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge60 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXSourceLocation kniStructResult = clang_getDiagnosticLocation((void*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge61 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXString kniStructResult = clang_getDiagnosticSpelling((void*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge62 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1, jlong p2) {
+ CXString kniStructResult = clang_getDiagnosticOption((void*)p0, (CXString*)p1);
+ memcpy(p2, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge63 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_getDiagnosticCategory((void*)p0);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge64 (JNIEnv* jniEnv, jclass jclss, jint p0, jlong p1) {
+ CXString kniStructResult = clang_getDiagnosticCategoryName(p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge65 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXString kniStructResult = clang_getDiagnosticCategoryText((void*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge66 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_getDiagnosticNumRanges((void*)p0);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge67 (JNIEnv* jniEnv, jclass jclss, jlong p0, jint p1, jlong p2) {
+ CXSourceRange kniStructResult = clang_getDiagnosticRange((void*)p0, p1);
+ memcpy(p2, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge68 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_getDiagnosticNumFixIts((void*)p0);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge69 (JNIEnv* jniEnv, jclass jclss, jlong p0, jint p1, jlong p2, jlong p3) {
+ CXString kniStructResult = clang_getDiagnosticFixIt((void*)p0, p1, (CXSourceRange*)p2);
+ memcpy(p3, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge70 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXString kniStructResult = clang_getTranslationUnitSpelling((struct CXTranslationUnitImpl*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge71 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1, jint p2, jlong p3, jint p4, jlong p5) {
+ return (jlong)clang_createTranslationUnitFromSourceFile((void*)p0, (char*)p1, p2, (char**)p3, p4, (struct CXUnsavedFile*)p5);
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge72 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ return (jlong)clang_createTranslationUnit((void*)p0, (char*)p1);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge73 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1, jlong p2) {
+ return (jint)clang_createTranslationUnit2((void*)p0, (char*)p1, (struct CXTranslationUnitImpl**)p2);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge74 (JNIEnv* jniEnv, jclass jclss) {
+ return (jint)clang_defaultEditingTranslationUnitOptions();
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge75 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1, jlong p2, jint p3, jlong p4, jint p5, jint p6) {
+ return (jlong)clang_parseTranslationUnit((void*)p0, (char*)p1, (char**)p2, p3, (struct CXUnsavedFile*)p4, p5, p6);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge76 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1, jlong p2, jint p3, jlong p4, jint p5, jint p6, jlong p7) {
+ return (jint)clang_parseTranslationUnit2((void*)p0, (char*)p1, (char**)p2, p3, (struct CXUnsavedFile*)p4, p5, p6, (struct CXTranslationUnitImpl**)p7);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge77 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1, jlong p2, jint p3, jlong p4, jint p5, jint p6, jlong p7) {
+ return (jint)clang_parseTranslationUnit2FullArgv((void*)p0, (char*)p1, (char**)p2, p3, (struct CXUnsavedFile*)p4, p5, p6, (struct CXTranslationUnitImpl**)p7);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge78 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_defaultSaveOptions((struct CXTranslationUnitImpl*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge79 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1, jint p2) {
+ return (jint)clang_saveTranslationUnit((struct CXTranslationUnitImpl*)p0, (char*)p1, p2);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge80 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_suspendTranslationUnit((struct CXTranslationUnitImpl*)p0);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge81 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ clang_disposeTranslationUnit((struct CXTranslationUnitImpl*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge82 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_defaultReparseOptions((struct CXTranslationUnitImpl*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge83 (JNIEnv* jniEnv, jclass jclss, jlong p0, jint p1, jlong p2, jint p3) {
+ return (jint)clang_reparseTranslationUnit((struct CXTranslationUnitImpl*)p0, p1, (struct CXUnsavedFile*)p2, p3);
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge84 (JNIEnv* jniEnv, jclass jclss, jint p0) {
+ return (jlong)clang_getTUResourceUsageName(p0);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge85 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ struct CXTUResourceUsage kniStructResult = clang_getCXTUResourceUsage((struct CXTranslationUnitImpl*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge86 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ clang_disposeCXTUResourceUsage(*(struct CXTUResourceUsage*)p0);
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge87 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jlong)clang_getTranslationUnitTargetInfo((struct CXTranslationUnitImpl*)p0);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge88 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ clang_TargetInfo_dispose((struct CXTargetInfoImpl*)p0);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge89 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXString kniStructResult = clang_TargetInfo_getTriple((struct CXTargetInfoImpl*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge90 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_TargetInfo_getPointerWidth((struct CXTargetInfoImpl*)p0);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge91 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ CXCursor kniStructResult = clang_getNullCursor();
+ memcpy(p0, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge92 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXCursor kniStructResult = clang_getTranslationUnitCursor((struct CXTranslationUnitImpl*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge93 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ return (jint)clang_equalCursors(*(CXCursor*)p0, *(CXCursor*)p1);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge94 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_Cursor_isNull(*(CXCursor*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge95 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_hashCursor(*(CXCursor*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge96 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_getCursorKind(*(CXCursor*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge97 (JNIEnv* jniEnv, jclass jclss, jint p0) {
+ return (jint)clang_isDeclaration(p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge98 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_isInvalidDeclaration(*(CXCursor*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge99 (JNIEnv* jniEnv, jclass jclss, jint p0) {
+ return (jint)clang_isReference(p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge100 (JNIEnv* jniEnv, jclass jclss, jint p0) {
+ return (jint)clang_isExpression(p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge101 (JNIEnv* jniEnv, jclass jclss, jint p0) {
+ return (jint)clang_isStatement(p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge102 (JNIEnv* jniEnv, jclass jclss, jint p0) {
+ return (jint)clang_isAttribute(p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge103 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_Cursor_hasAttrs(*(CXCursor*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge104 (JNIEnv* jniEnv, jclass jclss, jint p0) {
+ return (jint)clang_isInvalid(p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge105 (JNIEnv* jniEnv, jclass jclss, jint p0) {
+ return (jint)clang_isTranslationUnit(p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge106 (JNIEnv* jniEnv, jclass jclss, jint p0) {
+ return (jint)clang_isPreprocessing(p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge107 (JNIEnv* jniEnv, jclass jclss, jint p0) {
+ return (jint)clang_isUnexposed(p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge108 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_getCursorLinkage(*(CXCursor*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge109 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_getCursorVisibility(*(CXCursor*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge110 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_getCursorAvailability(*(CXCursor*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge111 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1, jlong p2, jlong p3, jlong p4, jlong p5, jint p6) {
+ return (jint)clang_getCursorPlatformAvailability(*(CXCursor*)p0, (int*)p1, (CXString*)p2, (int*)p3, (CXString*)p4, (struct CXPlatformAvailability*)p5, p6);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge112 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ clang_disposeCXPlatformAvailability((struct CXPlatformAvailability*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge113 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_getCursorLanguage(*(CXCursor*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge114 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_getCursorTLSKind(*(CXCursor*)p0);
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge115 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jlong)clang_Cursor_getTranslationUnit(*(CXCursor*)p0);
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge116 (JNIEnv* jniEnv, jclass jclss) {
+ return (jlong)clang_createCXCursorSet();
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge117 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ clang_disposeCXCursorSet((struct CXCursorSetImpl*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge118 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ return (jint)clang_CXCursorSet_contains((struct CXCursorSetImpl*)p0, *(CXCursor*)p1);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge119 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ return (jint)clang_CXCursorSet_insert((struct CXCursorSetImpl*)p0, *(CXCursor*)p1);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge120 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXCursor kniStructResult = clang_getCursorSemanticParent(*(CXCursor*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge121 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXCursor kniStructResult = clang_getCursorLexicalParent(*(CXCursor*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge122 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1, jlong p2) {
+ clang_getOverriddenCursors(*(CXCursor*)p0, (CXCursor**)p1, (unsigned int*)p2);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge123 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ clang_disposeOverriddenCursors((CXCursor*)p0);
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge124 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jlong)clang_getIncludedFile(*(CXCursor*)p0);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge125 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1, jlong p2) {
+ CXCursor kniStructResult = clang_getCursor((struct CXTranslationUnitImpl*)p0, *(CXSourceLocation*)p1);
+ memcpy(p2, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge126 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXSourceLocation kniStructResult = clang_getCursorLocation(*(CXCursor*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge127 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXSourceRange kniStructResult = clang_getCursorExtent(*(CXCursor*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge128 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXType kniStructResult = clang_getCursorType(*(CXCursor*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge129 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXString kniStructResult = clang_getTypeSpelling(*(CXType*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge130 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXType kniStructResult = clang_getTypedefDeclUnderlyingType(*(CXCursor*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge131 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXType kniStructResult = clang_getEnumDeclIntegerType(*(CXCursor*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge132 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jlong)clang_getEnumConstantDeclValue(*(CXCursor*)p0);
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge133 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jlong)clang_getEnumConstantDeclUnsignedValue(*(CXCursor*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge134 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_getFieldDeclBitWidth(*(CXCursor*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge135 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_Cursor_getNumArguments(*(CXCursor*)p0);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge136 (JNIEnv* jniEnv, jclass jclss, jlong p0, jint p1, jlong p2) {
+ CXCursor kniStructResult = clang_Cursor_getArgument(*(CXCursor*)p0, p1);
+ memcpy(p2, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge137 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_Cursor_getNumTemplateArguments(*(CXCursor*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge138 (JNIEnv* jniEnv, jclass jclss, jlong p0, jint p1) {
+ return (jint)clang_Cursor_getTemplateArgumentKind(*(CXCursor*)p0, p1);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge139 (JNIEnv* jniEnv, jclass jclss, jlong p0, jint p1, jlong p2) {
+ CXType kniStructResult = clang_Cursor_getTemplateArgumentType(*(CXCursor*)p0, p1);
+ memcpy(p2, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge140 (JNIEnv* jniEnv, jclass jclss, jlong p0, jint p1) {
+ return (jlong)clang_Cursor_getTemplateArgumentValue(*(CXCursor*)p0, p1);
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge141 (JNIEnv* jniEnv, jclass jclss, jlong p0, jint p1) {
+ return (jlong)clang_Cursor_getTemplateArgumentUnsignedValue(*(CXCursor*)p0, p1);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge142 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ return (jint)clang_equalTypes(*(CXType*)p0, *(CXType*)p1);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge143 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXType kniStructResult = clang_getCanonicalType(*(CXType*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge144 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_isConstQualifiedType(*(CXType*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge145 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_Cursor_isMacroFunctionLike(*(CXCursor*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge146 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_Cursor_isMacroBuiltin(*(CXCursor*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge147 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_Cursor_isFunctionInlined(*(CXCursor*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge148 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_isVolatileQualifiedType(*(CXType*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge149 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_isRestrictQualifiedType(*(CXType*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge150 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_getAddressSpace(*(CXType*)p0);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge151 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXString kniStructResult = clang_getTypedefName(*(CXType*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge152 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXType kniStructResult = clang_getPointeeType(*(CXType*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge153 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXCursor kniStructResult = clang_getTypeDeclaration(*(CXType*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge154 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXString kniStructResult = clang_getDeclObjCTypeEncoding(*(CXCursor*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge155 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXString kniStructResult = clang_Type_getObjCEncoding(*(CXType*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge156 (JNIEnv* jniEnv, jclass jclss, jint p0, jlong p1) {
+ CXString kniStructResult = clang_getTypeKindSpelling(p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge157 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_getFunctionTypeCallingConv(*(CXType*)p0);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge158 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXType kniStructResult = clang_getResultType(*(CXType*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge159 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_getExceptionSpecificationType(*(CXType*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge160 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_getNumArgTypes(*(CXType*)p0);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge161 (JNIEnv* jniEnv, jclass jclss, jlong p0, jint p1, jlong p2) {
+ CXType kniStructResult = clang_getArgType(*(CXType*)p0, p1);
+ memcpy(p2, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge162 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXType kniStructResult = clang_Type_getObjCObjectBaseType(*(CXType*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge163 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_Type_getNumObjCProtocolRefs(*(CXType*)p0);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge164 (JNIEnv* jniEnv, jclass jclss, jlong p0, jint p1, jlong p2) {
+ CXCursor kniStructResult = clang_Type_getObjCProtocolDecl(*(CXType*)p0, p1);
+ memcpy(p2, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge165 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_Type_getNumObjCTypeArgs(*(CXType*)p0);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge166 (JNIEnv* jniEnv, jclass jclss, jlong p0, jint p1, jlong p2) {
+ CXType kniStructResult = clang_Type_getObjCTypeArg(*(CXType*)p0, p1);
+ memcpy(p2, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge167 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_isFunctionTypeVariadic(*(CXType*)p0);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge168 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXType kniStructResult = clang_getCursorResultType(*(CXCursor*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge169 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_getCursorExceptionSpecificationType(*(CXCursor*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge170 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_isPODType(*(CXType*)p0);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge171 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXType kniStructResult = clang_getElementType(*(CXType*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge172 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jlong)clang_getNumElements(*(CXType*)p0);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge173 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXType kniStructResult = clang_getArrayElementType(*(CXType*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge174 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jlong)clang_getArraySize(*(CXType*)p0);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge175 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXType kniStructResult = clang_Type_getNamedType(*(CXType*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge176 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_Type_isTransparentTagTypedef(*(CXType*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge177 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_Type_getNullability(*(CXType*)p0);
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge178 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jlong)clang_Type_getAlignOf(*(CXType*)p0);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge179 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXType kniStructResult = clang_Type_getClassType(*(CXType*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge180 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jlong)clang_Type_getSizeOf(*(CXType*)p0);
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge181 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ return (jlong)clang_Type_getOffsetOf(*(CXType*)p0, (char*)p1);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge182 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXType kniStructResult = clang_Type_getModifiedType(*(CXType*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge183 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jlong)clang_Cursor_getOffsetOfField(*(CXCursor*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge184 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_Cursor_isAnonymous(*(CXCursor*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge185 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_Type_getNumTemplateArguments(*(CXType*)p0);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge186 (JNIEnv* jniEnv, jclass jclss, jlong p0, jint p1, jlong p2) {
+ CXType kniStructResult = clang_Type_getTemplateArgumentAsType(*(CXType*)p0, p1);
+ memcpy(p2, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge187 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_Type_getCXXRefQualifier(*(CXType*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge188 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_Cursor_isBitField(*(CXCursor*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge189 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_isVirtualBase(*(CXCursor*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge190 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_getCXXAccessSpecifier(*(CXCursor*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge191 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_Cursor_getStorageClass(*(CXCursor*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge192 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_getNumOverloadedDecls(*(CXCursor*)p0);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge193 (JNIEnv* jniEnv, jclass jclss, jlong p0, jint p1, jlong p2) {
+ CXCursor kniStructResult = clang_getOverloadedDecl(*(CXCursor*)p0, p1);
+ memcpy(p2, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge194 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXType kniStructResult = clang_getIBOutletCollectionType(*(CXCursor*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge195 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1, jlong p2) {
+ return (jint)clang_visitChildren(*(CXCursor*)p0, (void*)p1, (void*)p2);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge196 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXString kniStructResult = clang_getCursorUSR(*(CXCursor*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge197 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXString kniStructResult = clang_constructUSR_ObjCClass((char*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge198 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1, jlong p2) {
+ CXString kniStructResult = clang_constructUSR_ObjCCategory((char*)p0, (char*)p1);
+ memcpy(p2, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge199 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXString kniStructResult = clang_constructUSR_ObjCProtocol((char*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge200 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1, jlong p2) {
+ CXString kniStructResult = clang_constructUSR_ObjCIvar((char*)p0, *(CXString*)p1);
+ memcpy(p2, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge201 (JNIEnv* jniEnv, jclass jclss, jlong p0, jint p1, jlong p2, jlong p3) {
+ CXString kniStructResult = clang_constructUSR_ObjCMethod((char*)p0, p1, *(CXString*)p2);
+ memcpy(p3, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge202 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1, jlong p2) {
+ CXString kniStructResult = clang_constructUSR_ObjCProperty((char*)p0, *(CXString*)p1);
+ memcpy(p2, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge203 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXString kniStructResult = clang_getCursorSpelling(*(CXCursor*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge204 (JNIEnv* jniEnv, jclass jclss, jlong p0, jint p1, jint p2, jlong p3) {
+ CXSourceRange kniStructResult = clang_Cursor_getSpellingNameRange(*(CXCursor*)p0, p1, p2);
+ memcpy(p3, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge205 (JNIEnv* jniEnv, jclass jclss, jlong p0, jint p1) {
+ return (jint)clang_PrintingPolicy_getProperty((void*)p0, p1);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge206 (JNIEnv* jniEnv, jclass jclss, jlong p0, jint p1, jint p2) {
+ clang_PrintingPolicy_setProperty((void*)p0, p1, p2);
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge207 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jlong)clang_getCursorPrintingPolicy(*(CXCursor*)p0);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge208 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ clang_PrintingPolicy_dispose((void*)p0);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge209 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1, jlong p2) {
+ CXString kniStructResult = clang_getCursorPrettyPrinted(*(CXCursor*)p0, (void*)p1);
+ memcpy(p2, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge210 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXString kniStructResult = clang_getCursorDisplayName(*(CXCursor*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge211 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXCursor kniStructResult = clang_getCursorReferenced(*(CXCursor*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge212 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXCursor kniStructResult = clang_getCursorDefinition(*(CXCursor*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge213 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_isCursorDefinition(*(CXCursor*)p0);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge214 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXCursor kniStructResult = clang_getCanonicalCursor(*(CXCursor*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge215 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_Cursor_getObjCSelectorIndex(*(CXCursor*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge216 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_Cursor_isDynamicCall(*(CXCursor*)p0);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge217 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXType kniStructResult = clang_Cursor_getReceiverType(*(CXCursor*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge218 (JNIEnv* jniEnv, jclass jclss, jlong p0, jint p1) {
+ return (jint)clang_Cursor_getObjCPropertyAttributes(*(CXCursor*)p0, p1);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge219 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXString kniStructResult = clang_Cursor_getObjCPropertyGetterName(*(CXCursor*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge220 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXString kniStructResult = clang_Cursor_getObjCPropertySetterName(*(CXCursor*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge221 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_Cursor_getObjCDeclQualifiers(*(CXCursor*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge222 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_Cursor_isObjCOptional(*(CXCursor*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge223 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_Cursor_isVariadic(*(CXCursor*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge224 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1, jlong p2, jlong p3) {
+ return (jint)clang_Cursor_isExternalSymbol(*(CXCursor*)p0, (CXString*)p1, (CXString*)p2, (unsigned int*)p3);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge225 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXSourceRange kniStructResult = clang_Cursor_getCommentRange(*(CXCursor*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge226 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXString kniStructResult = clang_Cursor_getRawCommentText(*(CXCursor*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge227 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXString kniStructResult = clang_Cursor_getBriefCommentText(*(CXCursor*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge228 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXString kniStructResult = clang_Cursor_getMangling(*(CXCursor*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge229 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jlong)clang_Cursor_getCXXManglings(*(CXCursor*)p0);
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge230 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jlong)clang_Cursor_getObjCManglings(*(CXCursor*)p0);
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge231 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jlong)clang_Cursor_getModule(*(CXCursor*)p0);
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge232 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ return (jlong)clang_getModuleForFile((struct CXTranslationUnitImpl*)p0, (void*)p1);
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge233 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jlong)clang_Module_getASTFile((void*)p0);
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge234 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jlong)clang_Module_getParent((void*)p0);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge235 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXString kniStructResult = clang_Module_getName((void*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge236 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXString kniStructResult = clang_Module_getFullName((void*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge237 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_Module_isSystem((void*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge238 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ return (jint)clang_Module_getNumTopLevelHeaders((struct CXTranslationUnitImpl*)p0, (void*)p1);
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge239 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1, jint p2) {
+ return (jlong)clang_Module_getTopLevelHeader((struct CXTranslationUnitImpl*)p0, (void*)p1, p2);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge240 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_CXXConstructor_isConvertingConstructor(*(CXCursor*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge241 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_CXXConstructor_isCopyConstructor(*(CXCursor*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge242 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_CXXConstructor_isDefaultConstructor(*(CXCursor*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge243 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_CXXConstructor_isMoveConstructor(*(CXCursor*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge244 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_CXXField_isMutable(*(CXCursor*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge245 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_CXXMethod_isDefaulted(*(CXCursor*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge246 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_CXXMethod_isPureVirtual(*(CXCursor*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge247 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_CXXMethod_isStatic(*(CXCursor*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge248 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_CXXMethod_isVirtual(*(CXCursor*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge249 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_CXXRecord_isAbstract(*(CXCursor*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge250 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_EnumDecl_isScoped(*(CXCursor*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge251 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_CXXMethod_isConst(*(CXCursor*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge252 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_getTemplateCursorKind(*(CXCursor*)p0);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge253 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXCursor kniStructResult = clang_getSpecializedCursorTemplate(*(CXCursor*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge254 (JNIEnv* jniEnv, jclass jclss, jlong p0, jint p1, jint p2, jlong p3) {
+ CXSourceRange kniStructResult = clang_getCursorReferenceNameRange(*(CXCursor*)p0, p1, p2);
+ memcpy(p3, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge255 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ return (jlong)clang_getToken((struct CXTranslationUnitImpl*)p0, *(CXSourceLocation*)p1);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge256 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_getTokenKind(*(CXToken*)p0);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge257 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1, jlong p2) {
+ CXString kniStructResult = clang_getTokenSpelling((struct CXTranslationUnitImpl*)p0, *(CXToken*)p1);
+ memcpy(p2, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge258 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1, jlong p2) {
+ CXSourceLocation kniStructResult = clang_getTokenLocation((struct CXTranslationUnitImpl*)p0, *(CXToken*)p1);
+ memcpy(p2, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge259 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1, jlong p2) {
+ CXSourceRange kniStructResult = clang_getTokenExtent((struct CXTranslationUnitImpl*)p0, *(CXToken*)p1);
+ memcpy(p2, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge260 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1, jlong p2, jlong p3) {
+ clang_tokenize((struct CXTranslationUnitImpl*)p0, *(CXSourceRange*)p1, (CXToken**)p2, (unsigned int*)p3);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge261 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1, jint p2, jlong p3) {
+ clang_annotateTokens((struct CXTranslationUnitImpl*)p0, (CXToken*)p1, p2, (CXCursor*)p3);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge262 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1, jint p2) {
+ clang_disposeTokens((struct CXTranslationUnitImpl*)p0, (CXToken*)p1, p2);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge263 (JNIEnv* jniEnv, jclass jclss, jint p0, jlong p1) {
+ CXString kniStructResult = clang_getCursorKindSpelling(p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge264 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1, jlong p2, jlong p3, jlong p4, jlong p5, jlong p6) {
+ clang_getDefinitionSpellingAndExtent(*(CXCursor*)p0, (char**)p1, (char**)p2, (unsigned int*)p3, (unsigned int*)p4, (unsigned int*)p5, (unsigned int*)p6);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge265 (JNIEnv* jniEnv, jclass jclss) {
+ clang_enableStackTraces();
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge266 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1, jint p2) {
+ clang_executeOnThread((void*)p0, (void*)p1, p2);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge267 (JNIEnv* jniEnv, jclass jclss, jlong p0, jint p1) {
+ return (jint)clang_getCompletionChunkKind((void*)p0, p1);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge268 (JNIEnv* jniEnv, jclass jclss, jlong p0, jint p1, jlong p2) {
+ CXString kniStructResult = clang_getCompletionChunkText((void*)p0, p1);
+ memcpy(p2, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge269 (JNIEnv* jniEnv, jclass jclss, jlong p0, jint p1) {
+ return (jlong)clang_getCompletionChunkCompletionString((void*)p0, p1);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge270 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_getNumCompletionChunks((void*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge271 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_getCompletionPriority((void*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge272 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_getCompletionAvailability((void*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge273 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_getCompletionNumAnnotations((void*)p0);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge274 (JNIEnv* jniEnv, jclass jclss, jlong p0, jint p1, jlong p2) {
+ CXString kniStructResult = clang_getCompletionAnnotation((void*)p0, p1);
+ memcpy(p2, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge275 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1, jlong p2) {
+ CXString kniStructResult = clang_getCompletionParent((void*)p0, (void*)p1);
+ memcpy(p2, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge276 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXString kniStructResult = clang_getCompletionBriefComment((void*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge277 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jlong)clang_getCursorCompletionString(*(CXCursor*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge278 (JNIEnv* jniEnv, jclass jclss, jlong p0, jint p1) {
+ return (jint)clang_getCompletionNumFixIts((CXCodeCompleteResults*)p0, p1);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge279 (JNIEnv* jniEnv, jclass jclss, jlong p0, jint p1, jint p2, jlong p3, jlong p4) {
+ CXString kniStructResult = clang_getCompletionFixIt((CXCodeCompleteResults*)p0, p1, p2, (CXSourceRange*)p3);
+ memcpy(p4, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge280 (JNIEnv* jniEnv, jclass jclss) {
+ return (jint)clang_defaultCodeCompleteOptions();
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge281 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1, jint p2, jint p3, jlong p4, jint p5, jint p6) {
+ return (jlong)clang_codeCompleteAt((struct CXTranslationUnitImpl*)p0, (char*)p1, p2, p3, (struct CXUnsavedFile*)p4, p5, p6);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge282 (JNIEnv* jniEnv, jclass jclss, jlong p0, jint p1) {
+ clang_sortCodeCompletionResults((CXCompletionResult*)p0, p1);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge283 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ clang_disposeCodeCompleteResults((CXCodeCompleteResults*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge284 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_codeCompleteGetNumDiagnostics((CXCodeCompleteResults*)p0);
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge285 (JNIEnv* jniEnv, jclass jclss, jlong p0, jint p1) {
+ return (jlong)clang_codeCompleteGetDiagnostic((CXCodeCompleteResults*)p0, p1);
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge286 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jlong)clang_codeCompleteGetContexts((CXCodeCompleteResults*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge287 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ return (jint)clang_codeCompleteGetContainerKind((CXCodeCompleteResults*)p0, (unsigned int*)p1);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge288 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXString kniStructResult = clang_codeCompleteGetContainerUSR((CXCodeCompleteResults*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge289 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXString kniStructResult = clang_codeCompleteGetObjCSelector((CXCodeCompleteResults*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge290 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ CXString kniStructResult = clang_getClangVersion();
+ memcpy(p0, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge291 (JNIEnv* jniEnv, jclass jclss, jint p0) {
+ clang_toggleCrashRecovery(p0);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge292 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1, jlong p2) {
+ clang_getInclusions((struct CXTranslationUnitImpl*)p0, (void*)p1, (void*)p2);
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge293 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jlong)clang_Cursor_Evaluate(*(CXCursor*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge294 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_EvalResult_getKind((void*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge295 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_EvalResult_getAsInt((void*)p0);
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge296 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jlong)clang_EvalResult_getAsLongLong((void*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge297 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_EvalResult_isUnsignedInt((void*)p0);
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge298 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jlong)clang_EvalResult_getAsUnsigned((void*)p0);
+}
+JNIEXPORT jdouble JNICALL Java_clang_clang_kniBridge299 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jdouble)clang_EvalResult_getAsDouble((void*)p0);
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge300 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jlong)clang_EvalResult_getAsStr((void*)p0);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge301 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ clang_EvalResult_dispose((void*)p0);
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge302 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jlong)clang_getRemappings((char*)p0);
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge303 (JNIEnv* jniEnv, jclass jclss, jlong p0, jint p1) {
+ return (jlong)clang_getRemappingsFromFileList((char**)p0, p1);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge304 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_remap_getNumFiles((void*)p0);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge305 (JNIEnv* jniEnv, jclass jclss, jlong p0, jint p1, jlong p2, jlong p3) {
+ clang_remap_getFilenames((void*)p0, p1, (CXString*)p2, (CXString*)p3);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge306 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ clang_remap_dispose((void*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge307 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1, jlong p2) {
+ return (jint)clang_findReferencesInFile(*(CXCursor*)p0, (void*)p1, *(struct CXCursorAndRangeVisitor*)p2);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge308 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1, jlong p2) {
+ return (jint)clang_findIncludesInFile((struct CXTranslationUnitImpl*)p0, (void*)p1, *(struct CXCursorAndRangeVisitor*)p2);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge309 (JNIEnv* jniEnv, jclass jclss, jint p0) {
+ return (jint)clang_index_isEntityObjCContainerKind(p0);
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge310 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jlong)clang_index_getObjCContainerDeclInfo((CXIdxDeclInfo*)p0);
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge311 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jlong)clang_index_getObjCInterfaceDeclInfo((CXIdxDeclInfo*)p0);
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge312 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jlong)clang_index_getObjCCategoryDeclInfo((CXIdxDeclInfo*)p0);
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge313 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jlong)clang_index_getObjCProtocolRefListInfo((CXIdxDeclInfo*)p0);
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge314 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jlong)clang_index_getObjCPropertyDeclInfo((CXIdxDeclInfo*)p0);
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge315 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jlong)clang_index_getIBOutletCollectionAttrInfo((CXIdxAttrInfo*)p0);
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge316 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jlong)clang_index_getCXXClassDeclInfo((CXIdxDeclInfo*)p0);
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge317 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jlong)clang_index_getClientContainer((CXIdxContainerInfo*)p0);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge318 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ clang_index_setClientContainer((CXIdxContainerInfo*)p0, (void*)p1);
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge319 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jlong)clang_index_getClientEntity((CXIdxEntityInfo*)p0);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge320 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ clang_index_setClientEntity((CXIdxEntityInfo*)p0, (void*)p1);
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge321 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jlong)clang_IndexAction_create((void*)p0);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge322 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ clang_IndexAction_dispose((void*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge323 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1, jlong p2, jint p3, jint p4, jlong p5, jlong p6, jint p7, jlong p8, jint p9, jlong p10, jint p11) {
+ return (jint)clang_indexSourceFile((void*)p0, (void*)p1, (IndexerCallbacks*)p2, p3, p4, (char*)p5, (char**)p6, p7, (struct CXUnsavedFile*)p8, p9, (struct CXTranslationUnitImpl**)p10, p11);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge324 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1, jlong p2, jint p3, jint p4, jlong p5, jlong p6, jint p7, jlong p8, jint p9, jlong p10, jint p11) {
+ return (jint)clang_indexSourceFileFullArgv((void*)p0, (void*)p1, (IndexerCallbacks*)p2, p3, p4, (char*)p5, (char**)p6, p7, (struct CXUnsavedFile*)p8, p9, (struct CXTranslationUnitImpl**)p10, p11);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge325 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1, jlong p2, jint p3, jint p4, jlong p5) {
+ return (jint)clang_indexTranslationUnit((void*)p0, (void*)p1, (IndexerCallbacks*)p2, p3, p4, (struct CXTranslationUnitImpl*)p5);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge326 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1, jlong p2, jlong p3, jlong p4, jlong p5) {
+ clang_indexLoc_getFileLocation(*(CXIdxLoc*)p0, (void*)p1, (void*)p2, (unsigned int*)p3, (unsigned int*)p4, (unsigned int*)p5);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge327 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXSourceLocation kniStructResult = clang_indexLoc_getCXSourceLocation(*(CXIdxLoc*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge328 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1, jlong p2) {
+ return (jint)clang_Type_visitFields(*(CXType*)p0, (void*)p1, (void*)p2);
+}
+JNIEXPORT jlong JNICALL Java_clang_clang_kniBridge329 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jlong)clang_Cursor_getAttributeSpelling(*(CXCursor*)p0);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge330 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXTypeAttributes kniStructResult = clang_getDeclTypeAttributes(*(CXCursor*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge331 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXTypeAttributes kniStructResult = clang_getResultTypeAttributes(*(CXTypeAttributes*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge332 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ CXTypeAttributes kniStructResult = clang_getCursorResultTypeAttributes(*(CXCursor*)p0);
+ memcpy(p1, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge333 (JNIEnv* jniEnv, jclass jclss, jlong p0, jlong p1) {
+ return (jint)clang_Type_getNullabilityKind(*(CXType*)p0, *(CXTypeAttributes*)p1);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge334 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_Type_getNumProtocols(*(CXType*)p0);
+}
+JNIEXPORT void JNICALL Java_clang_clang_kniBridge335 (JNIEnv* jniEnv, jclass jclss, jlong p0, jint p1, jlong p2) {
+ CXCursor kniStructResult = clang_Type_getProtocol(*(CXType*)p0, p1);
+ memcpy(p2, &kniStructResult, sizeof(kniStructResult));
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge336 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_Cursor_isObjCInitMethod(*(CXCursor*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge337 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_Cursor_isObjCReturningRetainedMethod(*(CXCursor*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge338 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_Cursor_isObjCConsumingSelfMethod(*(CXCursor*)p0);
+}
+JNIEXPORT jint JNICALL Java_clang_clang_kniBridge339 (JNIEnv* jniEnv, jclass jclss, jlong p0) {
+ return (jint)clang_isExtVectorType(*(CXType*)p0);
+}
diff --git a/kotlin-native/Interop/Indexer/prebuilt/nativeInteropStubs/kotlin/clang/clang.kt b/kotlin-native/Interop/Indexer/prebuilt/nativeInteropStubs/kotlin/clang/clang.kt
new file mode 100644
index 00000000000..f98d9bf03fa
--- /dev/null
+++ b/kotlin-native/Interop/Indexer/prebuilt/nativeInteropStubs/kotlin/clang/clang.kt
@@ -0,0 +1,4733 @@
+@file:JvmName("clang")
+@file:Suppress("UNUSED_VARIABLE", "UNUSED_EXPRESSION", "DEPRECATION")
+package clang
+
+import kotlinx.cinterop.*
+
+// NOTE THIS FILE IS AUTO-GENERATED
+
+@CNaturalStruct("data", "private_flags")
+class CXString(rawPtr: NativePtr) : CStructVar(rawPtr) {
+
+ companion object : CStructVar.Type(16, 8)
+
+ var data: COpaquePointer?
+ get() = memberAt(0).value
+ set(value) { memberAt(0).value = value }
+
+ var private_flags: Int
+ get() = memberAt(8).value
+ set(value) { memberAt(8).value = value }
+}
+
+@CNaturalStruct("Strings", "Count")
+class CXStringSet(rawPtr: NativePtr) : CStructVar(rawPtr) {
+
+ companion object : CStructVar.Type(16, 8)
+
+ var Strings: CPointer?
+ get() = memberAt>(0).value
+ set(value) { memberAt>(0).value = value }
+
+ var Count: Int
+ get() = memberAt(8).value
+ set(value) { memberAt(8).value = value }
+}
+
+class CXVirtualFileOverlayImpl(rawPtr: NativePtr) : COpaque(rawPtr)
+
+class CXModuleMapDescriptorImpl(rawPtr: NativePtr) : COpaque(rawPtr)
+
+class CXTargetInfoImpl(rawPtr: NativePtr) : COpaque(rawPtr)
+
+class CXTranslationUnitImpl(rawPtr: NativePtr) : COpaque(rawPtr)
+
+@CNaturalStruct("Filename", "Contents", "Length")
+class CXUnsavedFile(rawPtr: NativePtr) : CStructVar(rawPtr) {
+
+ companion object : CStructVar.Type(24, 8)
+
+ var Filename: CPointer?
+ get() = memberAt>(0).value
+ set(value) { memberAt>(0).value = value }
+
+ var Contents: CPointer?
+ get() = memberAt>(8).value
+ set(value) { memberAt>(8).value = value }
+
+ var Length: Long
+ get() = memberAt(16).value
+ set(value) { memberAt(16).value = value }
+}
+
+@CNaturalStruct("Major", "Minor", "Subminor")
+class CXVersion(rawPtr: NativePtr) : CStructVar(rawPtr) {
+
+ companion object : CStructVar.Type(12, 4)
+
+ var Major: Int
+ get() = memberAt(0).value
+ set(value) { memberAt(0).value = value }
+
+ var Minor: Int
+ get() = memberAt(4).value
+ set(value) { memberAt(4).value = value }
+
+ var Subminor: Int
+ get() = memberAt(8).value
+ set(value) { memberAt(8).value = value }
+}
+
+@CNaturalStruct("data")
+class CXFileUniqueID(rawPtr: NativePtr) : CStructVar(rawPtr) {
+
+ companion object : CStructVar.Type(24, 8)
+
+ @CLength(3)
+ val data: CArrayPointer
+ get() = arrayMemberAt(0)
+}
+
+@CNaturalStruct("ptr_data", "int_data")
+class CXSourceLocation(rawPtr: NativePtr) : CStructVar(rawPtr) {
+
+ companion object : CStructVar.Type(24, 8)
+
+ @CLength(2)
+ val ptr_data: CArrayPointer
+ get() = arrayMemberAt(0)
+
+ var int_data: Int
+ get() = memberAt(16).value
+ set(value) { memberAt(16).value = value }
+}
+
+@CNaturalStruct("ptr_data", "begin_int_data", "end_int_data")
+class CXSourceRange(rawPtr: NativePtr) : CStructVar(rawPtr) {
+
+ companion object : CStructVar.Type(24, 8)
+
+ @CLength(2)
+ val ptr_data: CArrayPointer
+ get() = arrayMemberAt(0)
+
+ var begin_int_data: Int
+ get() = memberAt(16).value
+ set(value) { memberAt(16).value = value }
+
+ var end_int_data: Int
+ get() = memberAt(20).value
+ set(value) { memberAt(20).value = value }
+}
+
+@CNaturalStruct("count", "ranges")
+class CXSourceRangeList(rawPtr: NativePtr) : CStructVar(rawPtr) {
+
+ companion object : CStructVar.Type(16, 8)
+
+ var count: Int
+ get() = memberAt(0).value
+ set(value) { memberAt(0).value = value }
+
+ var ranges: CPointer?
+ get() = memberAt>(8).value
+ set(value) { memberAt>(8).value = value }
+}
+
+@CNaturalStruct("kind", "amount")
+class CXTUResourceUsageEntry(rawPtr: NativePtr) : CStructVar(rawPtr) {
+
+ companion object : CStructVar.Type(16, 8)
+
+ var kind: CXTUResourceUsageKind
+ get() = memberAt(0).value
+ set(value) { memberAt(0).value = value }
+
+ var amount: Long
+ get() = memberAt(8).value
+ set(value) { memberAt(8).value = value }
+}
+
+@CNaturalStruct("data", "numEntries", "entries")
+class CXTUResourceUsage(rawPtr: NativePtr) : CStructVar(rawPtr) {
+
+ companion object : CStructVar.Type(24, 8)
+
+ var data: COpaquePointer?
+ get() = memberAt(0).value
+ set(value) { memberAt(0).value = value }
+
+ var numEntries: Int
+ get() = memberAt(8).value
+ set(value) { memberAt(8).value = value }
+
+ var entries: CPointer?
+ get() = memberAt>(16).value
+ set(value) { memberAt>(16).value = value }
+}
+
+@CNaturalStruct("kind", "xdata", "data")
+class CXCursor(rawPtr: NativePtr) : CStructVar(rawPtr) {
+
+ companion object : CStructVar.Type(32, 8)
+
+ var kind: CXCursorKind
+ get() = memberAt(0).value
+ set(value) { memberAt(0).value = value }
+
+ var xdata: Int
+ get() = memberAt(4).value
+ set(value) { memberAt(4).value = value }
+
+ @CLength(3)
+ val data: CArrayPointer
+ get() = arrayMemberAt(8)
+}
+
+@CNaturalStruct("Platform", "Introduced", "Deprecated", "Obsoleted", "Unavailable", "Message")
+class CXPlatformAvailability(rawPtr: NativePtr) : CStructVar(rawPtr) {
+
+ companion object : CStructVar.Type(72, 8)
+
+ val Platform: CXString
+ get() = memberAt(0)
+
+ val Introduced: CXVersion
+ get() = memberAt(16)
+
+ val Deprecated: CXVersion
+ get() = memberAt(28)
+
+ val Obsoleted: CXVersion
+ get() = memberAt(40)
+
+ var Unavailable: Int
+ get() = memberAt(52).value
+ set(value) { memberAt(52).value = value }
+
+ val Message: CXString
+ get() = memberAt(56)
+}
+
+class CXCursorSetImpl(rawPtr: NativePtr) : COpaque(rawPtr)
+
+@CNaturalStruct("kind", "data")
+class CXType(rawPtr: NativePtr) : CStructVar(rawPtr) {
+
+ companion object : CStructVar.Type(24, 8)
+
+ var kind: CXTypeKind
+ get() = memberAt(0).value
+ set(value) { memberAt(0).value = value }
+
+ @CLength(2)
+ val data: CArrayPointer
+ get() = arrayMemberAt(8)
+}
+
+@CNaturalStruct("int_data", "ptr_data")
+class CXToken(rawPtr: NativePtr) : CStructVar(rawPtr) {
+
+ companion object : CStructVar.Type(24, 8)
+
+ @CLength(4)
+ val int_data: CArrayPointer
+ get() = arrayMemberAt(0)
+
+ var ptr_data: COpaquePointer?
+ get() = memberAt(16).value
+ set(value) { memberAt(16).value = value }
+}
+
+@CNaturalStruct("CursorKind", "CompletionString")
+class CXCompletionResult(rawPtr: NativePtr) : CStructVar(rawPtr) {
+
+ companion object : CStructVar.Type(16, 8)
+
+ var CursorKind: CXCursorKind
+ get() = memberAt(0).value
+ set(value) { memberAt(0).value = value }
+
+ var CompletionString: CXCompletionString?
+ get() = memberAt(8).value
+ set(value) { memberAt(8).value = value }
+}
+
+@CNaturalStruct("Results", "NumResults")
+class CXCodeCompleteResults(rawPtr: NativePtr) : CStructVar(rawPtr) {
+
+ companion object : CStructVar.Type(16, 8)
+
+ var Results: CPointer?
+ get() = memberAt>(0).value
+ set(value) { memberAt>(0).value = value }
+
+ var NumResults: Int
+ get() = memberAt(8).value
+ set(value) { memberAt(8).value = value }
+}
+
+@CNaturalStruct("context", "visit")
+class CXCursorAndRangeVisitor(rawPtr: NativePtr) : CStructVar(rawPtr) {
+
+ companion object : CStructVar.Type(16, 8)
+
+ var context: COpaquePointer?
+ get() = memberAt(0).value
+ set(value) { memberAt(0).value = value }
+
+ var visit: CPointer, CValue) -> CXVisitorResult>>?
+ get() = memberAt, CValue) -> CXVisitorResult>>>(8).value
+ set(value) { memberAt, CValue) -> CXVisitorResult>>>(8).value = value }
+}
+
+@CNaturalStruct("ptr_data", "int_data")
+class CXIdxLoc(rawPtr: NativePtr) : CStructVar(rawPtr) {
+
+ companion object : CStructVar.Type(24, 8)
+
+ @CLength(2)
+ val ptr_data: CArrayPointer
+ get() = arrayMemberAt(0)
+
+ var int_data: Int
+ get() = memberAt(16).value
+ set(value) { memberAt(16).value = value }
+}
+
+@CNaturalStruct("hashLoc", "filename", "file", "isImport", "isAngled", "isModuleImport")
+class CXIdxIncludedFileInfo(rawPtr: NativePtr) : CStructVar(rawPtr) {
+
+ companion object : CStructVar.Type(56, 8)
+
+ val hashLoc: CXIdxLoc
+ get() = memberAt(0)
+
+ var filename: CPointer?
+ get() = memberAt>(24).value
+ set(value) { memberAt>(24).value = value }
+
+ var file: CXFile?
+ get() = memberAt(32).value
+ set(value) { memberAt(32).value = value }
+
+ var isImport: Int
+ get() = memberAt(40).value
+ set(value) { memberAt(40).value = value }
+
+ var isAngled: Int
+ get() = memberAt(44).value
+ set(value) { memberAt(44).value = value }
+
+ var isModuleImport: Int
+ get() = memberAt(48).value
+ set(value) { memberAt(48).value = value }
+}
+
+@CNaturalStruct("file", "module", "loc", "isImplicit")
+class CXIdxImportedASTFileInfo(rawPtr: NativePtr) : CStructVar(rawPtr) {
+
+ companion object : CStructVar.Type(48, 8)
+
+ var file: CXFile?
+ get() = memberAt(0).value
+ set(value) { memberAt(0).value = value }
+
+ var module: CXModule?
+ get() = memberAt(8).value
+ set(value) { memberAt(8).value = value }
+
+ val loc: CXIdxLoc
+ get() = memberAt(16)
+
+ var isImplicit: Int
+ get() = memberAt(40).value
+ set(value) { memberAt(40).value = value }
+}
+
+@CNaturalStruct("kind", "cursor", "loc")
+class CXIdxAttrInfo(rawPtr: NativePtr) : CStructVar(rawPtr) {
+
+ companion object : CStructVar.Type(64, 8)
+
+ var kind: CXIdxAttrKind
+ get() = memberAt(0).value
+ set(value) { memberAt(0).value = value }
+
+ val cursor: CXCursor
+ get() = memberAt(8)
+
+ val loc: CXIdxLoc
+ get() = memberAt(40)
+}
+
+@CNaturalStruct("kind", "templateKind", "lang", "name", "USR", "cursor", "attributes", "numAttributes")
+class CXIdxEntityInfo(rawPtr: NativePtr) : CStructVar(rawPtr) {
+
+ companion object : CStructVar.Type(80, 8)
+
+ var kind: CXIdxEntityKind
+ get() = memberAt(0).value
+ set(value) { memberAt(0).value = value }
+
+ var templateKind: CXIdxEntityCXXTemplateKind
+ get() = memberAt(4).value
+ set(value) { memberAt(4).value = value }
+
+ var lang: CXIdxEntityLanguage
+ get() = memberAt(8).value
+ set(value) { memberAt(8).value = value }
+
+ var name: CPointer?
+ get() = memberAt>(16).value
+ set(value) { memberAt>(16).value = value }
+
+ var USR: CPointer?
+ get() = memberAt>(24).value
+ set(value) { memberAt>(24).value = value }
+
+ val cursor: CXCursor
+ get() = memberAt(32)
+
+ var attributes: CPointer>?
+ get() = memberAt>>(64).value
+ set(value) { memberAt>>(64).value = value }
+
+ var numAttributes: Int
+ get() = memberAt(72).value
+ set(value) { memberAt(72).value = value }
+}
+
+@CNaturalStruct("cursor")
+class CXIdxContainerInfo(rawPtr: NativePtr) : CStructVar(rawPtr) {
+
+ companion object : CStructVar.Type(32, 8)
+
+ val cursor: CXCursor
+ get() = memberAt(0)
+}
+
+@CNaturalStruct("attrInfo", "objcClass", "classCursor", "classLoc")
+class CXIdxIBOutletCollectionAttrInfo(rawPtr: NativePtr) : CStructVar(rawPtr) {
+
+ companion object : CStructVar.Type(72, 8)
+
+ var attrInfo: CPointer?
+ get() = memberAt>(0).value
+ set(value) { memberAt>(0).value = value }
+
+ var objcClass: CPointer?
+ get() = memberAt>(8).value
+ set(value) { memberAt>(8).value = value }
+
+ val classCursor: CXCursor
+ get() = memberAt(16)
+
+ val classLoc: CXIdxLoc
+ get() = memberAt(48)
+}
+
+@CNaturalStruct("entityInfo", "cursor", "loc", "semanticContainer", "lexicalContainer", "isRedeclaration", "isDefinition", "isContainer", "declAsContainer", "isImplicit", "attributes", "numAttributes", "flags")
+class CXIdxDeclInfo(rawPtr: NativePtr) : CStructVar(rawPtr) {
+
+ companion object : CStructVar.Type(128, 8)
+
+ var entityInfo: CPointer?
+ get() = memberAt>(0).value
+ set(value) { memberAt>(0).value = value }
+
+ val cursor: CXCursor
+ get() = memberAt(8)
+
+ val loc: CXIdxLoc
+ get() = memberAt(40)
+
+ var semanticContainer: CPointer?
+ get() = memberAt>(64).value
+ set(value) { memberAt>(64).value = value }
+
+ var lexicalContainer: CPointer?
+ get() = memberAt>(72).value
+ set(value) { memberAt>(72).value = value }
+
+ var isRedeclaration: Int
+ get() = memberAt(80).value
+ set(value) { memberAt(80).value = value }
+
+ var isDefinition: Int
+ get() = memberAt(84).value
+ set(value) { memberAt(84).value = value }
+
+ var isContainer: Int
+ get() = memberAt(88).value
+ set(value) { memberAt(88).value = value }
+
+ var declAsContainer: CPointer?
+ get() = memberAt>(96).value
+ set(value) { memberAt>(96).value = value }
+
+ var isImplicit: Int
+ get() = memberAt(104).value
+ set(value) { memberAt(104).value = value }
+
+ var attributes: CPointer>?
+ get() = memberAt>>(112).value
+ set(value) { memberAt>>(112).value = value }
+
+ var numAttributes: Int
+ get() = memberAt(120).value
+ set(value) { memberAt(120).value = value }
+
+ var flags: Int
+ get() = memberAt(124).value
+ set(value) { memberAt(124).value = value }
+}
+
+@CNaturalStruct("declInfo", "kind")
+class CXIdxObjCContainerDeclInfo(rawPtr: NativePtr) : CStructVar(rawPtr) {
+
+ companion object : CStructVar.Type(16, 8)
+
+ var declInfo: CPointer?
+ get() = memberAt>(0).value
+ set(value) { memberAt>(0).value = value }
+
+ var kind: CXIdxObjCContainerKind
+ get() = memberAt(8).value
+ set(value) { memberAt(8).value = value }
+}
+
+@CNaturalStruct("base", "cursor", "loc")
+class CXIdxBaseClassInfo(rawPtr: NativePtr) : CStructVar(rawPtr) {
+
+ companion object : CStructVar.Type(64, 8)
+
+ var base: CPointer?
+ get() = memberAt>(0).value
+ set(value) { memberAt>(0).value = value }
+
+ val cursor: CXCursor
+ get() = memberAt(8)
+
+ val loc: CXIdxLoc
+ get() = memberAt(40)
+}
+
+@CNaturalStruct("protocol", "cursor", "loc")
+class CXIdxObjCProtocolRefInfo(rawPtr: NativePtr) : CStructVar(rawPtr) {
+
+ companion object : CStructVar.Type(64, 8)
+
+ var protocol: CPointer?
+ get() = memberAt>(0).value
+ set(value) { memberAt>(0).value = value }
+
+ val cursor: CXCursor
+ get() = memberAt(8)
+
+ val loc: CXIdxLoc
+ get() = memberAt(40)
+}
+
+@CNaturalStruct("protocols", "numProtocols")
+class CXIdxObjCProtocolRefListInfo(rawPtr: NativePtr) : CStructVar(rawPtr) {
+
+ companion object : CStructVar.Type(16, 8)
+
+ var protocols: CPointer>?
+ get() = memberAt>>(0).value
+ set(value) { memberAt>>(0).value = value }
+
+ var numProtocols: Int
+ get() = memberAt(8).value
+ set(value) { memberAt(8).value = value }
+}
+
+@CNaturalStruct("containerInfo", "superInfo", "protocols")
+class CXIdxObjCInterfaceDeclInfo(rawPtr: NativePtr) : CStructVar(rawPtr) {
+
+ companion object : CStructVar.Type(24, 8)
+
+ var containerInfo: CPointer?
+ get() = memberAt>(0).value
+ set(value) { memberAt>(0).value = value }
+
+ var superInfo: CPointer?
+ get() = memberAt>(8).value
+ set(value) { memberAt>(8).value = value }
+
+ var protocols: CPointer?
+ get() = memberAt