update: minor c interop updates (#4893)

Author: danil-pavlov

docs/topics/native/mapping-function-pointers-from-c.md

@@ -88,7 +88,8 @@ As you can see, C function pointers are represented in Kotlin using `CPointer<CF
 takes an optional function pointer as a parameter, while `supply_fun()` returns a function pointer.
 
 `CFunction<(Int) -> Int>` represents the function signature, and `CPointer<CFunction<...>>?` represents a nullable
-function pointer. There is an `invoke` operator extension function available for all `CPointer<CFunction<...>>` types,
+function pointer. There is an [`.invoke()`](https://kotlinlang.org/api/core/kotlin-stdlib/kotlinx.cinterop/invoke.html)
+operator extension function available for all `CPointer<CFunction<...>>` types,
 allowing you to call function pointers as if they were regular Kotlin functions.
 
 ## Pass Kotlin function as a C function pointer

docs/topics/native/mapping-strings-from-c.md

@@ -154,8 +154,8 @@ fun passStringToC() {
 }
 ```
 
-Here, the `.toKString()` extension function converts a C string returned from the `return_string()` function
-into a Kotlin string.
+Here, the [`.toKString()`](https://kotlinlang.org/api/core/kotlin-stdlib/kotlinx.cinterop/to-k-string.html) extension
+function converts a C string returned from the `return_string()` function into a Kotlin string.
 
 Kotlin provides several extension functions for converting C `char *` strings into Kotlin strings,
 depending on the encoding:
@@ -195,9 +195,9 @@ fun sendString() {
 }
 ```
 
-Here, a native pointer is passed to the C function first. The `.usePinned` extension function temporarily
-pins the native memory address of the byte array. The C function fills in the byte array with data. Another extension
-function, `ByteArray.decodeToString()`, turns the byte array into a Kotlin string, assuming UTF-8 encoding. 
+Here, a native pointer is passed to the C function first. The [`.usePinned()`](https://kotlinlang.org/api/core/kotlin-stdlib/kotlinx.cinterop/use-pinned.html)
+extension function temporarily pins the native memory address of the byte array. The C function fills in the byte array with data.
+Another extension function, `ByteArray.decodeToString()`, turns the byte array into a Kotlin string, assuming UTF-8 encoding. 
 
 ## Update Kotlin code
 

docs/topics/native/native-app-with-c-and-libcurl.md

@@ -60,8 +60,8 @@ Kotlin/Native can use the [Gradle](https://gradle.org) build system through the
 
    * Targets are defined using `macosArm64`, `macosX64`, `linuxArm64`, `linuxX64`, and `mingwX64` for macOS, Linux,
      and Windows. See the complete list of [supported platforms](native-target-support.md).
-   * The entry itself defines a series of properties to indicate how the binary is generated and the entry
-     point of the applications. These can be left as default values.
+   * The `binaries {}` block defines how the binary is generated and the entry point of the application.
+     These can be left as default values.
    * C interoperability is configured as an additional step in the build. By default, all the symbols from C are
      imported to the `interop` package. You may want to import the whole package in `.kt` files. Learn more about
      [how to configure](gradle-configure-project.md#targeting-multiple-platforms) it.
@@ -100,7 +100,7 @@ In this app, you'll need the libcurl library to make some HTTP calls. To create
     linkerOpts.linux = -L/usr/lib/x86_64-linux-gnu -lcurl
     ```
 
-   * `headers` is the list of header files to generate Kotlin stubs for. You can add multiple files to this entry,
+   * `headers` is the list of header files to generate Kotlin stubs for. You can add multiple files here,
      separating each with a space. In this case, it's only `curl.h`. The referenced files need to be available
      on the specified path (in this case, it's `/usr/include/curl`).
    * `headerFilter` shows what exactly is included. In C, all the headers are also included when one file references
@@ -127,7 +127,7 @@ In this app, you'll need the libcurl library to make some HTTP calls. To create
 ## Add interoperability to the build process
 
 To use header files, make sure they are generated as a part of the build process. For this, add the following
-entry to the `build.gradle.kts` file:
+`compilations {}` block to the `build.gradle.kts` file:
 
 ```kotlin
 nativeTarget.apply {

docs/topics/native/native-c-interop.md

@@ -12,7 +12,7 @@
 This document covers general aspects of Kotlin's interoperability with C. Kotlin/Native comes with a cinterop tool,
 which you can use to quickly generate everything you need to interact with an external C library.
 
-The tool analyzes C headers and produces a straightforward mapping of C types, functions, and constants into Kotlin.
+The tool analyzes C headers and produces a straightforward mapping of C types, functions, and strings into Kotlin.
 The generated stubs then can be imported into an IDE to enable code completion and navigation.
 
 > Kotlin also provides interoperability with Objective-C. Objective-C libraries are imported through the cinterop tool
@@ -401,7 +401,7 @@ and pointers to such objects' inner data could be passed to C functions.
 
 There's a couple of approaches you can take:
 
-* Use the [`usePinned`](https://kotlinlang.org/api/core/kotlin-stdlib/kotlinx.cinterop/use-pinned.html) service function
+* Use the [`.usePinned()`](https://kotlinlang.org/api/core/kotlin-stdlib/kotlinx.cinterop/use-pinned.html) extension function
   that pins an object, executes a block, and unpins it on normal and exception paths:
 
   ```kotlin
@@ -423,10 +423,10 @@ There's a couple of approaches you can take:
   }
   ```
 
-  Here, `pinned` is an object of a special type `Pinned<T>`. It provides useful extensions like `addressOf`, which allows
-  getting the address of a pinned array body.
+  Here, `pinned` is an object of a special type `Pinned<T>`. It provides useful extensions like [`.addressOf()`](https://kotlinlang.org/api/core/kotlin-stdlib/kotlinx.cinterop/address-of.html),
+  which allows getting the address of a pinned array body.
 
-* Use the [`refTo()`](https://kotlinlang.org/api/core/kotlin-stdlib/kotlinx.cinterop/ref-to.html) function that has
+* Use the [`.refTo()`](https://kotlinlang.org/api/core/kotlin-stdlib/kotlinx.cinterop/ref-to.html) extension function that has
   similar functionality under the hood but, in certain cases, may help you reduce boilerplate code:
 
   ```kotlin
@@ -498,9 +498,9 @@ fun test() {
 
 ## What's next
 
-Learn how types, functions, and constants are mapped between Kotlin and C by completing the following tutorials:
+Learn how types, functions, and strings are mapped between Kotlin and C by completing the following tutorials:
 
 * [Mapping primitive data types from C](mapping-primitive-data-types-from-c.md)
-* [Mapping struct and union types from C](mapping-function-pointers-from-c.md)
+* [Mapping struct and union types from C](mapping-struct-union-types-from-c.md)
 * [Mapping function pointers from C](mapping-function-pointers-from-c.md)
 * [Mapping strings from C](mapping-strings-from-c.md)