RicheyWorks · Nov 4, 2026
diff --git a/JCudaJava/src/main/java/jcuda/Pointer.java b/JCudaJava/src/main/java/jcuda/Pointer.java
@@ -195,6 +195,10 @@ public static Pointer toBuffer(Buffer buffer)
         {
             return computePointer((ByteBuffer)buffer);
         }
+        if (buffer instanceof CharBuffer)
+        {
+            return computePointer((CharBuffer)buffer);
+        }
         if (buffer instanceof ShortBuffer)
         {
             return computePointer((ShortBuffer)buffer);
@@ -251,6 +255,32 @@ else if (buffer.hasArray())
     }
 
 
+    /**
+     * Creates a new Pointer to the given buffer, taking into
+     * account the position and array offset of the given buffer.
+     * The buffer is assumed to be non-<code>null</code>, and
+     * be either direct or have a backing array.
+     *
+     * @param buffer The buffer
+     * @return The pointer
+     */
+    private static Pointer computePointer(CharBuffer buffer)
+    {
+        if (buffer.isDirect())
+        {
+            CharBuffer duplicate = buffer.duplicate();
+            int position = duplicate.position();
+            duplicate.position(0);
+            return Pointer.to(duplicate.slice()).withByteOffset(
+                (long)position * Sizeof.CHAR);
+        }
+        CharBuffer arrayBuffer = CharBuffer.wrap(buffer.array());
+        long elementOffset = (long)buffer.position() + buffer.arrayOffset();
+        return Pointer.to(arrayBuffer).withByteOffset(
+            elementOffset * Sizeof.CHAR);
+    }
+
+
     /**
      * Creates a new Pointer to the given buffer, taking into
      * account the position and array offset of the given buffer.

diff --git a/JCudaJava/src/test/java/jcuda/test/PointerCharBufferTest.java b/JCudaJava/src/test/java/jcuda/test/PointerCharBufferTest.java
@@ -0,0 +1,103 @@
+/*
+ * JCuda - Java bindings for CUDA
+ *
+ * http://www.jcuda.org
+ */
+package jcuda.test;
+
+import static org.junit.Assert.assertEquals;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.CharBuffer;
+
+import org.junit.Test;
+
+import jcuda.Pointer;
+import jcuda.Sizeof;
+
+/** Tests character buffer pointer offsets without loading CUDA. */
+public class PointerCharBufferTest
+{
+    private static class InspectablePointer extends Pointer
+    {
+        InspectablePointer(Pointer pointer)
+        {
+            super(pointer);
+        }
+
+        long byteOffset()
+        {
+            return getByteOffset();
+        }
+    }
+
+    private static void assertOffset(long expected, CharBuffer buffer)
+    {
+        Pointer pointer = Pointer.toBuffer(buffer);
+        assertEquals(expected, new InspectablePointer(pointer).byteOffset());
+    }
+
+    @Test
+    public void testArrayBufferPosition()
+    {
+        CharBuffer buffer = CharBuffer.wrap(new char[10]);
+        buffer.position(3);
+        assertOffset(3L * Sizeof.CHAR, buffer);
+        assertEquals(3, buffer.position());
+    }
+
+    @Test
+    public void testArraySliceOffsetAndPosition()
+    {
+        CharBuffer buffer = CharBuffer.wrap(new char[10]);
+        buffer.position(2);
+        CharBuffer slice = buffer.slice();
+        slice.position(3);
+        assertOffset(5L * Sizeof.CHAR, slice);
+        assertEquals(3, slice.position());
+    }
+
+    @Test
+    public void testDirectBufferPreservesMarkPositionAndLimit()
+    {
+        CharBuffer buffer = ByteBuffer.allocateDirect(20)
+            .order(ByteOrder.nativeOrder()).asCharBuffer();
+        buffer.limit(8);
+        buffer.position(2);
+        buffer.mark();
+        buffer.position(3);
+        assertOffset(3L * Sizeof.CHAR, buffer);
+        assertEquals(3, buffer.position());
+        assertEquals(8, buffer.limit());
+        buffer.reset();
+        assertEquals(2, buffer.position());
+    }
+
+    @Test
+    public void testDirectSlicePosition()
+    {
+        CharBuffer buffer = ByteBuffer.allocateDirect(20)
+            .order(ByteOrder.nativeOrder()).asCharBuffer();
+        buffer.position(3);
+        CharBuffer slice = buffer.slice();
+        slice.position(2);
+        // JNI already obtains the native address of the slice itself.
+        assertOffset(2L * Sizeof.CHAR, slice);
+    }
+
+    @Test
+    public void testReadOnlyDirectBuffer()
+    {
+        CharBuffer buffer = ByteBuffer.allocateDirect(20)
+            .order(ByteOrder.nativeOrder()).asCharBuffer().asReadOnlyBuffer();
+        buffer.position(2);
+        assertOffset(2L * Sizeof.CHAR, buffer);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testReadOnlyArrayBufferRemainsUnsupported()
+    {
+        Pointer.toBuffer(CharBuffer.wrap(new char[10]).asReadOnlyBuffer());
+    }
+}