Merge with mbien's 2ea8c93d5fd27207872b97c964e3f8af5ac850c6

19 files changed, 2874 insertions, 0 deletions

diff --git a/src/java/com/jogamp/gluegen/runtime/BufferFactory.java.javame_cdc_fp b/src/java/com/jogamp/gluegen/runtime/BufferFactory.java.javame_cdc_fp
new file mode 100755
index 0000000..de09ef3
--- /dev/null
+++ b/src/java/com/jogamp/gluegen/runtime/BufferFactory.java.javame_cdc_fp
@@ -0,0 +1,267 @@
+/*
+ * 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.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.gluegen.runtime;
+
+import java.nio.*;
+
+public class BufferFactory {
+  public static final int SIZEOF_BYTE = 1;
+  public static final int SIZEOF_SHORT = 2;
+  public static final int SIZEOF_CHAR = 2;
+  public static final int SIZEOF_INT = 4;
+  public static final int SIZEOF_FLOAT = 4;
+  public static final int SIZEOF_LONG = 8;
+  public static final int SIZEOF_DOUBLE = 8;
+
+  private static final boolean isLittleEndian;
+
+  static {
+    ByteBuffer tst_b = BufferFactory.newDirectByteBuffer(BufferFactory.SIZEOF_INT); // 32bit in native order
+    IntBuffer tst_i = tst_b.asIntBuffer();
+    ShortBuffer tst_s = tst_b.asShortBuffer();
+    tst_i.put(0, 0x0A0B0C0D);
+    isLittleEndian = 0x0C0D == tst_s.get(0) ;
+  }
+
+  public static boolean isLittleEndian() {
+    return isLittleEndian;
+  }
+
+  /** Helper routine to create a direct ByteBuffer with native order */
+  public static ByteBuffer newDirectByteBuffer(int size) {
+    return nativeOrder(ByteBuffer.allocateDirect(size));
+  }
+
+  /** Helper routine to set a ByteBuffer to the native byte order, if
+      that operation is supported by the underlying NIO
+      implementation. */
+  public static ByteBuffer nativeOrder(ByteBuffer buf) {
+    // JSR 239 does not support the ByteOrder class or the order methods. The initial order of a byte buffer is the platform byte order.
+    return buf;
+  }
+
+  /** Helper routine to tell whether a buffer is direct or not. Null
+      pointers are considered NOT direct. isDirect() should really be
+      public in Buffer and not replicated in all subclasses. */
+  public static boolean isDirect(Object buf) {
+    if (buf == null) {
+      return true;
+    }
+    if (buf instanceof ByteBuffer) {
+      return ((ByteBuffer) buf).isDirect();
+    } else if (buf instanceof FloatBuffer) {
+      return ((FloatBuffer) buf).isDirect();
+    } else if (buf instanceof ShortBuffer) {
+      return ((ShortBuffer) buf).isDirect();
+    } else if (buf instanceof IntBuffer) {
+      return ((IntBuffer) buf).isDirect();
+    } else if (buf instanceof PointerBuffer) {
+      return ((PointerBuffer) buf).isDirect();
+    }
+    throw new RuntimeException("Unexpected buffer type " + buf.getClass().getName());
+  }
+
+
+  /** Helper routine to get the Buffer byte offset by taking into
+      account the Buffer position and the underlying type.  This is
+      the total offset for Direct Buffers.  */
+
+  public static int getDirectBufferByteOffset(Object buf) {
+    if(buf == null) {
+      return 0;
+    }
+    if(buf instanceof Buffer) {
+        int pos = ((Buffer)buf).position();
+        if(buf instanceof ByteBuffer) {
+          return pos;
+        } else if (buf instanceof FloatBuffer) {
+          return pos * SIZEOF_FLOAT;
+        } else if (buf instanceof IntBuffer) {
+          return pos * SIZEOF_INT;
+        } else if (buf instanceof ShortBuffer) {
+          return pos * SIZEOF_SHORT;
+        }
+    } else if (buf instanceof PointerBuffer) {
+      return (((PointerBuffer)buf).position() * SIZEOF_LONG);
+    } 
+
+    throw new RuntimeException("Disallowed array backing store type in buffer "
+                               + buf.getClass().getName());
+  }
+
+
+  /** Helper routine to return the array backing store reference from
+      a Buffer object.  */
+
+   public static Object getArray(Object buf) {
+     if (buf == null) {
+       return null;
+     }
+     if(buf instanceof ByteBuffer) {
+       return ((ByteBuffer) buf).array();
+     } else if (buf instanceof FloatBuffer) {
+       return ((FloatBuffer) buf).array();
+     } else if (buf instanceof IntBuffer) {
+       return ((IntBuffer) buf).array();
+     } else if (buf instanceof ShortBuffer) { 
+       return ((ShortBuffer) buf).array();
+     } else if (buf instanceof ShortBuffer) { 
+       return ((ShortBuffer) buf).array();
+     } else if (buf instanceof PointerBuffer) { 
+       return ((PointerBuffer) buf).array();
+     }
+
+     throw new RuntimeException("Disallowed array backing store type in buffer "
+                                + buf.getClass().getName());
+   } 
+
+
+  /** Helper routine to get the full byte offset from the beginning of
+      the array that is the storage for the indirect Buffer
+      object.  The array offset also includes the position offset 
+      within the buffer, in addition to any array offset. */
+
+  public static int getIndirectBufferByteOffset(Object buf) {
+    if(buf == null) {
+      return 0;
+    }
+    if(buf instanceof Buffer) {
+        int pos = ((Buffer)buf).position();
+        if(buf instanceof ByteBuffer) {
+          return (((ByteBuffer)buf).arrayOffset() + pos);
+        } else if(buf instanceof FloatBuffer) {
+          return (SIZEOF_FLOAT*(((FloatBuffer)buf).arrayOffset() + pos));
+        } else if(buf instanceof IntBuffer) {
+          return (SIZEOF_INT*(((IntBuffer)buf).arrayOffset() + pos));
+        } else if(buf instanceof ShortBuffer) {
+          return (SIZEOF_SHORT*(((ShortBuffer)buf).arrayOffset() + pos));
+        }
+    } else if(buf instanceof PointerBuffer) {
+        return (SIZEOF_LONG*(((PointerBuffer)buf).arrayOffset() + ((PointerBuffer)buf).position()));
+    }
+
+    throw new RuntimeException("Unknown buffer type " + buf.getClass().getName());
+  }
+
+  public static void rangeCheck(byte[] array, int offset, int minElementsRemaining) {
+    if (array == null) {
+      return;
+    }
+
+    if (array.length < offset + minElementsRemaining) {
+      throw new ArrayIndexOutOfBoundsException("Required " + minElementsRemaining + " elements in array, only had " + (array.length - offset));
+    }
+  }
+
+  public static void rangeCheck(char[] array, int offset, int minElementsRemaining) {
+    if (array == null) {
+      return;
+    }
+
+    if (array.length < offset + minElementsRemaining) {
+      throw new ArrayIndexOutOfBoundsException("Required " + minElementsRemaining + " elements in array, only had " + (array.length - offset));
+    }
+  }
+
+  public static void rangeCheck(short[] array, int offset, int minElementsRemaining) {
+    if (array == null) {
+      return;
+    }
+
+    if (array.length < offset + minElementsRemaining) {
+      throw new ArrayIndexOutOfBoundsException("Required " + minElementsRemaining + " elements in array, only had " + (array.length - offset));
+    }
+  }
+
+  public static void rangeCheck(int[] array, int offset, int minElementsRemaining) {
+    if (array == null) {
+      return;
+    }
+
+    if (array.length < offset + minElementsRemaining) {
+      throw new ArrayIndexOutOfBoundsException("Required " + minElementsRemaining + " elements in array, only had " + (array.length - offset));
+    }
+  }
+
+  public static void rangeCheck(float[] array, int offset, int minElementsRemaining) {
+    if (array == null) {
+      return;
+    }
+
+    if (array.length < offset + minElementsRemaining) {
+      throw new ArrayIndexOutOfBoundsException("Required " + minElementsRemaining + " elements in array, only had " + (array.length - offset));
+    }
+  }
+
+  public static void rangeCheck(Buffer buffer, int minElementsRemaining) {
+    if (buffer == null) {
+      return;
+    }
+
+    if (buffer.remaining() < minElementsRemaining) {
+      throw new IndexOutOfBoundsException("Required " + minElementsRemaining + " remaining elements in buffer, only had " + buffer.remaining());
+    }
+  }
+
+  public static void rangeCheckBytes(Object buffer, int minBytesRemaining) {
+    if (buffer == null) {
+      return;
+    }
+
+    int bytesRemaining = 0;
+    if (buffer instanceof Buffer) {
+        int elementsRemaining = ((Buffer)buffer).remaining();
+        if (buffer instanceof ByteBuffer) {
+          bytesRemaining = elementsRemaining;
+        } else if (buffer instanceof FloatBuffer) {
+          bytesRemaining = elementsRemaining * SIZEOF_FLOAT;
+        } else if (buffer instanceof IntBuffer) {
+          bytesRemaining = elementsRemaining * SIZEOF_INT;
+        } else if (buffer instanceof ShortBuffer) {
+          bytesRemaining = elementsRemaining * SIZEOF_SHORT;
+        }
+    } else if (buffer instanceof PointerBuffer) {
+      bytesRemaining = ((PointerBuffer)buffer).remaining() * SIZEOF_LONG;
+    }
+    if (bytesRemaining < minBytesRemaining) {
+      throw new IndexOutOfBoundsException("Required " + minBytesRemaining + " remaining bytes in buffer, only had " + bytesRemaining);
+    }
+  }
+}
diff --git a/src/java/com/jogamp/gluegen/runtime/BufferFactory.java.javase b/src/java/com/jogamp/gluegen/runtime/BufferFactory.java.javase
new file mode 100755
index 0000000..24d842c
--- /dev/null
+++ b/src/java/com/jogamp/gluegen/runtime/BufferFactory.java.javase
@@ -0,0 +1,317 @@
+/*
+ * 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.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.gluegen.runtime;
+
+import java.nio.*;
+
+public class BufferFactory {
+  public static final int SIZEOF_BYTE = 1;
+  public static final int SIZEOF_SHORT = 2;
+  public static final int SIZEOF_CHAR = 2;
+  public static final int SIZEOF_INT = 4;
+  public static final int SIZEOF_FLOAT = 4;
+  public static final int SIZEOF_LONG = 8;
+  public static final int SIZEOF_DOUBLE = 8;
+
+  private static final boolean isLittleEndian;
+
+  static {
+    ByteBuffer tst_b = BufferFactory.newDirectByteBuffer(BufferFactory.SIZEOF_INT); // 32bit in native order
+    IntBuffer tst_i = tst_b.asIntBuffer();
+    ShortBuffer tst_s = tst_b.asShortBuffer();
+    tst_i.put(0, 0x0A0B0C0D);
+    isLittleEndian = 0x0C0D == tst_s.get(0) ;
+  }
+
+  public static boolean isLittleEndian() {
+    return isLittleEndian;
+  }
+
+  /** Helper routine to create a direct ByteBuffer with native order */
+  public static ByteBuffer newDirectByteBuffer(int size) {
+    return nativeOrder(ByteBuffer.allocateDirect(size));
+  }
+
+  /** Helper routine to set a ByteBuffer to the native byte order, if
+      that operation is supported by the underlying NIO
+      implementation. */
+  public static ByteBuffer nativeOrder(ByteBuffer buf) {
+    return buf.order(ByteOrder.nativeOrder());
+  }
+
+  /** Helper routine to tell whether a buffer is direct or not. Null
+      pointers are considered NOT direct. isDirect() should really be
+      public in Buffer and not replicated in all subclasses. */
+  public static boolean isDirect(Object buf) {
+    if (buf == null) {
+      return true;
+    }
+    if (buf instanceof ByteBuffer) {
+      return ((ByteBuffer) buf).isDirect();
+    } else if (buf instanceof FloatBuffer) {
+      return ((FloatBuffer) buf).isDirect();
+    } else if (buf instanceof DoubleBuffer) {
+      return ((DoubleBuffer) buf).isDirect();
+    } else if (buf instanceof CharBuffer) {
+      return ((CharBuffer) buf).isDirect();
+    } else if (buf instanceof ShortBuffer) {
+      return ((ShortBuffer) buf).isDirect();
+    } else if (buf instanceof IntBuffer) {
+      return ((IntBuffer) buf).isDirect();
+    } else if (buf instanceof LongBuffer) {
+      return ((LongBuffer) buf).isDirect();
+    } else if (buf instanceof PointerBuffer) {
+      return ((PointerBuffer) buf).isDirect();
+    }
+    throw new RuntimeException("Unexpected buffer type " + buf.getClass().getName());
+  }
+
+
+  /** Helper routine to get the Buffer byte offset by taking into
+      account the Buffer position and the underlying type.  This is
+      the total offset for Direct Buffers.  */
+
+  public static int getDirectBufferByteOffset(Object buf) {
+    if(buf == null) {
+      return 0;
+    }
+    if(buf instanceof Buffer) {
+        int pos = ((Buffer)buf).position();
+        if(buf instanceof ByteBuffer) {
+          return pos;
+        } else if (buf instanceof FloatBuffer) {
+          return pos * SIZEOF_FLOAT;
+        } else if (buf instanceof IntBuffer) {
+          return pos * SIZEOF_INT;
+        } else if (buf instanceof ShortBuffer) {
+          return pos * SIZEOF_SHORT;
+        } else if (buf instanceof DoubleBuffer) {
+          return pos * SIZEOF_DOUBLE;
+        } else if (buf instanceof LongBuffer) {
+          return pos * SIZEOF_LONG;
+        } else if (buf instanceof CharBuffer) {
+          return pos * SIZEOF_CHAR;
+        }
+    } else if (buf instanceof PointerBuffer) {
+      PointerBuffer pb = (PointerBuffer)buf;
+      return pb.position() * pb.elementSize();
+    } 
+
+    throw new RuntimeException("Disallowed array backing store type in buffer "
+                               + buf.getClass().getName());
+  }
+
+
+  /** Helper routine to return the array backing store reference from
+      a Buffer object.  */
+
+   public static Object getArray(Object buf) {
+     if (buf == null) {
+       return null;
+     }
+     if(buf instanceof ByteBuffer) {
+       return ((ByteBuffer) buf).array();
+     } else if (buf instanceof FloatBuffer) {
+       return ((FloatBuffer) buf).array();
+     } else if (buf instanceof IntBuffer) {
+       return ((IntBuffer) buf).array();
+     } else if (buf instanceof ShortBuffer) { 
+       return ((ShortBuffer) buf).array();
+     } else if (buf instanceof DoubleBuffer) {
+       return ((DoubleBuffer) buf).array();
+     } else if (buf instanceof LongBuffer) {
+       return ((LongBuffer) buf).array();
+     } else if (buf instanceof CharBuffer) { 
+       return ((CharBuffer) buf).array();
+     } else if (buf instanceof PointerBuffer) { 
+       return ((PointerBuffer) buf).array();
+     }
+
+     throw new RuntimeException("Disallowed array backing store type in buffer "
+                                + buf.getClass().getName());
+   } 
+
+
+  /** Helper routine to get the full byte offset from the beginning of
+      the array that is the storage for the indirect Buffer
+      object.  The array offset also includes the position offset 
+      within the buffer, in addition to any array offset. */
+
+  public static int getIndirectBufferByteOffset(Object buf) {
+    if(buf == null) {
+      return 0;
+    }
+    if (buf instanceof Buffer) {
+        int pos = ((Buffer)buf).position();
+        if(buf instanceof ByteBuffer) {
+          return (((ByteBuffer)buf).arrayOffset() + pos);
+        } else if(buf instanceof FloatBuffer) {
+          return (SIZEOF_FLOAT*(((FloatBuffer)buf).arrayOffset() + pos));
+        } else if(buf instanceof IntBuffer) {
+          return (SIZEOF_INT*(((IntBuffer)buf).arrayOffset() + pos));
+        } else if(buf instanceof ShortBuffer) {
+          return (SIZEOF_SHORT*(((ShortBuffer)buf).arrayOffset() + pos));
+        } else if(buf instanceof DoubleBuffer) {
+          return (SIZEOF_DOUBLE*(((DoubleBuffer)buf).arrayOffset() + pos));
+        } else if(buf instanceof LongBuffer) {
+          return (SIZEOF_LONG*(((LongBuffer)buf).arrayOffset() + pos));
+        } else if(buf instanceof CharBuffer) {
+          return (SIZEOF_CHAR*(((CharBuffer)buf).arrayOffset() + pos));
+        }
+    } else if(buf instanceof PointerBuffer) {
+        PointerBuffer pb = (PointerBuffer)buf;
+        return pb.elementSize()*(pb.arrayOffset() + pb.position());
+    }
+
+    throw new RuntimeException("Unknown buffer type " + buf.getClass().getName());
+  }
+
+  public static void rangeCheck(byte[] array, int offset, int minElementsRemaining) {
+    if (array == null) {
+      return;
+    }
+
+    if (array.length < offset + minElementsRemaining) {
+      throw new ArrayIndexOutOfBoundsException("Required " + minElementsRemaining + " elements in array, only had " + (array.length - offset));
+    }
+  }
+
+  public static void rangeCheck(char[] array, int offset, int minElementsRemaining) {
+    if (array == null) {
+      return;
+    }
+
+    if (array.length < offset + minElementsRemaining) {
+      throw new ArrayIndexOutOfBoundsException("Required " + minElementsRemaining + " elements in array, only had " + (array.length - offset));
+    }
+  }
+
+  public static void rangeCheck(short[] array, int offset, int minElementsRemaining) {
+    if (array == null) {
+      return;
+    }
+
+    if (array.length < offset + minElementsRemaining) {
+      throw new ArrayIndexOutOfBoundsException("Required " + minElementsRemaining + " elements in array, only had " + (array.length - offset));
+    }
+  }
+
+  public static void rangeCheck(int[] array, int offset, int minElementsRemaining) {
+    if (array == null) {
+      return;
+    }
+
+    if (array.length < offset + minElementsRemaining) {
+      throw new ArrayIndexOutOfBoundsException("Required " + minElementsRemaining + " elements in array, only had " + (array.length - offset));
+    }
+  }
+
+  public static void rangeCheck(long[] array, int offset, int minElementsRemaining) {
+    if (array == null) {
+      return;
+    }
+    
+    if (array.length < offset + minElementsRemaining) {
+      throw new ArrayIndexOutOfBoundsException("Required " + minElementsRemaining + " elements in array, only had " + (array.length - offset));
+    }
+  }
+
+  public static void rangeCheck(float[] array, int offset, int minElementsRemaining) {
+    if (array == null) {
+      return;
+    }
+
+    if (array.length < offset + minElementsRemaining) {
+      throw new ArrayIndexOutOfBoundsException("Required " + minElementsRemaining + " elements in array, only had " + (array.length - offset));
+    }
+  }
+
+  public static void rangeCheck(double[] array, int offset, int minElementsRemaining) {
+    if (array == null) {
+      return;
+    }
+    
+    if (array.length < offset + minElementsRemaining) {
+      throw new ArrayIndexOutOfBoundsException("Required " + minElementsRemaining + " elements in array, only had " + (array.length - offset));
+    }
+  }
+
+  public static void rangeCheck(Buffer buffer, int minElementsRemaining) {
+    if (buffer == null) {
+      return;
+    }
+
+    if (buffer.remaining() < minElementsRemaining) {
+      throw new IndexOutOfBoundsException("Required " + minElementsRemaining + " remaining elements in buffer, only had " + buffer.remaining());
+    }
+  }
+
+  public static void rangeCheckBytes(Object buffer, int minBytesRemaining) {
+    if (buffer == null) {
+      return;
+    }
+
+    int bytesRemaining = 0;
+    if (buffer instanceof Buffer) {
+        int elementsRemaining = ((Buffer)buffer).remaining();
+        if (buffer instanceof ByteBuffer) {
+          bytesRemaining = elementsRemaining;
+        } else if (buffer instanceof FloatBuffer) {
+          bytesRemaining = elementsRemaining * SIZEOF_FLOAT;
+        } else if (buffer instanceof IntBuffer) {
+          bytesRemaining = elementsRemaining * SIZEOF_INT;
+        } else if (buffer instanceof ShortBuffer) {
+          bytesRemaining = elementsRemaining * SIZEOF_SHORT;
+        } else if (buffer instanceof DoubleBuffer) {
+          bytesRemaining = elementsRemaining * SIZEOF_DOUBLE;
+        } else if (buffer instanceof LongBuffer) {
+          bytesRemaining = elementsRemaining * SIZEOF_LONG;
+        } else if (buffer instanceof CharBuffer) {
+          bytesRemaining = elementsRemaining * SIZEOF_CHAR;
+        }
+    } else if (buffer instanceof PointerBuffer) {
+      PointerBuffer pb = (PointerBuffer)buffer;
+      bytesRemaining = pb.remaining() * pb.elementSize();
+    }
+    if (bytesRemaining < minBytesRemaining) {
+      throw new IndexOutOfBoundsException("Required " + minBytesRemaining + " remaining bytes in buffer, only had " + bytesRemaining);
+    }
+  }
+}
diff --git a/src/java/com/jogamp/gluegen/runtime/BufferFactoryInternal.java b/src/java/com/jogamp/gluegen/runtime/BufferFactoryInternal.java
new file mode 100755
index 0000000..e99fba6
--- /dev/null
+++ b/src/java/com/jogamp/gluegen/runtime/BufferFactoryInternal.java
@@ -0,0 +1,115 @@
+/*
+
+ * Copyright (c) 2006 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.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.gluegen.runtime;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.nio.*;
+import sun.misc.Unsafe;
+
+public class BufferFactoryInternal {
+  private static final long        addressFieldOffset;
+  private static final Constructor directByteBufferConstructor;
+
+  static {
+    try {
+      Field f = Buffer.class.getDeclaredField("address");
+      addressFieldOffset = UnsafeAccess.getUnsafe().objectFieldOffset(f);
+
+      Class directByteBufferClass = Class.forName("java.nio.DirectByteBuffer");
+      directByteBufferConstructor = directByteBufferClass.getDeclaredConstructor(new Class[] { Long.TYPE, Integer.TYPE });
+      directByteBufferConstructor.setAccessible(true);
+    } catch (Exception e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  public static long getDirectBufferAddress(Buffer buf) {
+    return ((buf == null) ? 0 : UnsafeAccess.getUnsafe().getLong(buf, addressFieldOffset));
+  }
+
+  public static ByteBuffer newDirectByteBuffer(long address, int capacity) {
+    try {
+      if (address == 0) {
+        return null;
+      }
+      return (ByteBuffer) directByteBufferConstructor.newInstance(new Object[] { new Long(address), new Integer(capacity) });
+    } catch (Exception e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  public static long newCString(String str) {
+    byte[] strBytes = str.getBytes();
+    long   strBlock = UnsafeAccess.getUnsafe().allocateMemory(strBytes.length+1);
+    for (int i = 0; i < strBytes.length; i++) {
+      UnsafeAccess.getUnsafe().putByte(strBlock+i, strBytes[i]);
+    }
+    UnsafeAccess.getUnsafe().putByte(strBlock+strBytes.length, (byte)0); // null termination
+    return strBlock;
+  }
+
+  public static void freeCString(long cStr) {
+    UnsafeAccess.getUnsafe().freeMemory(cStr);
+  }
+
+  public static String newJavaString(long cStr) {
+    if (cStr == 0) {
+      return null;
+    }
+    int numChars = 0;
+    while (UnsafeAccess.getUnsafe().getByte(cStr + numChars) != 0) {
+      ++numChars;
+    }
+    byte[] bytes = new byte[numChars];
+    for (int i = 0; i < numChars; i++) {
+      bytes[i] = UnsafeAccess.getUnsafe().getByte(cStr + i);
+    }
+    return new String(bytes);
+  }
+
+  public static int arrayBaseOffset(Object array) {
+    return UnsafeAccess.getUnsafe().arrayBaseOffset(array.getClass());
+  }
+  public static int arrayIndexScale(Object array) {
+    return UnsafeAccess.getUnsafe().arrayIndexScale(array.getClass());
+  }
+}
diff --git a/src/java/com/jogamp/gluegen/runtime/CPU.java b/src/java/com/jogamp/gluegen/runtime/CPU.java
new file mode 100755
index 0000000..027b602
--- /dev/null
+++ b/src/java/com/jogamp/gluegen/runtime/CPU.java
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 2005 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.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.gluegen.runtime;
+
+/** Provides information to autogenerated struct accessors about what
+    kind of data model (32- or 64-bit) is being used by the currently
+    running process. */
+
+public class CPU {
+
+  private final static boolean is32Bit;
+
+  static {
+
+    NativeLibrary.ensureNativeLibLoaded();
+
+    // Try to use Sun's sun.arch.data.model first ..
+    int bits = getPointerSizeInBits();
+    if ( 32 == bits || 64 == bits ) {
+        is32Bit = ( 32 == bits );
+    }else {
+        // We don't seem to need an AccessController.doPrivileged() block
+        // here as these system properties are visible even to unsigned
+        // applets
+        // Note: this code is replicated in StructLayout.java
+        String os = System.getProperty("os.name").toLowerCase();
+        String cpu = System.getProperty("os.arch").toLowerCase();
+
+        if ((os.startsWith("windows") && cpu.equals("x86")) ||
+            (os.startsWith("windows") && cpu.equals("arm")) ||
+            (os.startsWith("linux") && cpu.equals("i386")) ||
+            (os.startsWith("linux") && cpu.equals("x86")) ||
+            (os.startsWith("mac os") && cpu.equals("ppc")) ||
+            (os.startsWith("mac os") && cpu.equals("i386")) ||
+            (os.startsWith("darwin") && cpu.equals("ppc")) ||
+            (os.startsWith("darwin") && cpu.equals("i386")) ||
+            (os.startsWith("sunos") && cpu.equals("sparc")) ||
+            (os.startsWith("sunos") && cpu.equals("x86")) ||
+            (os.startsWith("freebsd") && cpu.equals("i386")) ||
+            (os.startsWith("hp-ux") && cpu.equals("pa_risc2.0"))) {
+          is32Bit = true;
+        }else if ((os.startsWith("windows") && cpu.equals("amd64")) ||
+                  (os.startsWith("linux") && cpu.equals("amd64")) ||
+                  (os.startsWith("linux") && cpu.equals("x86_64")) ||
+                  (os.startsWith("linux") && cpu.equals("ia64")) ||
+                  (os.startsWith("mac os") && cpu.equals("x86_64")) ||
+                  (os.startsWith("darwin") && cpu.equals("x86_64")) ||
+                  (os.startsWith("sunos") && cpu.equals("sparcv9")) ||
+                  (os.startsWith("sunos") && cpu.equals("amd64"))) {
+          is32Bit = false;
+        }else{
+          throw new RuntimeException("Please port CPU detection (32/64 bit) to your platform (" + os + "/" + cpu + ")");
+        }
+    }
+  }
+
+  public static boolean is32Bit() {
+    return is32Bit;
+  }
+
+  public static native int getPointerSizeInBits();
+
+}
diff --git a/src/java/com/jogamp/gluegen/runtime/DynamicLinker.java b/src/java/com/jogamp/gluegen/runtime/DynamicLinker.java
new file mode 100755
index 0000000..f3cfcfd
--- /dev/null
+++ b/src/java/com/jogamp/gluegen/runtime/DynamicLinker.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2006 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.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.gluegen.runtime;
+
+/** Provides an abstract interface to the OS's low-level dynamic
+    linking functionality. */
+
+interface DynamicLinker {
+  public long openLibraryGlobal(String pathname, boolean debug);
+  public long openLibraryLocal(String pathname, boolean debug);
+  public long lookupSymbol(long libraryHandle, String symbolName);
+  public void closeLibrary(long libraryHandle);
+}
diff --git a/src/java/com/jogamp/gluegen/runtime/DynamicLookupHelper.java b/src/java/com/jogamp/gluegen/runtime/DynamicLookupHelper.java
new file mode 100755
index 0000000..bc29732
--- /dev/null
+++ b/src/java/com/jogamp/gluegen/runtime/DynamicLookupHelper.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2003-2005 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.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.gluegen.runtime;
+
+/** Interface callers may use to use the ProcAddressHelper's {@link
+    ProcAddressHelper#resetProcAddressTable resetProcAddressTable}
+    helper method to install function pointers into a
+    ProcAddressTable. This must typically be written with native
+    code. */
+
+public interface DynamicLookupHelper {
+  /**
+   * Try to fetch the function pointer for function 'funcName'.
+   */
+  public long dynamicLookupFunction(String funcName);
+}
diff --git a/src/java/com/jogamp/gluegen/runtime/MacOSXDynamicLinkerImpl.java b/src/java/com/jogamp/gluegen/runtime/MacOSXDynamicLinkerImpl.java
new file mode 100755
index 0000000..8abbd4e
--- /dev/null
+++ b/src/java/com/jogamp/gluegen/runtime/MacOSXDynamicLinkerImpl.java
@@ -0,0 +1,60 @@
+/* !---- DO NOT EDIT: This file autogenerated by com\sun\gluegen\JavaEmitter.java on Mon Jul 31 16:27:00 PDT 2006 ----! */
+
+package com.jogamp.gluegen.runtime;
+
+import com.jogamp.gluegen.runtime.*;
+
+public class MacOSXDynamicLinkerImpl implements DynamicLinker
+{
+
+  public static final int RTLD_LAZY = 0x1;
+  public static final int RTLD_NOW = 0x2;
+  public static final int RTLD_LOCAL = 0x4;
+  public static final int RTLD_GLOBAL = 0x8;
+
+  /** Interface to C language function: <br> <code> int dlclose(void *  __handle); </code>    */
+  private static native int dlclose(long __handle);
+
+  /** Interface to C language function: <br> <code> char *  dlerror(void); </code>    */
+  private static native java.lang.String dlerror();
+
+  /** Interface to C language function: <br> <code> void *  dlopen(const char *  __path, int __mode); </code>    */
+  private static native long dlopen(java.lang.String __path, int __mode);
+
+  /** Interface to C language function: <br> <code> void *  dlsym(void *  __handle, const char *  __symbol); </code>    */
+  private static native long dlsym(long __handle, java.lang.String __symbol);
+
+
+  // --- Begin CustomJavaCode .cfg declarations
+  public long openLibraryLocal(String pathname, boolean debug) {
+    // Note we use RTLD_LOCAL visibility to _NOT_ allow this functionality to
+    // be used to pre-resolve dependent libraries of JNI code without
+    // requiring that all references to symbols in those libraries be
+    // looked up dynamically via the ProcAddressTable mechanism; in
+    // other words, one can actually link against the library instead of
+    // having to dlsym all entry points. System.loadLibrary() uses
+    // RTLD_LOCAL visibility so can't be used for this purpose.
+    return dlopen(pathname, RTLD_LAZY | RTLD_LOCAL);
+  }
+  
+  public long openLibraryGlobal(String pathname, boolean debug) {
+    // Note we use RTLD_GLOBAL visibility to allow this functionality to
+    // be used to pre-resolve dependent libraries of JNI code without
+    // requiring that all references to symbols in those libraries be
+    // looked up dynamically via the ProcAddressTable mechanism; in
+    // other words, one can actually link against the library instead of
+    // having to dlsym all entry points. System.loadLibrary() uses
+    // RTLD_LOCAL visibility so can't be used for this purpose.
+    return dlopen(pathname, RTLD_LAZY | RTLD_GLOBAL);
+  }
+  
+  public long lookupSymbol(long libraryHandle, String symbolName) {
+    return dlsym(libraryHandle, symbolName);
+  }
+  
+  public void closeLibrary(long libraryHandle) {
+    dlclose(libraryHandle);
+  }
+  // ---- End CustomJavaCode .cfg declarations
+
+} // end of class MacOSXDynamicLinkerImpl
diff --git a/src/java/com/jogamp/gluegen/runtime/NativeLibLoader.java b/src/java/com/jogamp/gluegen/runtime/NativeLibLoader.java
new file mode 100755
index 0000000..662a059
--- /dev/null
+++ b/src/java/com/jogamp/gluegen/runtime/NativeLibLoader.java
@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) 2006 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.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.gluegen.runtime;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.security.*;
+
+/** Class providing control over whether GlueGen loads the native code
+    associated with the NativeLibrary implementation. Alternative app
+    launchers such as those running within applets may want to disable
+    this default loading behavior and load the native code via another
+    (manual) mechanism. */
+public class NativeLibLoader {
+  private static volatile boolean loadingEnabled = true;
+  private static volatile boolean didLoading;
+
+  public static void disableLoading() {
+    loadingEnabled = false;
+  }
+
+  public static void enableLoading() {
+    loadingEnabled = true;
+  }
+  
+  public static void loadGlueGenRT() {
+    if (!didLoading && loadingEnabled) {
+      synchronized (NativeLibLoader.class) {
+        if (!didLoading && loadingEnabled) {
+          didLoading = true;
+          AccessController.doPrivileged(new PrivilegedAction() {
+              public Object run() {
+                loadLibraryInternal("gluegen-rt");
+                return null;
+              }
+            });
+        }
+      }
+    }
+  }
+
+  private static void loadLibraryInternal(String libraryName) {
+    String sunAppletLauncher = System.getProperty("sun.jnlp.applet.launcher");
+    boolean usingJNLPAppletLauncher = Boolean.valueOf(sunAppletLauncher).booleanValue();
+
+    if (usingJNLPAppletLauncher) {
+        try {
+          Class jnlpAppletLauncherClass = Class.forName("org.jdesktop.applet.util.JNLPAppletLauncher");
+          Method jnlpLoadLibraryMethod = jnlpAppletLauncherClass.getDeclaredMethod("loadLibrary", new Class[] { String.class });
+          jnlpLoadLibraryMethod.invoke(null, new Object[] { libraryName });
+        } catch (Exception e) {
+          Throwable t = e;
+          if (t instanceof InvocationTargetException) {
+            t = ((InvocationTargetException) t).getTargetException();
+          }
+          if (t instanceof Error)
+            throw (Error) t;
+          if (t instanceof RuntimeException) {
+            throw (RuntimeException) t;
+          }
+          // Throw UnsatisfiedLinkError for best compatibility with System.loadLibrary()
+          throw (UnsatisfiedLinkError) new UnsatisfiedLinkError().initCause(e);
+        }
+    } else {
+      System.loadLibrary(libraryName);
+    }
+  }
+}
diff --git a/src/java/com/jogamp/gluegen/runtime/NativeLibrary.java b/src/java/com/jogamp/gluegen/runtime/NativeLibrary.java
new file mode 100755
index 0000000..7de75a3
--- /dev/null
+++ b/src/java/com/jogamp/gluegen/runtime/NativeLibrary.java
@@ -0,0 +1,425 @@
+/*
+ * Copyright (c) 2006 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.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.gluegen.runtime;
+
+import java.io.*;
+import java.lang.reflect.*;
+import java.security.*;
+import java.util.*;
+
+/** Provides low-level, relatively platform-independent access to
+    shared ("native") libraries. The core library routines
+    <code>System.load()</code> and <code>System.loadLibrary()</code>
+    in general provide suitable functionality for applications using
+    native code, but are not flexible enough to support certain kinds
+    of glue code generation and deployment strategies. This class
+    supports direct linking of native libraries to other shared
+    objects not necessarily installed on the system (in particular,
+    via the use of dlopen(RTLD_GLOBAL) on Unix platforms) as well as
+    manual lookup of function names to support e.g. GlueGen's
+    ProcAddressTable glue code generation style without additional
+    supporting code needed in the generated library. */
+
+public class NativeLibrary implements DynamicLookupHelper {
+  private static final int WINDOWS = 1;
+  private static final int UNIX    = 2;
+  private static final int MACOSX  = 3;
+  private static boolean DEBUG;
+  private static int platform;
+  private static DynamicLinker dynLink;
+  private static String[] prefixes;
+  private static String[] suffixes;
+
+  static {
+    // Determine platform we're running on
+    AccessController.doPrivileged(new PrivilegedAction() {
+        public Object run() {
+          String osName = System.getProperty("os.name").toLowerCase();
+          if (osName.startsWith("wind")) {
+            platform = WINDOWS;
+          } else if (osName.startsWith("mac os x")) {
+            platform = MACOSX;
+          } else {
+            platform = UNIX;
+          }
+
+          DEBUG = (System.getProperty("gluegen.debug.NativeLibrary") != null);
+
+          return null;
+        }
+      });
+    // Instantiate dynamic linker implementation
+    switch (platform) {
+      case WINDOWS:
+        dynLink = new WindowsDynamicLinkerImpl();
+        prefixes = new String[] { "" };
+        suffixes = new String[] { ".dll" };
+        break;
+      case UNIX:
+        dynLink = new UnixDynamicLinkerImpl();
+        prefixes = new String[] { "lib" };
+        suffixes = new String[] { ".so" };
+        break;
+      case MACOSX:
+        dynLink = new MacOSXDynamicLinkerImpl();
+        prefixes = new String[] { "lib", "" };
+        suffixes = new String[] { ".dylib", ".jnilib", "" };
+        break;
+      default:
+        throw new InternalError("Platform not initialized properly");
+    }
+  }
+
+  // Platform-specific representation for the handle to the open
+  // library. This is an HMODULE on Windows and a void* (the result of
+  // a dlopen() call) on Unix and Mac OS X platforms.
+  private long libraryHandle;
+
+  // May as well keep around the path to the library we opened
+  private String libraryPath;
+
+  // Private constructor to prevent arbitrary instances from floating around
+  private NativeLibrary(long libraryHandle, String libraryPath) {
+    this.libraryHandle = libraryHandle;
+    this.libraryPath   = libraryPath;
+  }
+
+  /** Opens the given native library, assuming it has the same base
+      name on all platforms, looking first in the system's search
+      path, and in the context of the specified ClassLoader, which is
+      used to help find the library in the case of e.g. Java Web Start. */
+  public static NativeLibrary open(String libName, ClassLoader loader) {
+    return open(libName, libName, libName, true, loader, true);
+  }
+
+  /** Opens the given native library, assuming it has the same base
+      name on all platforms, looking first in the system's search
+      path, and in the context of the specified ClassLoader, which is
+      used to help find the library in the case of e.g. Java Web Start. */
+  public static NativeLibrary open(String libName, ClassLoader loader, boolean global) {
+    return open(libName, libName, libName, true, loader, global);
+  }
+
+  /** Opens the given native library, assuming it has the given base
+      names (no "lib" prefix or ".dll/.so/.dylib" suffix) on the
+      Windows, Unix and Mac OS X platforms, respectively, and in the
+      context of the specified ClassLoader, which is used to help find
+      the library in the case of e.g. Java Web Start. The
+      searchSystemPathFirst argument changes the behavior to first
+      search the default system path rather than searching it last.
+      Note that we do not currently handle DSO versioning on Unix.
+      Experience with JOAL and OpenAL has shown that it is extremely
+      problematic to rely on a specific .so version (for one thing,
+      ClassLoader.findLibrary on Unix doesn't work with files not
+      ending in .so, for example .so.0), and in general if this
+      dynamic loading facility is used correctly the version number
+      will be irrelevant.
+  */
+  public static NativeLibrary open(String windowsLibName,
+                                   String unixLibName,
+                                   String macOSXLibName,
+                                   boolean searchSystemPathFirst,
+                                   ClassLoader loader) {
+    return open(windowsLibName, unixLibName, macOSXLibName, searchSystemPathFirst, loader, true);
+  }
+
+  public static NativeLibrary open(String windowsLibName,
+                                   String unixLibName,
+                                   String macOSXLibName,
+                                   boolean searchSystemPathFirst,
+                                   ClassLoader loader, boolean global) {
+    List possiblePaths = enumerateLibraryPaths(windowsLibName,
+                                               unixLibName,
+                                               macOSXLibName,
+                                               searchSystemPathFirst,
+                                               loader);
+    // Iterate down these and see which one if any we can actually find.
+    for (Iterator iter = possiblePaths.iterator(); iter.hasNext(); ) {
+      String path = (String) iter.next();
+      if (DEBUG) {
+        System.out.println("Trying to load " + path);
+      }
+      ensureNativeLibLoaded();
+      long res;
+      if(global) {
+          res = dynLink.openLibraryGlobal(path, DEBUG);
+      } else {
+          res = dynLink.openLibraryLocal(path, DEBUG);
+      }
+      if (res != 0) {
+        if (DEBUG) {
+          System.out.println("Successfully loaded " + path + ": res = 0x" + Long.toHexString(res));
+        }
+        return new NativeLibrary(res, path);
+      }
+    }
+
+    if (DEBUG) {
+      System.out.println("Did not succeed in loading (" + windowsLibName + ", " + unixLibName + ", " + macOSXLibName + ")");
+    }
+
+    // For now, just return null to indicate the open operation didn't
+    // succeed (could also throw an exception if we could tell which
+    // of the openLibrary operations actually failed)
+    return null;
+  }
+
+  /** Looks up the given function name in this native library. */
+  public long dynamicLookupFunction(String funcName) {
+    if (libraryHandle == 0)
+      throw new RuntimeException("Library is not open");
+    return dynLink.lookupSymbol(libraryHandle, funcName);
+  }
+
+  /** Retrieves the low-level library handle from this NativeLibrary
+      object. On the Windows platform this is an HMODULE, and on Unix
+      and Mac OS X platforms the void* result of calling dlopen(). */
+  public long getLibraryHandle() {
+    return libraryHandle;
+  }
+
+  /** Retrieves the path under which this library was opened. */
+  public String getLibraryPath() {
+    return libraryPath;
+  }
+
+  /** Closes this native library. Further lookup operations are not
+      allowed after calling this method. */
+  public void close() {
+    if (libraryHandle == 0)
+      throw new RuntimeException("Library already closed");
+    long handle = libraryHandle;
+    libraryHandle = 0;
+    dynLink.closeLibrary(handle);
+  }
+
+  /** Given the base library names (no prefixes/suffixes) for the
+      various platforms, enumerate the possible locations and names of
+      the indicated native library on the system. */
+  private static List enumerateLibraryPaths(String windowsLibName,
+                                            String unixLibName,
+                                            String macOSXLibName,
+                                            boolean searchSystemPathFirst,
+                                            ClassLoader loader) {
+    List paths = new ArrayList();
+    String libName = selectName(windowsLibName, unixLibName, macOSXLibName);
+    if (libName == null)
+      return paths;
+
+    // Allow user's full path specification to override our building of paths
+    File file = new File(libName);
+    if (file.isAbsolute()) {
+	paths.add(libName);
+	return paths;
+    }
+
+    String[] baseNames = buildNames(libName);
+
+    if (searchSystemPathFirst) {
+      // Add just the library names to use the OS's search algorithm
+      for (int i = 0; i < baseNames.length; i++) {
+        paths.add(baseNames[i]);
+      }
+    }
+
+    // The idea to ask the ClassLoader to find the library is borrowed
+    // from the LWJGL library
+    String clPath = getPathFromClassLoader(libName, loader);
+    if (DEBUG) {
+      System.out.println("Class loader path to " + libName + ": " + clPath);
+    }
+    if (clPath != null) {
+      paths.add(clPath);
+    }
+
+    // Add entries from java.library.path
+    String javaLibraryPath =
+      (String) AccessController.doPrivileged(new PrivilegedAction() {
+          public Object run() {
+            return System.getProperty("java.library.path");
+          }
+        });
+    if (javaLibraryPath != null) {
+      StringTokenizer tokenizer = new StringTokenizer(javaLibraryPath, File.pathSeparator);
+      while (tokenizer.hasMoreTokens()) {
+        addPaths(tokenizer.nextToken(), baseNames, paths);
+      }
+    }
+
+    // Add current working directory
+    String userDir =
+      (String) AccessController.doPrivileged(new PrivilegedAction() {
+          public Object run() {
+            return System.getProperty("user.dir");
+          }
+        });
+    addPaths(userDir, baseNames, paths);
+
+    // Add probable Mac OS X-specific paths
+    if (platform == MACOSX) {
+      // Add historical location
+      addPaths("/Library/Frameworks/" + libName + ".Framework", baseNames, paths);
+      // Add current location
+      addPaths("/System/Library/Frameworks/" + libName + ".Framework", baseNames, paths);
+    }
+
+    if (!searchSystemPathFirst) {
+      // Add just the library names to use the OS's search algorithm
+      for (int i = 0; i < baseNames.length; i++) {
+        paths.add(baseNames[i]);
+      }
+    }
+
+    return paths;
+  }
+
+
+  private static String selectName(String windowsLibName,
+                                   String unixLibName,
+                                   String macOSXLibName) {
+    switch (platform) {
+      case WINDOWS:
+        return windowsLibName;
+      case UNIX:
+        return unixLibName;
+      case MACOSX:
+        return macOSXLibName;
+      default:
+        throw new InternalError();
+    }
+  }
+
+  private static String[] buildNames(String libName) {
+    // If the library name already has the prefix / suffix added
+    // (principally because we want to force a version number on Unix
+    // operating systems) then just return the library name.
+    if (libName.startsWith(prefixes[0])) {
+      if (libName.endsWith(suffixes[0])) {
+        return new String[] { libName };
+      }
+
+      int idx = libName.indexOf(suffixes[0]);
+      boolean ok = true;
+      if (idx >= 0) {
+        // Check to see if everything after it is a Unix version number
+        for (int i = idx + suffixes[0].length();
+             i < libName.length();
+             i++) {
+          char c = libName.charAt(i);
+          if (!(c == '.' || (c >= '0' && c <= '9'))) {
+            ok = false;
+            break;
+          }
+        }
+        if (ok) {
+          return new String[] { libName };
+        }
+      }
+    }
+
+    String[] res = new String[prefixes.length * suffixes.length];
+    int idx = 0;
+    for (int i = 0; i < prefixes.length; i++) {
+      for (int j = 0; j < suffixes.length; j++) {
+        res[idx++] = prefixes[i] + libName + suffixes[j];
+      }
+    }
+    return res;
+  }
+
+  private static void addPaths(String path, String[] baseNames, List paths) {
+    for (int j = 0; j < baseNames.length; j++) {
+      paths.add(path + File.separator + baseNames[j]);
+    }
+  }
+
+  private static boolean initializedFindLibraryMethod = false;
+  private static Method  findLibraryMethod = null;
+  private static String getPathFromClassLoader(final String libName, final ClassLoader loader) {
+    if (loader == null)
+      return null;
+    if (!initializedFindLibraryMethod) {
+      AccessController.doPrivileged(new PrivilegedAction() {
+          public Object run() {
+            try {
+              findLibraryMethod = ClassLoader.class.getDeclaredMethod("findLibrary",
+                                                                      new Class[] { String.class });
+              findLibraryMethod.setAccessible(true);
+            } catch (Exception e) {
+              // Fail silently disabling this functionality
+            }
+            initializedFindLibraryMethod = true;
+            return null;
+          }
+        });
+    }
+    if (findLibraryMethod != null) {
+      try {
+        return (String) AccessController.doPrivileged(new PrivilegedAction() {
+            public Object run() {
+              try {
+                return findLibraryMethod.invoke(loader, new Object[] { libName });
+              } catch (Exception e) {
+                throw new RuntimeException(e);
+              }
+            }
+          });
+      } catch (Exception e) {
+        if (DEBUG) {
+          e.printStackTrace();
+        }
+        // Fail silently and continue with other search algorithms
+      }
+    }
+    return null;
+  }
+
+  private static volatile boolean loadedDynLinkNativeLib;
+  static void ensureNativeLibLoaded() {
+    if (!loadedDynLinkNativeLib) {
+      synchronized (NativeLibrary.class) {
+        if (!loadedDynLinkNativeLib) {
+          loadedDynLinkNativeLib = true;
+          NativeLibLoader.loadGlueGenRT();
+        }
+      }
+    }
+  }
+}
diff --git a/src/java/com/jogamp/gluegen/runtime/PointerBuffer.java.javame_cdc_fp b/src/java/com/jogamp/gluegen/runtime/PointerBuffer.java.javame_cdc_fp
new file mode 100755
index 0000000..20a70c1
--- /dev/null
+++ b/src/java/com/jogamp/gluegen/runtime/PointerBuffer.java.javame_cdc_fp
@@ -0,0 +1,180 @@
+/*
+ * 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.*;
+
+public class PointerBuffer {
+  private ByteBuffer   bb;
+  private IntBuffer    ib;
+  private int capacity, position;
+  private long[] backup;
+
+  private PointerBuffer(ByteBuffer bb) {
+    this.bb = bb;
+    this.ib = bb.asIntBuffer();
+
+    capacity = bb.capacity() / elementSize();
+
+    position=0;
+    backup = new long[capacity];
+  }
+
+  public final int limit() {
+    return capacity;
+  }
+  public final int capacity() {
+    return capacity;
+  }
+
+  public final int position() {
+    return position;
+  }
+
+  public final PointerBuffer position(int newPos) {
+    if(0>newPos || newPos>=capacity) {
+        throw new IndexOutOfBoundsException();
+    }
+    position = newPos;
+    return this;
+  }
+
+  public final int remaining() {
+    return capacity - position;
+  }
+
+  public final boolean hasRemaining() {
+    return position < capacity;
+  }
+
+  public final PointerBuffer rewind() {
+    position=0;
+    return this;
+  }
+
+  int   arrayOffset() { return 0; }
+
+  boolean   hasArray() { return true; }
+
+  public long[] array() {
+    return backup;
+  }
+
+  public static PointerBuffer allocate(int size) {
+      return new PointerBuffer(ByteBuffer.wrap(new byte[elementSize()* size]));
+  }
+
+  public static PointerBuffer allocateDirect(int size) {
+      return new PointerBuffer(BufferFactory.newDirectByteBuffer(elementSize() * size));
+  }
+
+  public static PointerBuffer wrap(ByteBuffer src) {
+    PointerBuffer res =  new PointerBuffer(src);
+    res.updateBackup();
+    return res;
+  }
+
+  public ByteBuffer getBuffer() {
+    return bb;
+  }
+
+  public boolean isDirect() {
+    return bb.isDirect();
+  }
+
+  public long get(int idx) {
+    if(0>idx || idx>=capacity) {
+        throw new IndexOutOfBoundsException();
+    }
+    if(CPU.is32Bit()) {
+        return ib.get(idx);
+    } else {
+        idx = idx << 1 ; // 8-byte to 4-byte offset
+        long lo = 0x00000000FFFFFFFFL & ( (long) ib.get(idx)   );
+        long hi = 0x00000000FFFFFFFFL & ( (long) ib.get(idx+1) );
+        if(BufferFactory.isLittleEndian()) {
+            return hi << 32 | lo ;
+        }
+        return lo << 32 | hi ;
+    }
+  }
+
+  public long get() {
+    long r = get(position);
+    position++;
+    return r;
+  }
+
+  public PointerBuffer put(int idx, long v) {
+    if(0>idx || idx>=capacity) {
+        throw new IndexOutOfBoundsException();
+    }
+    backup[idx] = v;
+    if(CPU.is32Bit()) {
+        ib.put(idx, (int)v);
+    } else {
+        idx = idx << 1 ; // 8-byte to 4-byte offset
+        int lo = (int) ( ( v       ) & 0x00000000FFFFFFFFL ) ;
+        int hi = (int) ( ( v >> 32 ) & 0x00000000FFFFFFFFL ) ;
+        if(BufferFactory.isLittleEndian()) {
+            ib.put(idx, lo);
+            ib.put(idx+1, hi);
+        } else {
+            ib.put(idx, hi);
+            ib.put(idx+1, lo);
+        }
+    }
+    return this;
+  }
+
+  public PointerBuffer put(long v) {
+    put(position, v);
+    position++;
+    return this;
+  }
+
+  private void updateBackup() {
+    for (int i = 0; i < capacity; i++) {
+      backup[i] = get(i);
+    }
+  }
+
+  public static int elementSize() {
+    return CPU.is32Bit() ? BufferFactory.SIZEOF_INT : BufferFactory.SIZEOF_LONG;
+  }
+
+}
diff --git a/src/java/com/jogamp/gluegen/runtime/PointerBuffer.java.javase b/src/java/com/jogamp/gluegen/runtime/PointerBuffer.java.javase
new file mode 100755
index 0000000..09ca2db
--- /dev/null
+++ b/src/java/com/jogamp/gluegen/runtime/PointerBuffer.java.javase
@@ -0,0 +1,169 @@
+/*
+ * 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.*;
+
+public class PointerBuffer {
+  private ByteBuffer   bb;
+  private Buffer       pb;
+  private int capacity, position;
+  private long[] backup;
+
+  private PointerBuffer(ByteBuffer bb) {
+    this.bb = bb;
+
+    if(CPU.is32Bit()) {
+       this.pb = bb.asIntBuffer();
+    }else{
+       this.pb = bb.asLongBuffer();
+    }
+
+    capacity = bb.capacity() / elementSize();
+
+    position=0;
+    backup = new long[capacity];
+  }
+
+  public final int limit() {
+    return capacity;
+  }
+  public final int capacity() {
+    return capacity;
+  }
+
+  public final int position() {
+    return position;
+  }
+
+  public final PointerBuffer position(int newPos) {
+    if(0>newPos || newPos>=capacity) {
+        throw new IndexOutOfBoundsException();
+    }
+    position = newPos;
+    return this;
+  }
+
+  public final int remaining() {
+    return capacity - position;
+  }
+
+  public final boolean hasRemaining() {
+    return position < capacity;
+  }
+
+  public final PointerBuffer rewind() {
+    position=0;
+    return this;
+  }
+
+  int   arrayOffset() { return 0; }
+
+  boolean   hasArray() { return true; }
+
+  public long[] array() {
+    return backup;
+  }
+
+  public static PointerBuffer allocate(int size) {
+      return new PointerBuffer(ByteBuffer.wrap(new byte[elementSize()* size]));
+  }
+
+  public static PointerBuffer allocateDirect(int size) {
+      return new PointerBuffer(BufferFactory.newDirectByteBuffer(elementSize() * size));
+  }
+
+  public static PointerBuffer wrap(ByteBuffer src) {
+    PointerBuffer res =  new PointerBuffer(src);
+    res.updateBackup();
+    return res;
+  }
+
+  public ByteBuffer getBuffer() {
+    return bb;
+  }
+
+  public boolean isDirect() {
+    return bb.isDirect();
+  }
+
+  public long get(int idx) {
+    if(0>idx || idx>=capacity) {
+        throw new IndexOutOfBoundsException();
+    }
+    if(CPU.is32Bit()) {
+        return ((IntBuffer)pb).get(idx);
+    } else {
+        return ((LongBuffer)pb).get(idx);
+    }
+  }
+
+  public long get() {
+    long r = get(position);
+    position++;
+    return r;
+  }
+
+  public PointerBuffer put(int idx, long v) {
+    if(0>idx || idx>=capacity) {
+        throw new IndexOutOfBoundsException();
+    }
+    backup[idx] = v;
+    if(CPU.is32Bit()) {
+        ((IntBuffer)pb).put(idx, (int)v);
+    } else {
+        ((LongBuffer)pb).put(idx, v);
+    }
+    return this;
+  }
+
+  public PointerBuffer put(long v) {
+    put(position, v);
+    position++;
+    return this;
+  }
+
+  private void updateBackup() {
+    for (int i = 0; i < capacity; i++) {
+      backup[i] = get(i);
+    }
+  }
+
+  public static int elementSize() {
+    return CPU.is32Bit() ? BufferFactory.SIZEOF_INT : BufferFactory.SIZEOF_LONG;
+  }
+}
diff --git a/src/java/com/jogamp/gluegen/runtime/ProcAddressHelper.java b/src/java/com/jogamp/gluegen/runtime/ProcAddressHelper.java
new file mode 100644
index 0000000..1b7f9d6
--- /dev/null
+++ b/src/java/com/jogamp/gluegen/runtime/ProcAddressHelper.java
@@ -0,0 +1,125 @@
+/*
+ * Copyright (c) 2003-2005 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.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.gluegen.runtime;
+
+import java.security.*;
+
+// Debugging only
+import java.io.*;
+
+/** Helper class containing constants and methods to assist with the
+    manipulation of auto-generated ProcAddressTables. */
+
+public class ProcAddressHelper {
+  public static final String PROCADDRESS_VAR_PREFIX = "_addressof_";
+  protected static boolean DEBUG;
+  protected static String DEBUG_PREFIX;
+  protected static int debugNum;
+
+  static {
+    AccessController.doPrivileged(new PrivilegedAction() {
+        public Object run() {
+          DEBUG = (System.getProperty("gluegen.debug.ProcAddressHelper") != null);
+          if (DEBUG) {
+            DEBUG_PREFIX = System.getProperty("gluegen.debug.ProcAddressHelper.prefix");
+          }
+          return null;
+        }
+      });
+  }
+
+  protected static PrintStream getDebugOutStream() {
+    PrintStream out = null;
+    if (DEBUG) {
+      if (DEBUG_PREFIX != null) {
+        try {
+          out = new PrintStream(new BufferedOutputStream(new FileOutputStream(DEBUG_PREFIX + File.separatorChar +
+                                                                              "procaddresshelper-" + (++debugNum) + ".txt")));
+        } catch (IOException e) {
+          e.printStackTrace();
+          out = System.err;
+        }
+      } else {
+        out = System.err;
+      }
+    }
+    return out;
+  }
+
+  public static void resetProcAddressTable(Object table,
+                                           DynamicLookupHelper lookup) throws RuntimeException {
+    Class tableClass = table.getClass();
+    java.lang.reflect.Field[] fields = tableClass.getFields();
+    PrintStream dout = getDebugOutStream();
+    
+    if (DEBUG) {
+      dout.println("ProcAddressHelper.resetProcAddressTable(" + table.getClass().getName() + ")");
+    }
+    for (int i = 0; i < fields.length; ++i) {
+      String addressFieldName = fields[i].getName();
+      if (!addressFieldName.startsWith(ProcAddressHelper.PROCADDRESS_VAR_PREFIX)) {
+        // not a proc address variable
+        continue;
+      }
+      int startOfMethodName = ProcAddressHelper.PROCADDRESS_VAR_PREFIX.length();
+      String funcName = addressFieldName.substring(startOfMethodName);
+      try {
+        java.lang.reflect.Field addressField = fields[i];
+        assert(addressField.getType() == Long.TYPE);
+        long newProcAddress = lookup.dynamicLookupFunction(funcName);
+        // set the current value of the proc address variable in the table object
+        addressField.setLong(table, newProcAddress); 
+        if (DEBUG) {
+          dout.println("  " + addressField.getName() + " -> 0x" + Long.toHexString(newProcAddress));
+        }
+      } catch (Exception e) {
+        throw new RuntimeException("Can not get proc address for method \"" +
+                                   funcName + "\": Couldn't set value of field \"" + addressFieldName +
+                                   "\" in class " + tableClass.getName(), e);
+      }
+    }
+    if (DEBUG) {
+      dout.flush();
+      if (DEBUG_PREFIX != null) {
+        dout.close();
+      }
+    }
+  }
+}
diff --git a/src/java/com/jogamp/gluegen/runtime/ProcAddressTable.java b/src/java/com/jogamp/gluegen/runtime/ProcAddressTable.java
new file mode 100644
index 0000000..1e7d34b
--- /dev/null
+++ b/src/java/com/jogamp/gluegen/runtime/ProcAddressTable.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2003-2005 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;
+
+public interface ProcAddressTable {
+  public long getAddressFor(String functionName);
+}
diff --git a/src/java/com/jogamp/gluegen/runtime/StructAccessor.java.javame_cdc_fp b/src/java/com/jogamp/gluegen/runtime/StructAccessor.java.javame_cdc_fp
new file mode 100755
index 0000000..28a8339
--- /dev/null
+++ b/src/java/com/jogamp/gluegen/runtime/StructAccessor.java.javame_cdc_fp
@@ -0,0 +1,201 @@
+/*
+ * 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.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.gluegen.runtime;
+
+import java.nio.*;
+
+public class StructAccessor {
+  private ByteBuffer   bb;
+  private FloatBuffer  fb;
+  private IntBuffer    ib;
+  private ShortBuffer  sb;
+
+  public StructAccessor(ByteBuffer bb) {
+    this.bb = bb;
+  }
+
+  public ByteBuffer getBuffer() {
+    return bb;
+  }
+
+  /** Return a slice of the current ByteBuffer starting at the
+      specified byte offset and extending the specified number of
+      bytes. Note that this method is not thread-safe with respect to
+      the other methods in this class. */
+  public ByteBuffer slice(int byteOffset, int byteLength) {
+    bb.position(byteOffset);
+    bb.limit(byteOffset + byteLength);
+    ByteBuffer newBuf = bb.slice();
+    bb.position(0);
+    bb.limit(bb.capacity());
+    return newBuf;
+  }
+
+  /** Retrieves the byte at the specified slot (byte offset). */
+  public byte getByteAt(int slot) {
+    return bb.get(slot);
+  }
+
+  /** Puts a byte at the specified slot (byte offset). */
+  public void setByteAt(int slot, byte v) {
+    bb.put(slot, v);
+  }
+
+  /** Retrieves the float at the specified slot (4-byte offset). */
+  public float getFloatAt(int slot) {
+    return floatBuffer().get(slot);
+  }
+
+  /** Puts a float at the specified slot (4-byte offset). */
+  public void setFloatAt(int slot, float v) {
+    floatBuffer().put(slot, v);
+  }
+
+  /** Retrieves the int at the specified slot (4-byte offset). */
+  public int getIntAt(int slot) {
+    return intBuffer().get(slot);
+  }
+
+  /** Puts a int at the specified slot (4-byte offset). */
+  public void setIntAt(int slot, int v) {
+    intBuffer().put(slot, v);
+  }
+
+  public void setBytesAt(int slot, byte[] v) {
+      for (int i = 0; i < v.length; i++) {
+        bb.put(slot++, v[i]);
+      }
+  }
+
+  public byte[] getBytesAt(int slot, byte[] v) {
+      for (int i = 0; i < v.length; i++) {
+        v[i] = bb.get(slot++);
+      }
+      return v;
+  }
+
+  public void setIntsAt(int slot, int[] v) {
+      for (int i = 0; i < v.length; i++) {
+        intBuffer().put(slot++, v[i]);
+      }
+  }
+
+  public int[] getIntsAt(int slot, int[] v) {
+      for (int i = 0; i < v.length; i++) {
+        v[i] = intBuffer().get(slot++);
+      }
+      return v;
+  }
+
+  public void setFloatsAt(int slot, float[] v) {
+      for (int i = 0; i < v.length; i++) {
+        floatBuffer().put(slot++, v[i]);
+      }
+  }
+
+  public float[] getFloatsAt(int slot, float[] v) {
+      for (int i = 0; i < v.length; i++) {
+        v[i] = floatBuffer().get(slot++);
+      }
+      return v;
+  }
+
+  /** Retrieves the long at the specified slot (8-byte offset). */
+  public long getLongAt(int slot) {
+    slot = slot << 1 ; // 8-byte to 4-byte offset
+    IntBuffer intBuffer = intBuffer();
+    long lo = 0x00000000FFFFFFFFL & ( (long) intBuffer.get(slot)   );
+    long hi = 0x00000000FFFFFFFFL & ( (long) intBuffer.get(slot+1) );
+    if(BufferFactory.isLittleEndian()) {
+        return hi << 32 | lo ;
+    }
+    return lo << 32 | hi ;
+  }
+
+  /** Puts a long at the specified slot (8-byte offset). */
+  public void setLongAt(int slot, long v) {
+    slot = slot << 1 ; // 8-byte to 4-byte offset
+    IntBuffer intBuffer = intBuffer();
+    int lo = (int) ( ( v       ) & 0x00000000FFFFFFFFL ) ;
+    int hi = (int) ( ( v >> 32 ) & 0x00000000FFFFFFFFL ) ;
+    if(BufferFactory.isLittleEndian()) {
+        intBuffer.put(slot, lo);
+        intBuffer.put(slot+1, hi);
+    } else {
+        intBuffer.put(slot, hi);
+        intBuffer.put(slot+1, lo);
+    }
+  }
+
+  /** Retrieves the short at the specified slot (2-byte offset). */
+  public short getShortAt(int slot) {
+    return shortBuffer().get(slot);
+  }
+
+  /** Puts a short at the specified slot (2-byte offset). */
+  public void setShortAt(int slot, short v) {
+    shortBuffer().put(slot, v);
+  }
+
+  //----------------------------------------------------------------------
+  // Internals only below this point
+  //
+
+  private FloatBuffer floatBuffer() {
+    if (fb == null) {
+      fb = bb.asFloatBuffer();
+    }
+    return fb;
+  }
+
+  private IntBuffer intBuffer() {
+    if (ib == null) {
+      ib = bb.asIntBuffer();
+    }
+    return ib;
+  }
+
+  private ShortBuffer shortBuffer() {
+    if (sb == null) {
+      sb = bb.asShortBuffer();
+    }
+    return sb;
+  }
+}
diff --git a/src/java/com/jogamp/gluegen/runtime/StructAccessor.java.javase b/src/java/com/jogamp/gluegen/runtime/StructAccessor.java.javase
new file mode 100755
index 0000000..4101571
--- /dev/null
+++ b/src/java/com/jogamp/gluegen/runtime/StructAccessor.java.javase
@@ -0,0 +1,256 @@
+/*
+ * 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.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.gluegen.runtime;
+
+import java.nio.*;
+
+public class StructAccessor {
+  private ByteBuffer   bb;
+  private CharBuffer   cb;
+  private DoubleBuffer db;
+  private FloatBuffer  fb;
+  private IntBuffer    ib;
+  private LongBuffer   lb;
+  private ShortBuffer  sb;
+
+  public StructAccessor(ByteBuffer bb) {
+    // Setting of byte order is concession to native code which needs
+    // to instantiate these
+    this.bb = bb.order(ByteOrder.nativeOrder());
+  }
+
+  public ByteBuffer getBuffer() {
+    return bb;
+  }
+
+  /** Return a slice of the current ByteBuffer starting at the
+      specified byte offset and extending the specified number of
+      bytes. Note that this method is not thread-safe with respect to
+      the other methods in this class. */
+  public ByteBuffer slice(int byteOffset, int byteLength) {
+    bb.position(byteOffset);
+    bb.limit(byteOffset + byteLength);
+    ByteBuffer newBuf = bb.slice();
+    bb.position(0);
+    bb.limit(bb.capacity());
+    return newBuf;
+  }
+
+  /** Retrieves the byte at the specified slot (byte offset). */
+  public byte getByteAt(int slot) {
+    return bb.get(slot);
+  }
+
+  /** Puts a byte at the specified slot (byte offset). */
+  public void setByteAt(int slot, byte v) {
+    bb.put(slot, v);
+  }
+
+  /** Retrieves the char at the specified slot (2-byte offset). */
+  public char getCharAt(int slot) {
+    return charBuffer().get(slot);
+  }
+
+  /** Puts a char at the specified slot (2-byte offset). */
+  public void setCharAt(int slot, char v) {
+    charBuffer().put(slot, v);
+  }
+
+  /** Retrieves the double at the specified slot (8-byte offset). */
+  public double getDoubleAt(int slot) {
+    return doubleBuffer().get(slot);
+  }
+
+  /** Puts a double at the specified slot (8-byte offset). */
+  public void setDoubleAt(int slot, double v) {
+    doubleBuffer().put(slot, v);
+  }
+
+  /** Retrieves the float at the specified slot (4-byte offset). */
+  public float getFloatAt(int slot) {
+    return floatBuffer().get(slot);
+  }
+
+  /** Puts a float at the specified slot (4-byte offset). */
+  public void setFloatAt(int slot, float v) {
+    floatBuffer().put(slot, v);
+  }
+
+  /** Retrieves the int at the specified slot (4-byte offset). */
+  public int getIntAt(int slot) {
+    return intBuffer().get(slot);
+  }
+
+  /** Puts a int at the specified slot (4-byte offset). */
+  public void setIntAt(int slot, int v) {
+    intBuffer().put(slot, v);
+  }
+
+  /** Retrieves the long at the specified slot (8-byte offset). */
+  public long getLongAt(int slot) {
+    return longBuffer().get(slot);
+  }
+
+  /** Puts a long at the specified slot (8-byte offset). */
+  public void setLongAt(int slot, long v) {
+    longBuffer().put(slot, v);
+  }
+
+  /** Retrieves the short at the specified slot (2-byte offset). */
+  public short getShortAt(int slot) {
+    return shortBuffer().get(slot);
+  }
+
+  /** Puts a short at the specified slot (2-byte offset). */
+  public void setShortAt(int slot, short v) {
+    shortBuffer().put(slot, v);
+  }
+
+  public void setBytesAt(int slot, byte[] v) {
+      for (int i = 0; i < v.length; i++) {
+        bb.put(slot++, v[i]);
+      }
+  }
+
+  public byte[] getBytesAt(int slot, byte[] v) {
+      for (int i = 0; i < v.length; i++) {
+        v[i] = bb.get(slot++);
+      }
+      return v;
+  }
+
+  public void setCharsAt(int slot, char[] v) {
+      for (int i = 0; i < v.length; i++) {
+        charBuffer().put(slot++, v[i]);
+      }
+  }
+
+  public char[] getCharsAt(int slot, char[] v) {
+      for (int i = 0; i < v.length; i++) {
+        v[i] = charBuffer().get(slot++);
+      }
+      return v;
+  }
+
+  public void setIntsAt(int slot, int[] v) {
+      for (int i = 0; i < v.length; i++) {
+        intBuffer().put(slot++, v[i]);
+      }
+  }
+
+  public int[] getIntsAt(int slot, int[] v) {
+      for (int i = 0; i < v.length; i++) {
+        v[i] = intBuffer().get(slot++);
+      }
+      return v;
+  }
+
+  public void setFloatsAt(int slot, float[] v) {
+      for (int i = 0; i < v.length; i++) {
+        floatBuffer().put(slot++, v[i]);
+      }
+  }
+
+  public float[] getFloatsAt(int slot, float[] v) {
+      for (int i = 0; i < v.length; i++) {
+        v[i] = floatBuffer().get(slot++);
+      }
+      return v;
+  }
+
+  public void setDoublesAt(int slot, double[] v) {
+      for (int i = 0; i < v.length; i++) {
+        doubleBuffer().put(slot++, v[i]);
+      }
+  }
+
+  public double[] getDoublesAt(int slot, double[] v) {
+      for (int i = 0; i < v.length; i++) {
+        v[i] = doubleBuffer().get(slot++);
+      }
+      return v;
+  }
+
+  //----------------------------------------------------------------------
+  // Internals only below this point
+  //
+
+  private CharBuffer charBuffer() {
+    if (cb == null) {
+      cb = bb.asCharBuffer();
+    }
+    return cb;
+  }
+
+  private DoubleBuffer doubleBuffer() {
+    if (db == null) {
+      db = bb.asDoubleBuffer();
+    }
+    return db;
+  }
+
+  private FloatBuffer floatBuffer() {
+    if (fb == null) {
+      fb = bb.asFloatBuffer();
+    }
+    return fb;
+  }
+
+  private IntBuffer intBuffer() {
+    if (ib == null) {
+      ib = bb.asIntBuffer();
+    }
+    return ib;
+  }
+
+  private LongBuffer longBuffer() {
+    if (lb == null) {
+      lb = bb.asLongBuffer();
+    }
+    return lb;
+  }
+
+  private ShortBuffer shortBuffer() {
+    if (sb == null) {
+      sb = bb.asShortBuffer();
+    }
+    return sb;
+  }
+}
diff --git a/src/java/com/jogamp/gluegen/runtime/UnixDynamicLinkerImpl.java b/src/java/com/jogamp/gluegen/runtime/UnixDynamicLinkerImpl.java
new file mode 100755
index 0000000..018f31b
--- /dev/null
+++ b/src/java/com/jogamp/gluegen/runtime/UnixDynamicLinkerImpl.java
@@ -0,0 +1,66 @@
+/* !---- DO NOT EDIT: This file autogenerated by com\sun\gluegen\JavaEmitter.java on Mon Jul 31 16:26:59 PDT 2006 ----! */
+
+package com.jogamp.gluegen.runtime;
+
+import com.jogamp.gluegen.runtime.*;
+
+public class UnixDynamicLinkerImpl implements DynamicLinker
+{
+
+  public static final int RTLD_LAZY = 0x00001;
+  public static final int RTLD_NOW = 0x00002;
+  public static final int RTLD_NOLOAD = 0x00004;
+  public static final int RTLD_GLOBAL = 0x00100;
+  public static final int RTLD_LOCAL = 0x00000;
+  public static final int RTLD_PARENT = 0x00200;
+  public static final int RTLD_GROUP = 0x00400;
+  public static final int RTLD_WORLD = 0x00800;
+  public static final int RTLD_NODELETE = 0x01000;
+  public static final int RTLD_FIRST = 0x02000;
+
+  /** Interface to C language function: <br> <code> int dlclose(void * ); </code>    */
+  private static native int dlclose(long arg0);
+
+  /** Interface to C language function: <br> <code> char *  dlerror(void); </code>    */
+  private static native java.lang.String dlerror();
+
+  /** Interface to C language function: <br> <code> void *  dlopen(const char * , int); </code>    */
+  private static native long dlopen(java.lang.String arg0, int arg1);
+
+  /** Interface to C language function: <br> <code> void *  dlsym(void * , const char * ); </code>    */
+  private static native long dlsym(long arg0, java.lang.String arg1);
+
+
+  // --- Begin CustomJavaCode .cfg declarations
+  public long openLibraryLocal(String pathname, boolean debug) {
+    // Note we use RTLD_GLOBAL visibility to _NOT_ allow this functionality to
+    // be used to pre-resolve dependent libraries of JNI code without
+    // requiring that all references to symbols in those libraries be
+    // looked up dynamically via the ProcAddressTable mechanism; in
+    // other words, one can actually link against the library instead of
+    // having to dlsym all entry points. System.loadLibrary() uses
+    // RTLD_LOCAL visibility so can't be used for this purpose.
+    return dlopen(pathname, RTLD_LAZY | RTLD_LOCAL);
+  }
+
+  public long openLibraryGlobal(String pathname, boolean debug) {
+    // Note we use RTLD_GLOBAL visibility to allow this functionality to
+    // be used to pre-resolve dependent libraries of JNI code without
+    // requiring that all references to symbols in those libraries be
+    // looked up dynamically via the ProcAddressTable mechanism; in
+    // other words, one can actually link against the library instead of
+    // having to dlsym all entry points. System.loadLibrary() uses
+    // RTLD_LOCAL visibility so can't be used for this purpose.
+    return dlopen(pathname, RTLD_LAZY | RTLD_GLOBAL);
+  }
+  
+  public long lookupSymbol(long libraryHandle, String symbolName) {
+    return dlsym(libraryHandle, symbolName);
+  }
+  
+  public void closeLibrary(long libraryHandle) {
+    dlclose(libraryHandle);
+  }
+  // ---- End CustomJavaCode .cfg declarations
+
+} // end of class UnixDynamicLinkerImpl
diff --git a/src/java/com/jogamp/gluegen/runtime/WindowsDynamicLinkerImpl.java b/src/java/com/jogamp/gluegen/runtime/WindowsDynamicLinkerImpl.java
new file mode 100755
index 0000000..87b9a37
--- /dev/null
+++ b/src/java/com/jogamp/gluegen/runtime/WindowsDynamicLinkerImpl.java
@@ -0,0 +1,49 @@
+/* !---- DO NOT EDIT: This file autogenerated by com\sun\gluegen\JavaEmitter.java on Tue May 27 02:37:55 PDT 2008 ----! */
+
+package com.jogamp.gluegen.runtime;
+
+import com.jogamp.gluegen.runtime.*;
+
+public class WindowsDynamicLinkerImpl implements DynamicLinker
+{
+
+
+  /** Interface to C language function: <br> <code> BOOL FreeLibrary(HANDLE hLibModule); </code>    */
+  private static native int FreeLibrary(long hLibModule);
+
+  /** Interface to C language function: <br> <code> DWORD GetLastError(void); </code>    */
+  private static native int GetLastError();
+
+  /** Interface to C language function: <br> <code> PROC GetProcAddressA(HANDLE hModule, LPCSTR lpProcName); </code>    */
+  private static native long GetProcAddressA(long hModule, java.lang.String lpProcName);
+
+  /** Interface to C language function: <br> <code> HANDLE LoadLibraryW(LPCWSTR lpLibFileName); </code>    */
+  private static native long LoadLibraryW(java.lang.String lpLibFileName);
+
+
+  // --- Begin CustomJavaCode .cfg declarations
+  public long openLibraryLocal(String libraryName, boolean debug) {
+    // How does that work under Windows ?
+    // Don't know .. so it's an alias for the time being
+    return openLibraryGlobal(libraryName, debug);
+  }
+  
+  public long openLibraryGlobal(String libraryName, boolean debug) {
+    long handle = LoadLibraryW(libraryName);
+    if(0==handle && debug) {
+        int err = GetLastError();
+        System.err.println("LoadLibraryW \""+libraryName+"\" failed, error code: 0x"+Integer.toHexString(err)+", "+err);
+    }
+    return handle;
+  }
+  
+  public long lookupSymbol(long libraryHandle, String symbolName) {
+    return GetProcAddressA(libraryHandle, symbolName);
+  }
+  
+  public void closeLibrary(long libraryHandle) {
+    FreeLibrary(libraryHandle);
+  }
+  // ---- End CustomJavaCode .cfg declarations
+
+} // end of class WindowsDynamicLinkerImpl
diff --git a/src/java/com/jogamp/gluegen/runtime/opengl/GLExtensionNames.java b/src/java/com/jogamp/gluegen/runtime/opengl/GLExtensionNames.java
new file mode 100644
index 0000000..b07a96f
--- /dev/null
+++ b/src/java/com/jogamp/gluegen/runtime/opengl/GLExtensionNames.java
@@ -0,0 +1,187 @@
+/*
+ * Copyright (c) 2003-2005 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.opengl;
+
+import java.util.*;
+import com.jogamp.gluegen.runtime.*;
+
+public class GLExtensionNames {
+    //GL_XYZ : GL_XYZ, GL_XYZ_GL2, GL_XYZ_ARB, GL_XYZ_OES, GL_XYZ_OML
+    //GL_XYZ : GL_XYZ, GL_GL2_XYZ, GL_ARB_XYZ, GL_OES_XYZ, GL_OML_XYZ
+    //
+    // Pass-1 Unify ARB extensions with the same value
+    // Pass-2 Unify vendor extensions, 
+    //        if exist as an ARB extension with the same value.
+    // Pass-3 Emit
+
+    public static final String[] extensionsARB = { "ARB", "GL2", "OES", "KHR", "OML" };
+    public static final String[] extensionsVEN = { "3DFX", 
+                                                   "AMD",
+                                                   "APPLE",
+                                                   "ATI",
+                                                   "EXT",
+                                                   "HP",
+                                                   "IBM",
+                                                   "MESA",
+                                                   "MESAX",
+                                                   "NV",
+                                                   "SGI",
+                                                   "SGIS",
+                                                   "SGIX",
+                                                   "SUN",
+                                                   "WIN"
+                                                   };
+
+
+    public static final boolean isGLFunction(String str) {
+        return str.startsWith("gl")  || /* str.startsWith("glu") || str.startsWith("glX") || */
+               str.startsWith("egl") || str.startsWith("wgl") || str.startsWith("agl") ||
+               str.startsWith("cgl") ;
+    }
+
+    public static final boolean isGLEnumeration(String str) {
+        return str.startsWith("GL_")  || str.startsWith("GLU_") || str.startsWith("GLX_") ||
+               str.startsWith("EGL_") || str.startsWith("WGL_") || str.startsWith("AGL_") ||
+               str.startsWith("CGL_") ;
+    }
+
+    public static final int getExtensionIdx(String[] extensions, String str, boolean isGLFunc) {
+        if(isGLFunc) {
+            for(int i = extensions.length - 1 ; i>=0 ; i--) {
+                if( str.endsWith(extensions[i]) ) {
+                    return i;
+                }
+            }
+        } else {
+            for(int i = extensions.length - 1 ; i>=0 ; i--) {
+                if( str.endsWith("_"+extensions[i]) ) {
+                    return i;
+                }
+            }
+        }
+        return -1;
+    }
+
+    public static final boolean isExtension(String[] extensions, String str, boolean isGLFunc) {
+        return getExtensionIdx(extensions, str, isGLFunc)>=0;
+    }
+
+    public static final String getExtensionSuffix(String str, boolean isGLFunc) {
+        int idx = getExtensionIdx(extensionsARB, str, isGLFunc);
+        if(idx>=0) {
+            return extensionsARB[idx];
+        }
+        idx = getExtensionIdx(extensionsVEN, str, isGLFunc);
+        if(idx>=0) {
+            return extensionsVEN[idx];
+        }
+        return null;
+    }
+
+    public static final String normalize(String[] extensions, String str, boolean isGLFunc) {
+        boolean touched = false;
+        for(int i = extensions.length - 1 ; !touched && i>=0 ; i--) {
+            if(isGLFunc) {
+                if(str.endsWith(extensions[i])) {
+                    // functions
+                    str = str.substring(0, str.length()-extensions[i].length());
+                    touched=true;
+                }
+            } else {
+                if(str.endsWith("_"+extensions[i])) {
+                    // enums
+                    str = str.substring(0, str.length()-1-extensions[i].length());
+                    touched=true;
+                }
+            }
+        }
+        return str;
+    }
+    public static final String normalizeARB(String str, boolean isGLFunc) {
+        return normalize(extensionsARB, str, isGLFunc);
+    }
+    public static final boolean isExtensionARB(String str, boolean isGLFunc) {
+        return isExtension(extensionsARB, str, isGLFunc);
+    }
+    public static final String normalizeVEN(String str, boolean isGLFunc) {
+        return normalize(extensionsVEN, str, isGLFunc);
+    }
+    public static final boolean isExtensionVEN(String str, boolean isGLFunc) {
+        return isExtension(extensionsVEN, str, isGLFunc);
+    }
+    public static final String normalize(String str, boolean isGLFunc) {
+        if (isExtensionARB(str, isGLFunc)) {
+            return normalizeARB(str, isGLFunc);
+        }
+        if (isExtensionVEN(str, isGLFunc)) {
+            return normalizeVEN(str, isGLFunc);
+        }
+        return str;
+    }
+    public static final boolean isExtension(String str, boolean isGLFunc) {
+        return isExtension(extensionsARB, str, isGLFunc) || 
+               isExtension(extensionsVEN, str, isGLFunc);
+    }
+
+    public static final int getFuncNamePermutationNumber(String name) {
+        if(isExtensionARB(name, true) || isExtensionVEN(name, true)) {
+            // no name permutation, if it's already a known extension
+            return 1;
+        }
+        return 1 + extensionsARB.length + extensionsVEN.length;
+    }
+
+    public static final String getFuncNamePermutation(String name, int i) {
+        // identity
+        if(i==0) {
+            return name;
+        }
+        if(0>i || i>=(1+extensionsARB.length + extensionsVEN.length)) {
+            throw new RuntimeException("Index out of range [0.."+(1+extensionsARB.length+extensionsVEN.length-1)+"]: "+i);
+        }
+        // ARB
+        i-=1;
+        if(i<extensionsARB.length) {
+            return name+extensionsARB[i];
+        }
+        // VEN
+        i-=extensionsARB.length;
+        return name+extensionsVEN[i];
+    }
+}
+
diff --git a/src/java/com/jogamp/gluegen/runtime/opengl/GLProcAddressHelper.java b/src/java/com/jogamp/gluegen/runtime/opengl/GLProcAddressHelper.java
new file mode 100644
index 0000000..7470c46
--- /dev/null
+++ b/src/java/com/jogamp/gluegen/runtime/opengl/GLProcAddressHelper.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) 2003-2005 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.opengl;
+
+import com.jogamp.gluegen.runtime.*;
+
+// Debugging only
+import java.io.PrintStream;
+
+/** Helper class containing constants and methods to assist with the
+    manipulation of auto-generated ProcAddressTables. */
+
+public class GLProcAddressHelper extends ProcAddressHelper {
+
+  public static void resetProcAddressTable(Object table,
+                                           DynamicLookupHelper lookup) throws RuntimeException {
+    Class tableClass = table.getClass();
+    java.lang.reflect.Field[] fields = tableClass.getFields();
+    PrintStream dout = getDebugOutStream();
+    
+    if (DEBUG) {
+      dout.println("ProcAddressHelper.resetProcAddressTable(" + table.getClass().getName() + ")");
+    }
+    for (int i = 0; i < fields.length; ++i) {
+      String addressFieldName = fields[i].getName();
+      if (!addressFieldName.startsWith(ProcAddressHelper.PROCADDRESS_VAR_PREFIX)) {
+        // not a proc address variable
+        continue;
+      }
+      int startOfMethodName = ProcAddressHelper.PROCADDRESS_VAR_PREFIX.length();
+      String funcNameBase = addressFieldName.substring(startOfMethodName);
+      java.lang.reflect.Field addressField;
+      try {
+        addressField = fields[i];
+        assert(addressField.getType() == Long.TYPE);
+      } catch (Exception e) {
+        throw new RuntimeException("Can not get proper proc address field for method \"" +
+                                   funcNameBase + "\": Couldn't get field \"" + addressFieldName +
+                                   "\" in class " + tableClass.getName(), e);
+      }
+      long newProcAddress = 0;
+      int  funcNamePermNum = GLExtensionNames.getFuncNamePermutationNumber(funcNameBase);
+      String funcName = null;
+      for(int j = 0; 0==newProcAddress && j < funcNamePermNum; j++) {
+          funcName = GLExtensionNames.getFuncNamePermutation(funcNameBase, j);
+          try {
+            newProcAddress = lookup.dynamicLookupFunction(funcName);
+          } catch (Exception e) { 
+            if (DEBUG) {
+              dout.println(e);
+              e.printStackTrace();
+            }
+          }
+      } 
+      try {
+        // set the current value of the proc address variable in the table object
+        addressField.setLong(table, newProcAddress); 
+        if (DEBUG) {
+          dout.println("  " + addressField.getName() + " "+funcName+" -> 0x" + Long.toHexString(newProcAddress));
+        }
+      } catch (Exception e) {
+        throw new RuntimeException("Can not set proc address field for method \"" +
+                                   funcNameBase + "\": Couldn't set field \"" + addressFieldName +
+                                   "\" in class " + tableClass.getName(), e);
+      }
+    }
+    if (DEBUG) {
+      dout.flush();
+      if (DEBUG_PREFIX != null) {
+        dout.close();
+      }
+    }
+  }
+}