A modern programming language that makes developers happier.

kotlinlang

I got it to work by doing this, It feels like I am still not doing it correctly. Any help would be appreciated.
```fun main() {
    memScoped {
        val pointer = cValuesOf(0U).getPointer(memScope)
        val result = clGetPlatformIDs(0, null, pointer)
        if (CL_SUCCESS == result) {
            println("Detected OpenCL platforms: ${pointer[0]}")
        } else {
            println("Error calling clGetPlatformIDs. Error code: $result");
        }
    }
}```


This *might* be incorrect but should be along the lines of what you want:
```fun main() {
    memScoped {
        val numPlatformsPtr = alloc&lt;UIntVar&gt;()
        val result = clGetPlatformIDs(num_entries = 0, platforms = null, num_platforms = pointer)
        if (CL_SUCCESS == result) {
            println("Detected OpenCL platforms: ${numPlatformsPtr?.pointed}")
        } else {
            println("Error calling clGetPlatformIDs. Error code: $result");
        }
    }
}```

In the code example :point_up: the pointer (*numPlatformsPtr*) is allocated memory (of type *UIntVar*) through the `alloc` function. The pointer is passed as is to the `clGetPlatformIDs`  function, which initialises the pointer with a value. If the call to ``clGetPlatformIDs`` is successful then the pointer's value is printed via the `pointed`  extension property.

That doesn't appear to work.  Type mismatch when calling `clGetPlatformIDs` . The 3rd argument of that method is of type `CValuesRef&lt;cl_uintVar&gt;` . Whereas `alloc&lt;cl_uintVar&gt;` gives a `cl_uintVar`. It seems to work if we use `allocArray&lt;cl_uitVar&gt;` although I am little confused as to why.

```fun main() {
    memScoped {
        val numPlatformsPtr = allocArray&lt;cl_uintVar&gt;(1)
        val result = clGetPlatformIDs(0, null, numPlatformsPtr)
        if (CL_SUCCESS == result) {
            println("Detected OpenCL platforms: ${numPlatformsPtr[0]}")
        } else {
            println("Error calling clGetPlatformIDs. Error code: $result");
        }
    }
}```

You did it correctly the first time I am pretty sure. No need to allocate memory on the heap for that (This is no JVM :slightly_smiling_face:). How does it feel wrong to you?

The original kotlin code doesn't seem equivalent to the C code. I would think it possible to write code that is the same.

As long as Kotlin isn't C it will never be identical. Kotlin just doesn't expose the same concept like pointers so you need to make calls to the runtime for that. Besides that theyre identical

This line (in the code snippet - <https://kotlinlang.slack.com/archives/C3SGXARS6/p1577740299112900?thread_ts=1577730476.112600&amp;cid=C3SGXARS6> ) can be fixed by replacing `val result = clGetPlatformIDs(num_entries = 0, platforms = null, num_platforms = numPlatformsPtr)`  with `val result = clGetPlatformIDs(num_entries = 0, platforms = null, num_platforms = numPlatformsPtr.ptr`. The *numPlatformsPtr* should be renamed to *numPlatforms* to avoid confusion since it is a CPointerVar ( <https://kotlinlang.org/api/latest/jvm/stdlib/kotlinx.cinterop/-c-pointer-var.html> ), and not a CPointer. Can get a CPointer from CPointerVar via the `ptr`  extension property. CValuesRef ( <https://kotlinlang.org/api/latest/jvm/stdlib/kotlinx.cinterop/-c-values-ref/index.html> ) can take a CPointer by itself ( <https://github.com/JetBrains/kotlin-native/blob/master/INTEROP.md#passing-pointers-to-bindings> ), *"When passing `CPointer&lt;T&gt;` as the value of such a parameter, it is passed to the C function as is"*.

Yep. That has worked a treat. Thanks <@U5R5FGVH7>