summaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rwxr-xr-xsrc/java/com/jogamp/gluegen/runtime/BufferFactory.java13
-rw-r--r--src/java/com/jogamp/gluegen/runtime/Int64Buffer.java155
-rwxr-xr-xsrc/java/com/jogamp/gluegen/runtime/Int64BufferME_CDC_FP.java94
-rwxr-xr-xsrc/java/com/jogamp/gluegen/runtime/Int64BufferSE.java80
-rw-r--r--src/java/com/jogamp/gluegen/runtime/PointerBuffer.java6
-rw-r--r--src/java/com/sun/gluegen/JavaEmitter.java22
-rw-r--r--src/java/com/sun/gluegen/JavaMethodBindingEmitter.java2
-rw-r--r--src/java/com/sun/gluegen/JavaType.java14
-rw-r--r--src/junit/com/jogamp/gluegen/test/junit/BaseTest1.java96
-rw-r--r--src/junit/com/jogamp/gluegen/test/junit/test1.c48
-rw-r--r--src/junit/com/jogamp/gluegen/test/junit/test1.h22
11 files changed, 487 insertions, 65 deletions
diff --git a/src/java/com/jogamp/gluegen/runtime/BufferFactory.java b/src/java/com/jogamp/gluegen/runtime/BufferFactory.java
index 1f8182c..9b52640 100755
--- a/src/java/com/jogamp/gluegen/runtime/BufferFactory.java
+++ b/src/java/com/jogamp/gluegen/runtime/BufferFactory.java
@@ -98,6 +98,8 @@ public class BufferFactory {
return ((IntBuffer) buf).isDirect();
} else if (buf instanceof ShortBuffer) {
return ((ShortBuffer) buf).isDirect();
+ } else if (buf instanceof Int64Buffer) {
+ return ((Int64Buffer) buf).isDirect();
} else if (buf instanceof PointerBuffer) {
return ((PointerBuffer) buf).isDirect();
} else if (Platform.isJavaSE()) {
@@ -140,6 +142,9 @@ public class BufferFactory {
return pos * SIZEOF_CHAR;
}
}
+ } else if (buf instanceof Int64Buffer) {
+ Int64Buffer int64Buffer = (Int64Buffer) buf;
+ return int64Buffer.position() * Int64Buffer.elementSize();
} else if (buf instanceof PointerBuffer) {
PointerBuffer pointerBuffer = (PointerBuffer) buf;
return pointerBuffer.position() * PointerBuffer.elementSize();
@@ -165,6 +170,8 @@ public class BufferFactory {
return ((IntBuffer) buf).array();
} else if (buf instanceof ShortBuffer) {
return ((ShortBuffer) buf).array();
+ } else if (buf instanceof Int64Buffer) {
+ return ((Int64Buffer) buf).array();
} else if (buf instanceof PointerBuffer) {
return ((PointerBuffer) buf).array();
}else if(Platform.isJavaSE()) {
@@ -210,6 +217,9 @@ public class BufferFactory {
return (SIZEOF_CHAR * (((CharBuffer) buf).arrayOffset() + pos));
}
}
+ } else if (buf instanceof Int64Buffer) {
+ Int64Buffer int64Buffer = (Int64Buffer) buf;
+ return Int64Buffer.elementSize() * (int64Buffer.arrayOffset() + int64Buffer.position());
} else if (buf instanceof PointerBuffer) {
PointerBuffer pointerBuffer = (PointerBuffer) buf;
return PointerBuffer.elementSize() * (pointerBuffer.arrayOffset() + pointerBuffer.position());
@@ -323,6 +333,9 @@ public class BufferFactory {
bytesRemaining = elementsRemaining * SIZEOF_CHAR;
}
}
+ } else if (buffer instanceof Int64Buffer) {
+ Int64Buffer int64Buffer = (Int64Buffer) buffer;
+ bytesRemaining = int64Buffer.remaining() * Int64Buffer.elementSize();
} else if (buffer instanceof PointerBuffer) {
PointerBuffer pointerBuffer = (PointerBuffer) buffer;
bytesRemaining = pointerBuffer.remaining() * PointerBuffer.elementSize();
diff --git a/src/java/com/jogamp/gluegen/runtime/Int64Buffer.java b/src/java/com/jogamp/gluegen/runtime/Int64Buffer.java
new file mode 100644
index 0000000..ad218bc
--- /dev/null
+++ b/src/java/com/jogamp/gluegen/runtime/Int64Buffer.java
@@ -0,0 +1,155 @@
+/*
+ * Copyright (c) 2010, Michael Bien
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * * Neither the name of Michael Bien nor the
+ * names of its contributors may be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL Michael Bien BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package com.jogamp.gluegen.runtime;
+
+import java.nio.ByteBuffer;
+
+/**
+ * Hardware independent container for native int64_t arrays.
+ *
+ * The native values (NIO direct ByteBuffer) are always 64bit wide.
+ *
+ * @author Michael Bien
+ * @author Sven Gothel
+ */
+public abstract class Int64Buffer {
+
+ protected final ByteBuffer bb;
+ protected int capacity;
+ protected int position;
+ protected long[] backup;
+
+ protected Int64Buffer(ByteBuffer bb) {
+ this.bb = bb;
+ }
+
+ public static Int64Buffer allocate(int size) {
+ if (Platform.isJavaSE()) {
+ return new Int64BufferSE(ByteBuffer.wrap(new byte[elementSize() * size]));
+ } else {
+ return new Int64BufferME_CDC_FP(ByteBuffer.wrap(new byte[elementSize() * size]));
+ }
+ }
+
+ public static Int64Buffer allocateDirect(int size) {
+ if (Platform.isJavaSE()) {
+ return new Int64BufferSE(BufferFactory.newDirectByteBuffer(elementSize() * size));
+ } else {
+ return new Int64BufferME_CDC_FP(BufferFactory.newDirectByteBuffer(elementSize() * size));
+ }
+ }
+
+ public static Int64Buffer wrap(ByteBuffer src) {
+ Int64Buffer res;
+ if (Platform.isJavaSE()) {
+ res = new Int64BufferSE(src);
+ } else {
+ res = new Int64BufferME_CDC_FP(src);
+ }
+ res.updateBackup();
+ return res;
+
+ }
+
+ void updateBackup() {
+ for (int i = 0; i < capacity; i++) {
+ backup[i] = get(i);
+ }
+ }
+
+ int arrayOffset() {
+ return 0;
+ }
+
+ public static int elementSize() {
+ return BufferFactory.SIZEOF_LONG;
+ }
+
+ public int limit() {
+ return capacity;
+ }
+
+ public int capacity() {
+ return capacity;
+ }
+
+ public int position() {
+ return position;
+ }
+
+ public Int64Buffer position(int newPos) {
+ if (0 > newPos || newPos >= capacity) {
+ throw new IndexOutOfBoundsException("Sorry to interrupt, but the position "+newPos+" was out of bounds. " +
+ "My capacity is "+capacity()+".");
+ }
+ position = newPos;
+ return this;
+ }
+
+ public int remaining() {
+ return capacity - position;
+ }
+
+ public boolean hasRemaining() {
+ return position < capacity;
+ }
+
+ public Int64Buffer rewind() {
+ position = 0;
+ return this;
+ }
+
+ boolean hasArray() {
+ return true;
+ }
+
+ public long[] array() {
+ return backup;
+ }
+
+ public ByteBuffer getBuffer() {
+ return bb;
+ }
+
+ public boolean isDirect() {
+ return bb.isDirect();
+ }
+
+ public long get() {
+ long r = get(position);
+ position++;
+ return r;
+ }
+
+ public abstract long get(int idx);
+
+ public abstract Int64Buffer put(int index, long value);
+
+ public abstract Int64Buffer put(long value);
+
+}
diff --git a/src/java/com/jogamp/gluegen/runtime/Int64BufferME_CDC_FP.java b/src/java/com/jogamp/gluegen/runtime/Int64BufferME_CDC_FP.java
new file mode 100755
index 0000000..ec43897
--- /dev/null
+++ b/src/java/com/jogamp/gluegen/runtime/Int64BufferME_CDC_FP.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistribution of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistribution in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ *
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ */
+package com.jogamp.gluegen.runtime;
+
+import java.nio.*;
+
+/**
+ * @author Sven Gothel
+ * @author Michael Bien
+ */
+final class Int64BufferME_CDC_FP extends Int64Buffer {
+
+ private IntBuffer pb;
+
+ Int64BufferME_CDC_FP(ByteBuffer bb) {
+ super(bb);
+ this.pb = bb.asIntBuffer();
+
+ capacity = bb.capacity() / elementSize();
+
+ position = 0;
+ backup = new long[capacity];
+ }
+
+ public long get(int idx) {
+ if (0 > idx || idx >= capacity) {
+ throw new IndexOutOfBoundsException();
+ }
+ idx = idx << 1; // 8-byte to 4-byte offset
+ long lo = 0x00000000FFFFFFFFL & ((long) pb.get(idx));
+ long hi = 0x00000000FFFFFFFFL & ((long) pb.get(idx + 1));
+ if (BufferFactory.isLittleEndian()) {
+ return hi << 32 | lo;
+ }
+ return lo << 32 | hi;
+ }
+
+ public Int64Buffer put(int idx, long v) {
+ if (0 > idx || idx >= capacity) {
+ throw new IndexOutOfBoundsException();
+ }
+ backup[idx] = v;
+ idx = idx << 1; // 8-byte to 4-byte offset
+ int lo = (int) ((v) & 0x00000000FFFFFFFFL);
+ int hi = (int) ((v >> 32) & 0x00000000FFFFFFFFL);
+ if (BufferFactory.isLittleEndian()) {
+ pb.put(idx, lo);
+ pb.put(idx + 1, hi);
+ } else {
+ pb.put(idx, hi);
+ pb.put(idx + 1, lo);
+ }
+ return this;
+ }
+
+ public Int64Buffer put(long v) {
+ put(position, v);
+ position++;
+ return this;
+ }
+}
diff --git a/src/java/com/jogamp/gluegen/runtime/Int64BufferSE.java b/src/java/com/jogamp/gluegen/runtime/Int64BufferSE.java
new file mode 100755
index 0000000..166d0c6
--- /dev/null
+++ b/src/java/com/jogamp/gluegen/runtime/Int64BufferSE.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistribution of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistribution in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ *
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ */
+package com.jogamp.gluegen.runtime;
+
+import java.nio.*;
+
+/**
+ * @author Sven Gothel
+ * @author Michael Bien
+ */
+final class Int64BufferSE extends Int64Buffer {
+
+ private LongBuffer pb;
+
+ Int64BufferSE(ByteBuffer bb) {
+ super(bb);
+
+ this.pb = bb.asLongBuffer();
+
+ capacity = bb.capacity() / elementSize();
+
+ position = 0;
+ backup = new long[capacity];
+ }
+
+ public long get(int idx) {
+ if (0 > idx || idx >= capacity) {
+ throw new IndexOutOfBoundsException();
+ }
+ return pb.get(idx);
+ }
+
+ public Int64Buffer put(int idx, long v) {
+ if (0 > idx || idx >= capacity) {
+ throw new IndexOutOfBoundsException();
+ }
+ backup[idx] = v;
+ pb.put(idx, v);
+ return this;
+ }
+
+ public Int64Buffer put(long v) {
+ put(position, v);
+ position++;
+ return this;
+ }
+}
diff --git a/src/java/com/jogamp/gluegen/runtime/PointerBuffer.java b/src/java/com/jogamp/gluegen/runtime/PointerBuffer.java
index 3bff090..8e30ed8 100644
--- a/src/java/com/jogamp/gluegen/runtime/PointerBuffer.java
+++ b/src/java/com/jogamp/gluegen/runtime/PointerBuffer.java
@@ -33,7 +33,11 @@ package com.jogamp.gluegen.runtime;
import java.nio.ByteBuffer;
/**
- * Hardware independent container for native long- and pointer arrays.
+ * Hardware independent container for native pointer arrays.
+ *
+ * The native values (NIO direct ByteBuffer) might be 32bit or 64bit wide,
+ * depending of the CPU pointer width.
+ *
* @author Michael Bien
* @author Sven Gothel
*/
diff --git a/src/java/com/sun/gluegen/JavaEmitter.java b/src/java/com/sun/gluegen/JavaEmitter.java
index 6658a16..e283fcb 100644
--- a/src/java/com/sun/gluegen/JavaEmitter.java
+++ b/src/java/com/sun/gluegen/JavaEmitter.java
@@ -695,12 +695,12 @@ public class JavaEmitter implements GlueEmitter {
//
// boolean arg_direct = arg != null && BufferFactory.isDirect(arg);
//
- // fooMethod0(arg_direct?arg:BufferFactory.getArray(arg),
+ // fooMethod1(arg_direct?arg:BufferFactory.getArray(arg),
// arg_direct?BufferFactory.getDirectBufferByteOffset(arg):BufferFactory.getIndirectBufferByteOffset(arg),
// arg_direct,
// ... );
// }
- // private native void fooMethod0(Object arg, int arg_byte_offset, boolean arg_is_direct, ...);
+ // private native void fooMethod1(Object arg, int arg_byte_offset, boolean arg_is_direct, ...);
//
// Method taking primitive array argument:
// Interface class:
@@ -713,13 +713,15 @@ public class JavaEmitter implements GlueEmitter {
// }
// public void fooMethod(IntBuffer arg) {
// ... bounds checks, etc. ...
- // if (arg.isDirect()) {
- // fooMethod0(arg, computeDirectBufferByteOffset(arg));
- // } else {
- // fooMethod1(getIndirectBufferArray(arg), computeIndirectBufferByteOffset(arg));
- // }
+ //
+ // boolean arg_direct = BufferFactory.isDirect(arg);
+ //
+ // fooMethod1(arg_direct?arg:BufferFactory.getArray(arg),
+ // arg_direct?BufferFactory.getDirectBufferByteOffset(arg):BufferFactory.getIndirectBufferByteOffset(arg),
+ // arg_direct,
+ // ... );
// }
- // private native void fooMethod0(Object arg, int arg_byte_offset, boolean arg_is_direct, ...);
+ // private native void fooMethod1(Object arg, int arg_byte_offset, boolean arg_is_direct, ...);
//
// Note in particular that the public entry point taking an
// array is merely a special case of the indirect buffer case.
@@ -1794,7 +1796,7 @@ public class JavaEmitter implements GlueEmitter {
if (convertToArrays) {
result = result.replaceJavaArgumentType(i, javaType(ArrayTypes.longArrayClass));
} else {
- result = result.replaceJavaArgumentType(i, JavaType.forNIOPointerBufferClass());
+ result = result.replaceJavaArgumentType(i, JavaType.forNIOInt64BufferClass());
}
} else if (t.isCFloatPointerType()) {
arrayPossible = true;
@@ -1828,7 +1830,7 @@ public class JavaEmitter implements GlueEmitter {
} else if (t.isCInt32PointerType()) {
result = result.replaceJavaArgumentType(-1, JavaType.forNIOIntBufferClass());
} else if (t.isCInt64PointerType()) {
- result = result.replaceJavaArgumentType(-1, JavaType.forNIOPointerBufferClass());
+ result = result.replaceJavaArgumentType(-1, JavaType.forNIOInt64BufferClass());
} else if (t.isCFloatPointerType()) {
result = result.replaceJavaArgumentType(-1, JavaType.forNIOFloatBufferClass());
} else if (t.isCDoublePointerType()) {
diff --git a/src/java/com/sun/gluegen/JavaMethodBindingEmitter.java b/src/java/com/sun/gluegen/JavaMethodBindingEmitter.java
index da5484b..b992fcc 100644
--- a/src/java/com/sun/gluegen/JavaMethodBindingEmitter.java
+++ b/src/java/com/sun/gluegen/JavaMethodBindingEmitter.java
@@ -589,7 +589,7 @@ public class JavaMethodBindingEmitter extends FunctionEmitter
}
if (type.isNIOBuffer()) {
- if(type.isNIOPointerBuffer()) {
+ if(type.isNIOInt64Buffer() || type.isNIOPointerBuffer()) {
if (directNIOOnly) {
writer.print( getArgumentName(i)+ " != null ? " + getArgumentName(i) + ".getBuffer() : null");
} else {
diff --git a/src/java/com/sun/gluegen/JavaType.java b/src/java/com/sun/gluegen/JavaType.java
index 19ac945..23f48b2 100644
--- a/src/java/com/sun/gluegen/JavaType.java
+++ b/src/java/com/sun/gluegen/JavaType.java
@@ -71,6 +71,7 @@ public class JavaType {
private static JavaType nioIntBufferType;
private static JavaType nioLongBufferType;
private static JavaType nioPointerBufferType;
+ private static JavaType nioInt64BufferType;
private static JavaType nioFloatBufferType;
private static JavaType nioDoubleBufferType;
private static JavaType nioByteBufferArrayType;
@@ -194,6 +195,12 @@ public class JavaType {
return nioLongBufferType;
}
+ public static JavaType forNIOInt64BufferClass() {
+ if(nioInt64BufferType == null)
+ nioInt64BufferType = createForClass(com.jogamp.gluegen.runtime.Int64Buffer.class);
+ return nioInt64BufferType;
+ }
+
public static JavaType forNIOPointerBufferClass() {
if(nioPointerBufferType == null)
nioPointerBufferType = createForClass(com.jogamp.gluegen.runtime.PointerBuffer.class);
@@ -333,7 +340,8 @@ public class JavaType {
public boolean isNIOBuffer() {
return clazz != null && ( (java.nio.Buffer.class).isAssignableFrom(clazz) ||
- (com.jogamp.gluegen.runtime.PointerBuffer.class).isAssignableFrom(clazz) ) ;
+ (com.jogamp.gluegen.runtime.PointerBuffer.class).isAssignableFrom(clazz) ||
+ (com.jogamp.gluegen.runtime.Int64Buffer.class).isAssignableFrom(clazz) ) ;
}
public boolean isNIOByteBuffer() {
@@ -353,6 +361,10 @@ public class JavaType {
return (clazz == java.nio.LongBuffer.class);
}
+ public boolean isNIOInt64Buffer() {
+ return (clazz == com.jogamp.gluegen.runtime.Int64Buffer.class);
+ }
+
public boolean isNIOPointerBuffer() {
return (clazz == com.jogamp.gluegen.runtime.PointerBuffer.class);
}
diff --git a/src/junit/com/jogamp/gluegen/test/junit/BaseTest1.java b/src/junit/com/jogamp/gluegen/test/junit/BaseTest1.java
index ddf2906..f030459 100644
--- a/src/junit/com/jogamp/gluegen/test/junit/BaseTest1.java
+++ b/src/junit/com/jogamp/gluegen/test/junit/BaseTest1.java
@@ -34,6 +34,7 @@ package com.jogamp.gluegen.test.junit;
import com.jogamp.gluegen.runtime.BufferFactory;
import com.jogamp.gluegen.runtime.PointerBuffer;
+import com.jogamp.gluegen.runtime.Int64Buffer;
import java.nio.*;
import java.io.File;
import java.lang.reflect.InvocationTargetException;
@@ -87,30 +88,35 @@ public class BaseTest1 {
long result;
long context = 0;
ByteBuffer bb=null;
- PointerBuffer pb=null;
- LongBuffer lb=null;
+ Int64Buffer lb=null;
+ IntBuffer ib=null;
long[] larray = null;
- int array_offset = 0;
+ int larray_offset = 0;
String str=null;
String[] strings = null;
- IntBuffer ib = null;
int[] iarray = null;
int iarray_offset = 0;
- result = binding.arrayTest(context, pb);
- result = binding.arrayTest(context, larray, array_offset);
- result = binding.arrayTestNioOnly(context, pb);
+ result = binding.arrayTestInt32(context, ib);
+ result = binding.arrayTestInt32(context, iarray, iarray_offset);
+
+ result = binding.arrayTestInt64(context, lb);
+ result = binding.arrayTestInt64(context, larray, larray_offset);
+
+ result = binding.arrayTestFoo(context, lb);
+ result = binding.arrayTestFoo(context, larray, larray_offset);
+ result = binding.arrayTestFooNioOnly(context, lb);
result = binding.bufferTest(bb);
result = binding.bufferTestNioOnly(bb);
- result = binding.doubleTest(context, bb, pb, bb, pb);
- result = binding.doubleTest(context, bb, larray, array_offset, bb, larray, array_offset);
- result = binding.doubleTestNioOnly(context, bb, pb, bb, pb);
+ result = binding.doubleTest(context, bb, lb, bb, lb);
+ result = binding.doubleTest(context, bb, larray, larray_offset, bb, larray, larray_offset);
+ result = binding.doubleTestNioOnly(context, bb, lb, bb, lb);
- result = binding.mixedTest(context, bb, pb);
- result = binding.mixedTest(context, bb, larray, array_offset);
- result = binding.mixedTestNioOnly(context, bb, pb);
+ result = binding.mixedTest(context, bb, lb);
+ result = binding.mixedTest(context, bb, larray, larray_offset);
+ result = binding.mixedTestNioOnly(context, bb, lb);
result = binding.nopTest();
@@ -135,66 +141,88 @@ public class BaseTest1 {
long result;
long context = 1;
- ByteBuffer bb1 = BufferFactory.newDirectByteBuffer(BufferFactory.SIZEOF_LONG);
- LongBuffer bb1L = bb1.asLongBuffer();
- bb1L.put(0, 10);
+ Int64Buffer lb = Int64Buffer.allocateDirect(1);
+ lb.put(0, 10);
ByteBuffer bb2 = BufferFactory.newDirectByteBuffer(BufferFactory.SIZEOF_LONG);
- LongBuffer bb2L = bb2.asLongBuffer();
+ Int64Buffer bb2L = Int64Buffer.wrap(bb2);
bb2L.put(0, 100);
- PointerBuffer pb1 = PointerBuffer.allocateDirect(BindingTest1.ARRAY_SIZE);
+ IntBuffer ib1 = BufferFactory.newDirectByteBuffer(BufferFactory.SIZEOF_INT * BindingTest1.ARRAY_SIZE).asIntBuffer();
+ for(i=0; i<BindingTest1.ARRAY_SIZE; i++) {
+ ib1.put(i, 1000);
+ }
+
+ Int64Buffer lb1 = Int64Buffer.allocateDirect(BindingTest1.ARRAY_SIZE);
+ for(i=0; i<BindingTest1.ARRAY_SIZE; i++) {
+ lb1.put(i, 1000);
+ }
+ Int64Buffer lb2 = Int64Buffer.allocateDirect(BindingTest1.ARRAY_SIZE);
for(i=0; i<BindingTest1.ARRAY_SIZE; i++) {
- pb1.put(i, 1000);
+ lb2.put(i, 10000);
}
- PointerBuffer pb2 = PointerBuffer.allocateDirect(BindingTest1.ARRAY_SIZE);
+
+ int[] iarray1 = new int[BindingTest1.ARRAY_SIZE];
+ int iarray1_offset = 0;
for(i=0; i<BindingTest1.ARRAY_SIZE; i++) {
- pb2.put(i, 10000);
+ iarray1[i]= 1000;
}
long[] larray1 = new long[BindingTest1.ARRAY_SIZE];
- int array1_offset = 0;
+ int larray1_offset = 0;
for(i=0; i<BindingTest1.ARRAY_SIZE; i++) {
larray1[i]= 1000;
}
long[] larray2 = new long[BindingTest1.ARRAY_SIZE];
- int array2_offset = 0;
+ int larray2_offset = 0;
for(i=0; i<BindingTest1.ARRAY_SIZE; i++) {
larray2[i]= 10000;
}
- result = binding.arrayTest(context, pb1);
+ result = binding.arrayTestInt32(context, ib1);
+ Assert.assertTrue("Wrong result: "+result, 1+8000==result);
+
+ result = binding.arrayTestInt32(context, iarray1, iarray1_offset);
+ Assert.assertTrue("Wrong result: "+result, 1+8000==result);
+
+ result = binding.arrayTestInt64(context, lb1);
+ Assert.assertTrue("Wrong result: "+result, 1+8000==result);
+
+ result = binding.arrayTestInt64(context, larray1, larray1_offset);
+ Assert.assertTrue("Wrong result: "+result, 1+8000==result);
+
+ result = binding.arrayTestFoo(context, lb1);
Assert.assertTrue("Wrong result: "+result, 1+8000==result);
- result = binding.arrayTest(context, larray1, array1_offset);
+ result = binding.arrayTestFoo(context, larray1, larray1_offset);
Assert.assertTrue("Wrong result: "+result, 1+8000==result);
- result = binding.arrayTestNioOnly(context, pb1);
+ result = binding.arrayTestFooNioOnly(context, lb1);
Assert.assertTrue("Wrong result: "+result, 1+8000==result);
- result = binding.bufferTest(bb1);
+ result = binding.bufferTest(lb.getBuffer());
Assert.assertTrue("Wrong result: "+result, 10==result);
- result = binding.bufferTestNioOnly(bb1);
+ result = binding.bufferTestNioOnly(lb.getBuffer());
Assert.assertTrue("Wrong result: "+result, 10==result);
- result = binding.doubleTest(context, bb1, pb1, bb2, pb2);
+ result = binding.doubleTest(context, lb.getBuffer(), lb1, bb2, lb2);
Assert.assertTrue("Wrong result: "+result, 1+10+8000+100+80000==result);
- result = binding.doubleTest(context, bb1, larray1, array1_offset, bb2, larray2, array2_offset);
+ result = binding.doubleTest(context, lb.getBuffer(), larray1, larray1_offset, bb2, larray2, larray2_offset);
Assert.assertTrue("Wrong result: "+result, 1+10+8000+100+80000==result);
- result = binding.doubleTestNioOnly(context, bb1, pb1, bb2, pb2);
+ result = binding.doubleTestNioOnly(context, lb.getBuffer(), lb1, bb2, lb2);
Assert.assertTrue("Wrong result: "+result, 1+10+8000+100+80000==result);
- result = binding.mixedTest(context, bb1, pb1);
+ result = binding.mixedTest(context, lb.getBuffer(), lb1);
Assert.assertTrue("Wrong result: "+result, 1+10+8000==result);
- result = binding.mixedTest(context, bb1, larray1, array1_offset);
+ result = binding.mixedTest(context, lb.getBuffer(), larray1, larray1_offset);
Assert.assertTrue("Wrong result: "+result, 1+10+8000==result);
- result = binding.mixedTestNioOnly(context, bb1, pb1);
+ result = binding.mixedTestNioOnly(context, lb.getBuffer(), lb1);
Assert.assertTrue("Wrong result: "+result, 1+10+8000==result);
result = binding.nopTest();
diff --git a/src/junit/com/jogamp/gluegen/test/junit/test1.c b/src/junit/com/jogamp/gluegen/test/junit/test1.c
index 31c5f40..0fa4abb 100644
--- a/src/junit/com/jogamp/gluegen/test/junit/test1.c
+++ b/src/junit/com/jogamp/gluegen/test/junit/test1.c
@@ -1,18 +1,44 @@
#include "test1.h"
#include <assert.h>
#include <stdlib.h>
+#include <stdio.h>
foo nopTest() {
return 42;
}
-foo arrayTest(long context, foo * array) {
+int32_t arrayTestInt32(int64_t context, int32_t * array) {
+ int32_t r=0;
+ int i;
+ assert(NULL!=array);
+ // printf("array test - %p sizeof(int32_t) %d\n", array, sizeof(int32_t));
+ for(i=0; i<ARRAY_SIZE; i++) {
+ r+=array[i];
+ // printf("array[%d]: %d -> %d\n", i, array[i], r);
+ }
+ return r+context;
+}
+
+int64_t arrayTestInt64(int64_t context, int64_t * array) {
+ int64_t r=0;
+ int i;
+ assert(NULL!=array);
+ // printf("array test - %p sizeof(int64_t) %d\n", array, sizeof(int64_t));
+ for(i=0; i<ARRAY_SIZE; i++) {
+ r+=array[i];
+ // printf("array[%d]: %d -> %d\n", i, array[i], r);
+ }
+ return r+context;
+}
+
+foo arrayTestFoo(int64_t context, foo * array) {
foo r=0;
int i;
assert(NULL!=array);
- // printf("array test - %p\n", array);
+ // printf("array test - %p sizeof(foo) %d\n", array, sizeof(foo));
for(i=0; i<ARRAY_SIZE; i++) {
r+=array[i];
+ // printf("array[%d]: %d -> %d\n", i, array[i], r);
}
return r+context;
}
@@ -22,36 +48,36 @@ foo bufferTest(void * object) {
return *((foo *)object);
}
-foo mixedTest(long context, void * object, foo * array){
+foo mixedTest(int64_t context, void * object, foo * array){
assert(NULL!=object);
assert(NULL!=array);
- return arrayTest(context, array) + bufferTest(object);
+ return arrayTestFoo(context, array) + bufferTest(object);
}
-foo doubleTest(long context, void * object1, foo * array1, void * object2, foo * array2) {
+foo doubleTest(int64_t context, void * object1, foo * array1, void * object2, foo * array2) {
assert(NULL!=object1);
assert(NULL!=array1);
assert(NULL!=object2);
assert(NULL!=array2);
- return arrayTest(context, array1) +
- arrayTest( 0, array2) +
+ return arrayTestFoo(context, array1) +
+ arrayTestFoo( 0, array2) +
bufferTest(object1) +
bufferTest(object2);
}
-foo arrayTestNioOnly(long context, foo * array ) {
- return arrayTest(context, array);
+foo arrayTestFooNioOnly(int64_t context, foo * array ) {
+ return arrayTestFoo(context, array);
}
foo bufferTestNioOnly(void * object) {
return bufferTest(object);
}
-foo mixedTestNioOnly(long context, void * object, foo * array ) {
+foo mixedTestNioOnly(int64_t context, void * object, foo * array ) {
return mixedTest(context, object, array);
}
-foo doubleTestNioOnly(long context, void * object1, foo * array1, void * object2, foo * array2 ) {
+foo doubleTestNioOnly(int64_t context, void * object1, foo * array1, void * object2, foo * array2 ) {
return doubleTest(context, object1, array1, object2, array2);
}
diff --git a/src/junit/com/jogamp/gluegen/test/junit/test1.h b/src/junit/com/jogamp/gluegen/test/junit/test1.h
index 38b4911..2d92607 100644
--- a/src/junit/com/jogamp/gluegen/test/junit/test1.h
+++ b/src/junit/com/jogamp/gluegen/test/junit/test1.h
@@ -11,34 +11,42 @@
#define CONSTANT_ONE 1
#define ARRAY_SIZE 8
-typedef unsigned long foo;
+#include "gluegenint.h"
+
+typedef uint64_t foo;
/** Returns 42 */
MYAPI foo MYAPIENTRY nopTest();
/** Returns Sum(array) + context */
-MYAPI foo MYAPIENTRY arrayTest(long context, foo * array );
+MYAPI int32_t MYAPIENTRY arrayTestInt32(int64_t context, int32_t * array );
+
+/** Returns Sum(array) + context */
+MYAPI int64_t MYAPIENTRY arrayTestInt64(int64_t context, int64_t * array );
+
+/** Returns Sum(array) + context */
+MYAPI foo MYAPIENTRY arrayTestFoo(int64_t context, foo * array );
/** Returns *((foo *)object) */
MYAPI foo MYAPIENTRY bufferTest(void * object);
/** Returns Sum(array) + context + *((foo *)object) */
-MYAPI foo MYAPIENTRY mixedTest(long context, void * object, foo * array );
+MYAPI foo MYAPIENTRY mixedTest(int64_t context, void * object, foo * array );
/** Returns Sum(array1) + Sum(array2) + context + *((foo *)object1) + *((foo *)object2) */
-MYAPI foo MYAPIENTRY doubleTest(long context, void * object1, foo * array1, void * object2, foo * array2 );
+MYAPI foo MYAPIENTRY doubleTest(int64_t context, void * object1, foo * array1, void * object2, foo * array2 );
/** Returns Sum(array) + context */
-MYAPI foo MYAPIENTRY arrayTestNioOnly(long context, foo * array );
+MYAPI foo MYAPIENTRY arrayTestFooNioOnly(int64_t context, foo * array );
/** Returns *((foo *)object) */
MYAPI foo MYAPIENTRY bufferTestNioOnly(void * object);
/** Returns Sum(array) + context + *((foo *)object) */
-MYAPI foo MYAPIENTRY mixedTestNioOnly(long context, void * object, foo * array );
+MYAPI foo MYAPIENTRY mixedTestNioOnly(int64_t context, void * object, foo * array );
/** Returns Sum(array1) + Sum(array2) + context + *((foo *)object1) + *((foo *)object2) */
-MYAPI foo MYAPIENTRY doubleTestNioOnly(long context, void * object1, foo * array1, void * object2, foo * array2 );
+MYAPI foo MYAPIENTRY doubleTestNioOnly(int64_t context, void * object1, foo * array1, void * object2, foo * array2 );
/** Returns atoi(str) */
MYAPI int MYAPIENTRY strToInt(const char* str);
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-16 00:18:32 +0000