refactoring and code cleanup in gluegen.opengl and gluegen.procaddress package.

12 files changed, 2716 insertions, 2784 deletions

diff --git a/src/java/com/sun/gluegen/JavaEmitter.java b/src/java/com/sun/gluegen/JavaEmitter.java
index f84c19a..0703f76 100644
--- a/src/java/com/sun/gluegen/JavaEmitter.java
+++ b/src/java/com/sun/gluegen/JavaEmitter.java
@@ -647,7 +647,7 @@ public class JavaEmitter implements GlueEmitter {
    * Generate all appropriate Java bindings for the specified C function
    * symbols.
    */
-  protected List<FunctionEmitter> generateMethodBindingEmitters(HashSet<MethodBinding> methodBindingSet, FunctionSymbol sym) throws Exception {
+  protected List<? extends FunctionEmitter> generateMethodBindingEmitters(Set<MethodBinding> methodBindingSet, FunctionSymbol sym) throws Exception {
 
     ArrayList<FunctionEmitter> allEmitters = new ArrayList<FunctionEmitter>();
 
@@ -1163,9 +1163,11 @@ public class JavaEmitter implements GlueEmitter {
   }
   public void endStructs() throws Exception {}
 
-  public static int addStrings2Buffer(StringBuffer buf, String sep, String first, Collection<String> col) {
+  public static int addStrings2Buffer(StringBuilder buf, String sep, String first, Collection<String> col) {
     int num = 0;
-    if(null==buf) buf = new StringBuffer();
+    if(null==buf) {
+        buf = new StringBuilder();
+    }
 
     Iterator<String> iter = col.iterator();
     if(null!=first) {
diff --git a/src/java/com/sun/gluegen/nativesig/NativeSignatureEmitter.java b/src/java/com/sun/gluegen/nativesig/NativeSignatureEmitter.java
index 314a9bb..f20495b 100755
--- a/src/java/com/sun/gluegen/nativesig/NativeSignatureEmitter.java
+++ b/src/java/com/sun/gluegen/nativesig/NativeSignatureEmitter.java
@@ -36,7 +36,6 @@
  * Sun gratefully acknowledges that this software was originally authored
  * and developed by Kenneth Bradley Russell and Christopher John Kline.
  */
-
 package com.sun.gluegen.nativesig;
 
 import java.io.*;
@@ -47,142 +46,141 @@ import com.sun.gluegen.cgram.types.*;
 import com.sun.gluegen.opengl.*;
 import com.sun.gluegen.procaddress.*;
 
-/** Emitter producing NativeSignature attributes. */
-
+/**
+ * Emitter producing NativeSignature attributes.
+ */
 public class NativeSignatureEmitter extends GLEmitter {
-  protected List generateMethodBindingEmitters(HashSet/*<MethodBinding>*/ methodBindingSet, FunctionSymbol sym) throws Exception {
-    // Allow superclass to do most of the work for us
-    List res = super.generateMethodBindingEmitters(methodBindingSet, sym);
-
-    // Filter out all non-JavaMethodBindingEmitters
-    for (Iterator iter = res.iterator(); iter.hasNext(); ) {
-      FunctionEmitter emitter = (FunctionEmitter) iter.next();
-      if (!(emitter instanceof JavaMethodBindingEmitter)) {
-        iter.remove();
-      }
-    }
 
-    if (res.isEmpty()) {
-      return res;
-    }
+    @Override
+    protected List<? extends FunctionEmitter> generateMethodBindingEmitters(Set<MethodBinding> methodBindingSet, FunctionSymbol sym) throws Exception {
 
-    PrintWriter writer = (getConfig().allStatic() ? javaWriter() : javaImplWriter());
+        // Allow superclass to do most of the work for us
+        List<? extends FunctionEmitter> res = super.generateMethodBindingEmitters(methodBindingSet, sym);
 
-    List processed = new ArrayList();
+        // Filter out all non-JavaMethodBindingEmitters
+        for (Iterator<? extends FunctionEmitter> iter = res.iterator(); iter.hasNext();) {
+            FunctionEmitter emitter = iter.next();
+            if (!(emitter instanceof JavaMethodBindingEmitter)) {
+                iter.remove();
+            }
+        }
 
-    // First, filter out all emitters going to the "other" (public) writer
-    for (Iterator iter = res.iterator(); iter.hasNext(); ) {
-      FunctionEmitter emitter = (FunctionEmitter) iter.next();
-      if (emitter.getDefaultOutput() != writer) {
-        processed.add(emitter);
-        iter.remove();
-      }
-    }
+        if (res.isEmpty()) {
+            return res;
+        }
+
+        PrintWriter writer = (getConfig().allStatic() ? javaWriter() : javaImplWriter());
+
+        List<FunctionEmitter> processed = new ArrayList<FunctionEmitter>();
 
-    // Now process all of the remaining emitters sorted by MethodBinding
-    while (!res.isEmpty()) {
-      List emittersForBinding = new ArrayList();
-      JavaMethodBindingEmitter emitter = (JavaMethodBindingEmitter) res.remove(0);
-      emittersForBinding.add(emitter);
-      MethodBinding binding = emitter.getBinding();
-      for (Iterator iter = res.iterator(); iter.hasNext(); ) {
-        JavaMethodBindingEmitter emitter2 = (JavaMethodBindingEmitter) iter.next();
-        if (emitter2.getBinding() == binding) {
-          emittersForBinding.add(emitter2);
-          iter.remove();
+        // First, filter out all emitters going to the "other" (public) writer
+        for (Iterator<? extends FunctionEmitter> iter = res.iterator(); iter.hasNext();) {
+            FunctionEmitter emitter = iter.next();
+            if (emitter.getDefaultOutput() != writer) {
+                processed.add(emitter);
+                iter.remove();
+            }
         }
-      }
-      generateNativeSignatureEmitters(binding, emittersForBinding);
-      processed.addAll(emittersForBinding);
-    }
 
-    return processed;
-  }
+        // Now process all of the remaining emitters sorted by MethodBinding
+        while (!res.isEmpty()) {
+            List<JavaMethodBindingEmitter> emittersForBinding = new ArrayList<JavaMethodBindingEmitter>();
+            JavaMethodBindingEmitter emitter = (JavaMethodBindingEmitter) res.remove(0);
+            emittersForBinding.add(emitter);
+            MethodBinding binding = emitter.getBinding();
+            for (Iterator<? extends FunctionEmitter> iter = res.iterator(); iter.hasNext();) {
+                JavaMethodBindingEmitter emitter2 = (JavaMethodBindingEmitter) iter.next();
+                if (emitter2.getBinding() == binding) {
+                    emittersForBinding.add(emitter2);
+                    iter.remove();
+                }
+            }
+            generateNativeSignatureEmitters(binding, emittersForBinding);
+            processed.addAll(emittersForBinding);
+        }
 
-  protected void generateNativeSignatureEmitters(MethodBinding binding,
-                                                 List allEmitters) {
-    if (allEmitters.isEmpty()) {
-      return;
+        return processed;
     }
 
-    PrintWriter writer = (getConfig().allStatic() ? javaWriter() : javaImplWriter());
-    
-    // Give ourselves the chance to interpose on the generation of all code to keep things simple
-    List newEmitters = new ArrayList();
-    for (Iterator iter = allEmitters.iterator(); iter.hasNext(); ) {
-      JavaMethodBindingEmitter javaEmitter = (JavaMethodBindingEmitter) iter.next();
-      NativeSignatureJavaMethodBindingEmitter newEmitter = null;
-      if (javaEmitter instanceof GLJavaMethodBindingEmitter) {
-        newEmitter = new NativeSignatureJavaMethodBindingEmitter((GLJavaMethodBindingEmitter) javaEmitter);
-      } else if (javaEmitter instanceof ProcAddressJavaMethodBindingEmitter) {
-        newEmitter = new NativeSignatureJavaMethodBindingEmitter((ProcAddressJavaMethodBindingEmitter) javaEmitter);
-      } else {
-        newEmitter = new NativeSignatureJavaMethodBindingEmitter(javaEmitter, this);
-      }
-      newEmitters.add(newEmitter);
-    }
-    allEmitters.clear();
-    allEmitters.addAll(newEmitters);
-
-    // Detect whether we need to produce more or modify some of these emitters.
-    // Note that at this point we are assuming that generatePublicEmitters has
-    // been called with signatureOnly both true and false.
-    if (signatureContainsStrings(binding) &&
-        !haveEmitterWithBody(allEmitters)) {
-      // This basically handles glGetString but also any similar methods
-      NativeSignatureJavaMethodBindingEmitter javaEmitter = findEmitterWithWriter(allEmitters, writer);
-
-      // First, we need to clone this emitter to produce the native
-      // entry point
-      NativeSignatureJavaMethodBindingEmitter emitter =
-        new NativeSignatureJavaMethodBindingEmitter(javaEmitter);
-      emitter.removeModifier(JavaMethodBindingEmitter.PUBLIC);
-      emitter.addModifier(JavaMethodBindingEmitter.PRIVATE);
-      emitter.setForImplementingMethodCall(true);
-      // Note: this is chosen so we don't have to change the logic in
-      // emitReturnVariableSetupAndCall which decides which variant
-      // (direct / indirect) to call
-      emitter.setForDirectBufferImplementation(true);
-      allEmitters.add(emitter);
-
-      // Now make the original emitter non-native and cause it to emit a body
-      javaEmitter.removeModifier(JavaMethodBindingEmitter.NATIVE);
-      javaEmitter.setEmitBody(true);
-    }
-  }
-
-  protected boolean signatureContainsStrings(MethodBinding binding) {
-    for (int i = 0; i < binding.getNumArguments(); i++) {
-      JavaType type = binding.getJavaArgumentType(i);
-      if (type.isString() || type.isStringArray()) {
-        return true;
-      }
+    protected void generateNativeSignatureEmitters(MethodBinding binding, List<JavaMethodBindingEmitter> allEmitters) {
+
+        if (allEmitters.isEmpty()) {
+            return;
+        }
+
+        PrintWriter writer = (getConfig().allStatic() ? javaWriter() : javaImplWriter());
+
+        // Give ourselves the chance to interpose on the generation of all code to keep things simple
+        List<JavaMethodBindingEmitter> newEmitters = new ArrayList<JavaMethodBindingEmitter>();
+        for (JavaMethodBindingEmitter javaEmitter : allEmitters) {
+            NativeSignatureJavaMethodBindingEmitter newEmitter = null;
+            if (javaEmitter instanceof GLJavaMethodBindingEmitter) {
+                newEmitter = new NativeSignatureJavaMethodBindingEmitter((GLJavaMethodBindingEmitter) javaEmitter);
+            } else if (javaEmitter instanceof ProcAddressJavaMethodBindingEmitter) {
+                newEmitter = new NativeSignatureJavaMethodBindingEmitter((ProcAddressJavaMethodBindingEmitter) javaEmitter);
+            } else {
+                newEmitter = new NativeSignatureJavaMethodBindingEmitter(javaEmitter, this);
+            }
+            newEmitters.add(newEmitter);
+        }
+        allEmitters.clear();
+        allEmitters.addAll(newEmitters);
+
+        // Detect whether we need to produce more or modify some of these emitters.
+        // Note that at this point we are assuming that generatePublicEmitters has
+        // been called with signatureOnly both true and false.
+        if (signatureContainsStrings(binding) && !haveEmitterWithBody(allEmitters)) {
+            // This basically handles glGetString but also any similar methods
+            NativeSignatureJavaMethodBindingEmitter javaEmitter = findEmitterWithWriter(allEmitters, writer);
+
+            // First, we need to clone this emitter to produce the native
+            // entry point
+            NativeSignatureJavaMethodBindingEmitter emitter = new NativeSignatureJavaMethodBindingEmitter(javaEmitter);
+            emitter.removeModifier(JavaMethodBindingEmitter.PUBLIC);
+            emitter.addModifier(JavaMethodBindingEmitter.PRIVATE);
+            emitter.setForImplementingMethodCall(true);
+            // Note: this is chosen so we don't have to change the logic in
+            // emitReturnVariableSetupAndCall which decides which variant
+            // (direct / indirect) to call
+            emitter.setForDirectBufferImplementation(true);
+            allEmitters.add(emitter);
+
+            // Now make the original emitter non-native and cause it to emit a body
+            javaEmitter.removeModifier(JavaMethodBindingEmitter.NATIVE);
+            javaEmitter.setEmitBody(true);
+        }
     }
-    JavaType retType = binding.getJavaReturnType();
-    if (retType.isString() || retType.isStringArray()) {
-      return true;
+
+    protected boolean signatureContainsStrings(MethodBinding binding) {
+        for (int i = 0; i < binding.getNumArguments(); i++) {
+            JavaType type = binding.getJavaArgumentType(i);
+            if (type.isString() || type.isStringArray()) {
+                return true;
+            }
+        }
+        JavaType retType = binding.getJavaReturnType();
+        if (retType.isString() || retType.isStringArray()) {
+            return true;
+        }
+        return false;
     }
-    return false;
-  }
-
-  protected boolean haveEmitterWithBody(List allEmitters) {
-    for (Iterator iter = allEmitters.iterator(); iter.hasNext(); ) {
-      JavaMethodBindingEmitter emitter = (JavaMethodBindingEmitter) iter.next();
-      if (!emitter.signatureOnly()) {
-        return true;
-      }
+
+    protected boolean haveEmitterWithBody(List<JavaMethodBindingEmitter> allEmitters) {
+        for (JavaMethodBindingEmitter emitter : allEmitters) {
+            if (!emitter.signatureOnly()) {
+                return true;
+            }
+        }
+        return false;
     }
-    return false;
-  }
-
-  protected NativeSignatureJavaMethodBindingEmitter findEmitterWithWriter(List allEmitters, PrintWriter writer) {
-    for (Iterator iter = allEmitters.iterator(); iter.hasNext(); ) {
-      NativeSignatureJavaMethodBindingEmitter emitter =
-        (NativeSignatureJavaMethodBindingEmitter) iter.next();
-      if (emitter.getDefaultOutput() == writer) {
-        return emitter;
-      }
+
+    protected NativeSignatureJavaMethodBindingEmitter findEmitterWithWriter(List<JavaMethodBindingEmitter> allEmitters, PrintWriter writer) {
+        for (JavaMethodBindingEmitter jemitter : allEmitters) {
+            NativeSignatureJavaMethodBindingEmitter emitter = (NativeSignatureJavaMethodBindingEmitter)jemitter;
+            if (emitter.getDefaultOutput() == writer) {
+                return emitter;
+            }
+        }
+        throw new RuntimeException("Unexpectedly failed to find an emitter with the given writer");
     }
-    throw new RuntimeException("Unexpectedly failed to find an emitter with the given writer");
-  }    
 }
diff --git a/src/java/com/sun/gluegen/nativesig/NativeSignatureJavaMethodBindingEmitter.java b/src/java/com/sun/gluegen/nativesig/NativeSignatureJavaMethodBindingEmitter.java
index b4dc130..379eccf 100755
--- a/src/java/com/sun/gluegen/nativesig/NativeSignatureJavaMethodBindingEmitter.java
+++ b/src/java/com/sun/gluegen/nativesig/NativeSignatureJavaMethodBindingEmitter.java
@@ -40,16 +40,14 @@
 package com.sun.gluegen.nativesig;
 
 import java.io.*;
-import java.util.*;
-import java.text.MessageFormat;
 
 import com.sun.gluegen.*;
 import com.sun.gluegen.cgram.types.*;
-import com.sun.gluegen.cgram.*;
 import com.sun.gluegen.opengl.*;
 import com.sun.gluegen.procaddress.*;
 
 public class NativeSignatureJavaMethodBindingEmitter extends GLJavaMethodBindingEmitter {
+
   public NativeSignatureJavaMethodBindingEmitter(GLJavaMethodBindingEmitter methodToWrap) {
     super(methodToWrap);
   }
@@ -58,11 +56,11 @@ public class NativeSignatureJavaMethodBindingEmitter extends GLJavaMethodBinding
     super(methodToWrap, false);
   }
 
-  public NativeSignatureJavaMethodBindingEmitter(JavaMethodBindingEmitter methodToWrap,
-                                                 NativeSignatureEmitter emitter) {
+  public NativeSignatureJavaMethodBindingEmitter(JavaMethodBindingEmitter methodToWrap, NativeSignatureEmitter emitter) {
     super(methodToWrap, false, null, false, false, emitter);
   }
 
+    @Override
   protected void emitSignature(PrintWriter writer) {
     writer.print(getBaseIndentString());
     emitNativeSignatureAnnotation(writer);
diff --git a/src/java/com/sun/gluegen/opengl/BuildComposablePipeline.java b/src/java/com/sun/gluegen/opengl/BuildComposablePipeline.java
index cbc0d89..9750c13 100644
--- a/src/java/com/sun/gluegen/opengl/BuildComposablePipeline.java
+++ b/src/java/com/sun/gluegen/opengl/BuildComposablePipeline.java
@@ -36,7 +36,6 @@
  * Sun gratefully acknowledges that this software was originally authored
  * and developed by Kenneth Bradley Russell and Christopher John Kline.
  */
-
 package com.sun.gluegen.opengl;
 
 import com.sun.gluegen.*;
@@ -44,1079 +43,1042 @@ import com.sun.gluegen.*;
 import java.lang.reflect.*;
 import java.io.*;
 import java.util.*;
-import java.util.regex.*;
-
-public class BuildComposablePipeline
-{
-  public static final int GEN_DEBUG  = 1 << 0 ; // default
-  public static final int GEN_TRACE  = 1 << 1 ; // default
-  public static final int GEN_CUSTOM = 1 << 2 ;
-  public static final int GEN_PROLOG_XOR_DOWNSTREAM = 1 << 3 ;
-
-  int mode;
-  private String outputDir;
-  private String outputPackage;
-  private String outputName;
-  private Class classToComposeAround;
-  private Class classPrologOpt;
-  private Class classDownstream;
-  private String basePackage;
-  private String baseName; // does not include package!
-  private String downstreamPackage;
-  private String downstreamName; // does not include package!
-
-  // Only desktop OpenGL has immediate mode glBegin / glEnd
-  private boolean hasImmediateMode;
-
-  // Desktop OpenGL and GLES1 have GL_STACK_OVERFLOW and GL_STACK_UNDERFLOW errors
-  private boolean hasStackOverflow;
-
-  public static Class getClass(String name) {
-    Class clazz=null;
-    try {
-      clazz = Class.forName(name);      
-    } catch (Exception e) {
-      throw new RuntimeException(
-        "Could not find class \"" + name + "\"", e);
-    }
-    return clazz;
-  }
-
-  public static Method getMethod(Class clazz, Method m) {
-      Method res = null;
-      try {
-          res = clazz.getMethod(m.getName(), m.getParameterTypes());
-      } catch (Exception e) { }
-      return res;
-  }
-
-  public static void main(String[] args)
-  {
-    String classToComposeAroundName = args[0];
-    Class classPrologOpt, classDownstream;
-    Class classToComposeAround = getClass(classToComposeAroundName);
-    
-    String outputDir = args[1];
-    String outputPackage, outputName;
+
+public class BuildComposablePipeline {
+
+    public static final int GEN_DEBUG = 1 << 0; // default
+    public static final int GEN_TRACE = 1 << 1; // default
+    public static final int GEN_CUSTOM = 1 << 2;
+    public static final int GEN_PROLOG_XOR_DOWNSTREAM = 1 << 3;
     int mode;
+    private String outputDir;
+    private String outputPackage;
+    private String outputName;
+    private Class<?> classToComposeAround;
+    private Class<?> classPrologOpt;
+    private Class<?> classDownstream;
+    // Only desktop OpenGL has immediate mode glBegin / glEnd
+    private boolean hasImmediateMode;
+    // Desktop OpenGL and GLES1 have GL_STACK_OVERFLOW and GL_STACK_UNDERFLOW errors
+    private boolean hasStackOverflow;
+
+    public static Class<?> getClass(String name) {
+        Class<?> clazz = null;
+        try {
+            clazz = Class.forName(name);
+        } catch (Exception e) {
+            throw new RuntimeException(
+                    "Could not find class \"" + name + "\"", e);
+        }
+        return clazz;
+    }
 
-    if(args.length>2) {
-        String outputClazzName = args[2];
-        outputPackage = getPackageName(outputClazzName);
-        outputName = getBaseClassName(outputClazzName);
-        classPrologOpt = getClass(args[3]);
-        classDownstream = getClass(args[4]);
-        mode = GEN_CUSTOM;
-        if(args.length>5) {
-            if(args[5].equals("prolog_xor_downstream")) {
-                mode |= GEN_PROLOG_XOR_DOWNSTREAM;
+    public static Method getMethod(Class<?> clazz, Method m) {
+        Method res = null;
+        try {
+            res = clazz.getMethod(m.getName(), m.getParameterTypes());
+        } catch (Exception e) {
+        }
+        return res;
+    }
+
+    public static void main(String[] args) {
+        String classToComposeAroundName = args[0];
+        Class<?> classPrologOpt, classDownstream;
+        Class<?> classToComposeAround = getClass(classToComposeAroundName);
+
+        String outputDir = args[1];
+        String outputPackage, outputName;
+        int mode;
+
+        if (args.length > 2) {
+            String outputClazzName = args[2];
+            outputPackage = getPackageName(outputClazzName);
+            outputName = getBaseClassName(outputClazzName);
+            classPrologOpt = getClass(args[3]);
+            classDownstream = getClass(args[4]);
+            mode = GEN_CUSTOM;
+            if (args.length > 5) {
+                if (args[5].equals("prolog_xor_downstream")) {
+                    mode |= GEN_PROLOG_XOR_DOWNSTREAM;
+                }
             }
+        } else {
+            outputPackage = getPackageName(classToComposeAroundName);
+            outputName = null; // TBD ..
+            classPrologOpt = null;
+            classDownstream = classToComposeAround;
+            mode = GEN_DEBUG | GEN_TRACE;
         }
-    } else {
-        outputPackage = getPackageName(classToComposeAroundName);
-        outputName = null; // TBD ..
-        classPrologOpt = null;
-        classDownstream = classToComposeAround;
-        mode = GEN_DEBUG | GEN_TRACE;
-    }
 
-    BuildComposablePipeline composer =
-      new BuildComposablePipeline(mode, outputDir, outputPackage, outputName, classToComposeAround, classPrologOpt, classDownstream);
+        BuildComposablePipeline composer =
+                new BuildComposablePipeline(mode, outputDir, outputPackage, outputName, classToComposeAround, classPrologOpt, classDownstream);
 
-    try
-    {
-      composer.emit();
-    }
-    catch (IOException e)
-    {
-      throw new RuntimeException(
-        "Error generating composable pipeline source files", e);
-    }
-  }
-  
-  protected BuildComposablePipeline(int mode, String outputDir, String outputPackage, String outputName, 
-                                    Class classToComposeAround, Class classPrologOpt, Class classDownstream)
-  {
-    this.mode=mode;
-    this.outputDir=outputDir;
-    this.outputPackage=outputPackage;
-    this.outputName=outputName;
-    this.classToComposeAround=classToComposeAround;
-    this.classPrologOpt=classPrologOpt;
-    this.classDownstream=classDownstream;
-
-    if (! classToComposeAround.isInterface())
-    {
-      throw new IllegalArgumentException(
-        classToComposeAround.getName() + " is not an interface class");
-    }    
-
-    try {
-      hasImmediateMode =
-        (classToComposeAround.getMethod("glBegin", new Class[] { Integer.TYPE }) != null);
-    } catch (Exception e) {
+        try {
+            composer.emit();
+        } catch (IOException e) {
+            throw new RuntimeException(
+                    "Error generating composable pipeline source files", e);
+        }
     }
 
-    try {
-      hasStackOverflow =
-        (classToComposeAround.getField("GL_STACK_OVERFLOW") != null);
-    } catch (Exception e) {
-    }
-  }
-
-  /**
-   * Emit the java source code for the classes that comprise the composable
-   * pipeline.
-   */
-  public void emit() throws IOException
-  {
-    List/*<Method>*/ publicMethodsRaw   = new ArrayList();
-    publicMethodsRaw.addAll(Arrays.asList(classToComposeAround.getMethods()));
-    Set/*<Method>*/  publicMethodsPlain = new HashSet();
-    for (Iterator iter=publicMethodsRaw.iterator(); iter.hasNext(); ) {
-        Method method = (Method) iter.next();
-        // Don't hook methods which aren't real GL methods,
-        // such as the synthetic "isGL2ES2" "getGL2ES2"
-        String name = method.getName();
-        boolean runHooks = name.startsWith("gl");
-        if (!name.startsWith("getGL") && !name.startsWith("isGL") && !name.equals("toString")) {
-            publicMethodsPlain.add(new PlainMethod(method, runHooks));
+    protected BuildComposablePipeline(int mode, String outputDir, String outputPackage, String outputName,
+            Class<?> classToComposeAround, Class<?> classPrologOpt, Class<?> classDownstream) {
+        this.mode = mode;
+        this.outputDir = outputDir;
+        this.outputPackage = outputPackage;
+        this.outputName = outputName;
+        this.classToComposeAround = classToComposeAround;
+        this.classPrologOpt = classPrologOpt;
+        this.classDownstream = classDownstream;
+
+        if (!classToComposeAround.isInterface()) {
+            throw new IllegalArgumentException(
+                    classToComposeAround.getName() + " is not an interface class");
+        }
+
+        try {
+            hasImmediateMode =
+                    (classToComposeAround.getMethod("glBegin", new Class<?>[]{Integer.TYPE}) != null);
+        } catch (Exception e) {
         }
-    }
 
-    if(0!=(mode&GEN_DEBUG)) {
-        (new DebugPipeline(outputDir, outputPackage, classToComposeAround, classDownstream)).emit(publicMethodsPlain.iterator());
+        try {
+            hasStackOverflow =
+                    (classToComposeAround.getField("GL_STACK_OVERFLOW") != null);
+        } catch (Exception e) {
+        }
     }
-    if(0!=(mode&GEN_TRACE)) {
-        (new TracePipeline(outputDir, outputPackage, classToComposeAround, classDownstream)).emit(publicMethodsPlain.iterator());
+
+    /**
+     * Emit the java source code for the classes that comprise the composable
+     * pipeline.
+     */
+    public void emit() throws IOException {
+
+        List<Method> publicMethodsRaw = Arrays.asList(classToComposeAround.getMethods());
+
+        Set<PlainMethod> publicMethodsPlain = new HashSet<PlainMethod>();
+        for (Iterator<Method> iter = publicMethodsRaw.iterator(); iter.hasNext();) {
+            Method method = iter.next();
+            // Don't hook methods which aren't real GL methods,
+            // such as the synthetic "isGL2ES2" "getGL2ES2"
+            String name = method.getName();
+            boolean runHooks = name.startsWith("gl");
+            if (!name.startsWith("getGL") && !name.startsWith("isGL") && !name.equals("toString")) {
+                publicMethodsPlain.add(new PlainMethod(method, runHooks));
+            }
+        }
+
+        if (0 != (mode & GEN_DEBUG)) {
+            (new DebugPipeline(outputDir, outputPackage, classToComposeAround, classDownstream)).emit(publicMethodsPlain.iterator());
+        }
+        if (0 != (mode & GEN_TRACE)) {
+            (new TracePipeline(outputDir, outputPackage, classToComposeAround, classDownstream)).emit(publicMethodsPlain.iterator());
+        }
+        if (0 != (mode & GEN_CUSTOM)) {
+            (new CustomPipeline(mode, outputDir, outputPackage, outputName, classToComposeAround, classPrologOpt, classDownstream)).emit(publicMethodsPlain.iterator());
+        }
     }
-    if(0!=(mode&GEN_CUSTOM)) {
-        (new CustomPipeline(mode, outputDir, outputPackage, outputName, classToComposeAround, classPrologOpt, classDownstream)).emit(publicMethodsPlain.iterator());
+
+    public static String getPackageName(String clazzName) {
+        int lastDot = clazzName.lastIndexOf('.');
+        if (lastDot == -1) {
+            // no package, class is at root level
+            return null;
+        }
+        return clazzName.substring(0, lastDot);
     }
-  }
-
-  public static String getPackageName(String clazzName) {
-      int lastDot = clazzName.lastIndexOf('.');
-      if (lastDot == -1)
-      {
-        // no package, class is at root level
-        return null;
-      }
-      return clazzName.substring(0, lastDot);
-  }
-
-  public static String getBaseClassName(String clazzName) {
-      int lastDot = clazzName.lastIndexOf('.');
-      if (lastDot == -1)
-      {
-        // no package, class is at root level
-        return clazzName;
-      }
-      return clazzName.substring(lastDot+1);
-  }
-
-  //-------------------------------------------------------
-
-  protected class PlainMethod
-  {
-    Method m;
-    boolean runHooks;
-
-    public PlainMethod(Method m, boolean runHooks) {
-        this.m=m;
-        this.runHooks = runHooks;
+
+    public static String getBaseClassName(String clazzName) {
+        int lastDot = clazzName.lastIndexOf('.');
+        if (lastDot == -1) {
+            // no package, class is at root level
+            return clazzName;
+        }
+        return clazzName.substring(lastDot + 1);
     }
 
-    public Method getWrappedMethod() { return m; }
+    //-------------------------------------------------------
+    protected class PlainMethod {
 
-    public boolean runHooks() { return runHooks; }
+        Method m;
+        boolean runHooks;
 
-    public boolean equals(Object obj) {
-        if(obj instanceof PlainMethod) {
-            PlainMethod b = (PlainMethod)obj;
-            boolean res =
-                   m.getName().equals(b.m.getName()) && 
-                   m.getModifiers() == b.m.getModifiers() &&
-                   m.getReturnType().equals(b.m.getReturnType()) &&
-                   Arrays.equals( m.getParameterTypes() , b.m.getParameterTypes() ) ;
-            return res;
+        PlainMethod(Method m, boolean runHooks) {
+            this.m = m;
+            this.runHooks = runHooks;
         }
-        return false;
-    }
 
-    public int hashCode() {
-        int hash = m.getName().hashCode() ^ m.getModifiers() ^ m.getReturnType().hashCode();
-        Class[] args = m.getParameterTypes();
-        for(int i=0; i<args.length; i++) {
-            hash ^= args[i].hashCode();
+        public Method getWrappedMethod() {
+            return m;
         }
-        return hash;
-    }
 
-    public String toString() {
-        Class[] args = m.getParameterTypes();
-        StringBuffer argsString = new StringBuffer();
-        argsString.append("(");
-        for (int i = 0; i < args.length; i++) {
-            if (i > 0)
-                argsString.append(", ");
-            argsString.append(args[i].getName());
-        }
-        argsString.append(")");
-        return m.toString() +
-               "\n\tname: " + m.getName() +
-               "\n\tmods: " + m.getModifiers() +
-               "\n\tretu: " + m.getReturnType() +
-               "\n\targs[" + args.length + "]: "+argsString.toString();
+        public boolean runHooks() {
+            return runHooks;
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+            if (obj instanceof PlainMethod) {
+                PlainMethod b = (PlainMethod) obj;
+                boolean res =
+                        m.getName().equals(b.m.getName())
+                        && m.getModifiers() == b.m.getModifiers()
+                        && m.getReturnType().equals(b.m.getReturnType())
+                        && Arrays.equals(m.getParameterTypes(), b.m.getParameterTypes());
+                return res;
+            }
+            return false;
+        }
+
+        @Override
+        public int hashCode() {
+            int hash = m.getName().hashCode() ^ m.getModifiers() ^ m.getReturnType().hashCode();
+            Class<?>[] args = m.getParameterTypes();
+            for (int i = 0; i < args.length; i++) {
+                hash ^= args[i].hashCode();
+            }
+            return hash;
+        }
+
+        @Override
+        public String toString() {
+            Class<?>[] args = m.getParameterTypes();
+            StringBuilder argsString = new StringBuilder();
+            argsString.append("(");
+            for (int i = 0; i < args.length; i++) {
+                if (i > 0) {
+                    argsString.append(", ");
+                }
+                argsString.append(args[i].getName());
+            }
+            argsString.append(")");
+            return m.toString()
+                    + "\n\tname: " + m.getName()
+                    + "\n\tmods: " + m.getModifiers()
+                    + "\n\tretu: " + m.getReturnType()
+                    + "\n\targs[" + args.length + "]: " + argsString.toString();
+        }
     }
-  }
-
-  /**
-   * Emits a Java source file that represents one element of the composable
-   * pipeline. 
-   */
-  protected abstract class PipelineEmitter
-  {
-    private File file;
-    protected String basePackage;
-    protected String baseName; // does not include package!
-    protected String downstreamPackage;
-    protected String downstreamName; // does not include package!
-    protected String prologPackageOpt=null;
-    protected String prologNameOpt=null; // does not include package!
-
-    protected String outputDir;
-    protected String outputPackage;
-    protected Class baseInterfaceClass;
-    protected Class prologClassOpt=null;
-    protected Class downstreamClass;
 
     /**
-     * @param outputDir the directory into which the pipeline classes will be
-     * generated.
-     * @param baseInterfaceClassName the full class name (including package,
-     * e.g. "java.lang.String") of the interface that the pipeline wraps
-     * @exception IllegalArgumentException if classToComposeAround is not an
-     * interface.
+     * Emits a Java source file that represents one element of the composable
+     * pipeline.
      */
-    public PipelineEmitter(String outputDir, String outputPackage, Class baseInterfaceClass, Class prologClassOpt, Class downstreamClass)
-    {
-      this.outputDir=outputDir;
-      this.outputPackage=outputPackage;
-      this.baseInterfaceClass=baseInterfaceClass;
-      this.prologClassOpt=prologClassOpt;
-      this.downstreamClass=downstreamClass;
-
-      basePackage = getPackageName(baseInterfaceClass.getName());
-      baseName = getBaseClassName(baseInterfaceClass.getName());
-      downstreamPackage = getPackageName(downstreamClass.getName());
-      downstreamName = getBaseClassName(downstreamClass.getName());
-      if(null!=prologClassOpt) {
-          prologPackageOpt = getPackageName(prologClassOpt.getName());
-          prologNameOpt = getBaseClassName(prologClassOpt.getName());
-      }
-    }
+    protected abstract class PipelineEmitter {
+
+        private File file;
+        protected String basePackage;
+        protected String baseName; // does not include package!
+        protected String downstreamPackage;
+        protected String downstreamName; // does not include package!
+        protected String prologPackageOpt = null;
+        protected String prologNameOpt = null; // does not include package!
+        protected String outputDir;
+        protected String outputPackage;
+        protected Class<?> baseInterfaceClass;
+        protected Class<?> prologClassOpt = null;
+        protected Class<?> downstreamClass;
+
+        /**
+         * @param outputDir the directory into which the pipeline classes will be
+         * generated.
+         * @param baseInterfaceClassName the full class name (including package,
+         * e.g. "java.lang.String") of the interface that the pipeline wraps
+         * @exception IllegalArgumentException if classToComposeAround is not an
+         * interface.
+         */
+        PipelineEmitter(String outputDir, String outputPackage, Class<?> baseInterfaceClass, Class<?> prologClassOpt, Class<?> downstreamClass) {
+            this.outputDir = outputDir;
+            this.outputPackage = outputPackage;
+            this.baseInterfaceClass = baseInterfaceClass;
+            this.prologClassOpt = prologClassOpt;
+            this.downstreamClass = downstreamClass;
+
+            basePackage = getPackageName(baseInterfaceClass.getName());
+            baseName = getBaseClassName(baseInterfaceClass.getName());
+            downstreamPackage = getPackageName(downstreamClass.getName());
+            downstreamName = getBaseClassName(downstreamClass.getName());
+            if (null != prologClassOpt) {
+                prologPackageOpt = getPackageName(prologClassOpt.getName());
+                prologNameOpt = getBaseClassName(prologClassOpt.getName());
+            }
+        }
+
+        public void emit(Iterator<PlainMethod> methodsToWrap) throws IOException {
+            String outputClassName = getOutputName();
+            this.file = new File(outputDir + File.separatorChar + outputClassName + ".java");
+            String parentDir = file.getParent();
+            if (parentDir != null) {
+                File pDirFile = new File(parentDir);
+                pDirFile.mkdirs();
+            }
 
-    public void emit(Iterator/*<Method>*/ methodsToWrap) throws IOException
-    {
-      String outputClassName = getOutputName();
-      this.file = new File(outputDir + File.separatorChar + outputClassName + ".java"); 
-      String parentDir = file.getParent();
-      if (parentDir != null)
-      {
-        File pDirFile = new File(parentDir);
-        pDirFile.mkdirs();
-      }
-
-      PrintWriter output = new PrintWriter(new BufferedWriter(new FileWriter(file)));
-
-      List baseInterfaces = Arrays.asList(baseInterfaceClass.getInterfaces());
-      HashSet clazzList = new HashSet();
-      clazzList.add(baseInterfaceClass);
-      clazzList.addAll(baseInterfaces);
-      int ifNamesNumber = clazzList.size();
-
-      // keep original order ..
-      clazzList.clear();
-      String[] ifNames = new String[ifNamesNumber];
-      {
-          int i=0;
-
-          for (Iterator iter=baseInterfaces.iterator(); iter.hasNext(); ) {
-                Class ifClass = (Class)iter.next();
-                if(!clazzList.contains(ifClass)) {
-                    ifNames[i++] = new String(ifClass.getName());
-                    clazzList.add(ifClass);
+            PrintWriter output = new PrintWriter(new BufferedWriter(new FileWriter(file)));
+
+            List<Class<?>> baseInterfaces = Arrays.asList(baseInterfaceClass.getInterfaces());
+            HashSet<Class<?>> clazzList = new HashSet<Class<?>>();
+            clazzList.add(baseInterfaceClass);
+            clazzList.addAll(baseInterfaces);
+            int ifNamesNumber = clazzList.size();
+
+            // keep original order ..
+            clazzList.clear();
+            String[] ifNames = new String[ifNamesNumber];
+            {
+                int i = 0;
+
+                for (Iterator<Class<?>> iter = baseInterfaces.iterator(); iter.hasNext();) {
+                    Class<?> ifClass = iter.next();
+                    if (!clazzList.contains(ifClass)) {
+                        ifNames[i++] = ifClass.getName();
+                        clazzList.add(ifClass);
+                    }
                 }
-          }
-
-          if(null!=baseInterfaceClass && !clazzList.contains(baseInterfaceClass)) {
-              ifNames[i++] = new String(baseInterfaceClass.getName());
-              clazzList.add(baseInterfaceClass);
-          }
-      }
-
-      clazzList.add(downstreamClass);
-      if(null!=prologClassOpt) {
-          clazzList.add(prologClassOpt);
-      }
-
-      String[] importNames = new String[clazzList.size()+2];
-      {
-          int i=0;
-          importNames[i++] = new String("java.io.*");
-          importNames[i++] = new String("javax.media.opengl.*");
-          for (Iterator iter=clazzList.iterator(); iter.hasNext(); ) {
-                importNames[i++] = new String(((Class)iter.next()).getName());
-          }
-      }
-
-      CodeGenUtils.emitJavaHeaders(output, 
-                  outputPackage,
-                  outputClassName,
-                  "com.jogamp.gluegen.runtime", // FIXME: should make configurable
-                  true,
-                  importNames,
-                  new String[] { "public" },
-                  ifNames,
-                  null,
-                  new CodeGenUtils.EmissionCallback() {
-                    public void emit(PrintWriter w) { emitClassDocComment(w); }
-                  }
-                  );
-      
-      preMethodEmissionHook(output);
-                  
-      constructorHook(output);
-
-      emitGLIsMethods(output);
-      emitGLGetMethods(output);
-
-      while (methodsToWrap.hasNext())
-      {
-        PlainMethod pm = (PlainMethod)methodsToWrap.next();
-        Method m = pm.getWrappedMethod();
-        emitMethodDocComment(output, m);
-        emitSignature(output, m);
-        emitBody(output, m, pm.runHooks());
-      }
-
-      postMethodEmissionHook(output);
-
-      output.println();
-      output.print("  private " + downstreamName + " " + getDownstreamObjectName() + ";");
-
-      // end the class
-      output.println();
-      output.print("} // end class ");
-      output.println(outputClassName);
-
-      output.flush();
-      output.close();
-
-      System.out.println("wrote to file: "+file); // JAU
-    }
 
-    /** Get the name of the object through which API calls should be routed. */
-    protected String getDownstreamObjectName()
-    {
-      return "downstream" + downstreamName;
-    }
-    
-    /** Get the name of the object which shall be called as a prolog. */
-    protected String getPrologObjectNameOpt()
-    {
-      if(null!=prologNameOpt) {
-          return "prolog" + prologNameOpt;
-      }
-      return null;
-    }
-    
-    protected void emitMethodDocComment(PrintWriter output, Method m)
-    {
-    }
-    
-    protected void emitSignature(PrintWriter output, Method m)
-    {
-      output.print("  public ");
-      output.print(' ');
-      output.print(JavaType.createForClass(m.getReturnType()).getName());
-      output.print(' ');
-      output.print(m.getName());
-      output.print('(');
-      output.print(getArgListAsString(m, true, true));
-      output.println(")");
-    }
-    
-    protected void emitBody(PrintWriter output, Method m, boolean runHooks)
-    {
-      output.println("  {");
-      output.print("    ");
-      Class retType = m.getReturnType();
-
-      boolean callPreDownstreamHook = runHooks && hasPreDownstreamCallHook(m);
-      boolean callPostDownstreamHook = runHooks && hasPostDownstreamCallHook(m);
-      boolean callDownstream =  (null!=getMethod(downstreamClass, m)) && 
-                               !( 0!=(GEN_PROLOG_XOR_DOWNSTREAM&getMode()) && callPreDownstreamHook ) ;
-      boolean hasResult = (retType != Void.TYPE);
-
-      if(!callDownstream) {
-        if(!emptyDownstreamAllowed()) {
-            throw new RuntimeException("Method "+m+" has no downstream ("+downstreamName+")");
-        }
-      }
-
-      if(!callPreDownstreamHook && !callPostDownstreamHook && !callDownstream) {
-        if(!emptyMethodAllowed()) {
-            throw new RuntimeException("Method "+m+" is empty, no downstream ("+downstreamName+") nor prolog ("+prologNameOpt+").");
-        } else {
-            output.print("    if(DEBUG) { System.out.println(\"WARNING: No prolog, no downstream, empty: \"+");
-            printFunctionCallString(output, m);
-            output.println("); } ");
+                if (null != baseInterfaceClass && !clazzList.contains(baseInterfaceClass)) {
+                    ifNames[i++] = baseInterfaceClass.getName();
+                    clazzList.add(baseInterfaceClass);
+                }
+            }
+
+            clazzList.add(downstreamClass);
+            if (null != prologClassOpt) {
+                clazzList.add(prologClassOpt);
+            }
+
+            String[] importNames = new String[clazzList.size() + 2];
+            {
+                int i = 0;
+                importNames[i++] = "java.io.*";
+                importNames[i++] = "javax.media.opengl.*";
+                for (Iterator<Class<?>> iter = clazzList.iterator(); iter.hasNext();) {
+                    importNames[i++] = iter.next().getName();
+                }
+            }
+
+            CodeGenUtils.emitJavaHeaders(output,
+                    outputPackage,
+                    outputClassName,
+                    "com.jogamp.gluegen.runtime", // FIXME: should make configurable
+                    true,
+                    importNames,
+                    new String[]{"public"},
+                    ifNames,
+                    null,
+                    new CodeGenUtils.EmissionCallback() {
+                        public void emit(PrintWriter w) {
+                            emitClassDocComment(w);
+                        }
+                    });
+
+            preMethodEmissionHook(output);
+
+            constructorHook(output);
+
+            emitGLIsMethods(output);
+            emitGLGetMethods(output);
+
+            while (methodsToWrap.hasNext()) {
+                PlainMethod pm = methodsToWrap.next();
+                Method m = pm.getWrappedMethod();
+                emitMethodDocComment(output, m);
+                emitSignature(output, m);
+                emitBody(output, m, pm.runHooks());
+            }
+
+            postMethodEmissionHook(output);
+
+            output.println();
+            output.print("  private " + downstreamName + " " + getDownstreamObjectName() + ";");
+
+            // end the class
+            output.println();
+            output.print("} // end class ");
+            output.println(outputClassName);
+
+            output.flush();
+            output.close();
+
+            System.out.println("wrote to file: " + file); // JAU
         }
-      }
 
-      if (callPreDownstreamHook) {
-          if(hasResult && !callDownstream) {
-            if(callPostDownstreamHook) {
-                output.print("    "+JavaType.createForClass(retType).getName());
-                output.print(" _res = ");
-            } else {
-                output.print("    return ");
+        /** Get the name of the object through which API calls should be routed. */
+        protected String getDownstreamObjectName() {
+            return "downstream" + downstreamName;
+        }
+
+        /** Get the name of the object which shall be called as a prolog. */
+        protected String getPrologObjectNameOpt() {
+            if (null != prologNameOpt) {
+                return "prolog" + prologNameOpt;
             }
-          }
-          preDownstreamCallHook(output, m);
-      }
-      
-      if(callDownstream) {
-          if (hasResult) {
-            if(callPostDownstreamHook) {
-                output.print("    "+JavaType.createForClass(retType).getName());
-                output.print(" _res = ");
-            } else {
-                output.print("    return ");
+            return null;
+        }
+
+        protected void emitMethodDocComment(PrintWriter output, Method m) {
+        }
+
+        protected void emitSignature(PrintWriter output, Method m) {
+            output.print("  public ");
+            output.print(' ');
+            output.print(JavaType.createForClass(m.getReturnType()).getName());
+            output.print(' ');
+            output.print(m.getName());
+            output.print('(');
+            output.print(getArgListAsString(m, true, true));
+            output.println(")");
+        }
+
+        protected void emitBody(PrintWriter output, Method m, boolean runHooks) {
+            output.println("  {");
+            output.print("    ");
+            Class<?> retType = m.getReturnType();
+
+            boolean callPreDownstreamHook = runHooks && hasPreDownstreamCallHook(m);
+            boolean callPostDownstreamHook = runHooks && hasPostDownstreamCallHook(m);
+            boolean callDownstream = (null != getMethod(downstreamClass, m))
+                    && !(0 != (GEN_PROLOG_XOR_DOWNSTREAM & getMode()) && callPreDownstreamHook);
+            boolean hasResult = (retType != Void.TYPE);
+
+            if (!callDownstream) {
+                if (!emptyDownstreamAllowed()) {
+                    throw new RuntimeException("Method " + m + " has no downstream (" + downstreamName + ")");
+                }
             }
-          }
-          output.print(getDownstreamObjectName());
-          output.print('.');
-          output.print(m.getName());
-          output.print('(');
-          output.print(getArgListAsString(m, false, true));
-          output.println(");");
-      }
-      
-      if (callPostDownstreamHook) {
-          postDownstreamCallHook(output, m);
-      }
-
-      if (hasResult && callDownstream && callPostDownstreamHook) {
-          output.println("    return _res;");
-      }
-      output.println("  }");
 
-    }
+            if (!callPreDownstreamHook && !callPostDownstreamHook && !callDownstream) {
+                if (!emptyMethodAllowed()) {
+                    throw new RuntimeException("Method " + m + " is empty, no downstream (" + downstreamName + ") nor prolog (" + prologNameOpt + ").");
+                } else {
+                    output.print("    if(DEBUG) { System.out.println(\"WARNING: No prolog, no downstream, empty: \"+");
+                    printFunctionCallString(output, m);
+                    output.println("); } ");
+                }
+            }
 
-    protected String getArgListAsString(Method m, boolean includeArgTypes, boolean includeArgNames)
-    {
-      StringBuffer buf = new StringBuffer(256);
-      if (!includeArgNames && !includeArgTypes)
-      {
-        throw new IllegalArgumentException(
-          "Cannot generate arglist without both arg types and arg names");
-      }
-      
-      Class[] argTypes = m.getParameterTypes();
-      for (int i = 0; i < argTypes.length; ++i)
-      {
-        if (includeArgTypes)
-        {
-          buf.append(JavaType.createForClass(argTypes[i]).getName());
-          buf.append(' ');
-        }
-        
-        if (includeArgNames)
-        {
-          buf.append("arg");
-          buf.append(i);
-        }
-        if (i < argTypes.length-1) { buf.append(','); }
-      }
-
-      return buf.toString();
-    }
-    
-    /** The name of the class around which this pipeline is being
-     * composed. E.g., if this pipeline was constructed with
-     * "java.util.Set" as the baseInterfaceClassName, then this method will
-     * return "Set".
-     */
-    protected String getBaseInterfaceName()
-    {
-      return baseName;
-    }
-    
-    /** Get the output name for this pipeline class. */
-    protected abstract String getOutputName();    
+            if (callPreDownstreamHook) {
+                if (hasResult && !callDownstream) {
+                    if (callPostDownstreamHook) {
+                        output.print("    " + JavaType.createForClass(retType).getName());
+                        output.print(" _res = ");
+                    } else {
+                        output.print("    return ");
+                    }
+                }
+                preDownstreamCallHook(output, m);
+            }
 
-    /**
-     * Called after the class headers have been generated, but before any
-     * method wrappers have been generated.
-     */
-    protected void preMethodEmissionHook(PrintWriter output) {
-      output.println("  public static final boolean DEBUG = com.jogamp.opengl.impl.Debug.debug(\""+getOutputName()+"\");");
-    }
+            if (callDownstream) {
+                if (hasResult) {
+                    if (callPostDownstreamHook) {
+                        output.print("    " + JavaType.createForClass(retType).getName());
+                        output.print(" _res = ");
+                    } else {
+                        output.print("    return ");
+                    }
+                }
+                output.print(getDownstreamObjectName());
+                output.print('.');
+                output.print(m.getName());
+                output.print('(');
+                output.print(getArgListAsString(m, false, true));
+                output.println(");");
+            }
 
-    /**
-     * Emits the constructor for the pipeline; called after the preMethodEmissionHook.
-     */
-    protected abstract void constructorHook(PrintWriter output);
+            if (callPostDownstreamHook) {
+                postDownstreamCallHook(output, m);
+            }
 
-    /**
-     * Called after the method wrappers have been generated, but before the
-     * closing parenthesis of the class is emitted.
-     */
-    protected void postMethodEmissionHook(PrintWriter output) {
-      output.println(  "  public String toString() {");
-      output.println(  "    StringBuffer sb = new StringBuffer();");
-      output.println(  "    sb.append(\""+getOutputName()+" [ implementing "+baseInterfaceClass.getName()+",\\n\\t\");");
-      if(null!=prologClassOpt) {
-          output.println(  "    sb.append(\" prolog: \"+"+getPrologObjectNameOpt()+".toString()+\",\\n\\t\");");
-      }
-      output.println(  "    sb.append(\" downstream: \"+"+getDownstreamObjectName()+".toString()+\"\\n\\t]\");");
-      output.println(  "    return sb.toString();");
-      output.println(  "  }");
-    }
+            if (hasResult && callDownstream && callPostDownstreamHook) {
+                output.println("    return _res;");
+            }
+            output.println("  }");
 
-    /**
-     * Called before the pipeline routes the call to the downstream object.
-     */
-    protected abstract void preDownstreamCallHook(PrintWriter output, Method m);    
-    protected abstract boolean hasPreDownstreamCallHook(Method m);    
+        }
 
-    /**
-     * Called after the pipeline has routed the call to the downstream object,
-     * but before the calling function exits or returns a value.
-     */
-    protected abstract void postDownstreamCallHook(PrintWriter output, Method m);    
+        protected String getArgListAsString(Method m, boolean includeArgTypes, boolean includeArgNames) {
+            StringBuilder buf = new StringBuilder(256);
+            if (!includeArgNames && !includeArgTypes) {
+                throw new IllegalArgumentException(
+                        "Cannot generate arglist without both arg types and arg names");
+            }
 
-    protected abstract boolean hasPostDownstreamCallHook(Method m);    
+            Class<?>[] argTypes = m.getParameterTypes();
+            for (int i = 0; i < argTypes.length; ++i) {
+                if (includeArgTypes) {
+                    buf.append(JavaType.createForClass(argTypes[i]).getName());
+                    buf.append(' ');
+                }
 
-    protected abstract int getMode();
-    protected abstract boolean emptyMethodAllowed();    
-    protected abstract boolean emptyDownstreamAllowed();    
+                if (includeArgNames) {
+                    buf.append("arg");
+                    buf.append(i);
+                }
+                if (i < argTypes.length - 1) {
+                    buf.append(',');
+                }
+            }
 
-    /** Emit a Javadoc comment for this pipeline class. */
-    protected abstract void emitClassDocComment(PrintWriter output);
+            return buf.toString();
+        }
 
-    /**
-     * Emits one of the isGL* methods.
-     */
-    protected void emitGLIsMethod(PrintWriter output, String type) {
-      output.println("  public boolean is" + type + "() {");
-      Class clazz = BuildComposablePipeline.getClass("javax.media.opengl." + type);
-      if (clazz.isAssignableFrom(baseInterfaceClass)) {
-        output.println("    return true;");
-      } else {
-        output.println("    return false;");
-      }
-      output.println("  }");
-    }
+        /** The name of the class around which this pipeline is being
+         * composed. E.g., if this pipeline was constructed with
+         * "java.util.Set" as the baseInterfaceClassName, then this method will
+         * return "Set".
+         */
+        protected String getBaseInterfaceName() {
+            return baseName;
+        }
 
-    /**
-     * Emits all of the isGL* methods.
-     */
-    protected void emitGLIsMethods(PrintWriter output) {
-      emitGLIsMethod(output, "GL");
-      emitGLIsMethod(output, "GL3bc");
-      emitGLIsMethod(output, "GL3");
-      emitGLIsMethod(output, "GL2");
-      emitGLIsMethod(output, "GLES1");
-      emitGLIsMethod(output, "GLES2");
-      emitGLIsMethod(output, "GL2ES1");
-      emitGLIsMethod(output, "GL2ES2");
-      emitGLIsMethod(output, "GL2GL3");
-      output.println("  public boolean isGLES() {");
-      output.println("    return isGLES2() || isGLES1();");
-      output.println("  }");
-    }
-    /**
-     * Emits one of the getGL* methods.
-     */
-    protected void emitGLGetMethod(PrintWriter output, String type) {
-      output.println("  public javax.media.opengl." + type + " get" + type + "() {");
-      Class clazz = BuildComposablePipeline.getClass("javax.media.opengl." + type);
-      if (clazz.isAssignableFrom(baseInterfaceClass)) {
-        output.println("    return this;");
-      } else {
-        output.println("    throw new GLException(\"Not a " + type + " implementation\");");
-      }
-      output.println("  }");
-    }
+        /** Get the output name for this pipeline class. */
+        protected abstract String getOutputName();
 
-    /**
-     * Emits all of the getGL* methods.
-     */
-    protected void emitGLGetMethods(PrintWriter output) {
-      emitGLGetMethod(output, "GL");
-      emitGLGetMethod(output, "GL3bc");
-      emitGLGetMethod(output, "GL3");
-      emitGLGetMethod(output, "GL2");
-      emitGLGetMethod(output, "GLES1");
-      emitGLGetMethod(output, "GLES2");
-      emitGLGetMethod(output, "GL2ES1");
-      emitGLGetMethod(output, "GL2ES2");
-      emitGLGetMethod(output, "GL2GL3");
-      output.println("  public GLProfile getGLProfile() {");
-      output.println("    return "+getDownstreamObjectName()+".getGLProfile();");
-      output.println("  }");
-    }
-  } // end class PipelineEmitter
+        /**
+         * Called after the class headers have been generated, but before any
+         * method wrappers have been generated.
+         */
+        protected void preMethodEmissionHook(PrintWriter output) {
+            output.println("  public static final boolean DEBUG = com.jogamp.opengl.impl.Debug.debug(\"" + getOutputName() + "\");");
+        }
 
-  //-------------------------------------------------------
+        /**
+         * Emits the constructor for the pipeline; called after the preMethodEmissionHook.
+         */
+        protected abstract void constructorHook(PrintWriter output);
+
+        /**
+         * Called after the method wrappers have been generated, but before the
+         * closing parenthesis of the class is emitted.
+         */
+        protected void postMethodEmissionHook(PrintWriter output) {
+            output.println("  public String toString() {");
+            output.println("    StringBuffer sb = new StringBuffer();");
+            output.println("    sb.append(\"" + getOutputName() + " [ implementing " + baseInterfaceClass.getName() + ",\\n\\t\");");
+            if (null != prologClassOpt) {
+                output.println("    sb.append(\" prolog: \"+" + getPrologObjectNameOpt() + ".toString()+\",\\n\\t\");");
+            }
+            output.println("    sb.append(\" downstream: \"+" + getDownstreamObjectName() + ".toString()+\"\\n\\t]\");");
+            output.println("    return sb.toString();");
+            output.println("  }");
+        }
 
-  protected class CustomPipeline extends PipelineEmitter
-  {
-    String className;
-    int mode;
+        /**
+         * Called before the pipeline routes the call to the downstream object.
+         */
+        protected abstract void preDownstreamCallHook(PrintWriter output, Method m);
 
-    public CustomPipeline(int mode, String outputDir, String outputPackage, String outputName, Class baseInterfaceClass, Class prologClassOpt, Class downstreamClass)
-    {
-      super(outputDir, outputPackage, baseInterfaceClass, prologClassOpt, downstreamClass);
-      className = outputName;
-      this.mode = mode;
-    }
+        protected abstract boolean hasPreDownstreamCallHook(Method m);
 
-    protected String getOutputName()
-    {
-      return className;
-    }
+        /**
+         * Called after the pipeline has routed the call to the downstream object,
+         * but before the calling function exits or returns a value.
+         */
+        protected abstract void postDownstreamCallHook(PrintWriter output, Method m);
 
-    protected int getMode() { return mode; }
+        protected abstract boolean hasPostDownstreamCallHook(Method m);
 
-    protected boolean emptyMethodAllowed() {
-        return true;
-    }
-    protected boolean emptyDownstreamAllowed() {
-        return true;
-    }
+        protected abstract int getMode();
 
-    protected void preMethodEmissionHook(PrintWriter output)
-    {
-        super.preMethodEmissionHook(output);
-    }
+        protected abstract boolean emptyMethodAllowed();
 
-    protected void constructorHook(PrintWriter output) {
-      output.print(  "  public " + getOutputName() + "(" );
-      output.print(  downstreamName + " " + getDownstreamObjectName() );
-      if(null!=prologNameOpt) {
-          output.println(  ", " + prologNameOpt + " " + getPrologObjectNameOpt() + ")");
-      } else {
-          output.println(")");
-      }
-      output.println("  {");
-      output.println("    if (" + getDownstreamObjectName() + " == null) {");
-      output.println("      throw new IllegalArgumentException(\"null " + getDownstreamObjectName() + "\");");
-      output.println("    }");
-      output.print(  "    this." + getDownstreamObjectName());
-      output.println(" = " + getDownstreamObjectName() + ";");
-      if(null!=prologNameOpt) {
-          output.print(  "    this." + getPrologObjectNameOpt());
-          output.println(" = " + getPrologObjectNameOpt() + ";");
-      }
-      output.println("  }");
-      output.println();
-    }
+        protected abstract boolean emptyDownstreamAllowed();
 
-    protected void postMethodEmissionHook(PrintWriter output)
-    {
-      super.postMethodEmissionHook(output);
-      if(null!=prologNameOpt) {
-          output.print("  private " + prologNameOpt + " " + getPrologObjectNameOpt() + ";");
-      }
-    }
+        /** Emit a Javadoc comment for this pipeline class. */
+        protected abstract void emitClassDocComment(PrintWriter output);
 
-    protected void emitClassDocComment(PrintWriter output)
-    {
-      output.println("/**");
-      output.println(" * Composable pipeline {@link "+outputPackage+"."+outputName+"}, implementing the interface");
-      output.println(" * {@link "+baseInterfaceClass.getName()+"}");
-      output.println(" * <p>");
-      output.println(" * Each method follows the call graph <ul>");
-      if(null!=prologClassOpt) {
-          output.println(" *   <li> call <em>prolog</em> {@link "+prologClassOpt.getName()+"} if available");
-      }
-      output.println(" *   <li> call <em>downstream</em> {@link "+downstreamClass.getName()+"} if available");
-      if(null!=prologClassOpt && 0!=(GEN_PROLOG_XOR_DOWNSTREAM&getMode())) {
-          output.println(" *        <strong>and</strong> if no call to {@link "+prologClassOpt.getName()+"} is made");
-      }
-      output.println(" * </ul><p>");
-      output.println(" * ");
-      output.println(" * <ul>");
-      output.println(" *   <li> <em>Interface</em> {@link "+baseInterfaceClass.getName()+"}");
-      if(null!=prologClassOpt) {
-          output.println(" *   <li> <em>Prolog</em> {@link "+prologClassOpt.getName()+"}");
-      }
-      output.println(" *   <li> <em>Downstream</em> {@link "+downstreamClass.getName()+"}");
-      output.println(" * </ul><p>");
-      output.println(" *  Sample code which installs this pipeline: </P>");
-      output.println(" * ");
-      output.println("<PRE>");
-      if(null!=prologNameOpt) {
-          output.println("     GL gl = drawable.setGL( new "+className+"( drawable.getGL().getGL2ES2(), new "+prologNameOpt+"( drawable.getGL().getGL2ES2() ) ) );");
-      } else {
-          output.println("     GL gl = drawable.setGL( new "+className+"( drawable.getGL().getGL2ES2() ) );");
-      }
-      output.println("</PRE>");
-      output.println("*/");
-    }
-    
-    protected boolean hasPreDownstreamCallHook(Method m) {
-        return null!=getMethod(prologClassOpt, m);
-    }
+        /**
+         * Emits one of the isGL* methods.
+         */
+        protected void emitGLIsMethod(PrintWriter output, String type) {
+            output.println("  public boolean is" + type + "() {");
+            Class<?> clazz = BuildComposablePipeline.getClass("javax.media.opengl." + type);
+            if (clazz.isAssignableFrom(baseInterfaceClass)) {
+                output.println("    return true;");
+            } else {
+                output.println("    return false;");
+            }
+            output.println("  }");
+        }
 
-    protected void preDownstreamCallHook(PrintWriter output, Method m)
-    {
-      if(null!=prologNameOpt) {
-          output.print(getPrologObjectNameOpt());
-          output.print('.');
-          output.print(m.getName());
-          output.print('(');
-          output.print(getArgListAsString(m, false, true));
-          output.println(");");
-      }
-    }
+        /**
+         * Emits all of the isGL* methods.
+         */
+        protected void emitGLIsMethods(PrintWriter output) {
+            emitGLIsMethod(output, "GL");
+            emitGLIsMethod(output, "GL3bc");
+            emitGLIsMethod(output, "GL3");
+            emitGLIsMethod(output, "GL2");
+            emitGLIsMethod(output, "GLES1");
+            emitGLIsMethod(output, "GLES2");
+            emitGLIsMethod(output, "GL2ES1");
+            emitGLIsMethod(output, "GL2ES2");
+            emitGLIsMethod(output, "GL2GL3");
+            output.println("  public boolean isGLES() {");
+            output.println("    return isGLES2() || isGLES1();");
+            output.println("  }");
+        }
 
-    protected boolean hasPostDownstreamCallHook(Method m) {
-        return false;
-    }
+        /**
+         * Emits one of the getGL* methods.
+         */
+        protected void emitGLGetMethod(PrintWriter output, String type) {
+            output.println("  public javax.media.opengl." + type + " get" + type + "() {");
+            Class<?> clazz = BuildComposablePipeline.getClass("javax.media.opengl." + type);
+            if (clazz.isAssignableFrom(baseInterfaceClass)) {
+                output.println("    return this;");
+            } else {
+                output.println("    throw new GLException(\"Not a " + type + " implementation\");");
+            }
+            output.println("  }");
+        }
 
-    protected void postDownstreamCallHook(PrintWriter output, Method m)
-    {
-    }
+        /**
+         * Emits all of the getGL* methods.
+         */
+        protected void emitGLGetMethods(PrintWriter output) {
+            emitGLGetMethod(output, "GL");
+            emitGLGetMethod(output, "GL3bc");
+            emitGLGetMethod(output, "GL3");
+            emitGLGetMethod(output, "GL2");
+            emitGLGetMethod(output, "GLES1");
+            emitGLGetMethod(output, "GLES2");
+            emitGLGetMethod(output, "GL2ES1");
+            emitGLGetMethod(output, "GL2ES2");
+            emitGLGetMethod(output, "GL2GL3");
+            output.println("  public GLProfile getGLProfile() {");
+            output.println("    return " + getDownstreamObjectName() + ".getGLProfile();");
+            output.println("  }");
+        }
+    } // end class PipelineEmitter
 
-  } // end class CustomPipeline
+    //-------------------------------------------------------
+    protected class CustomPipeline extends PipelineEmitter {
 
-  protected class DebugPipeline extends PipelineEmitter
-  {
-    String className;
-    public DebugPipeline(String outputDir, String outputPackage, Class baseInterfaceClass, Class downstreamClass)
-    {
-      super(outputDir, outputPackage, baseInterfaceClass, null, downstreamClass);
-      className = "Debug" + getBaseInterfaceName();
-    }
+        String className;
+        int mode;
 
-    protected String getOutputName()
-    {
-      return className;
-    }
+        CustomPipeline(int mode, String outputDir, String outputPackage, String outputName, Class<?> baseInterfaceClass, Class<?> prologClassOpt, Class<?> downstreamClass) {
+            super(outputDir, outputPackage, baseInterfaceClass, prologClassOpt, downstreamClass);
+            className = outputName;
+            this.mode = mode;
+        }
 
-    protected int getMode() { return 0; }
+        protected String getOutputName() {
+            return className;
+        }
 
-    protected boolean emptyMethodAllowed() {
-        return false;
-    }
-    protected boolean emptyDownstreamAllowed() {
-        return false;
-    }
+        protected int getMode() {
+            return mode;
+        }
 
-    protected void preMethodEmissionHook(PrintWriter output)
-    {
-        super.preMethodEmissionHook(output);
-    }
+        protected boolean emptyMethodAllowed() {
+            return true;
+        }
 
-    protected void constructorHook(PrintWriter output) {
-      output.print(  "  public " + getOutputName() + "(" );
-      output.println(  downstreamName + " " + getDownstreamObjectName() + ")");
-      output.println("  {");
-      output.println("    if (" + getDownstreamObjectName() + " == null) {");
-      output.println("      throw new IllegalArgumentException(\"null " + getDownstreamObjectName() + "\");");
-      output.println("    }");
-      output.print(  "    this." + getDownstreamObjectName());
-      output.println(" = " + getDownstreamObjectName() + ";");
-      if(null!=prologNameOpt) {
-          output.print(  "    this." + getPrologObjectNameOpt());
-          output.println(" = " + getPrologObjectNameOpt() + ";");
-      }
-      output.println("    // Fetch GLContext object for better error checking (if possible)");
-      output.println("    _context = " + getDownstreamObjectName() + ".getContext();");
-      output.println("  }");
-      output.println();
-    }
+        protected boolean emptyDownstreamAllowed() {
+            return true;
+        }
 
-    protected void postMethodEmissionHook(PrintWriter output)
-    {
-      super.postMethodEmissionHook(output);
-      output.println("  private void checkGLGetError(String caller)");
-      output.println("  {");
-      if (hasImmediateMode) {
-        output.println("    if (insideBeginEndPair) {");
-        output.println("      return;");
-        output.println("    }");
-        output.println();
-      }
-      output.println("    // Debug code to make sure the pipeline is working; leave commented out unless testing this class");
-      output.println("    //System.err.println(\"Checking for GL errors " +
-                     "after call to \" + caller);");
-      output.println();
-      output.println("    int err = " +
-                     getDownstreamObjectName() +
-                     ".glGetError();");
-      output.println("    if (err == GL_NO_ERROR) { return; }");
-      output.println();
-      output.println("    StringBuffer buf = new StringBuffer(Thread.currentThread()+");
-      output.println("      \" glGetError() returned the following error codes " +
-                     "after a call to \" + caller + \": \");");
-      output.println();
-      output.println("    // Loop repeatedly to allow for distributed GL implementations,");
-      output.println("    // as detailed in the glGetError() specification");
-      output.println("    int recursionDepth = 10;");
-      output.println("    do {");
-      output.println("      switch (err) {");
-      output.println("        case GL_INVALID_ENUM: buf.append(\"GL_INVALID_ENUM \"); break;");
-      output.println("        case GL_INVALID_VALUE: buf.append(\"GL_INVALID_VALUE \"); break;");
-      output.println("        case GL_INVALID_OPERATION: buf.append(\"GL_INVALID_OPERATION \"); break;");
-      if (hasStackOverflow) {
-        output.println("        case GL_STACK_OVERFLOW: buf.append(\"GL_STACK_OVERFLOW \"); break;");
-        output.println("        case GL_STACK_UNDERFLOW: buf.append(\"GL_STACK_UNDERFLOW \"); break;");
-      }
-      output.println("        case GL_OUT_OF_MEMORY: buf.append(\"GL_OUT_OF_MEMORY \"); break;");
-      output.println("        case GL_NO_ERROR: throw new InternalError(\"Should not be treating GL_NO_ERROR as error\");");
-      output.println("        default: buf.append(\"Unknown glGetError() return value: \");");
-      output.println("      }");
-      output.println("      buf.append(\"( \" + err + \" 0x\"+Integer.toHexString(err).toUpperCase() + \"), \");");
-      output.println("    } while ((--recursionDepth >= 0) && (err = " +
-                     getDownstreamObjectName() +
-                     ".glGetError()) != GL_NO_ERROR);");
-      output.println("    throw new GLException(buf.toString());");
-      output.println("  }");
-      if (hasImmediateMode) {
-        output.println("  /** True if the pipeline is inside a glBegin/glEnd pair.*/");
-        output.println("  private boolean insideBeginEndPair = false;");
-        output.println();
-      }
-      output.println("  private void checkContext() {");
-      output.println("    GLContext currentContext = GLContext.getCurrent();");
-      output.println("    if (currentContext == null) {");
-      output.println("      throw new GLException(\"No OpenGL context is current on this thread\");");
-      output.println("    }");
-      output.println("    if ((_context != null) && (_context != currentContext)) {");
-      output.println("      throw new GLException(\"This GL object is being incorrectly used with a different GLContext than that which created it\");");
-      output.println("    }");
-      output.println("  }");
-      output.println("  private GLContext _context;");
-    }
+        @Override
+        protected void preMethodEmissionHook(PrintWriter output) {
+            super.preMethodEmissionHook(output);
+        }
 
-    protected void emitClassDocComment(PrintWriter output)
-    {
-      output.println("/** <P> Composable pipeline which wraps an underlying {@link GL} implementation,");
-      output.println("    providing error checking after each OpenGL method call. If an error occurs,");
-      output.println("    causes a {@link GLException} to be thrown at exactly the point of failure.");
-      output.println("    Sample code which installs this pipeline: </P>");
-      output.println();
-      output.println("<PRE>");
-      output.println("     GL gl = drawable.setGL(new DebugGL(drawable.getGL()));");
-      output.println("</PRE>");
-      output.println("*/");
-    }
-    
-    protected boolean hasPreDownstreamCallHook(Method m) {
-        return true;
-    }
+        protected void constructorHook(PrintWriter output) {
+            output.print("  public " + getOutputName() + "(");
+            output.print(downstreamName + " " + getDownstreamObjectName());
+            if (null != prologNameOpt) {
+                output.println(", " + prologNameOpt + " " + getPrologObjectNameOpt() + ")");
+            } else {
+                output.println(")");
+            }
+            output.println("  {");
+            output.println("    if (" + getDownstreamObjectName() + " == null) {");
+            output.println("      throw new IllegalArgumentException(\"null " + getDownstreamObjectName() + "\");");
+            output.println("    }");
+            output.print("    this." + getDownstreamObjectName());
+            output.println(" = " + getDownstreamObjectName() + ";");
+            if (null != prologNameOpt) {
+                output.print("    this." + getPrologObjectNameOpt());
+                output.println(" = " + getPrologObjectNameOpt() + ";");
+            }
+            output.println("  }");
+            output.println();
+        }
 
-    protected void preDownstreamCallHook(PrintWriter output, Method m)
-    {
-      output.println("    checkContext();");
-    }
+        @Override
+        protected void postMethodEmissionHook(PrintWriter output) {
+            super.postMethodEmissionHook(output);
+            if (null != prologNameOpt) {
+                output.print("  private " + prologNameOpt + " " + getPrologObjectNameOpt() + ";");
+            }
+        }
 
-    protected boolean hasPostDownstreamCallHook(Method m) {
-        return true;
-    }
+        protected void emitClassDocComment(PrintWriter output) {
+            output.println("/**");
+            output.println(" * Composable pipeline {@link " + outputPackage + "." + outputName + "}, implementing the interface");
+            output.println(" * {@link " + baseInterfaceClass.getName() + "}");
+            output.println(" * <p>");
+            output.println(" * Each method follows the call graph <ul>");
+            if (null != prologClassOpt) {
+                output.println(" *   <li> call <em>prolog</em> {@link " + prologClassOpt.getName() + "} if available");
+            }
+            output.println(" *   <li> call <em>downstream</em> {@link " + downstreamClass.getName() + "} if available");
+            if (null != prologClassOpt && 0 != (GEN_PROLOG_XOR_DOWNSTREAM & getMode())) {
+                output.println(" *        <strong>and</strong> if no call to {@link " + prologClassOpt.getName() + "} is made");
+            }
+            output.println(" * </ul><p>");
+            output.println(" * ");
+            output.println(" * <ul>");
+            output.println(" *   <li> <em>Interface</em> {@link " + baseInterfaceClass.getName() + "}");
+            if (null != prologClassOpt) {
+                output.println(" *   <li> <em>Prolog</em> {@link " + prologClassOpt.getName() + "}");
+            }
+            output.println(" *   <li> <em>Downstream</em> {@link " + downstreamClass.getName() + "}");
+            output.println(" * </ul><p>");
+            output.println(" *  Sample code which installs this pipeline: </P>");
+            output.println(" * ");
+            output.println("<PRE>");
+            if (null != prologNameOpt) {
+                output.println("     GL gl = drawable.setGL( new " + className + "( drawable.getGL().getGL2ES2(), new " + prologNameOpt + "( drawable.getGL().getGL2ES2() ) ) );");
+            } else {
+                output.println("     GL gl = drawable.setGL( new " + className + "( drawable.getGL().getGL2ES2() ) );");
+            }
+            output.println("</PRE>");
+            output.println("*/");
+        }
 
-    protected void postDownstreamCallHook(PrintWriter output, Method m)
-    {
-      if (m.getName().equals("glBegin"))
-      {
-        output.println("    insideBeginEndPair = true;");
-        output.println("    // NOTE: can't check glGetError(); it's not allowed inside glBegin/glEnd pair");
-      }
-      else
-      {
-        if (m.getName().equals("glEnd"))
-        {
-          output.println("    insideBeginEndPair = false;");
-        }
-        
-        output.println("    String txt = new String(\""+ m.getName() + "(\" +");
-        Class[] params = m.getParameterTypes() ;
-        for(int i=0; params!=null && i<params.length; i++) {
-           if(params[i].equals(int.class)) {
-            output.println("    \"<"+params[i].getName()+"> 0x\"+Integer.toHexString(arg"+i+").toUpperCase() +");
-           } else {
-            output.println("    \"<"+params[i].getName()+">\" +");
-           }
-           if(i<params.length-1) {
-            output.println("    \", \" +");
-           }
-        }
-        output.println("    \")\");");
-        // calls to glGetError() are only allowed outside of glBegin/glEnd pairs
-        output.println("    checkGLGetError( txt );");
-      }
-    }
+        protected boolean hasPreDownstreamCallHook(Method m) {
+            return null != getMethod(prologClassOpt, m);
+        }
 
-  } // end class DebugPipeline
+        protected void preDownstreamCallHook(PrintWriter output, Method m) {
+            if (null != prologNameOpt) {
+                output.print(getPrologObjectNameOpt());
+                output.print('.');
+                output.print(m.getName());
+                output.print('(');
+                output.print(getArgListAsString(m, false, true));
+                output.println(");");
+            }
+        }
 
-  //-------------------------------------------------------
+        protected boolean hasPostDownstreamCallHook(Method m) {
+            return false;
+        }
 
-  protected class TracePipeline extends PipelineEmitter
-  {
-    String className;
-    public TracePipeline(String outputDir, String outputPackage, Class baseInterfaceClass, Class downstreamClass)
-    {
-      super(outputDir, outputPackage, baseInterfaceClass, null, downstreamClass);
-      className = "Trace" + getBaseInterfaceName();
-    }
+        protected void postDownstreamCallHook(PrintWriter output, Method m) {
+        }
+    } // end class CustomPipeline
 
-    protected String getOutputName()
-    {
-      return className;
-    }
+    protected class DebugPipeline extends PipelineEmitter {
 
-    protected int getMode() { return 0; }
+        String className;
 
-    protected boolean emptyMethodAllowed() {
-        return false;
-    }
-    protected boolean emptyDownstreamAllowed() {
-        return false;
-    }
+        DebugPipeline(String outputDir, String outputPackage, Class<?> baseInterfaceClass, Class<?> downstreamClass) {
+            super(outputDir, outputPackage, baseInterfaceClass, null, downstreamClass);
+            className = "Debug" + getBaseInterfaceName();
+        }
 
-    protected void preMethodEmissionHook(PrintWriter output)
-    {
-        super.preMethodEmissionHook(output);
-    }
+        protected String getOutputName() {
+            return className;
+        }
 
-    protected void constructorHook(PrintWriter output) {
-      output.print(  "  public " + getOutputName() + "(" );
-      output.println(  downstreamName + " " + getDownstreamObjectName() + ", PrintStream " + getOutputStreamName() + ")");
-      output.println("  {");
-      output.println("    if (" + getDownstreamObjectName() + " == null) {");
-      output.println("      throw new IllegalArgumentException(\"null " + getDownstreamObjectName() + "\");");
-      output.println("    }");
-      output.print(  "    this." + getDownstreamObjectName());
-      output.println(" = " + getDownstreamObjectName() + ";");
-      output.print(  "    this." + getOutputStreamName());
-      output.println(" = " + getOutputStreamName() + ";");
-      output.println("  }");
-      output.println();
-    }
+        protected int getMode() {
+            return 0;
+        }
 
-    protected void postMethodEmissionHook(PrintWriter output)
-    {
-      super.postMethodEmissionHook(output);
-      output.println("private PrintStream " + getOutputStreamName() + ";");
-      output.println("private int indent = 0;"); 
-      output.println("protected String dumpArray(Object obj)");
-      output.println("{");
-      output.println("  if (obj == null) return \"[null]\";");
-      output.println("  StringBuffer sb = new StringBuffer(\"[\");");
-      output.println("  int len  = java.lang.reflect.Array.getLength(obj);");
-      output.println("  int count = Math.min(len,16);");
-      output.println("  for ( int i =0; i < count; i++ ) {");
-      output.println("    sb.append(java.lang.reflect.Array.get(obj,i));");
-      output.println("    if (i < count-1)"); 
-      output.println("      sb.append(',');");
-      output.println("  }");
-      output.println("  if ( len > 16 )");
-      output.println("    sb.append(\"...\").append(len);");
-      output.println("  sb.append(']');");
-      output.println("  return sb.toString();");
-      output.println("}");
-      output.println("protected void print(String str)");
-      output.println("{");
-      output.println("  "+getOutputStreamName()+".print(str);");
-      output.println("}");
-      output.println("protected void println(String str)");
-      output.println("{");
-      output.println("  "+getOutputStreamName()+".println(str);");
-      output.println("}");
-      output.println("protected void printIndent()");
-      output.println("{");
-      output.println("  for( int i =0; i < indent; i++) {"+getOutputStreamName()+".print(' ');}");
-      output.println("}");
-    }
-    protected void emitClassDocComment(PrintWriter output)
-    {
-      output.println("/** <P> Composable pipeline which wraps an underlying {@link GL} implementation,");
-      output.println("    providing tracing information to a user-specified {@link java.io.PrintStream}");
-      output.println("    before and after each OpenGL method call. Sample code which installs this pipeline: </P>");
-      output.println();
-      output.println("<PRE>");
-      output.println("     GL gl = drawable.setGL(new TraceGL(drawable.getGL(), System.err));");
-      output.println("</PRE>");
-      output.println("*/");
-    }
-    
-    protected boolean hasPreDownstreamCallHook(Method m) {
-        return true;
-    }
+        protected boolean emptyMethodAllowed() {
+            return false;
+        }
 
-    protected void preDownstreamCallHook(PrintWriter output, Method m)
-    {
-      if ( m.getName().equals("glEnd") || m.getName().equals("glEndList")) 
-      {
-        output.println("indent-=2;");
-        output.println("    printIndent();");
-      } 
-      else 
-      {
-        output.println("printIndent();");
-      }
-      
-      output.print("    print(");
-          printFunctionCallString(output, m);
-      output.println(");");
-    }
+        protected boolean emptyDownstreamAllowed() {
+            return false;
+        }
 
-    protected boolean hasPostDownstreamCallHook(Method m) {
-        return true;
-    }
+        @Override
+        protected void preMethodEmissionHook(PrintWriter output) {
+            super.preMethodEmissionHook(output);
+        }
 
-    protected void postDownstreamCallHook(PrintWriter output, Method m)
-    {
-      Class ret = m.getReturnType();
-      if ( ret != Void.TYPE ) 
-      {
-        output.println("    println(\" = \"+_res);"); 
-      }
-      else 
-      {
-        output.println("    println(\"\");");
-      }
-    }
+        protected void constructorHook(PrintWriter output) {
+            output.print("  public " + getOutputName() + "(");
+            output.println(downstreamName + " " + getDownstreamObjectName() + ")");
+            output.println("  {");
+            output.println("    if (" + getDownstreamObjectName() + " == null) {");
+            output.println("      throw new IllegalArgumentException(\"null " + getDownstreamObjectName() + "\");");
+            output.println("    }");
+            output.print("    this." + getDownstreamObjectName());
+            output.println(" = " + getDownstreamObjectName() + ";");
+            if (null != prologNameOpt) {
+                output.print("    this." + getPrologObjectNameOpt());
+                output.println(" = " + getPrologObjectNameOpt() + ";");
+            }
+            output.println("    // Fetch GLContext object for better error checking (if possible)");
+            output.println("    _context = " + getDownstreamObjectName() + ".getContext();");
+            output.println("  }");
+            output.println();
+        }
 
-    private String getOutputStreamName() {
-      return "stream";
-    }
+        @Override
+        protected void postMethodEmissionHook(PrintWriter output) {
+            super.postMethodEmissionHook(output);
+            output.println("  private void checkGLGetError(String caller)");
+            output.println("  {");
+            if (hasImmediateMode) {
+                output.println("    if (insideBeginEndPair) {");
+                output.println("      return;");
+                output.println("    }");
+                output.println();
+            }
+            output.println("    // Debug code to make sure the pipeline is working; leave commented out unless testing this class");
+            output.println("    //System.err.println(\"Checking for GL errors "
+                    + "after call to \" + caller);");
+            output.println();
+            output.println("    int err = "
+                    + getDownstreamObjectName()
+                    + ".glGetError();");
+            output.println("    if (err == GL_NO_ERROR) { return; }");
+            output.println();
+            output.println("    StringBuffer buf = new StringBuffer(Thread.currentThread()+");
+            output.println("      \" glGetError() returned the following error codes after a call to \" + caller + \": \");");
+            output.println();
+            output.println("    // Loop repeatedly to allow for distributed GL implementations,");
+            output.println("    // as detailed in the glGetError() specification");
+            output.println("    int recursionDepth = 10;");
+            output.println("    do {");
+            output.println("      switch (err) {");
+            output.println("        case GL_INVALID_ENUM: buf.append(\"GL_INVALID_ENUM \"); break;");
+            output.println("        case GL_INVALID_VALUE: buf.append(\"GL_INVALID_VALUE \"); break;");
+            output.println("        case GL_INVALID_OPERATION: buf.append(\"GL_INVALID_OPERATION \"); break;");
+            if (hasStackOverflow) {
+                output.println("        case GL_STACK_OVERFLOW: buf.append(\"GL_STACK_OVERFLOW \"); break;");
+                output.println("        case GL_STACK_UNDERFLOW: buf.append(\"GL_STACK_UNDERFLOW \"); break;");
+            }
+            output.println("        case GL_OUT_OF_MEMORY: buf.append(\"GL_OUT_OF_MEMORY \"); break;");
+            output.println("        case GL_NO_ERROR: throw new InternalError(\"Should not be treating GL_NO_ERROR as error\");");
+            output.println("        default: buf.append(\"Unknown glGetError() return value: \");");
+            output.println("      }");
+            output.println("      buf.append(\"( \" + err + \" 0x\"+Integer.toHexString(err).toUpperCase() + \"), \");");
+            output.println("    } while ((--recursionDepth >= 0) && (err = "
+                    + getDownstreamObjectName()
+                    + ".glGetError()) != GL_NO_ERROR);");
+            output.println("    throw new GLException(buf.toString());");
+            output.println("  }");
+            if (hasImmediateMode) {
+                output.println("  /** True if the pipeline is inside a glBegin/glEnd pair.*/");
+                output.println("  private boolean insideBeginEndPair = false;");
+                output.println();
+            }
+            output.println("  private void checkContext() {");
+            output.println("    GLContext currentContext = GLContext.getCurrent();");
+            output.println("    if (currentContext == null) {");
+            output.println("      throw new GLException(\"No OpenGL context is current on this thread\");");
+            output.println("    }");
+            output.println("    if ((_context != null) && (_context != currentContext)) {");
+            output.println("      throw new GLException(\"This GL object is being incorrectly used with a different GLContext than that which created it\");");
+            output.println("    }");
+            output.println("  }");
+            output.println("  private GLContext _context;");
+        }
 
-  } // end class TracePipeline
-  
-  public static final void printFunctionCallString(PrintWriter output, Method m) {
-      Class[] params = m.getParameterTypes();
-      output.print("    \"" + m.getName() + "(\"");
-      for ( int i =0; i < params.length; i++ ) 
-      {
-        if ( params[i].isArray() ) {
-            output.print("+\"<"+params[i].getName()+">\"");
-        } else if(params[i].equals(int.class)) {
-            output.print("+\"<"+params[i].getName()+"> 0x\"+Integer.toHexString(arg"+i+").toUpperCase()");
-        } else {
-            output.print("+\"<"+params[i].getName()+"> \"+arg"+i);
+        protected void emitClassDocComment(PrintWriter output) {
+            output.println("/** <P> Composable pipeline which wraps an underlying {@link GL} implementation,");
+            output.println("    providing error checking after each OpenGL method call. If an error occurs,");
+            output.println("    causes a {@link GLException} to be thrown at exactly the point of failure.");
+            output.println("    Sample code which installs this pipeline: </P>");
+            output.println();
+            output.println("<PRE>");
+            output.println("     GL gl = drawable.setGL(new DebugGL(drawable.getGL()));");
+            output.println("</PRE>");
+            output.println("*/");
+        }
+
+        protected boolean hasPreDownstreamCallHook(Method m) {
+            return true;
+        }
+
+        protected void preDownstreamCallHook(PrintWriter output, Method m) {
+            output.println("    checkContext();");
+        }
+
+        protected boolean hasPostDownstreamCallHook(Method m) {
+            return true;
+        }
+
+        protected void postDownstreamCallHook(PrintWriter output, Method m) {
+            if (m.getName().equals("glBegin")) {
+                output.println("    insideBeginEndPair = true;");
+                output.println("    // NOTE: can't check glGetError(); it's not allowed inside glBegin/glEnd pair");
+            } else {
+                if (m.getName().equals("glEnd")) {
+                    output.println("    insideBeginEndPair = false;");
+                }
+
+                output.println("    String txt = new String(\"" + m.getName() + "(\" +");
+                Class<?>[] params = m.getParameterTypes();
+                for (int i = 0; params != null && i < params.length; i++) {
+                    if (params[i].equals(int.class)) {
+                        output.println("    \"<" + params[i].getName() + "> 0x\"+Integer.toHexString(arg" + i + ").toUpperCase() +");
+                    } else {
+                        output.println("    \"<" + params[i].getName() + ">\" +");
+                    }
+                    if (i < params.length - 1) {
+                        output.println("    \", \" +");
+                    }
+                }
+                output.println("    \")\");");
+                // calls to glGetError() are only allowed outside of glBegin/glEnd pairs
+                output.println("    checkGLGetError( txt );");
+            }
+        }
+    } // end class DebugPipeline
+
+    //-------------------------------------------------------
+    protected class TracePipeline extends PipelineEmitter {
+
+        String className;
+
+        TracePipeline(String outputDir, String outputPackage, Class<?> baseInterfaceClass, Class<?> downstreamClass) {
+            super(outputDir, outputPackage, baseInterfaceClass, null, downstreamClass);
+            className = "Trace" + getBaseInterfaceName();
+        }
+
+        protected String getOutputName() {
+            return className;
+        }
+
+        protected int getMode() {
+            return 0;
         }
-        if ( i < params.length-1) {
-          output.print("+\", \"");      
+
+        protected boolean emptyMethodAllowed() {
+            return false;
         }
-      }
-      output.print("+\")\"");
-  }
+
+        protected boolean emptyDownstreamAllowed() {
+            return false;
+        }
+
+        @Override
+        protected void preMethodEmissionHook(PrintWriter output) {
+            super.preMethodEmissionHook(output);
+        }
+
+        protected void constructorHook(PrintWriter output) {
+            output.print("  public " + getOutputName() + "(");
+            output.println(downstreamName + " " + getDownstreamObjectName() + ", PrintStream " + getOutputStreamName() + ")");
+            output.println("  {");
+            output.println("    if (" + getDownstreamObjectName() + " == null) {");
+            output.println("      throw new IllegalArgumentException(\"null " + getDownstreamObjectName() + "\");");
+            output.println("    }");
+            output.print("    this." + getDownstreamObjectName());
+            output.println(" = " + getDownstreamObjectName() + ";");
+            output.print("    this." + getOutputStreamName());
+            output.println(" = " + getOutputStreamName() + ";");
+            output.println("  }");
+            output.println();
+        }
+
+        @Override
+        protected void postMethodEmissionHook(PrintWriter output) {
+            super.postMethodEmissionHook(output);
+            output.println("private PrintStream " + getOutputStreamName() + ";");
+            output.println("private int indent = 0;");
+            output.println("protected String dumpArray(Object obj)");
+            output.println("{");
+            output.println("  if (obj == null) return \"[null]\";");
+            output.println("  StringBuffer sb = new StringBuffer(\"[\");");
+            output.println("  int len  = java.lang.reflect.Array.getLength(obj);");
+            output.println("  int count = Math.min(len,16);");
+            output.println("  for ( int i =0; i < count; i++ ) {");
+            output.println("    sb.append(java.lang.reflect.Array.get(obj,i));");
+            output.println("    if (i < count-1)");
+            output.println("      sb.append(',');");
+            output.println("  }");
+            output.println("  if ( len > 16 )");
+            output.println("    sb.append(\"...\").append(len);");
+            output.println("  sb.append(']');");
+            output.println("  return sb.toString();");
+            output.println("}");
+            output.println("protected void print(String str)");
+            output.println("{");
+            output.println("  " + getOutputStreamName() + ".print(str);");
+            output.println("}");
+            output.println("protected void println(String str)");
+            output.println("{");
+            output.println("  " + getOutputStreamName() + ".println(str);");
+            output.println("}");
+            output.println("protected void printIndent()");
+            output.println("{");
+            output.println("  for( int i =0; i < indent; i++) {" + getOutputStreamName() + ".print(' ');}");
+            output.println("}");
+        }
+
+        protected void emitClassDocComment(PrintWriter output) {
+            output.println("/** <P> Composable pipeline which wraps an underlying {@link GL} implementation,");
+            output.println("    providing tracing information to a user-specified {@link java.io.PrintStream}");
+            output.println("    before and after each OpenGL method call. Sample code which installs this pipeline: </P>");
+            output.println();
+            output.println("<PRE>");
+            output.println("     GL gl = drawable.setGL(new TraceGL(drawable.getGL(), System.err));");
+            output.println("</PRE>");
+            output.println("*/");
+        }
+
+        protected boolean hasPreDownstreamCallHook(Method m) {
+            return true;
+        }
+
+        protected void preDownstreamCallHook(PrintWriter output, Method m) {
+            if (m.getName().equals("glEnd") || m.getName().equals("glEndList")) {
+                output.println("indent-=2;");
+                output.println("    printIndent();");
+            } else {
+                output.println("printIndent();");
+            }
+
+            output.print("    print(");
+            printFunctionCallString(output, m);
+            output.println(");");
+        }
+
+        protected boolean hasPostDownstreamCallHook(Method m) {
+            return true;
+        }
+
+        protected void postDownstreamCallHook(PrintWriter output, Method m) {
+            Class<?> ret = m.getReturnType();
+            if (ret != Void.TYPE) {
+                output.println("    println(\" = \"+_res);");
+            } else {
+                output.println("    println(\"\");");
+            }
+        }
+
+        private String getOutputStreamName() {
+            return "stream";
+        }
+    } // end class TracePipeline
+
+    public static final void printFunctionCallString(PrintWriter output, Method m) {
+        Class<?>[] params = m.getParameterTypes();
+        output.print("    \"" + m.getName() + "(\"");
+        for (int i = 0; i < params.length; i++) {
+            if (params[i].isArray()) {
+                output.print("+\"<" + params[i].getName() + ">\"");
+            } else if (params[i].equals(int.class)) {
+                output.print("+\"<" + params[i].getName() + "> 0x\"+Integer.toHexString(arg" + i + ").toUpperCase()");
+            } else {
+                output.print("+\"<" + params[i].getName() + "> \"+arg" + i);
+            }
+            if (i < params.length - 1) {
+                output.print("+\", \"");
+            }
+        }
+        output.print("+\")\"");
+    }
 }
diff --git a/src/java/com/sun/gluegen/opengl/BuildStaticGLInfo.java b/src/java/com/sun/gluegen/opengl/BuildStaticGLInfo.java
index f7a7fe0..2be5519 100644
--- a/src/java/com/sun/gluegen/opengl/BuildStaticGLInfo.java
+++ b/src/java/com/sun/gluegen/opengl/BuildStaticGLInfo.java
@@ -88,8 +88,8 @@ import java.util.regex.*;
    * with the symbol
    *   <code> GL_ARB_texture_compression </code>.
    * */
-public class BuildStaticGLInfo
-{
+public class BuildStaticGLInfo {
+
   // Handles function pointer 
   protected static int funcIdentifierGroup = 10;
   protected static Pattern funcPattern =
@@ -110,242 +110,237 @@ public class BuildStaticGLInfo
   protected Map<String, Set<String>> extensionToDeclarationMap = new HashMap<String, Set<String>>();
   protected boolean debug = false;
 
-  /**
-   * The first argument is the package to which the StaticGLInfo class
-   * belongs, the second is the path to the directory in which that package's
-   * classes reside, and the remaining arguments are paths to the C header
-   * files that should be parsed
-   */
-  public static void main(String[] args) throws IOException
-  {
-    if (args.length > 0 && args[0].equals("-test")) {
-      BuildStaticGLInfo builder = new BuildStaticGLInfo();
-      builder.setDebug(true);
-      String[] newArgs = new String[args.length - 1];
-      System.arraycopy(args, 1, newArgs, 0, args.length - 1);
-      builder.parse(newArgs);
-      builder.dump();
-      System.exit(0);
-    }
+    /**
+     * The first argument is the package to which the StaticGLInfo class
+     * belongs, the second is the path to the directory in which that package's
+     * classes reside, and the remaining arguments are paths to the C header
+     * files that should be parsed
+     */
+    public static void main(String[] args) throws IOException {
+        if (args.length > 0 && args[0].equals("-test")) {
+            BuildStaticGLInfo builder = new BuildStaticGLInfo();
+            builder.setDebug(true);
+            String[] newArgs = new String[args.length - 1];
+            System.arraycopy(args, 1, newArgs, 0, args.length - 1);
+            builder.parse(newArgs);
+            builder.dump();
+            System.exit(0);
+        }
 
-    String packageName = args[0];
-    String packageDir = args[1];
+        String packageName = args[0];
+        String packageDir = args[1];
 
-    String[] cHeaderFilePaths = new String[args.length-2];
-    System.arraycopy(args, 2, cHeaderFilePaths, 0, cHeaderFilePaths.length);
-    
-    BuildStaticGLInfo builder = new BuildStaticGLInfo();
-    try {
-      builder.parse(cHeaderFilePaths);
+        String[] cHeaderFilePaths = new String[args.length - 2];
+        System.arraycopy(args, 2, cHeaderFilePaths, 0, cHeaderFilePaths.length);
 
-      File file = new File(packageDir + File.separatorChar + "StaticGLInfo.java");
-      String parentDir = file.getParent();
-      if (parentDir != null) {
-        File pDirFile = new File(parentDir);
-        pDirFile.mkdirs();
-      }
+        BuildStaticGLInfo builder = new BuildStaticGLInfo();
+        try {
+            builder.parse(cHeaderFilePaths);
 
-      PrintWriter writer = new PrintWriter(new BufferedWriter(new FileWriter(file)));
-      builder.emitJavaCode(writer, packageName);
+            File file = new File(packageDir + File.separatorChar + "StaticGLInfo.java");
+            String parentDir = file.getParent();
+            if (parentDir != null) {
+                File pDirFile = new File(parentDir);
+                pDirFile.mkdirs();
+            }
 
-      writer.flush();
-      writer.close();
-    }
-    catch (Exception e)
-    {
-      StringBuffer buf = new StringBuffer("{ ");
-      for (int i = 0; i < cHeaderFilePaths.length; ++i)
-      {
-        buf.append(cHeaderFilePaths[i]);
-        buf.append(" ");
-      }
-      buf.append('}');
-      throw new RuntimeException(
-        "Error building StaticGLInfo.java from " + buf.toString(), e);        
+            PrintWriter writer = new PrintWriter(new BufferedWriter(new FileWriter(file)));
+            builder.emitJavaCode(writer, packageName);
+
+            writer.flush();
+            writer.close();
+        } catch (Exception e) {
+            StringBuilder buf = new StringBuilder("{ ");
+            for (int i = 0; i < cHeaderFilePaths.length; ++i) {
+                buf.append(cHeaderFilePaths[i]);
+                buf.append(" ");
+            }
+            buf.append('}');
+            throw new RuntimeException(
+                    "Error building StaticGLInfo.java from " + buf.toString(), e);
+        }
     }
-  }
 
-  public void setDebug(boolean v) {
-      debug = v;
-  }
-  
-  /** Parses the supplied C header files and adds the function
-      associations contained therein to the internal map. */
-  public void parse(String[] cHeaderFilePaths) throws IOException {
-    for (int i = 0; i < cHeaderFilePaths.length; i++) {
-      parse(cHeaderFilePaths[i]);
+    public void setDebug(boolean v) {
+        debug = v;
     }
-  }
 
-  /** Parses the supplied C header file and adds the function
-      associations contained therein to the internal map. */
-  public void parse(String cHeaderFilePath) throws IOException {
-    BufferedReader reader = new BufferedReader(new FileReader(cHeaderFilePath));
-    String line, activeAssociation = null;
-    Matcher m = null;
-    while ((line = reader.readLine()) != null) {
-      int type = 0; // 1-define, 2-function
-      // see if we're inside a #ifndef GL_XXX block and matching a function
-      if (activeAssociation != null) {
-        String identifier = null;
-        if ((m = funcPattern.matcher(line)).matches()) {
-          identifier = m.group(funcIdentifierGroup).trim();
-          type =2;
-        } else if ((m = definePattern.matcher(line)).matches()) {
-          identifier = m.group(defineIdentifierGroup).trim();
-          type =1;
-        } else if (line.startsWith("#endif")) {
-          if(debug) {
-              System.err.println("END ASSOCIATION BLOCK: <" + activeAssociation + ">");
-          }
-          activeAssociation = null;
+    /** Parses the supplied C header files and adds the function
+    associations contained therein to the internal map. */
+    public void parse(String[] cHeaderFilePaths) throws IOException {
+        for (int i = 0; i < cHeaderFilePaths.length; i++) {
+            parse(cHeaderFilePaths[i]);
         }
-        if ((identifier != null) &&
-            (activeAssociation != null) &&
-            // Handles #ifndef GL_... #define GL_...
-            !identifier.equals(activeAssociation)) {
-          addAssociation(identifier, activeAssociation);
-          if(debug) {
-              System.err.println("  ADDING ASSOCIATION: <" + identifier + "> <" + activeAssociation + "> ; type "+type);
-          }
+    }
+
+    /** Parses the supplied C header file and adds the function
+    associations contained therein to the internal map. */
+    public void parse(String cHeaderFilePath) throws IOException {
+        BufferedReader reader = new BufferedReader(new FileReader(cHeaderFilePath));
+        String line, activeAssociation = null;
+        Matcher m = null;
+        while ((line = reader.readLine()) != null) {
+            int type = 0; // 1-define, 2-function
+            // see if we're inside a #ifndef GL_XXX block and matching a function
+            if (activeAssociation != null) {
+                String identifier = null;
+                if ((m = funcPattern.matcher(line)).matches()) {
+                    identifier = m.group(funcIdentifierGroup).trim();
+                    type = 2;
+                } else if ((m = definePattern.matcher(line)).matches()) {
+                    identifier = m.group(defineIdentifierGroup).trim();
+                    type = 1;
+                } else if (line.startsWith("#endif")) {
+                    if (debug) {
+                        System.err.println("END ASSOCIATION BLOCK: <" + activeAssociation + ">");
+                    }
+                    activeAssociation = null;
+                }
+                if ((identifier != null)
+                        && (activeAssociation != null)
+                        && // Handles #ifndef GL_... #define GL_...
+                        !identifier.equals(activeAssociation)) {
+                    addAssociation(identifier, activeAssociation);
+                    if (debug) {
+                        System.err.println("  ADDING ASSOCIATION: <" + identifier + "> <" + activeAssociation + "> ; type " + type);
+                    }
+                }
+            } else if ((m = associationPattern.matcher(line)).matches()) {
+                // found a new #ifndef GL_XXX block
+                activeAssociation = m.group(1).trim();
+
+                if (debug) {
+                    System.err.println("BEGIN ASSOCIATION BLOCK: <" + activeAssociation + ">");
+                }
+            }
         }
-      } else if ((m = associationPattern.matcher(line)).matches()) {
-        // found a new #ifndef GL_XXX block
-        activeAssociation = m.group(1).trim();
-        
-        if(debug) {
-            System.err.println("BEGIN ASSOCIATION BLOCK: <" + activeAssociation + ">");
+        reader.close();
+    }
+
+    public void dump() {
+        for (String name : extensionToDeclarationMap.keySet()) {
+            Set<String> decls = extensionToDeclarationMap.get(name);
+            System.out.println("<" + name + "> :");
+            List<String> l = new ArrayList<String>();
+            l.addAll(decls);
+            Collections.sort(l);
+            for (String str : l) {
+                System.out.println("  <" + str + ">");
+            }
         }
-      }
     }
-    reader.close();
-  }
 
-  public void dump() {
-    for (String name : extensionToDeclarationMap.keySet()) {
-      Set<String> decls = extensionToDeclarationMap.get(name);
-      System.out.println("<"+name+"> :");
-      List<String> l = new ArrayList<String>();
-      l.addAll(decls);
-      Collections.sort(l);
-      for (String str : l) {
-        System.out.println("  <" + str + ">");
-      }
+    public String getExtension(String identifier) {
+        return declarationToExtensionMap.get(identifier);
     }
-  }
 
-  public String getExtension(String identifier) {
-    return declarationToExtensionMap.get(identifier);
-  }
-  
-  public Set<String> getDeclarations(String extension) {
-    return extensionToDeclarationMap.get(extension);
-  }
+    public Set<String> getDeclarations(String extension) {
+        return extensionToDeclarationMap.get(extension);
+    }
 
-  public Set<String> getExtensions() {
-    return extensionToDeclarationMap.keySet();
-  }
+    public Set<String> getExtensions() {
+        return extensionToDeclarationMap.keySet();
+    }
 
-  public void emitJavaCode(PrintWriter output, String packageName) {
-    output.println("package " + packageName + ";");
-    output.println();
-    output.println("import java.util.*;");
-    output.println();
-    output.println("public final class StaticGLInfo");
-    output.println("{");
+    public void emitJavaCode(PrintWriter output, String packageName) {
+        output.println("package " + packageName + ";");
+        output.println();
+        output.println("import java.util.*;");
+        output.println();
+        output.println("public final class StaticGLInfo");
+        output.println("{");
 
-    output.println("  // maps function names to the extension string or OpenGL");
-    output.println("  // specification version string to which they correspond.");
-    output.println("  private static HashMap funcToAssocMap;");
-    output.println();
+        output.println("  // maps function names to the extension string or OpenGL");
+        output.println("  // specification version string to which they correspond.");
+        output.println("  private static HashMap funcToAssocMap;");
+        output.println();
 
-    output.println("  /**");
-    output.println("   * Returns the OpenGL extension string or GL_VERSION string with which the");
-    output.println("   * given function is associated. <P>");
-    output.println("   *");
-    output.println("   * If the");
-    output.println("   * function is part of the OpenGL core, the returned value will be");
-    output.println("   * GL_VERSION_XXX where XXX represents the OpenGL version of which the");
-    output.println("   * function is a member (XXX will be of the form \"A\" or \"A_B\" or \"A_B_C\";");
-    output.println("   * e.g., GL_VERSION_1_2_1 for OpenGL version 1.2.1).");
-    output.println("   *");
-    output.println("   * If the function is an extension function, the returned value will the");
-    output.println("   * OpenGL extension string for the extension to which the function");
-    output.println("   * corresponds. For example, if glLoadTransposeMatrixfARB is the argument,");
-    output.println("   * GL_ARB_transpose_matrix will be the value returned.");
-    output.println("   * Please see http://oss.sgi.com/projects/ogl-sample/registry/index.html for");
-    output.println("   * a list of extension names and the functions they expose.");
-    output.println("   *");
-    output.println("   * If the function specified is not part of any known OpenGL core version or");
-    output.println("   * extension, then NULL will be returned.");
-    output.println("   */");
-    output.println("  public static String getFunctionAssociation(String glFunctionName)");
-    output.println("  {");
-    output.println("    String mappedName = null;");
-    output.println("    int  funcNamePermNum = com.jogamp.gluegen.runtime.opengl.GLExtensionNames.getFuncNamePermutationNumber(glFunctionName);");
-    output.println("    for(int i = 0; null==mappedName && i < funcNamePermNum; i++) {");
-    output.println("        String tmp = com.jogamp.gluegen.runtime.opengl.GLExtensionNames.getFuncNamePermutation(glFunctionName, i);");
-    output.println("        try {");
-    output.println("          mappedName = (String)funcToAssocMap.get(tmp);");
-    output.println("        } catch (Exception e) { }");
-    output.println("    }");
-    output.println("    return mappedName;");
-    output.println("  }");
-    output.println();
+        output.println("  /**");
+        output.println("   * Returns the OpenGL extension string or GL_VERSION string with which the");
+        output.println("   * given function is associated. <P>");
+        output.println("   *");
+        output.println("   * If the");
+        output.println("   * function is part of the OpenGL core, the returned value will be");
+        output.println("   * GL_VERSION_XXX where XXX represents the OpenGL version of which the");
+        output.println("   * function is a member (XXX will be of the form \"A\" or \"A_B\" or \"A_B_C\";");
+        output.println("   * e.g., GL_VERSION_1_2_1 for OpenGL version 1.2.1).");
+        output.println("   *");
+        output.println("   * If the function is an extension function, the returned value will the");
+        output.println("   * OpenGL extension string for the extension to which the function");
+        output.println("   * corresponds. For example, if glLoadTransposeMatrixfARB is the argument,");
+        output.println("   * GL_ARB_transpose_matrix will be the value returned.");
+        output.println("   * Please see http://oss.sgi.com/projects/ogl-sample/registry/index.html for");
+        output.println("   * a list of extension names and the functions they expose.");
+        output.println("   *");
+        output.println("   * If the function specified is not part of any known OpenGL core version or");
+        output.println("   * extension, then NULL will be returned.");
+        output.println("   */");
+        output.println("  public static String getFunctionAssociation(String glFunctionName)");
+        output.println("  {");
+        output.println("    String mappedName = null;");
+        output.println("    int  funcNamePermNum = com.jogamp.gluegen.runtime.opengl.GLExtensionNames.getFuncNamePermutationNumber(glFunctionName);");
+        output.println("    for(int i = 0; null==mappedName && i < funcNamePermNum; i++) {");
+        output.println("        String tmp = com.jogamp.gluegen.runtime.opengl.GLExtensionNames.getFuncNamePermutation(glFunctionName, i);");
+        output.println("        try {");
+        output.println("          mappedName = (String)funcToAssocMap.get(tmp);");
+        output.println("        } catch (Exception e) { }");
+        output.println("    }");
+        output.println("    return mappedName;");
+        output.println("  }");
+        output.println();
 
-    output.println("  static");
-    output.println("  {");
+        output.println("  static");
+        output.println("  {");
 
-    // Compute max capacity
-    int maxCapacity = 0;
-    for (String name : declarationToExtensionMap.keySet()) {
-      if (!name.startsWith("GL")) {
-        ++maxCapacity;
-      }
-    }
+        // Compute max capacity
+        int maxCapacity = 0;
+        for (String name : declarationToExtensionMap.keySet()) {
+            if (!name.startsWith("GL")) {
+                ++maxCapacity;
+            }
+        }
 
-    output.println("    funcToAssocMap = new HashMap(" + maxCapacity + "); // approximate max capacity");
-    output.println("    String group;");
-    ArrayList<String> sets = new ArrayList<String>(extensionToDeclarationMap.keySet());
-    Collections.sort(sets);
-    for (String groupName : sets) {
-      Set<String> funcs = extensionToDeclarationMap.get(groupName);
-      List<String> l = new ArrayList<String>();
-      l.addAll(funcs);
-      Collections.sort(l);
-      Iterator<String> funcIter = l.iterator();
-      boolean printedHeader = false;
-      while (funcIter.hasNext()) {
-        String funcName = funcIter.next();
-        if (!funcName.startsWith("GL")) {
-          if (!printedHeader) {
-            output.println();
-            output.println("    //----------------------------------------------------------------");
-            output.println("    //                 " + groupName);
-            output.println("    //----------------------------------------------------------------");
-            output.println("    group = \"" + groupName + "\";");
-            printedHeader = true;
-          }
+        output.println("    funcToAssocMap = new HashMap(" + maxCapacity + "); // approximate max capacity");
+        output.println("    String group;");
+        ArrayList<String> sets = new ArrayList<String>(extensionToDeclarationMap.keySet());
+        Collections.sort(sets);
+        for (String groupName : sets) {
+            Set<String> funcs = extensionToDeclarationMap.get(groupName);
+            List<String> l = new ArrayList<String>();
+            l.addAll(funcs);
+            Collections.sort(l);
+            Iterator<String> funcIter = l.iterator();
+            boolean printedHeader = false;
+            while (funcIter.hasNext()) {
+                String funcName = funcIter.next();
+                if (!funcName.startsWith("GL")) {
+                    if (!printedHeader) {
+                        output.println();
+                        output.println("    //----------------------------------------------------------------");
+                        output.println("    //                 " + groupName);
+                        output.println("    //----------------------------------------------------------------");
+                        output.println("    group = \"" + groupName + "\";");
+                        printedHeader = true;
+                    }
 
-          output.println("    funcToAssocMap.put(\"" + funcName + "\", group);");
+                    output.println("    funcToAssocMap.put(\"" + funcName + "\", group);");
+                }
+            }
         }
-      }
+        output.println("  }");
+        output.println("} // end class StaticGLInfo");
     }
-    output.println("  }");
-    output.println("} // end class StaticGLInfo");
-  }
 
-  //----------------------------------------------------------------------
-  // Internals only below this point
-  //
-
-  protected void addAssociation(String identifier, String association) {
-    declarationToExtensionMap.put(identifier, association);
-    Set<String> identifiers = extensionToDeclarationMap.get(association);
-    if (identifiers == null) {
-      identifiers = new HashSet<String>();
-      extensionToDeclarationMap.put(association, identifiers);
+    //----------------------------------------------------------------------
+    // Internals only below this point
+    //
+    protected void addAssociation(String identifier, String association) {
+        declarationToExtensionMap.put(identifier, association);
+        Set<String> identifiers = extensionToDeclarationMap.get(association);
+        if (identifiers == null) {
+            identifiers = new HashSet<String>();
+            extensionToDeclarationMap.put(association, identifiers);
+        }
+        identifiers.add(identifier);
     }
-    identifiers.add(identifier);
-  }
 }
diff --git a/src/java/com/sun/gluegen/opengl/GLConfiguration.java b/src/java/com/sun/gluegen/opengl/GLConfiguration.java
index 6d08a10..d712e90 100755
--- a/src/java/com/sun/gluegen/opengl/GLConfiguration.java
+++ b/src/java/com/sun/gluegen/opengl/GLConfiguration.java
@@ -36,7 +36,6 @@
  * Sun gratefully acknowledges that this software was originally authored
  * and developed by Kenneth Bradley Russell and Christopher John Kline.
  */
-
 package com.sun.gluegen.opengl;
 
 import java.io.*;
@@ -47,30 +46,33 @@ import com.sun.gluegen.procaddress.*;
 import com.jogamp.gluegen.runtime.opengl.GLExtensionNames;
 
 public class GLConfiguration extends ProcAddressConfiguration {
-  // The following data members support ignoring an entire extension at a time
-  private List<String> glHeaders = new ArrayList<String>();
-  private Set<String> ignoredExtensions = new HashSet<String>();
-  private Set<String> extensionsRenamedIntoCore = new HashSet<String>();
-  private BuildStaticGLInfo glInfo;
-  // Maps function names to the kind of buffer object it deals with
-  private Map<String,GLEmitter.BufferObjectKind> bufferObjectKinds = new HashMap<String,GLEmitter.BufferObjectKind>();
-  private GLEmitter emitter;
-  private Set<String> dropUniqVendorExtensions = new HashSet<String>();
-  // This directive is off by default but can help automatically
-  // indicate which extensions have been folded into the core OpenGL
-  // namespace, and if not, then why not
-  private boolean autoUnifyExtensions=false;
-  private boolean allowNonGLExtensions=false;
-
-  public GLConfiguration(GLEmitter emitter) {
-    super();
-    this.emitter = emitter;
-    try {
-      setProcAddressNameExpr("PFN $UPPERCASE({0}) PROC");
-    } catch (NoSuchElementException e) {
-      throw new RuntimeException("Error configuring ProcAddressNameExpr", e);
+
+    // The following data members support ignoring an entire extension at a time
+    private List<String> glHeaders = new ArrayList<String>();
+    private Set<String> ignoredExtensions = new HashSet<String>();
+    private Set<String> extensionsRenamedIntoCore = new HashSet<String>();
+    private BuildStaticGLInfo glInfo;
+
+    // Maps function names to the kind of buffer object it deals with
+    private Map<String, GLEmitter.BufferObjectKind> bufferObjectKinds = new HashMap<String, GLEmitter.BufferObjectKind>();
+    private GLEmitter emitter;
+    private Set<String> dropUniqVendorExtensions = new HashSet<String>();
+
+    // This directive is off by default but can help automatically
+    // indicate which extensions have been folded into the core OpenGL
+    // namespace, and if not, then why not
+    private boolean autoUnifyExtensions = false;
+    private boolean allowNonGLExtensions = false;
+
+    public GLConfiguration(GLEmitter emitter) {
+        super();
+        this.emitter = emitter;
+        try {
+            setProcAddressNameExpr("PFN $UPPERCASE({0}) PROC");
+        } catch (NoSuchElementException e) {
+            throw new RuntimeException("Error configuring ProcAddressNameExpr", e);
+        }
     }
-  }
 
     @Override
     protected void dispatch(String cmd, StringTokenizer tok, File file, String filename, int lineNo) throws IOException {
@@ -97,199 +99,198 @@ public class GLConfiguration extends ProcAddressConfiguration {
         }
     }
 
-  protected void readBufferObjectKind(StringTokenizer tok, String filename, int lineNo) {
-    try {
-      String kindString = tok.nextToken();
-      GLEmitter.BufferObjectKind kind = null;
-      String target = tok.nextToken();
-      if (kindString.equalsIgnoreCase("UnpackPixel")) {
-        kind = GLEmitter.BufferObjectKind.UNPACK_PIXEL;
-      } else if (kindString.equalsIgnoreCase("PackPixel")) {
-        kind = GLEmitter.BufferObjectKind.PACK_PIXEL;
-      } else if (kindString.equalsIgnoreCase("Array")) {
-        kind = GLEmitter.BufferObjectKind.ARRAY;
-      } else if (kindString.equalsIgnoreCase("Element")) {
-        kind = GLEmitter.BufferObjectKind.ELEMENT;
-      } else {
-        throw new RuntimeException("Error parsing \"BufferObjectKind\" command at line " + lineNo +
-                                   " in file \"" + filename + "\": illegal BufferObjectKind \"" +
-                                   kindString + "\", expected one of UnpackPixel, PackPixel, Array, or Element");
-      }
-
-      bufferObjectKinds.put(target, kind);
-    } catch (NoSuchElementException e) {
-      throw new RuntimeException("Error parsing \"BufferObjectKind\" command at line " + lineNo +
-                                 " in file \"" + filename + "\"", e);
-    }
-  }
-
-  /** Overrides javaPrologueForMethod in superclass and
-      automatically generates prologue code for functions associated
-      with buffer objects. */
-  @Override
-  public List<String> javaPrologueForMethod(MethodBinding binding, boolean forImplementingMethodCall, boolean eraseBufferAndArrayTypes) {
-
-    List<String> res = super.javaPrologueForMethod(binding, forImplementingMethodCall, eraseBufferAndArrayTypes);
-    GLEmitter.BufferObjectKind kind = getBufferObjectKind(binding.getName());
-    if (kind != null) {
-      // Need to generate appropriate prologue based on both buffer
-      // object kind and whether this variant of the MethodBinding
-      // is the one accepting a "long" as argument
-      //
-      // NOTE we MUST NOT mutate the array returned from the super
-      // call!
-      ArrayList<String> res2 = new ArrayList<String>();
-      if (res != null) {
-        res2.addAll(res);
-      }
-      res = res2;
-
-      String prologue = "check";
-
-      if (kind == GLEmitter.BufferObjectKind.UNPACK_PIXEL) {
-        prologue = prologue + "UnpackPBO";
-      } else if (kind == GLEmitter.BufferObjectKind.PACK_PIXEL) {
-        prologue = prologue + "PackPBO";
-      } else if (kind == GLEmitter.BufferObjectKind.ARRAY) {
-        prologue = prologue + "ArrayVBO";
-      } else if (kind == GLEmitter.BufferObjectKind.ELEMENT) {
-        prologue = prologue + "ElementVBO";
-      } else {
-        throw new RuntimeException("Unknown BufferObjectKind " + kind);
-      }
-
-      if (emitter.isBufferObjectMethodBinding(binding)) {
-        prologue = prologue + "Enabled";
-      } else {
-        prologue = prologue + "Disabled";
-      }
-
-      prologue = prologue + "(true);";
-
-      res.add(0, prologue);
-
-      // Must also filter out bogus rangeCheck directives for VBO/PBO
-      // variants
-      if (emitter.isBufferObjectMethodBinding(binding)) {
-        for (Iterator<String> iter = res.iterator(); iter.hasNext(); ) {
-          String line = iter.next();
-          if (line.indexOf("Buffers.rangeCheck") >= 0) {
-            iter.remove();
-          }
+    protected void readBufferObjectKind(StringTokenizer tok, String filename, int lineNo) {
+        try {
+            String kindString = tok.nextToken();
+            GLEmitter.BufferObjectKind kind = null;
+            String target = tok.nextToken();
+            if (kindString.equalsIgnoreCase("UnpackPixel")) {
+                kind = GLEmitter.BufferObjectKind.UNPACK_PIXEL;
+            } else if (kindString.equalsIgnoreCase("PackPixel")) {
+                kind = GLEmitter.BufferObjectKind.PACK_PIXEL;
+            } else if (kindString.equalsIgnoreCase("Array")) {
+                kind = GLEmitter.BufferObjectKind.ARRAY;
+            } else if (kindString.equalsIgnoreCase("Element")) {
+                kind = GLEmitter.BufferObjectKind.ELEMENT;
+            } else {
+                throw new RuntimeException("Error parsing \"BufferObjectKind\" command at line " + lineNo
+                        + " in file \"" + filename + "\": illegal BufferObjectKind \""
+                        + kindString + "\", expected one of UnpackPixel, PackPixel, Array, or Element");
+            }
+
+            bufferObjectKinds.put(target, kind);
+        } catch (NoSuchElementException e) {
+            throw new RuntimeException("Error parsing \"BufferObjectKind\" command at line " + lineNo
+                    + " in file \"" + filename + "\"", e);
         }
-      }
     }
 
-    return res;
-  }
+    /** Overrides javaPrologueForMethod in superclass and
+    automatically generates prologue code for functions associated
+    with buffer objects. */
+    @Override
+    public List<String> javaPrologueForMethod(MethodBinding binding, boolean forImplementingMethodCall, boolean eraseBufferAndArrayTypes) {
+
+        List<String> res = super.javaPrologueForMethod(binding, forImplementingMethodCall, eraseBufferAndArrayTypes);
+        GLEmitter.BufferObjectKind kind = getBufferObjectKind(binding.getName());
+        if (kind != null) {
+            // Need to generate appropriate prologue based on both buffer
+            // object kind and whether this variant of the MethodBinding
+            // is the one accepting a "long" as argument
+            //
+            // NOTE we MUST NOT mutate the array returned from the super
+            // call!
+            ArrayList<String> res2 = new ArrayList<String>();
+            if (res != null) {
+                res2.addAll(res);
+            }
+            res = res2;
+
+            String prologue = "check";
+
+            if (kind == GLEmitter.BufferObjectKind.UNPACK_PIXEL) {
+                prologue = prologue + "UnpackPBO";
+            } else if (kind == GLEmitter.BufferObjectKind.PACK_PIXEL) {
+                prologue = prologue + "PackPBO";
+            } else if (kind == GLEmitter.BufferObjectKind.ARRAY) {
+                prologue = prologue + "ArrayVBO";
+            } else if (kind == GLEmitter.BufferObjectKind.ELEMENT) {
+                prologue = prologue + "ElementVBO";
+            } else {
+                throw new RuntimeException("Unknown BufferObjectKind " + kind);
+            }
+
+            if (emitter.isBufferObjectMethodBinding(binding)) {
+                prologue = prologue + "Enabled";
+            } else {
+                prologue = prologue + "Disabled";
+            }
+
+            prologue = prologue + "(true);";
 
-  @Override
-  public void dumpIgnores() {
-    System.err.println("GL Ignored extensions: ");
-    for (String str : ignoredExtensions) {
-        System.err.println("\t"+str);
+            res.add(0, prologue);
+
+            // Must also filter out bogus rangeCheck directives for VBO/PBO
+            // variants
+            if (emitter.isBufferObjectMethodBinding(binding)) {
+                for (Iterator<String> iter = res.iterator(); iter.hasNext();) {
+                    String line = iter.next();
+                    if (line.indexOf("Buffers.rangeCheck") >= 0) {
+                        iter.remove();
+                    }
+                }
+            }
+        }
+
+        return res;
+    }
+
+    @Override
+    public void dumpIgnores() {
+        System.err.println("GL Ignored extensions: ");
+        for (String str : ignoredExtensions) {
+            System.err.println("\t" + str);
+        }
+        super.dumpIgnores();
     }
-    super.dumpIgnores();
-  }
-
-  protected boolean shouldIgnoreExtension(String symbol, boolean criteria) {
-    if (criteria && glInfo != null) {
-      String extension = glInfo.getExtension(symbol);
-      if (extension != null &&
-          ignoredExtensions.contains(extension)) {
-          return true;
-      }
-      boolean isGLEnum = GLExtensionNames.isGLEnumeration(symbol);
-      boolean isGLFunc = GLExtensionNames.isGLFunction(symbol);
-      if(isGLFunc || isGLEnum) {
-        if(GLExtensionNames.isExtensionVEN(symbol, isGLFunc)) {
-          String extSuffix = GLExtensionNames.getExtensionSuffix(symbol, isGLFunc);
-          if( getDropUniqVendorExtensions(extSuffix) ) {
-            if(DEBUG_IGNORES) {
-              System.err.println("Ignore UniqVendorEXT: "+symbol+", vendor "+extSuffix);
+
+    protected boolean shouldIgnoreExtension(String symbol, boolean criteria) {
+        if (criteria && glInfo != null) {
+            String extension = glInfo.getExtension(symbol);
+            if (extension != null
+                    && ignoredExtensions.contains(extension)) {
+                return true;
+            }
+            boolean isGLEnum = GLExtensionNames.isGLEnumeration(symbol);
+            boolean isGLFunc = GLExtensionNames.isGLFunction(symbol);
+            if (isGLFunc || isGLEnum) {
+                if (GLExtensionNames.isExtensionVEN(symbol, isGLFunc)) {
+                    String extSuffix = GLExtensionNames.getExtensionSuffix(symbol, isGLFunc);
+                    if (getDropUniqVendorExtensions(extSuffix)) {
+                        if (DEBUG_IGNORES) {
+                            System.err.println("Ignore UniqVendorEXT: " + symbol + ", vendor " + extSuffix);
+                        }
+                        return true;
+                    }
+                }
             }
-            return true;
-          }
         }
-      }
+        return false;
+    }
+
+    @Override
+    public boolean shouldIgnoreInInterface(String symbol) {
+        return shouldIgnoreInInterface(symbol, true);
+    }
+
+    public boolean shouldIgnoreInInterface(String symbol, boolean checkEXT) {
+        return shouldIgnoreExtension(symbol, checkEXT) || super.shouldIgnoreInInterface(symbol);
+    }
+
+    @Override
+    public boolean shouldIgnoreInImpl(String symbol) {
+        return shouldIgnoreInImpl(symbol, true);
+    }
+
+    public boolean shouldIgnoreInImpl(String symbol, boolean checkEXT) {
+        return shouldIgnoreExtension(symbol, checkEXT) || super.shouldIgnoreInImpl(symbol);
+    }
+
+    /** Should we automatically ignore extensions that have already been
+    fully subsumed into the OpenGL core namespace, and if they have
+    not been, indicate which definition is not already in the core? */
+    public boolean getAutoUnifyExtensions() {
+        return autoUnifyExtensions;
+    }
+
+    /** If true, accept all non encapsulated defines and functions,
+     * as it is mandatory for GL declarations. */
+    public boolean getAllowNonGLExtensions() {
+        return allowNonGLExtensions;
     }
-    return false;
-  }
-
-  @Override
-  public boolean shouldIgnoreInInterface(String symbol) {
-    return shouldIgnoreInInterface(symbol, true);
-  }
-
-  public boolean shouldIgnoreInInterface(String symbol, boolean checkEXT) {
-    return shouldIgnoreExtension(symbol, checkEXT) || super.shouldIgnoreInInterface(symbol);
-  }
-
-  @Override
-  public boolean shouldIgnoreInImpl(String symbol) {
-    return shouldIgnoreInImpl(symbol, true);
-  }
-
-  public boolean shouldIgnoreInImpl(String symbol, boolean checkEXT) {
-    return shouldIgnoreExtension(symbol, checkEXT) || super.shouldIgnoreInImpl(symbol);
-  }
-
-  /** Should we automatically ignore extensions that have already been
-      fully subsumed into the OpenGL core namespace, and if they have
-      not been, indicate which definition is not already in the core? */
-  public boolean getAutoUnifyExtensions() {
-    return autoUnifyExtensions;
-  }
-
-  /** If true, accept all non encapsulated defines and functions,
-    * as it is mandatory for GL declarations. */
-  public boolean getAllowNonGLExtensions() {
-    return allowNonGLExtensions;
-  }
-
-
-  /** shall the non unified (uniq) vendor extensions be dropped ?  */
-  public boolean getDropUniqVendorExtensions(String extName) {
-      return dropUniqVendorExtensions.contains(extName);
-  }
-
-  /** Returns the kind of buffer object this function deals with, or
-      null if none. */
-  GLEmitter.BufferObjectKind getBufferObjectKind(String name) {
-    return bufferObjectKinds.get(name);
-  }
-
-  public boolean isBufferObjectFunction(String name) {
-    return (getBufferObjectKind(name) != null);
-  }
-
-  /** Parses any GL headers specified in the configuration file for
-      the purpose of being able to ignore an extension at a time. */
-  public void parseGLHeaders(GlueEmitterControls controls) throws IOException {
-    if (!glHeaders.isEmpty()) {
-      glInfo = new BuildStaticGLInfo();
-      for (String file : glHeaders) {
-        String fullPath = controls.findHeaderFile(file);
-        if (fullPath == null) {
-          throw new IOException("Unable to locate header file \"" + file + "\"");
+
+    /** shall the non unified (uniq) vendor extensions be dropped ?  */
+    public boolean getDropUniqVendorExtensions(String extName) {
+        return dropUniqVendorExtensions.contains(extName);
+    }
+
+    /** Returns the kind of buffer object this function deals with, or
+    null if none. */
+    GLEmitter.BufferObjectKind getBufferObjectKind(String name) {
+        return bufferObjectKinds.get(name);
+    }
+
+    public boolean isBufferObjectFunction(String name) {
+        return (getBufferObjectKind(name) != null);
+    }
+
+    /** Parses any GL headers specified in the configuration file for
+    the purpose of being able to ignore an extension at a time. */
+    public void parseGLHeaders(GlueEmitterControls controls) throws IOException {
+        if (!glHeaders.isEmpty()) {
+            glInfo = new BuildStaticGLInfo();
+            for (String file : glHeaders) {
+                String fullPath = controls.findHeaderFile(file);
+                if (fullPath == null) {
+                    throw new IOException("Unable to locate header file \"" + file + "\"");
+                }
+                glInfo.parse(fullPath);
+            }
         }
-        glInfo.parse(fullPath);
-      }
     }
-  }
-
-  /** Returns the information about the association between #defines,
-      function symbols and the OpenGL extensions they are defined
-      in. */
-  public BuildStaticGLInfo getGLInfo() {
-    return glInfo;
-  }
-
-  /** Returns the OpenGL extensions that should have all of their
-      constant definitions and functions renamed into the core
-      namespace; for example, glGenFramebuffersEXT to
-      glGenFramebuffers and GL_FRAMEBUFFER_EXT to GL_FRAMEBUFFER. */
-  public Set<String> getExtensionsRenamedIntoCore() {
-    return extensionsRenamedIntoCore;
-  }
+
+    /** Returns the information about the association between #defines,
+    function symbols and the OpenGL extensions they are defined
+    in. */
+    public BuildStaticGLInfo getGLInfo() {
+        return glInfo;
+    }
+
+    /** Returns the OpenGL extensions that should have all of their
+    constant definitions and functions renamed into the core
+    namespace; for example, glGenFramebuffersEXT to
+    glGenFramebuffers and GL_FRAMEBUFFER_EXT to GL_FRAMEBUFFER. */
+    public Set<String> getExtensionsRenamedIntoCore() {
+        return extensionsRenamedIntoCore;
+    }
 }
diff --git a/src/java/com/sun/gluegen/opengl/GLEmitter.java b/src/java/com/sun/gluegen/opengl/GLEmitter.java
index e9ae750..006287e 100644
--- a/src/java/com/sun/gluegen/opengl/GLEmitter.java
+++ b/src/java/com/sun/gluegen/opengl/GLEmitter.java
@@ -36,11 +36,9 @@
  * Sun gratefully acknowledges that this software was originally authored
  * and developed by Kenneth Bradley Russell and Christopher John Kline.
  */
-
 package com.sun.gluegen.opengl;
 
 import java.io.*;
-import java.text.MessageFormat;
 import java.util.*;
 import com.sun.gluegen.*;
 import com.sun.gluegen.cgram.types.*;
@@ -53,417 +51,405 @@ import com.jogamp.gluegen.runtime.opengl.GLExtensionNames;
  */
 public class GLEmitter extends ProcAddressEmitter {
 
-  // Keeps track of which MethodBindings were created for handling
-  // Buffer Object variants. Used as a Set rather than a Map.
-  private Map<MethodBinding, MethodBinding> bufferObjectMethodBindings = new IdentityHashMap<MethodBinding, MethodBinding>();
-
-  static class BufferObjectKind {
-
-    private BufferObjectKind() {}
-
-    static final BufferObjectKind UNPACK_PIXEL = new BufferObjectKind();
-    static final BufferObjectKind PACK_PIXEL   = new BufferObjectKind();
-    static final BufferObjectKind ARRAY        = new BufferObjectKind();
-    static final BufferObjectKind ELEMENT      = new BufferObjectKind();
-  }
-  
-  @Override
-  public void beginEmission(GlueEmitterControls controls) throws IOException  {
-    getGLConfig().parseGLHeaders(controls);
-    renameExtensionsIntoCore();
-    if (getGLConfig().getAutoUnifyExtensions()) {
-      unifyExtensions(controls);
-    }
-    super.beginEmission(controls);
-  }
-
-  protected void renameExtensionsIntoCore() {
-    // This method handles renaming of entire extensions into the
-    // OpenGL core namespace. For example, it is used to move certain
-    // OpenGL ES (OES) extensions into the core namespace which are
-    // already in the core namespace in desktop OpenGL. It builds upon
-    // renaming mechanisms that are built elsewhere.
-    
-    GLConfiguration config = getGLConfig();
-    Set<String> extensionsRenamedIntoCore = config.getExtensionsRenamedIntoCore();
-    BuildStaticGLInfo glInfo = config.getGLInfo();
-    if(null==glInfo) {
-        if(extensionsRenamedIntoCore.size()>0) {
-            throw new RuntimeException("ExtensionRenamedIntoCore (num: "+extensionsRenamedIntoCore.size()+"), but no GLHeader");
+    // Keeps track of which MethodBindings were created for handling
+    // Buffer Object variants. Used as a Set rather than a Map.
+    private Map<MethodBinding, MethodBinding> bufferObjectMethodBindings = new IdentityHashMap<MethodBinding, MethodBinding>();
+
+    enum BufferObjectKind { UNPACK_PIXEL, PACK_PIXEL, ARRAY, ELEMENT}
+
+    @Override
+    public void beginEmission(GlueEmitterControls controls) throws IOException {
+        getGLConfig().parseGLHeaders(controls);
+        renameExtensionsIntoCore();
+        if (getGLConfig().getAutoUnifyExtensions()) {
+            unifyExtensions(controls);
         }
-        return;
+        super.beginEmission(controls);
     }
-    for (String extension : extensionsRenamedIntoCore) {
-      Set<String> declarations = glInfo.getDeclarations(extension);
-      if (declarations != null) {
-        for (Iterator i2 = declarations.iterator(); i2.hasNext(); ) {
-          String decl = (String) i2.next();
-          boolean isGLFunction = GLExtensionNames.isGLFunction(decl);
-          boolean isGLEnumeration = false;
-          if (!isGLFunction) {
-            isGLEnumeration = GLExtensionNames.isGLEnumeration(decl);
-          }
-          if (isGLFunction || isGLEnumeration) {
-            String renamed = GLExtensionNames.normalize(decl, isGLFunction);
-            if(!renamed.equals(decl)) {
-                config.addJavaSymbolRename(decl, renamed);
+
+    protected void renameExtensionsIntoCore() {
+        // This method handles renaming of entire extensions into the
+        // OpenGL core namespace. For example, it is used to move certain
+        // OpenGL ES (OES) extensions into the core namespace which are
+        // already in the core namespace in desktop OpenGL. It builds upon
+        // renaming mechanisms that are built elsewhere.
+
+        GLConfiguration config = getGLConfig();
+        Set<String> extensionsRenamedIntoCore = config.getExtensionsRenamedIntoCore();
+        BuildStaticGLInfo glInfo = config.getGLInfo();
+        if (null == glInfo) {
+            if (extensionsRenamedIntoCore.size() > 0) {
+                throw new RuntimeException("ExtensionRenamedIntoCore (num: " + extensionsRenamedIntoCore.size() + "), but no GLHeader");
+            }
+            return;
+        }
+        for (String extension : extensionsRenamedIntoCore) {
+            Set<String> declarations = glInfo.getDeclarations(extension);
+            if (declarations != null) {
+                for (Iterator<String> iterator = declarations.iterator(); iterator.hasNext();) {
+                    String decl = iterator.next();
+                    boolean isGLFunction = GLExtensionNames.isGLFunction(decl);
+                    boolean isGLEnumeration = false;
+                    if (!isGLFunction) {
+                        isGLEnumeration = GLExtensionNames.isGLEnumeration(decl);
+                    }
+                    if (isGLFunction || isGLEnumeration) {
+                        String renamed = GLExtensionNames.normalize(decl, isGLFunction);
+                        if (!renamed.equals(decl)) {
+                            config.addJavaSymbolRename(decl, renamed);
+                        }
+                    }
+                }
             }
-          }
         }
-      }
-    }
-  }
-
-  class ExtensionUnifier implements SymbolFilter {
-      private List<ConstantDefinition> constants;
-      private List<FunctionSymbol> functions;
-
-      public void filterSymbols(List<ConstantDefinition> constants,
-                                List<FunctionSymbol> functions) {
-          this.constants = constants;
-          this.functions = functions;
-          doWork();
-      }
-
-      public List<ConstantDefinition> getConstants() {
-          return constants;
-      }
-      
-      public List<FunctionSymbol> getFunctions() {
-          return functions;
-      }
-
-      private void doWork() {
-          BuildStaticGLInfo glInfo = getGLConfig().getGLInfo();
-          if (glInfo == null) {
-              return;
-          }
-          // Try to retain a "good" ordering for these symbols
-          Map<String, ConstantDefinition> constantMap = new LinkedHashMap();
-          Map<String, FunctionSymbol> functionMap = new LinkedHashMap();
-          for (Iterator iter = constants.iterator(); iter.hasNext(); ) {
-              ConstantDefinition def = (ConstantDefinition) iter.next();
-              constantMap.put(def.getName(), def);
-          }
-          for (Iterator iter = functions.iterator(); iter.hasNext(); ) {
-              FunctionSymbol sym = (FunctionSymbol) iter.next();
-              functionMap.put(sym.getName(), sym);
-          }
-          // Go through all of the declared extensions.
-          // For each extension, look at its #define and function symbols.
-          // If we find all of the extension's symbols in the core API under
-          // non-ARB (or whatever is the suffix) names, then remove this extension
-          // from the public API. If it turns out that we are running on hardware
-          // that doesn't support the core version of these APIs, the runtime
-          // will take care of looking up the extension version of these entry
-          // points.
-          Set<String> extensionNames = glInfo.getExtensions();
-          for (Iterator iter1 = extensionNames.iterator(); iter1.hasNext(); ) {
-              String extension = (String) iter1.next();
-              Set<String> declarations = glInfo.getDeclarations(extension);
-              boolean isExtension = true;
-              boolean shouldUnify = true;
-              String cause = null;
-              for (Iterator iter2 = declarations.iterator(); iter2.hasNext(); ) {
-                  String decl = (String) iter2.next();
-                  boolean isFunc = !decl.startsWith("GL_");
-                  if (!GLExtensionNames.isExtension(decl, isFunc)) {
-                      isExtension = false;
-                      break;
-                  }
-                  // See whether we're emitting glue code for this
-                  // entry point or definition at all
-                  if (isFunc) {
-                      if (!functionMap.containsKey(decl)) {
-                          isExtension = false;
-                          break;
-                      }
-                  } else {
-                      if (!constantMap.containsKey(decl)) {
-                          isExtension = false;
-                          break;
-                      }
-                  }
-                  cause = decl;
-                  String unifiedName = GLExtensionNames.normalize(decl, isFunc);
-                  // NOTE that we look up the unified name in the
-                  // BuildStaticGLInfo's notion of the APIs -- since
-                  // we might not be emitting glue code for the
-                  // headers that actually contain the core entry
-                  // point. Think of the case where we are parsing the
-                  // GLES2 gl2.h, which contains certain desktop
-                  // OpenGL extensions that have been moved into the
-                  // core, but later generating the implementing glue
-                  // code (not the interface) for the desktop gl.h /
-                  // glext.h.
-                  shouldUnify = (glInfo.getExtension(unifiedName) != null);
-                  //                  if (isFunc) {
-                  //                      shouldUnify = functionMap.containsKey(unifiedName);
-                  //                  } else {
-                  //                      shouldUnify = constantMap.containsKey(unifiedName);
-                  //                  }
-                  if (!shouldUnify) {
-                      break;
-                  }
-              }
-              if (isExtension) {
-                  if (shouldUnify) {
-                      for (Iterator iter2 = declarations.iterator(); iter2.hasNext(); ) {
-                          String decl = (String) iter2.next();
-                          boolean isFunc = !decl.startsWith("GL_");
-                          if (isFunc) {
-                              functionMap.remove(decl);
-                          } else {
-                              constantMap.remove(decl);
-                          }
-                      }
-                      System.err.println("INFO: unified extension " + extension + " into core API");
-                  } else {
-                      System.err.println("INFO: didn't unify extension " + extension + " into core API because of " + cause);
-                  }
-              }
-          }
-          constants = new ArrayList();
-          for (Iterator iter = constantMap.keySet().iterator(); iter.hasNext(); ) {
-              constants.add(constantMap.get(iter.next()));
-          }
-          functions = new ArrayList();
-          for (Iterator iter = functionMap.keySet().iterator(); iter.hasNext(); ) {
-              functions.add(functionMap.get(iter.next()));
-          }
-      }
-  }
-
-  private void unifyExtensions(GlueEmitterControls controls) {
-      controls.runSymbolFilter(new ExtensionUnifier());
-  }
-
-  protected JavaConfiguration createConfig() {
-    return new GLConfiguration(this);
-  }
-
-  /** In order to implement Buffer Object variants of certain
-      functions we generate another MethodBinding which maps the void*
-      argument to a Java long. The generation of emitters then takes
-      place as usual. We do however need to keep track of the modified
-      MethodBinding object so that we can also modify the emitters
-      later to inform them that their argument has changed. We might
-      want to push this functionality down into the MethodBinding
-      (i.e., mutators for argument names). We also would need to
-      inform the CMethodBindingEmitter that it is overloaded in this
-      case (though we default to true currently). */
-  protected List<MethodBinding> expandMethodBinding(MethodBinding binding) {
-    List<MethodBinding> bindings = super.expandMethodBinding(binding);
-    
-    if (!getGLConfig().isBufferObjectFunction(binding.getName())) {
-      return bindings;
     }
 
-    List<MethodBinding> newBindings = new ArrayList();
-    newBindings.addAll(bindings);
-
-    // Need to expand each one of the generated bindings to take a
-    // Java long instead of a Buffer for each void* argument
-    for (Iterator iter = bindings.iterator(); iter.hasNext(); ) {
-      MethodBinding cur = (MethodBinding) iter.next();
-      
-      // Some of these routines (glBitmap) take strongly-typed
-      // primitive pointers as arguments which are expanded into
-      // non-void* arguments
-      // This test (rather than !signatureUsesNIO) is used to catch
-      // more unexpected situations
-      if (cur.signatureUsesJavaPrimitiveArrays()) {
-        continue;
-      }
-
-      MethodBinding result = cur;
-      for (int i = 0; i < cur.getNumArguments(); i++) {
-        if (cur.getJavaArgumentType(i).isNIOBuffer()) {
-          result = result.replaceJavaArgumentType(i, JavaType.createForClass(Long.TYPE));
+    class ExtensionUnifier implements SymbolFilter {
+
+        private List<ConstantDefinition> constants;
+        private List<FunctionSymbol> functions;
+
+        public void filterSymbols(List<ConstantDefinition> constants,
+                List<FunctionSymbol> functions) {
+            this.constants = constants;
+            this.functions = functions;
+            doWork();
         }
-      }
 
-      if (result == cur) {
-        throw new RuntimeException("Error: didn't find any void* arguments for BufferObject function " +
-                                   binding.getName());
-      }
+        public List<ConstantDefinition> getConstants() {
+            return constants;
+        }
 
-      newBindings.add(result);
-      // Now need to flag this MethodBinding so that we generate the
-      // correct flags in the emitters later
-      bufferObjectMethodBindings.put(result, result);
+        public List<FunctionSymbol> getFunctions() {
+            return functions;
+        }
+
+        private void doWork() {
+            BuildStaticGLInfo glInfo = getGLConfig().getGLInfo();
+            if (glInfo == null) {
+                return;
+            }
+            // Try to retain a "good" ordering for these symbols
+            Map<String, ConstantDefinition> constantMap = new LinkedHashMap<String, ConstantDefinition>();
+            for (ConstantDefinition def : constants) {
+                constantMap.put(def.getName(), def);
+            }
+            Map<String, FunctionSymbol> functionMap = new LinkedHashMap<String, FunctionSymbol>();
+            for (FunctionSymbol sym : functions) {
+                functionMap.put(sym.getName(), sym);
+            }
+
+            // Go through all of the declared extensions.
+            // For each extension, look at its #define and function symbols.
+            // If we find all of the extension's symbols in the core API under
+            // non-ARB (or whatever is the suffix) names, then remove this extension
+            // from the public API. If it turns out that we are running on hardware
+            // that doesn't support the core version of these APIs, the runtime
+            // will take care of looking up the extension version of these entry
+            // points.
+            Set<String> extensionNames = glInfo.getExtensions();
+
+            for (String extension : extensionNames) {
+                Set<String> declarations = glInfo.getDeclarations(extension);
+                boolean isExtension = true;
+                boolean shouldUnify = true;
+                String cause = null;
+                for (String decl : declarations) {
+                    boolean isFunc = !decl.startsWith("GL_");
+                    if (!GLExtensionNames.isExtension(decl, isFunc)) {
+                        isExtension = false;
+                        break;
+                    }
+                    // See whether we're emitting glue code for this
+                    // entry point or definition at all
+                    if (isFunc) {
+                        if (!functionMap.containsKey(decl)) {
+                            isExtension = false;
+                            break;
+                        }
+                    } else {
+                        if (!constantMap.containsKey(decl)) {
+                            isExtension = false;
+                            break;
+                        }
+                    }
+                    cause = decl;
+                    String unifiedName = GLExtensionNames.normalize(decl, isFunc);
+                    // NOTE that we look up the unified name in the
+                    // BuildStaticGLInfo's notion of the APIs -- since
+                    // we might not be emitting glue code for the
+                    // headers that actually contain the core entry
+                    // point. Think of the case where we are parsing the
+                    // GLES2 gl2.h, which contains certain desktop
+                    // OpenGL extensions that have been moved into the
+                    // core, but later generating the implementing glue
+                    // code (not the interface) for the desktop gl.h /
+                    // glext.h.
+                    shouldUnify = (glInfo.getExtension(unifiedName) != null);
+                    //                  if (isFunc) {
+                    //                      shouldUnify = functionMap.containsKey(unifiedName);
+                    //                  } else {
+                    //                      shouldUnify = constantMap.containsKey(unifiedName);
+                    //                  }
+                    if (!shouldUnify) {
+                        break;
+                    }
+                }
+                if (isExtension) {
+                    if (shouldUnify) {
+                        for (String decl : declarations) {
+                            boolean isFunc = !decl.startsWith("GL_");
+                            if (isFunc) {
+                                functionMap.remove(decl);
+                            } else {
+                                constantMap.remove(decl);
+                            }
+                        }
+                        System.err.println("INFO: unified extension " + extension + " into core API");
+                    } else {
+                        System.err.println("INFO: didn't unify extension " + extension + " into core API because of " + cause);
+                    }
+                }
+            }
+            constants = new ArrayList<ConstantDefinition>(constantMap.values());
+            functions = new ArrayList<FunctionSymbol>(functionMap.values());
+        }
     }
 
-    return newBindings;
-  }
+    private void unifyExtensions(GlueEmitterControls controls) {
+        controls.runSymbolFilter(new ExtensionUnifier());
+    }
 
-  protected boolean needsModifiedEmitters(FunctionSymbol sym) {
-    if ((!needsProcAddressWrapper(sym) && !needsBufferObjectVariant(sym)) ||
-        getConfig().isUnimplemented(sym.getName())) {
-      return false;
+    @Override
+    protected JavaConfiguration createConfig() {
+        return new GLConfiguration(this);
     }
 
-    return true;
-  }
-
-  public boolean isBufferObjectMethodBinding(MethodBinding binding) {
-    return bufferObjectMethodBindings.containsKey(binding);
-  }
-
-  public void emitDefine(ConstantDefinition def, String optionalComment) throws Exception {
-      BuildStaticGLInfo glInfo = getGLConfig().getGLInfo();
-      if(null==glInfo) {
-        throw new Exception("No GLInfo for: "+def);
-      }
-      String symbolRenamed = def.getName();
-      StringBuffer newComment = new StringBuffer();
-      newComment.append("Part of <code>");
-      if(0==addExtensionsOfSymbols2Buffer(newComment, ", ", symbolRenamed, def.getAliasedNames())) {
-        if(def.isEnum()) {
-          String enumName = def.getEnumName();
-          if(null!=enumName) {
-              newComment.append(enumName);
-          } else {
-              newComment.append("CORE ENUM");
-          }
-        } else {
-          if(getGLConfig().getAllowNonGLExtensions()) {
-              newComment.append("CORE DEF");
-          } else {
-              // Note: All GL defines must be contained within an extension marker !
-              // #ifndef GL_EXT_lala
-              // #define GL_EXT_lala 1
-              // ...
-              // #endif
-              if(JavaConfiguration.DEBUG_IGNORES) {
-                  StringBuffer sb = new StringBuffer();
-                  JavaEmitter.addStrings2Buffer(sb, ", ", symbolRenamed, def.getAliasedNames());
-                  System.err.println("Dropping marker: "+sb.toString());
-              }
-              return;
-          }
+    /** In order to implement Buffer Object variants of certain
+    functions we generate another MethodBinding which maps the void*
+    argument to a Java long. The generation of emitters then takes
+    place as usual. We do however need to keep track of the modified
+    MethodBinding object so that we can also modify the emitters
+    later to inform them that their argument has changed. We might
+    want to push this functionality down into the MethodBinding
+    (i.e., mutators for argument names). We also would need to
+    inform the CMethodBindingEmitter that it is overloaded in this
+    case (though we default to true currently). */
+    @Override
+    protected List<MethodBinding> expandMethodBinding(MethodBinding binding) {
+        List<MethodBinding> bindings = super.expandMethodBinding(binding);
+
+        if (!getGLConfig().isBufferObjectFunction(binding.getName())) {
+            return bindings;
         }
-      }
-      newComment.append("</code>");
 
-      if(null!=optionalComment) {
-        newComment.append("<br>");
-        newComment.append(optionalComment);
-      }
+        List<MethodBinding> newBindings = new ArrayList<MethodBinding>(bindings);
 
-      super.emitDefine(def, newComment.toString());
-  }
+        // Need to expand each one of the generated bindings to take a
+        // Java long instead of a Buffer for each void* argument
 
-  public int addExtensionsOfSymbols2Buffer(StringBuffer buf, String sep, String first, Collection col) {
-    BuildStaticGLInfo glInfo = getGLConfig().getGLInfo();
-    if(null==glInfo) {
-        throw new RuntimeException("No GLInfo for: "+first);
-    }
-    int num = 0;
-    if(null==buf) buf=new StringBuffer();
-    String extensionName;
-
-    Iterator iter=col.iterator();
-    if(null!=first) {
-        extensionName = glInfo.getExtension(first);
-        if(null!=extensionName) {
-            buf.append(extensionName);
-            if( iter.hasNext() ) {
-                buf.append(sep);
+        for (MethodBinding cur : bindings) {
+
+            // Some of these routines (glBitmap) take strongly-typed
+            // primitive pointers as arguments which are expanded into
+            // non-void* arguments
+            // This test (rather than !signatureUsesNIO) is used to catch
+            // more unexpected situations
+            if (cur.signatureUsesJavaPrimitiveArrays()) {
+                continue;
+            }
+
+            MethodBinding result = cur;
+            for (int i = 0; i < cur.getNumArguments(); i++) {
+                if (cur.getJavaArgumentType(i).isNIOBuffer()) {
+                    result = result.replaceJavaArgumentType(i, JavaType.createForClass(Long.TYPE));
+                }
             }
-            num++;
+
+            if (result == cur) {
+                throw new RuntimeException("Error: didn't find any void* arguments for BufferObject function "
+                        + binding.getName());
+            }
+
+            newBindings.add(result);
+            // Now need to flag this MethodBinding so that we generate the
+            // correct flags in the emitters later
+            bufferObjectMethodBindings.put(result, result);
         }
+
+        return newBindings;
+    }
+
+    @Override
+    protected boolean needsModifiedEmitters(FunctionSymbol sym) {
+        if ((!needsProcAddressWrapper(sym) && !needsBufferObjectVariant(sym))
+                || getConfig().isUnimplemented(sym.getName())) {
+            return false;
+        }
+
+        return true;
+    }
+
+    public boolean isBufferObjectMethodBinding(MethodBinding binding) {
+        return bufferObjectMethodBindings.containsKey(binding);
     }
-    while( iter.hasNext() ) {
-        extensionName = glInfo.getExtension((String)iter.next());
-        if(null!=extensionName) {
-            buf.append(extensionName);
-            if( iter.hasNext() ) {
-                buf.append(sep);
+
+    @Override
+    public void emitDefine(ConstantDefinition def, String optionalComment) throws Exception {
+        BuildStaticGLInfo glInfo = getGLConfig().getGLInfo();
+        if (null == glInfo) {
+            throw new Exception("No GLInfo for: " + def);
+        }
+        String symbolRenamed = def.getName();
+        StringBuilder newComment = new StringBuilder();
+        newComment.append("Part of <code>");
+        if (0 == addExtensionsOfSymbols2Buffer(newComment, ", ", symbolRenamed, def.getAliasedNames())) {
+            if (def.isEnum()) {
+                String enumName = def.getEnumName();
+                if (null != enumName) {
+                    newComment.append(enumName);
+                } else {
+                    newComment.append("CORE ENUM");
+                }
+            } else {
+                if (getGLConfig().getAllowNonGLExtensions()) {
+                    newComment.append("CORE DEF");
+                } else {
+                    // Note: All GL defines must be contained within an extension marker !
+                    // #ifndef GL_EXT_lala
+                    // #define GL_EXT_lala 1
+                    // ...
+                    // #endif
+                    if (JavaConfiguration.DEBUG_IGNORES) {
+                        StringBuilder sb = new StringBuilder();
+                        JavaEmitter.addStrings2Buffer(sb, ", ", symbolRenamed, def.getAliasedNames());
+                        System.err.println("Dropping marker: " + sb.toString());
+                    }
+                    return;
+                }
             }
-            num++;
         }
+        newComment.append("</code>");
+
+        if (null != optionalComment) {
+            newComment.append("<br>");
+            newComment.append(optionalComment);
+        }
+
+        super.emitDefine(def, newComment.toString());
     }
-    return num;
-  }
 
-  //----------------------------------------------------------------------
-  // Internals only below this point
-  //
+    public int addExtensionsOfSymbols2Buffer(StringBuilder buf, String sep, String first, Collection<String> col) {
+        BuildStaticGLInfo glInfo = getGLConfig().getGLInfo();
+        if (null == glInfo) {
+            throw new RuntimeException("No GLInfo for: " + first);
+        }
+        int num = 0;
+        if (null == buf) {
+            buf = new StringBuilder();
+        }
+        String extensionName;
+
+        Iterator<String> iter = col.iterator();
+        if (null != first) {
+            extensionName = glInfo.getExtension(first);
+            if (null != extensionName) {
+                buf.append(extensionName);
+                if (iter.hasNext()) {
+                    buf.append(sep);
+                }
+                num++;
+            }
+        }
+        while (iter.hasNext()) {
+            extensionName = glInfo.getExtension(iter.next());
+            if (null != extensionName) {
+                buf.append(extensionName);
+                if (iter.hasNext()) {
+                    buf.append(sep);
+                }
+                num++;
+            }
+        }
+        return num;
+    }
 
-  protected void generateModifiedEmitters(JavaMethodBindingEmitter baseJavaEmitter, List emitters) {
-    List superEmitters = new ArrayList();
-    super.generateModifiedEmitters(baseJavaEmitter, superEmitters);
+    //----------------------------------------------------------------------
+    // Internals only below this point
+    //
+    @Override
+    protected void generateModifiedEmitters(JavaMethodBindingEmitter baseJavaEmitter, List<FunctionEmitter> emitters) {
+        List<FunctionEmitter> superEmitters = new ArrayList<FunctionEmitter>();
+        super.generateModifiedEmitters(baseJavaEmitter, superEmitters);
 
-    // See whether this is one of the Buffer Object variants
-    boolean bufferObjectVariant = bufferObjectMethodBindings.containsKey(baseJavaEmitter.getBinding());
+        // See whether this is one of the Buffer Object variants
+        boolean bufferObjectVariant = bufferObjectMethodBindings.containsKey(baseJavaEmitter.getBinding());
 
-    for (Iterator iter = superEmitters.iterator(); iter.hasNext(); ) {
-        JavaMethodBindingEmitter emitter = (JavaMethodBindingEmitter) iter.next();
-        if (emitter instanceof ProcAddressJavaMethodBindingEmitter) {
-          emitter = new GLJavaMethodBindingEmitter((ProcAddressJavaMethodBindingEmitter) emitter, this, bufferObjectVariant);
+        for (FunctionEmitter emitter : superEmitters) {
+            if (emitter instanceof ProcAddressJavaMethodBindingEmitter) {
+                emitter = new GLJavaMethodBindingEmitter((ProcAddressJavaMethodBindingEmitter) emitter, this, bufferObjectVariant);
+            }
+            emitters.add(emitter);
         }
-        emitters.add(emitter);
     }
-  }
-
-  protected boolean needsBufferObjectVariant(FunctionSymbol sym) {
-    return getGLConfig().isBufferObjectFunction(sym.getName());
-  }
-  
-  protected GLConfiguration getGLConfig() {
-    return (GLConfiguration) getConfig();
-  }
-
-  protected void endProcAddressTable() throws Exception
-  {
-    PrintWriter w = tableWriter;
-
-    w.println("  /**");
-    w.println("   * This is a convenience method to get (by name) the native function");
-    w.println("   * pointer for a given function. It lets you avoid having to");
-    w.println("   * manually compute the &quot;" + PROCADDRESS_VAR_PREFIX + " + ");
-    w.println("   * &lt;functionName&gt;&quot; member variable name and look it up via");
-    w.println("   * reflection; it also will throw an exception if you try to get the");
-    w.println("   * address of an unknown function, or one that is statically linked");
-    w.println("   * and therefore does not have a function pointer in this table.");
-    w.println("   *");
-    w.println("   * @throws RuntimeException if the function pointer was not found in");
-    w.println("   *   this table, either because the function was unknown or because");
-    w.println("   *   it was statically linked.");
-    w.println("   */");
-    w.println("  public long getAddressFor(String functionNameUsr) {");
-    w.println("    String functionNameBase = com.jogamp.gluegen.runtime.opengl.GLExtensionNames.normalizeVEN(com.jogamp.gluegen.runtime.opengl.GLExtensionNames.normalizeARB(functionNameUsr, true), true);");
-    w.println("    String addressFieldNameBase = " + getProcAddressConfig().gluegenRuntimePackage() + ".ProcAddressHelper.PROCADDRESS_VAR_PREFIX + functionNameBase;");
-    w.println("    java.lang.reflect.Field addressField = null;");
-    w.println("    int  funcNamePermNum = com.jogamp.gluegen.runtime.opengl.GLExtensionNames.getFuncNamePermutationNumber(functionNameBase);");
-    w.println("    for(int i = 0; null==addressField && i < funcNamePermNum; i++) {");
-    w.println("        String addressFieldName = com.jogamp.gluegen.runtime.opengl.GLExtensionNames.getFuncNamePermutation(addressFieldNameBase, i);");
-    w.println("        try {");
-    w.println("          addressField = getClass().getField(addressFieldName);");
-    w.println("        } catch (Exception e) { }");
-    w.println("    }");
-    w.println("");
-    w.println("    if(null==addressField) {");
-    w.println("      // The user is calling a bogus function or one which is not");
-    w.println("      // runtime linked");
-    w.println("      throw new RuntimeException(");
-    w.println("          \"WARNING: Address field query failed for \\\"\" + functionNameBase + \"\\\"/\\\"\" + functionNameUsr +");
-    w.println("          \"\\\"; it's either statically linked or address field is not a known \" +");
-    w.println("          \"function\");");
-    w.println("    } ");
-    w.println("    try {");
-    w.println("      return addressField.getLong(this);");
-    w.println("    } catch (Exception e) {");
-    w.println("      throw new RuntimeException(");
-    w.println("          \"WARNING: Address query failed for \\\"\" + functionNameBase + \"\\\"/\\\"\" + functionNameUsr +");
-    w.println("          \"\\\"; it's either statically linked or is not a known \" +");
-    w.println("          \"function\", e);");
-    w.println("    }");
-    w.println("  }");
-
-    w.println("} // end of class " + tableClassName);
-    w.flush();
-    w.close();
-  }
+
+    protected boolean needsBufferObjectVariant(FunctionSymbol sym) {
+        return getGLConfig().isBufferObjectFunction(sym.getName());
+    }
+
+    protected GLConfiguration getGLConfig() {
+        return (GLConfiguration) getConfig();
+    }
+
+    @Override
+    protected void endProcAddressTable() throws Exception {
+        PrintWriter w = tableWriter;
+
+        w.println("  /**");
+        w.println("   * This is a convenience method to get (by name) the native function");
+        w.println("   * pointer for a given function. It lets you avoid having to");
+        w.println("   * manually compute the &quot;" + PROCADDRESS_VAR_PREFIX + " + ");
+        w.println("   * &lt;functionName&gt;&quot; member variable name and look it up via");
+        w.println("   * reflection; it also will throw an exception if you try to get the");
+        w.println("   * address of an unknown function, or one that is statically linked");
+        w.println("   * and therefore does not have a function pointer in this table.");
+        w.println("   *");
+        w.println("   * @throws RuntimeException if the function pointer was not found in");
+        w.println("   *   this table, either because the function was unknown or because");
+        w.println("   *   it was statically linked.");
+        w.println("   */");
+        w.println("  public long getAddressFor(String functionNameUsr) {");
+        w.println("    String functionNameBase = com.jogamp.gluegen.runtime.opengl.GLExtensionNames.normalizeVEN(com.jogamp.gluegen.runtime.opengl.GLExtensionNames.normalizeARB(functionNameUsr, true), true);");
+        w.println("    String addressFieldNameBase = " + getProcAddressConfig().gluegenRuntimePackage() + ".ProcAddressHelper.PROCADDRESS_VAR_PREFIX + functionNameBase;");
+        w.println("    java.lang.reflect.Field addressField = null;");
+        w.println("    int  funcNamePermNum = com.jogamp.gluegen.runtime.opengl.GLExtensionNames.getFuncNamePermutationNumber(functionNameBase);");
+        w.println("    for(int i = 0; null==addressField && i < funcNamePermNum; i++) {");
+        w.println("        String addressFieldName = com.jogamp.gluegen.runtime.opengl.GLExtensionNames.getFuncNamePermutation(addressFieldNameBase, i);");
+        w.println("        try {");
+        w.println("          addressField = getClass().getField(addressFieldName);");
+        w.println("        } catch (Exception e) { }");
+        w.println("    }");
+        w.println("");
+        w.println("    if(null==addressField) {");
+        w.println("      // The user is calling a bogus function or one which is not");
+        w.println("      // runtime linked");
+        w.println("      throw new RuntimeException(");
+        w.println("          \"WARNING: Address field query failed for \\\"\" + functionNameBase + \"\\\"/\\\"\" + functionNameUsr +");
+        w.println("          \"\\\"; it's either statically linked or address field is not a known \" +");
+        w.println("          \"function\");");
+        w.println("    } ");
+        w.println("    try {");
+        w.println("      return addressField.getLong(this);");
+        w.println("    } catch (Exception e) {");
+        w.println("      throw new RuntimeException(");
+        w.println("          \"WARNING: Address query failed for \\\"\" + functionNameBase + \"\\\"/\\\"\" + functionNameUsr +");
+        w.println("          \"\\\"; it's either statically linked or is not a known \" +");
+        w.println("          \"function\", e);");
+        w.println("    }");
+        w.println("  }");
+
+        w.println("} // end of class " + tableClassName);
+        w.flush();
+        w.close();
+    }
 }
diff --git a/src/java/com/sun/gluegen/opengl/GLJavaMethodBindingEmitter.java b/src/java/com/sun/gluegen/opengl/GLJavaMethodBindingEmitter.java
index 33f94fb..51182c1 100755
--- a/src/java/com/sun/gluegen/opengl/GLJavaMethodBindingEmitter.java
+++ b/src/java/com/sun/gluegen/opengl/GLJavaMethodBindingEmitter.java
@@ -36,7 +36,6 @@
  * Sun gratefully acknowledges that this software was originally authored
  * and developed by Kenneth Bradley Russell and Christopher John Kline.
  */
-
 package com.sun.gluegen.opengl;
 
 import java.io.*;
@@ -45,89 +44,80 @@ import com.sun.gluegen.cgram.types.*;
 import com.sun.gluegen.procaddress.*;
 
 /** A specialization of the proc address emitter which knows how to
-    change argument names to take into account Vertex Buffer Object /
-    Pixel Buffer Object variants. */
-
+change argument names to take into account Vertex Buffer Object /
+Pixel Buffer Object variants. */
 public class GLJavaMethodBindingEmitter extends ProcAddressJavaMethodBindingEmitter {
-  protected boolean bufferObjectVariant;
-  protected GLEmitter glEmitter;
-  protected CommentEmitter glCommentEmitter = new GLCommentEmitter();
-  
-  public GLJavaMethodBindingEmitter(JavaMethodBindingEmitter methodToWrap,
-                                    boolean callThroughProcAddress,
-                                    String  getProcAddressTableExpr,
-                                    boolean changeNameAndArguments,
-                                    boolean bufferObjectVariant,
-                                    GLEmitter emitter) {
-    super(methodToWrap,
-          callThroughProcAddress,
-          getProcAddressTableExpr,
-          changeNameAndArguments,
-          emitter);
-    this.bufferObjectVariant = bufferObjectVariant;
-    this.glEmitter=emitter;
-    setCommentEmitter(glCommentEmitter);
-  }
-
-  public GLJavaMethodBindingEmitter(ProcAddressJavaMethodBindingEmitter methodToWrap,
-                                    GLEmitter emitter,
-                                    boolean bufferObjectVariant) {
-    super(methodToWrap);
-    this.bufferObjectVariant = bufferObjectVariant;
-    this.glEmitter=emitter;
-    setCommentEmitter(glCommentEmitter);
-  }
-
-  public GLJavaMethodBindingEmitter(GLJavaMethodBindingEmitter methodToWrap) {
-    this(methodToWrap, methodToWrap.glEmitter, methodToWrap.bufferObjectVariant);
-  }
-
-  @Override
-  protected String getArgumentName(int i) {
-    String name = super.getArgumentName(i);
-
-    if (!bufferObjectVariant) {
-      return name;
+
+    protected boolean bufferObjectVariant;
+    protected GLEmitter glEmitter;
+    protected CommentEmitter glCommentEmitter = new GLCommentEmitter();
+
+    public GLJavaMethodBindingEmitter(JavaMethodBindingEmitter methodToWrap, boolean callThroughProcAddress,
+            String getProcAddressTableExpr, boolean changeNameAndArguments, boolean bufferObjectVariant, GLEmitter emitter) {
+
+        super(methodToWrap, callThroughProcAddress, getProcAddressTableExpr, changeNameAndArguments, emitter);
+        this.bufferObjectVariant = bufferObjectVariant;
+        this.glEmitter = emitter;
+        setCommentEmitter(glCommentEmitter);
     }
 
-    // Emitters for VBO/PBO-related routines change the outgoing
-    // argument name for the buffer
-    if (binding.getJavaArgumentType(i).isLong()) {
-      Type cType = binding.getCArgumentType(i);
-      if (cType.isPointer() &&
-          (cType.asPointer().getTargetType().isVoid() ||
-           cType.asPointer().getTargetType().isPrimitive())) {
-        return name + "_buffer_offset";
-      }
+    public GLJavaMethodBindingEmitter(ProcAddressJavaMethodBindingEmitter methodToWrap, GLEmitter emitter, boolean bufferObjectVariant) {
+        super(methodToWrap);
+        this.bufferObjectVariant = bufferObjectVariant;
+        this.glEmitter = emitter;
+        setCommentEmitter(glCommentEmitter);
     }
 
-    return name;
-  }
+    public GLJavaMethodBindingEmitter(GLJavaMethodBindingEmitter methodToWrap) {
+        this(methodToWrap, methodToWrap.glEmitter, methodToWrap.bufferObjectVariant);
+    }
 
-  protected class GLCommentEmitter extends JavaMethodBindingEmitter.DefaultCommentEmitter  {
-      
     @Override
-    protected void emitBindingCSignature(MethodBinding binding, PrintWriter writer) {      
-      super.emitBindingCSignature(binding, writer);
-
-      String symbolRenamed = binding.getName();
-      StringBuffer newComment = new StringBuffer();
-      newComment.append("<br>Part of <code>");
-      if(0==glEmitter.addExtensionsOfSymbols2Buffer(newComment, ", ", symbolRenamed, binding.getAliasedNames())) {
-          if(glEmitter.getGLConfig().getAllowNonGLExtensions()) {
-              newComment.append("CORE FUNC");
-          } else {
-              StringBuffer sb = new StringBuffer();
-              JavaEmitter.addStrings2Buffer(sb, ", ", symbolRenamed, binding.getAliasedNames());
-              RuntimeException ex = new RuntimeException("Couldn't find extension to: "+binding+" ; "+sb.toString());
-              ex.printStackTrace();
-              glEmitter.getGLConfig().getGLInfo().dump();
-              // glEmitter.getGLConfig().dumpRenames();
-              throw ex;
-          }
-      }
-      newComment.append("</code>");
-      writer.print(newComment.toString());
+    protected String getArgumentName(int i) {
+        String name = super.getArgumentName(i);
+
+        if (!bufferObjectVariant) {
+            return name;
+        }
+
+        // Emitters for VBO/PBO-related routines change the outgoing
+        // argument name for the buffer
+        if (binding.getJavaArgumentType(i).isLong()) {
+            Type cType = binding.getCArgumentType(i);
+            Type targetType = cType.asPointer().getTargetType();
+            if (cType.isPointer() && (targetType.isVoid() || targetType.isPrimitive())) {
+                return name + "_buffer_offset";
+            }
+        }
+
+        return name;
+    }
+
+    protected class GLCommentEmitter extends JavaMethodBindingEmitter.DefaultCommentEmitter {
+
+        @Override
+        protected void emitBindingCSignature(MethodBinding binding, PrintWriter writer) {
+
+            super.emitBindingCSignature(binding, writer);
+
+            String symbolRenamed = binding.getName();
+            StringBuilder newComment = new StringBuilder();
+
+            newComment.append("<br>Part of <code>");
+            if (0 == glEmitter.addExtensionsOfSymbols2Buffer(newComment, ", ", symbolRenamed, binding.getAliasedNames())) {
+                if (glEmitter.getGLConfig().getAllowNonGLExtensions()) {
+                    newComment.append("CORE FUNC");
+                } else {
+                    StringBuilder sb = new StringBuilder();
+                    JavaEmitter.addStrings2Buffer(sb, ", ", symbolRenamed, binding.getAliasedNames());
+                    RuntimeException ex = new RuntimeException("Couldn't find extension to: " + binding + " ; " + sb.toString());
+                    glEmitter.getGLConfig().getGLInfo().dump();
+                    // glEmitter.getGLConfig().dumpRenames();
+                    throw ex;
+                }
+            }
+            newComment.append("</code>");
+            writer.print(newComment.toString());
+        }
     }
-  }
 }
diff --git a/src/java/com/sun/gluegen/procaddress/ProcAddressCMethodBindingEmitter.java b/src/java/com/sun/gluegen/procaddress/ProcAddressCMethodBindingEmitter.java
index b7fac1b..a951c42 100755
--- a/src/java/com/sun/gluegen/procaddress/ProcAddressCMethodBindingEmitter.java
+++ b/src/java/com/sun/gluegen/procaddress/ProcAddressCMethodBindingEmitter.java
@@ -40,165 +40,170 @@
 package com.sun.gluegen.procaddress;
 
 import java.io.*;
-import java.util.*;
 import com.sun.gluegen.*;
 import com.sun.gluegen.cgram.types.*;
 
 public class ProcAddressCMethodBindingEmitter extends CMethodBindingEmitter {
+
   private boolean callThroughProcAddress;
   private boolean needsLocalTypedef;
+
   private String localTypedefCallingConvention;
-  private static String procAddressJavaTypeName =
-    JavaType.createForClass(Long.TYPE).jniTypeName();
+
+  private static final String procAddressJavaTypeName = JavaType.createForClass(Long.TYPE).jniTypeName();
   private ProcAddressEmitter emitter;
 
-  public ProcAddressCMethodBindingEmitter(CMethodBindingEmitter methodToWrap,
-                                          final boolean callThroughProcAddress,
-                                          boolean needsLocalTypedef,
-                                          String localTypedefCallingConvention,
-                                          ProcAddressEmitter emitter) {
-    super(
-      new MethodBinding(methodToWrap.getBinding()) {
-        public String getName() {
-          if (callThroughProcAddress) {
-            return ProcAddressEmitter.WRAP_PREFIX + super.getName();
-          } else {
-            return super.getName();
-          }
+  public ProcAddressCMethodBindingEmitter(CMethodBindingEmitter methodToWrap, final boolean callThroughProcAddress,
+                          boolean needsLocalTypedef, String localTypedefCallingConvention, ProcAddressEmitter emitter) {
+        
+        super(
+                new MethodBinding(methodToWrap.getBinding()) {
+                    @Override
+                    public String getName() {
+                        if (callThroughProcAddress) {
+                            return ProcAddressEmitter.WRAP_PREFIX + super.getName();
+                        } else {
+                            return super.getName();
+                        }
+                    }
+                },
+                methodToWrap.getDefaultOutput(),
+                methodToWrap.getJavaPackageName(),
+                methodToWrap.getJavaClassName(),
+                methodToWrap.getIsOverloadedBinding(),
+                methodToWrap.getIsJavaMethodStatic(),
+                true,
+                methodToWrap.forIndirectBufferAndArrayImplementation(),
+                methodToWrap.getMachineDescription()
+        );
+
+        if (methodToWrap.getReturnValueCapacityExpression() != null) {
+            setReturnValueCapacityExpression(methodToWrap.getReturnValueCapacityExpression());
         }
-      },
-      methodToWrap.getDefaultOutput(),
-      methodToWrap.getJavaPackageName(),
-      methodToWrap.getJavaClassName(),
-      methodToWrap.getIsOverloadedBinding(),
-      methodToWrap.getIsJavaMethodStatic(),
-      true,
-      methodToWrap.forIndirectBufferAndArrayImplementation(),
-      methodToWrap.getMachineDescription()
-    );
-
-    if (methodToWrap.getReturnValueCapacityExpression() != null) {
-      setReturnValueCapacityExpression(methodToWrap.getReturnValueCapacityExpression());
-    }
-    if (methodToWrap.getReturnValueLengthExpression() != null) {
-      setReturnValueLengthExpression(methodToWrap.getReturnValueLengthExpression());
+        if (methodToWrap.getReturnValueLengthExpression() != null) {
+            setReturnValueLengthExpression(methodToWrap.getReturnValueLengthExpression());
+        }
+        setTemporaryCVariableDeclarations(methodToWrap.getTemporaryCVariableDeclarations());
+        setTemporaryCVariableAssignments(methodToWrap.getTemporaryCVariableAssignments());
+
+        setCommentEmitter(defaultCommentEmitter);
+
+        this.callThroughProcAddress = callThroughProcAddress;
+        this.needsLocalTypedef = needsLocalTypedef;
+        this.localTypedefCallingConvention = localTypedefCallingConvention;
+        this.emitter = emitter;
     }
-    setTemporaryCVariableDeclarations(methodToWrap.getTemporaryCVariableDeclarations());
-    setTemporaryCVariableAssignments (methodToWrap.getTemporaryCVariableAssignments ());
-    
-    setCommentEmitter(defaultCommentEmitter);
-    this.callThroughProcAddress = callThroughProcAddress;
-    this.needsLocalTypedef = needsLocalTypedef;
-    this.localTypedefCallingConvention = localTypedefCallingConvention;
-    this.emitter = emitter;
-  }
-  
-  protected int emitArguments(PrintWriter writer) {
-    int numEmitted = super.emitArguments(writer);
-    if (callThroughProcAddress) {
-      if (numEmitted > 0)
-        {
-          writer.print(", ");
+
+    @Override
+    protected int emitArguments(PrintWriter writer) {
+        int numEmitted = super.emitArguments(writer);
+        if (callThroughProcAddress) {
+            if (numEmitted > 0) {
+                writer.print(", ");
+            }
+            writer.print(procAddressJavaTypeName);
+            writer.print(" procAddress");
+            ++numEmitted;
         }
-      writer.print(procAddressJavaTypeName);
-      writer.print(" procAddress");
-      ++numEmitted;
+
+        return numEmitted;
     }
 
-    return numEmitted;
-  }
-
-  protected void emitBodyVariableDeclarations(PrintWriter writer) {
-    if (callThroughProcAddress) {
-      // create variable for the function pointer with the right type, and set
-      // it to the value of the passed-in proc address
-      FunctionSymbol cSym = getBinding().getCSymbol();
-      String funcPointerTypedefName =
-        emitter.getFunctionPointerTypedefName(cSym);
-
-      if (needsLocalTypedef) {
-        // We (probably) didn't get a typedef for this function
-        // pointer type in the header file; the user requested that we
-        // forcibly generate one. Here we force the emission of one.
-        PointerType funcPtrType = new PointerType(null, cSym.getType(), 0);
-        // Just for safety, emit this name slightly differently than
-        // the mangling would otherwise produce
-        funcPointerTypedefName = "_local_" + funcPointerTypedefName;
-
-        writer.print("  typedef ");
-        writer.print(funcPtrType.toString(funcPointerTypedefName, localTypedefCallingConvention));
-        writer.println(";");
-      }
-    
-      writer.print("  ");
-      writer.print(funcPointerTypedefName);
-      writer.print(" ptr_");
-      writer.print(cSym.getName());
-      writer.println(";");
+    @Override
+    protected void emitBodyVariableDeclarations(PrintWriter writer) {
+        if (callThroughProcAddress) {
+            // create variable for the function pointer with the right type, and set
+            // it to the value of the passed-in proc address
+            FunctionSymbol cSym = getBinding().getCSymbol();
+            String funcPointerTypedefName =
+                    emitter.getFunctionPointerTypedefName(cSym);
+
+            if (needsLocalTypedef) {
+                // We (probably) didn't get a typedef for this function
+                // pointer type in the header file; the user requested that we
+                // forcibly generate one. Here we force the emission of one.
+                PointerType funcPtrType = new PointerType(null, cSym.getType(), 0);
+                // Just for safety, emit this name slightly differently than
+                // the mangling would otherwise produce
+                funcPointerTypedefName = "_local_" + funcPointerTypedefName;
+
+                writer.print("  typedef ");
+                writer.print(funcPtrType.toString(funcPointerTypedefName, localTypedefCallingConvention));
+                writer.println(";");
+            }
+
+            writer.print("  ");
+            writer.print(funcPointerTypedefName);
+            writer.print(" ptr_");
+            writer.print(cSym.getName());
+            writer.println(";");
+        }
+
+        super.emitBodyVariableDeclarations(writer);
     }
 
-    super.emitBodyVariableDeclarations(writer);
-  }
+    @Override
+    protected void emitBodyVariablePreCallSetup(PrintWriter writer) {
+        super.emitBodyVariablePreCallSetup(writer);
 
-  protected void emitBodyVariablePreCallSetup(PrintWriter writer) {
-    super.emitBodyVariablePreCallSetup(writer);
+        if (callThroughProcAddress) {
+            // set the function pointer to the value of the passed-in procAddress
+            FunctionSymbol cSym = getBinding().getCSymbol();
+            String funcPointerTypedefName = emitter.getFunctionPointerTypedefName(cSym);
+            if (needsLocalTypedef) {
+                funcPointerTypedefName = "_local_" + funcPointerTypedefName;
+            }
 
-    if (callThroughProcAddress) {
-        // set the function pointer to the value of the passed-in procAddress
-        FunctionSymbol cSym = getBinding().getCSymbol();
-        String funcPointerTypedefName = emitter.getFunctionPointerTypedefName(cSym);
-        if (needsLocalTypedef) {
-            funcPointerTypedefName = "_local_" + funcPointerTypedefName;
-        }
+            String ptrVarName = "ptr_" + cSym.getName();
 
-        String ptrVarName = "ptr_" + cSym.getName();
-    
-        writer.print("  ");
-        writer.print(ptrVarName);
-        writer.print(" = (");
-        writer.print(funcPointerTypedefName);
-        writer.println(") (intptr_t) procAddress;");
+            writer.print("  ");
+            writer.print(ptrVarName);
+            writer.print(" = (");
+            writer.print(funcPointerTypedefName);
+            writer.println(") (intptr_t) procAddress;");
 
-        writer.println("  assert(" + ptrVarName + " != NULL);");
+            writer.println("  assert(" + ptrVarName + " != NULL);");
+        }
     }
-  }
-
-  protected void emitBodyCallCFunction(PrintWriter writer) {
-    if (!callThroughProcAddress) {
-      super.emitBodyCallCFunction(writer);
-    } else {
-      // Make the call to the actual C function
-      writer.print("  ");
-
-      // WARNING: this code assumes that the return type has already been
-      // typedef-resolved.
-      Type cReturnType = binding.getCReturnType();
-
-      if (!cReturnType.isVoid()) {
-        writer.print("_res = ");
-      }
-      MethodBinding binding = getBinding();
-      if (binding.hasContainingType()) {
-        // FIXME: this can and should be handled and unified with the
-        // associated code in the CMethodBindingEmitter
-        throw new IllegalStateException("Cannot call through function pointer because binding has containing type: " + binding);
-      }
-
-      // call throught the run-time function pointer
-      writer.print("(* ptr_");
-      writer.print(binding.getCSymbol().getName());
-      writer.print(") ");
-      writer.print("(");
-      emitBodyPassCArguments(writer);
-      writer.println(");");
+
+    @Override
+    protected void emitBodyCallCFunction(PrintWriter writer) {
+        if (!callThroughProcAddress) {
+            super.emitBodyCallCFunction(writer);
+        } else {
+            // Make the call to the actual C function
+            writer.print("  ");
+
+            // WARNING: this code assumes that the return type has already been
+            // typedef-resolved.
+            Type cReturnType = binding.getCReturnType();
+
+            if (!cReturnType.isVoid()) {
+                writer.print("_res = ");
+            }
+            MethodBinding mBinding = getBinding();
+            if (mBinding.hasContainingType()) {
+                // FIXME: this can and should be handled and unified with the
+                // associated code in the CMethodBindingEmitter
+                throw new IllegalStateException("Cannot call through function pointer because binding has containing type: " + mBinding);
+            }
+
+            // call throught the run-time function pointer
+            writer.print("(* ptr_");
+            writer.print(mBinding.getCSymbol().getName());
+            writer.print(") ");
+            writer.print("(");
+            emitBodyPassCArguments(writer);
+            writer.println(");");
+        }
     }
-  }
 
-  protected String jniMangle(MethodBinding binding) {
-    StringBuffer buf = new StringBuffer(super.jniMangle(binding));
-    if (callThroughProcAddress) {
-      jniMangle(Long.TYPE, buf, false);  // to account for the additional _addr_ parameter
+    @Override
+    protected String jniMangle(MethodBinding binding) {
+        StringBuffer buf = new StringBuffer(super.jniMangle(binding));
+        if (callThroughProcAddress) {
+            jniMangle(Long.TYPE, buf, false);  // to account for the additional _addr_ parameter
+        }
+        return buf.toString();
     }
-    return buf.toString();
-  }
 }
diff --git a/src/java/com/sun/gluegen/procaddress/ProcAddressConfiguration.java b/src/java/com/sun/gluegen/procaddress/ProcAddressConfiguration.java
index 9409a1e..993f917 100755
--- a/src/java/com/sun/gluegen/procaddress/ProcAddressConfiguration.java
+++ b/src/java/com/sun/gluegen/procaddress/ProcAddressConfiguration.java
@@ -36,7 +36,6 @@
  * Sun gratefully acknowledges that this software was originally authored
  * and developed by Kenneth Bradley Russell and Christopher John Kline.
  */
-
 package com.sun.gluegen.procaddress;
 
 import java.io.*;
@@ -45,262 +44,279 @@ import java.util.*;
 
 import com.sun.gluegen.*;
 
-public class ProcAddressConfiguration extends JavaConfiguration
-{
-  private boolean emitProcAddressTable = false;
-  private String  tableClassPackage;
-  private String  tableClassName = "ProcAddressTable";
-  private Set/*<String>*/ skipProcAddressGen  = new HashSet();
-  private List/*<String>*/ forceProcAddressGen  = new ArrayList();
-  private Set/*<String>*/ forceProcAddressGenSet = new HashSet();
-  private boolean forceProcAddressGen4All=false;
-  private String  getProcAddressTableExpr;
-  private ConvNode procAddressNameConverter;
-  // This is needed only on Windows. Ideally we would modify the
-  // HeaderParser and PCPP to automatically pick up the calling
-  // convention from the headers
-  private Map/*<String,String>*/ localProcAddressCallingConventionMap = new HashMap();
-  private String localProcAddressCallingConvention4All=null;
-
-  protected void dispatch(String cmd, StringTokenizer tok, File file, String filename, int lineNo) throws IOException {
-    if (cmd.equalsIgnoreCase("EmitProcAddressTable"))
-      {
-        emitProcAddressTable =
-          readBoolean("EmitProcAddressTable", tok, filename, lineNo).booleanValue();
-      }
-    else if (cmd.equalsIgnoreCase("ProcAddressTablePackage"))
-      {
-        tableClassPackage = readString("ProcAddressTablePackage", tok, filename, lineNo);
-      }
-    else if (cmd.equalsIgnoreCase("ProcAddressTableClassName"))
-      {
-        tableClassName = readString("ProcAddressTableClassName", tok, filename, lineNo);
-      }
-    else if (cmd.equalsIgnoreCase("SkipProcAddressGen"))
-      {
-        String sym = readString("SkipProcAddressGen", tok, filename, lineNo);
-        skipProcAddressGen.add(sym);
-      }
-    else if (cmd.equalsIgnoreCase("ForceProcAddressGen"))
-      {
-        String funcName = readString("ForceProcAddressGen", tok, filename, lineNo);
-        if(funcName.equals("__ALL__")) {
-            forceProcAddressGen4All=true;
+public class ProcAddressConfiguration extends JavaConfiguration {
+
+    private boolean emitProcAddressTable = false;
+    private boolean forceProcAddressGen4All = false;
+
+    private String tableClassPackage;
+    private String tableClassName = "ProcAddressTable";
+    private String getProcAddressTableExpr;
+    private String localProcAddressCallingConvention4All = null;
+
+    private ConvNode procAddressNameConverter;
+    private final Set<String> skipProcAddressGen = new HashSet<String>();
+    private final List<String> forceProcAddressGen = new ArrayList<String>();
+    private final Set<String> forceProcAddressGenSet = new HashSet<String>();
+
+    // This is needed only on Windows. Ideally we would modify the
+    // HeaderParser and PCPP to automatically pick up the calling
+    // convention from the headers
+    private Map<String, String> localProcAddressCallingConventionMap = new HashMap<String, String>();
+
+    @Override
+    protected void dispatch(String cmd, StringTokenizer tok, File file, String filename, int lineNo) throws IOException {
+        if (cmd.equalsIgnoreCase("EmitProcAddressTable")) {
+            emitProcAddressTable = readBoolean("EmitProcAddressTable", tok, filename, lineNo).booleanValue();
+        } else if (cmd.equalsIgnoreCase("ProcAddressTablePackage")) {
+            tableClassPackage = readString("ProcAddressTablePackage", tok, filename, lineNo);
+        } else if (cmd.equalsIgnoreCase("ProcAddressTableClassName")) {
+            tableClassName = readString("ProcAddressTableClassName", tok, filename, lineNo);
+        } else if (cmd.equalsIgnoreCase("SkipProcAddressGen")) {
+            String sym = readString("SkipProcAddressGen", tok, filename, lineNo);
+            skipProcAddressGen.add(sym);
+        } else if (cmd.equalsIgnoreCase("ForceProcAddressGen")) {
+            String funcName = readString("ForceProcAddressGen", tok, filename, lineNo);
+            if (funcName.equals("__ALL__")) {
+                forceProcAddressGen4All = true;
+            } else {
+                addForceProcAddressGen(funcName);
+            }
+        } else if (cmd.equalsIgnoreCase("GetProcAddressTableExpr")) {
+            getProcAddressTableExpr = readGetProcAddressTableExpr(tok, filename, lineNo);
+        } else if (cmd.equalsIgnoreCase("ProcAddressNameExpr")) {
+            readProcAddressNameExpr(tok, filename, lineNo);
+        } else if (cmd.equalsIgnoreCase("LocalProcAddressCallingConvention")) {
+            readLocalProcAddressCallingConvention(tok, filename, lineNo);
         } else {
-            addForceProcAddressGen( funcName );
+            super.dispatch(cmd, tok, file, filename, lineNo);
         }
-      }
-    else if (cmd.equalsIgnoreCase("GetProcAddressTableExpr"))
-      {
-        getProcAddressTableExpr = readGetProcAddressTableExpr(tok, filename, lineNo);
-      }
-    else if (cmd.equalsIgnoreCase("ProcAddressNameExpr"))
-      {
-        readProcAddressNameExpr(tok, filename, lineNo);
-      }
-    else if (cmd.equalsIgnoreCase("LocalProcAddressCallingConvention"))
-      {
-        readLocalProcAddressCallingConvention(tok, filename, lineNo);
-      }
-    else
-      {
-        super.dispatch(cmd,tok,file,filename,lineNo);
-      }
-  }
-
-  protected String readGetProcAddressTableExpr(StringTokenizer tok, String filename, int lineNo) {
-    try {
-      String restOfLine = tok.nextToken("\n\r\f");
-      return restOfLine.trim();
-    } catch (NoSuchElementException e) {
-      throw new RuntimeException("Error parsing \"GetProcAddressTableExpr\" command at line " + lineNo +
-                                 " in file \"" + filename + "\"", e);
     }
-  }
-
-  protected void setProcAddressNameExpr(String expr) {
-    // Parse this into something allowing us to map from a function
-    // name to the typedef'ed function pointer name
-    List/*<String>*/ tokens = new ArrayList/*<String>*/();
-    StringTokenizer tok1 = new StringTokenizer(expr);
-    while (tok1.hasMoreTokens()) {
-      String sstr = tok1.nextToken();
-      StringTokenizer tok2 = new StringTokenizer(sstr, "$()", true);
-      while (tok2.hasMoreTokens()) {
-        tokens.add(tok2.nextToken());
-      }
+
+    protected String readGetProcAddressTableExpr(StringTokenizer tok, String filename, int lineNo) {
+        try {
+            String restOfLine = tok.nextToken("\n\r\f");
+            return restOfLine.trim();
+        } catch (NoSuchElementException e) {
+            throw new RuntimeException("Error parsing \"GetProcAddressTableExpr\" command at line " + lineNo
+                    + " in file \"" + filename + "\"", e);
+        }
     }
 
-    // Now that the string is flattened out, convert it to nodes
-    procAddressNameConverter = makeConverter(tokens.iterator());
-    if (procAddressNameConverter == null) {
-      throw new NoSuchElementException("Error creating converter from string");
+    protected void setProcAddressNameExpr(String expr) {
+        // Parse this into something allowing us to map from a function
+        // name to the typedef'ed function pointer name
+        List<String> tokens = new ArrayList<String>();
+        StringTokenizer tok1 = new StringTokenizer(expr);
+        while (tok1.hasMoreTokens()) {
+            String sstr = tok1.nextToken();
+            StringTokenizer tok2 = new StringTokenizer(sstr, "$()", true);
+            while (tok2.hasMoreTokens()) {
+                tokens.add(tok2.nextToken());
+            }
+        }
+
+        // Now that the string is flattened out, convert it to nodes
+        procAddressNameConverter = makeConverter(tokens.iterator());
+        if (procAddressNameConverter == null) {
+            throw new NoSuchElementException("Error creating converter from string");
+        }
     }
-  }
-
-  protected void readProcAddressNameExpr(StringTokenizer tok, String filename, int lineNo) {
-    try {
-      String restOfLine = tok.nextToken("\n\r\f");
-      restOfLine = restOfLine.trim();
-      setProcAddressNameExpr(restOfLine);
-    } catch (NoSuchElementException e) {
-      throw new RuntimeException("Error parsing \"ProcAddressNameExpr\" command at line " + lineNo +
-                                 " in file \"" + filename + "\"", e);
+
+    protected void readProcAddressNameExpr(StringTokenizer tok, String filename, int lineNo) {
+        try {
+            String restOfLine = tok.nextToken("\n\r\f");
+            restOfLine = restOfLine.trim();
+            setProcAddressNameExpr(restOfLine);
+        } catch (NoSuchElementException e) {
+            throw new RuntimeException("Error parsing \"ProcAddressNameExpr\" command at line " + lineNo
+                    + " in file \"" + filename + "\"", e);
+        }
     }
-  }
-
-  protected void readLocalProcAddressCallingConvention(StringTokenizer tok, String filename, int lineNo) throws IOException {
-    try {
-      String functionName = tok.nextToken();
-      String callingConvention = tok.nextToken();
-      if(functionName.equals("__ALL__")) {
-        localProcAddressCallingConvention4All=callingConvention;
-      } else {
-        localProcAddressCallingConventionMap.put(functionName, callingConvention);
-      }
-    } catch (NoSuchElementException e) {
-      throw new RuntimeException("Error parsing \"LocalProcAddressCallingConvention\" command at line " + lineNo +
-        " in file \"" + filename + "\"", e);
+
+    protected void readLocalProcAddressCallingConvention(StringTokenizer tok, String filename, int lineNo) throws IOException {
+        try {
+            String functionName = tok.nextToken();
+            String callingConvention = tok.nextToken();
+            if (functionName.equals("__ALL__")) {
+                localProcAddressCallingConvention4All = callingConvention;
+            } else {
+                localProcAddressCallingConventionMap.put(functionName, callingConvention);
+            }
+        } catch (NoSuchElementException e) {
+            throw new RuntimeException("Error parsing \"LocalProcAddressCallingConvention\" command at line " + lineNo
+                    + " in file \"" + filename + "\"", e);
+        }
     }
-  }
-
-  private static ConvNode makeConverter(Iterator/*<String>*/ iter) {
-    List/*<ConvNode>*/ result = new ArrayList/*<ConvNode>*/();
-    while (iter.hasNext()) {
-      String str = (String) iter.next();
-      if (str.equals("$")) {
-        String command = (String) iter.next();
-        String openParen = (String) iter.next();
-        if (!openParen.equals("(")) {
-          throw new NoSuchElementException("Expected \"(\"");
+
+    private static ConvNode makeConverter(Iterator<String> iter) {
+        List<ConvNode> result = new ArrayList<ConvNode>();
+
+        while (iter.hasNext()) {
+            String str = iter.next();
+            if (str.equals("$")) {
+                String command = iter.next();
+                String openParen = iter.next();
+                if (!openParen.equals("(")) {
+                    throw new NoSuchElementException("Expected \"(\"");
+                }
+                boolean uppercase = false;
+                if (command.equalsIgnoreCase("UPPERCASE")) {
+                    uppercase = true;
+                } else if (!command.equalsIgnoreCase("LOWERCASE")) {
+                    throw new NoSuchElementException("Unknown ProcAddressNameExpr command \"" + command + "\"");
+                }
+                result.add(new CaseNode(uppercase, makeConverter(iter)));
+            } else if (str.equals(")")) {
+                // Fall through and return
+            } else if (str.indexOf('{') >= 0) {
+                result.add(new FormatNode(str));
+            } else {
+                result.add(new ConstStringNode(str));
+            }
         }
-        boolean uppercase = false;
-        if (command.equalsIgnoreCase("UPPERCASE")) {
-          uppercase = true;
-        } else if (!command.equalsIgnoreCase("LOWERCASE")) {
-          throw new NoSuchElementException("Unknown ProcAddressNameExpr command \"" + command + "\"");
+        if (result.isEmpty()) {
+            return null;
+        } else if (result.size() == 1) {
+            return result.get(0);
+        } else {
+            return new ConcatNode(result);
         }
-        result.add(new CaseNode(uppercase, makeConverter(iter)));
-      } else if (str.equals(")")) {
-        // Fall through and return
-      } else if (str.indexOf('{') >= 0) {
-        result.add(new FormatNode(str));
-      } else {
-        result.add(new ConstStringNode(str));
-      }
     }
-    if (result.size() == 0) {
-      return null;
-    } else if (result.size() == 1) {
-      return (ConvNode) result.get(0);
-    } else {
-      return new ConcatNode(result);
+
+    /** Helper class for converting a function name to the typedef'ed
+    function pointer name */
+    static abstract class ConvNode {
+        abstract String convert(String funcName);
     }
-  }
 
-  /** Helper class for converting a function name to the typedef'ed
-      function pointer name */
-  static abstract class ConvNode {
-    abstract String convert(String funcName);
-  }
+    static class FormatNode extends ConvNode {
+
+        private MessageFormat msgFmt;
 
-  static class FormatNode extends ConvNode {
-    private MessageFormat msgFmt;
+        FormatNode(String fmt) {
+            msgFmt = new MessageFormat(fmt);
+        }
 
-    FormatNode(String fmt) {
-      msgFmt = new MessageFormat(fmt);
+        String convert(String funcName) {
+            StringBuffer buf = new StringBuffer();
+            msgFmt.format(new Object[]{funcName}, buf, null);
+            return buf.toString();
+        }
     }
 
-    String convert(String funcName) {
-      StringBuffer buf = new StringBuffer();
-      msgFmt.format(new Object[] { funcName }, buf, null);
-      return buf.toString();
+    static class ConstStringNode extends ConvNode {
+
+        private String str;
+
+        ConstStringNode(String str) {
+            this.str = str;
+        }
+
+        String convert(String funcName) {
+            return str;
+        }
     }
-  }
 
-  static class ConstStringNode extends ConvNode {
-    private String str;
+    static class ConcatNode extends ConvNode {
 
-    ConstStringNode(String str) {
-      this.str = str;
+        private List<ConvNode> children;
+
+        ConcatNode(List<ConvNode> children) {
+            this.children = children;
+        }
+
+        String convert(String funcName) {
+            StringBuilder res = new StringBuilder();
+            for (ConvNode node : children) {
+                res.append(node.convert(funcName));
+            }
+            return res.toString();
+        }
     }
 
-    String convert(String funcName) {
-      return str;
+    static class CaseNode extends ConvNode {
+
+        private boolean upperCase;
+        private ConvNode child;
+
+        CaseNode(boolean upperCase, ConvNode child) {
+            this.upperCase = upperCase;
+            this.child = child;
+        }
+
+        public String convert(String funcName) {
+            if (upperCase) {
+                return child.convert(funcName).toUpperCase();
+            } else {
+                return child.convert(funcName).toLowerCase();
+            }
+        }
     }
-  }
 
-  static class ConcatNode extends ConvNode {
-    private List/*<ConvNode>*/ children;
+    public boolean emitProcAddressTable() {
+        return emitProcAddressTable;
+    }
 
-    ConcatNode(List/*<ConvNode>*/ children) {
-      this.children = children;
+    public String tableClassPackage() {
+        return tableClassPackage;
     }
 
-    String convert(String funcName) {
-      StringBuffer res = new StringBuffer();
-      for (Iterator iter = children.iterator(); iter.hasNext(); ) {
-        ConvNode node = (ConvNode) iter.next();
-        res.append(node.convert(funcName));
-      }
-      return res.toString();
+    public String tableClassName() {
+        return tableClassName;
     }
-  }
 
-  static class CaseNode extends ConvNode {
-    private boolean upperCase;
-    private ConvNode child;
+    public boolean skipProcAddressGen(String name) {
+        return skipProcAddressGen.contains(name);
+    }
 
-    CaseNode(boolean upperCase, ConvNode child) {
-      this.upperCase = upperCase;
-      this.child = child;
+    public boolean isForceProcAddressGen4All() {
+        return forceProcAddressGen4All;
     }
 
-    public String convert(String funcName) {
-      if (upperCase) {
-        return child.convert(funcName).toUpperCase();
-      } else {
-        return child.convert(funcName).toLowerCase();
-      }
+    public List<String> getForceProcAddressGen() {
+        return forceProcAddressGen;
     }
-  }
-
-  public boolean emitProcAddressTable()           { return emitProcAddressTable;               }
-  public String  tableClassPackage()              { return tableClassPackage;                  }
-  public String  tableClassName()                 { return tableClassName;                     }
-  public boolean skipProcAddressGen (String name) { return skipProcAddressGen.contains(name);  }
-  public boolean isForceProcAddressGen4All()      { return forceProcAddressGen4All;            }
-  public List    getForceProcAddressGen()         { return forceProcAddressGen;                }
-  public String  getProcAddressTableExpr() {
-    if (getProcAddressTableExpr == null) {
-      throw new RuntimeException("GetProcAddressTableExpr was not defined in .cfg file");
+
+    public String getProcAddressTableExpr() {
+        if (getProcAddressTableExpr == null) {
+            throw new RuntimeException("GetProcAddressTableExpr was not defined in .cfg file");
+        }
+        return getProcAddressTableExpr;
     }
-    return getProcAddressTableExpr;
-  }
-  public String  convertToFunctionPointerName(String funcName) {
-    if (procAddressNameConverter == null) {
-      throw new RuntimeException("ProcAddressNameExpr was not defined in .cfg file");
+
+    public String convertToFunctionPointerName(String funcName) {
+        if (procAddressNameConverter == null) {
+            throw new RuntimeException("ProcAddressNameExpr was not defined in .cfg file");
+        }
+        return procAddressNameConverter.convert(funcName);
     }
 
-    return procAddressNameConverter.convert(funcName);
-  }
-  public boolean forceProcAddressGen(String funcName) {
-    return forceProcAddressGen4All || forceProcAddressGenSet.contains(funcName);
-  }
+    public boolean forceProcAddressGen(String funcName) {
+        return forceProcAddressGen4All || forceProcAddressGenSet.contains(funcName);
+    }
 
-  public void addForceProcAddressGen(String funcName) {
+    public void addForceProcAddressGen(String funcName) {
         forceProcAddressGen.add(funcName);
         forceProcAddressGenSet.add(funcName);
-  }
-
-  public void addLocalProcAddressCallingConvention(String funcName, String callingConvention) {
-    localProcAddressCallingConventionMap.put(funcName, callingConvention);
-  }
-
-  public String getLocalProcAddressCallingConvention(String funcName) {
-    if(isLocalProcAddressCallingConvention4All()) return getLocalProcAddressCallingConvention4All();
-    return (String) localProcAddressCallingConventionMap.get(funcName);
-  }
-  public boolean isLocalProcAddressCallingConvention4All()  { return localProcAddressCallingConvention4All!=null; }
-  public String  getLocalProcAddressCallingConvention4All()  { return localProcAddressCallingConvention4All; }
+    }
+
+    public void addLocalProcAddressCallingConvention(String funcName, String callingConvention) {
+        localProcAddressCallingConventionMap.put(funcName, callingConvention);
+    }
+
+    public String getLocalProcAddressCallingConvention(String funcName) {
+        if (isLocalProcAddressCallingConvention4All()) {
+            return getLocalProcAddressCallingConvention4All();
+        }
+        return localProcAddressCallingConventionMap.get(funcName);
+    }
+
+    public boolean isLocalProcAddressCallingConvention4All() {
+        return localProcAddressCallingConvention4All != null;
+    }
+
+    public String getLocalProcAddressCallingConvention4All() {
+        return localProcAddressCallingConvention4All;
+    }
 }
diff --git a/src/java/com/sun/gluegen/procaddress/ProcAddressEmitter.java b/src/java/com/sun/gluegen/procaddress/ProcAddressEmitter.java
index 98ff860..c49e239 100755
--- a/src/java/com/sun/gluegen/procaddress/ProcAddressEmitter.java
+++ b/src/java/com/sun/gluegen/procaddress/ProcAddressEmitter.java
@@ -36,7 +36,6 @@
  * Sun gratefully acknowledges that this software was originally authored
  * and developed by Kenneth Bradley Russell and Christopher John Kline.
  */
-
 package com.sun.gluegen.procaddress;
 
 import java.io.*;
@@ -51,351 +50,334 @@ import com.jogamp.gluegen.runtime.*;
  * and Java code to allow dynamic lookups of the C entry points
  * associated with the Java methods.
  */
-
-public class ProcAddressEmitter extends JavaEmitter
-{
-  public static final String PROCADDRESS_VAR_PREFIX = ProcAddressHelper.PROCADDRESS_VAR_PREFIX;
-  protected static final String WRAP_PREFIX = "dispatch_";
-  private TypeDictionary typedefDictionary;
-  protected PrintWriter tableWriter;
-  protected Set emittedTableEntries;
-  protected String tableClassPackage;
-  protected String tableClassName;
-
-  public void beginFunctions(TypeDictionary typedefDictionary,
-                             TypeDictionary structDictionary,
-                             Map            canonMap) throws Exception
-  {
-    this.typedefDictionary = typedefDictionary;
-
-    if (getProcAddressConfig().emitProcAddressTable())
-    {
-      beginProcAddressTable();
+public class ProcAddressEmitter extends JavaEmitter {
+
+    public static final String PROCADDRESS_VAR_PREFIX = ProcAddressHelper.PROCADDRESS_VAR_PREFIX;
+    protected static final String WRAP_PREFIX = "dispatch_";
+    private TypeDictionary typedefDictionary;
+    protected PrintWriter tableWriter;
+    protected Set<String> emittedTableEntries;
+    protected String tableClassPackage;
+    protected String tableClassName;
+
+    @Override
+    public void beginFunctions(TypeDictionary typedefDictionary, TypeDictionary structDictionary, Map<Type, Type>  canonMap) throws Exception {
+        this.typedefDictionary = typedefDictionary;
+
+        if (getProcAddressConfig().emitProcAddressTable()) {
+            beginProcAddressTable();
+        }
+        super.beginFunctions(typedefDictionary, structDictionary, canonMap);
     }
-    super.beginFunctions(typedefDictionary, structDictionary, canonMap);
-  }
-
-  public void endFunctions() throws Exception
-  {
-    if (getProcAddressConfig().emitProcAddressTable())
-    {
-      endProcAddressTable();
+
+    @Override
+    public void endFunctions() throws Exception {
+        if (getProcAddressConfig().emitProcAddressTable()) {
+            endProcAddressTable();
+        }
+        super.endFunctions();
     }
-    super.endFunctions();
-  }
-  
-  public void beginStructs(TypeDictionary typedefDictionary,
-                           TypeDictionary structDictionary,
-                           Map            canonMap) throws Exception {
-    super.beginStructs(typedefDictionary, structDictionary, canonMap);
-  }
-
-  public String runtimeExceptionType() {
-    return getConfig().runtimeExceptionType();
-  }
-
-  public String unsupportedExceptionType() {
-    return getConfig().unsupportedExceptionType();
-  }
-
-  protected JavaConfiguration createConfig() {
-    return new ProcAddressConfiguration();
-  }
-
-  protected List generateMethodBindingEmitters(HashSet/*<MethodBinding>*/ methodBindingSet, FunctionSymbol sym) throws Exception {
-    return generateMethodBindingEmittersImpl(methodBindingSet, sym);
-  }
-
-  protected boolean needsModifiedEmitters(FunctionSymbol sym) {
-    if (!needsProcAddressWrapper(sym) ||
-        getConfig().isUnimplemented(getAliasedSymName(sym))) {
-      return false;
+
+    @Override
+    public void beginStructs(TypeDictionary typedefDictionary, TypeDictionary structDictionary, Map<Type, Type>  canonMap) throws Exception {
+        super.beginStructs(typedefDictionary, structDictionary, canonMap);
     }
 
-    return true;
-  }
+    public String runtimeExceptionType() {
+        return getConfig().runtimeExceptionType();
+    }
 
-  private List generateMethodBindingEmittersImpl(HashSet/*<MethodBinding>*/ methodBindingSet, FunctionSymbol sym) throws Exception {
-    List defaultEmitters = super.generateMethodBindingEmitters(methodBindingSet, sym);
+    public String unsupportedExceptionType() {
+        return getConfig().unsupportedExceptionType();
+    }
 
-    // if the superclass didn't generate any bindings for the symbol, let's
-    // honor that (for example, the superclass might have caught an Ignore
-    // direction that matched the symbol's name).
-    if (defaultEmitters.isEmpty())
-    {
-      return defaultEmitters;
+    @Override
+    protected JavaConfiguration createConfig() {
+        return new ProcAddressConfiguration();
     }
-    
-    // Don't do anything special if this symbol doesn't require
-    // modifications
-    if (!needsModifiedEmitters(sym))
-    {
-      return defaultEmitters;
+
+    @Override
+    protected List<? extends FunctionEmitter> generateMethodBindingEmitters(Set<MethodBinding> methodBindingSet, FunctionSymbol sym) throws Exception {
+        return generateMethodBindingEmittersImpl(methodBindingSet, sym);
     }
 
-    ArrayList modifiedEmitters = new ArrayList(defaultEmitters.size());
+    protected boolean needsModifiedEmitters(FunctionSymbol sym) {
+        if (!needsProcAddressWrapper(sym)
+                || getConfig().isUnimplemented(getAliasedSymName(sym))) {
+            return false;
+        }
 
-    if (needsProcAddressWrapper(sym)) {
-      if (getProcAddressConfig().emitProcAddressTable()) {
-        // emit an entry in the GL proc address table for this method.
-        emitProcAddressTableEntryForString(getAliasedSymName(sym));
-      }
+        return true;
     }
-    
-    for (Iterator iter = defaultEmitters.iterator(); iter.hasNext(); )
-    {
-      FunctionEmitter emitter = (FunctionEmitter) iter.next();
-      if (emitter instanceof JavaMethodBindingEmitter)
-      {
-        generateModifiedEmitters((JavaMethodBindingEmitter) emitter, modifiedEmitters);
-      }
-      else if (emitter instanceof CMethodBindingEmitter)
-      {
-        generateModifiedEmitters((CMethodBindingEmitter) emitter, modifiedEmitters);
-      }
-      else
-      {
-        throw new RuntimeException("Unexpected emitter type: " +
-                                   emitter.getClass().getName());
-      }
-    }
-    
-    return modifiedEmitters;
-  }
-
-  /**
-   * Returns the name of the typedef for a pointer to the function
-   * represented by the argument as defined by the ProcAddressNameExpr
-   * in the .cfg file. For example, in the OpenGL headers, if the
-   * argument is the function "glFuncName", the value returned will be
-   * "PFNGLFUNCNAMEPROC". This returns a valid string regardless of
-   * whether or not the typedef is actually defined.
-   */
-  protected String getFunctionPointerTypedefName(FunctionSymbol sym) {
-    return getProcAddressConfig().convertToFunctionPointerName(sym.getName());
-  }
-
-  //----------------------------------------------------------------------
-  // Internals only below this point
-  //
-  
-  protected void generateModifiedEmitters(JavaMethodBindingEmitter baseJavaEmitter, List emitters) {
-    if (getConfig().manuallyImplement(baseJavaEmitter.getName())) {
-      // User will provide Java-side implementation of this routine;
-      // pass through any emitters which will produce signatures for
-      // it unmodified
-      emitters.add(baseJavaEmitter);
-      return;
+
+    private List<? extends FunctionEmitter> generateMethodBindingEmittersImpl(Set<MethodBinding> methodBindingSet, FunctionSymbol sym) throws Exception {
+        List<? extends FunctionEmitter> defaultEmitters = super.generateMethodBindingEmitters(methodBindingSet, sym);
+
+        // if the superclass didn't generate any bindings for the symbol, let's
+        // honor that (for example, the superclass might have caught an Ignore
+        // direction that matched the symbol's name).
+        if (defaultEmitters.isEmpty()) {
+            return defaultEmitters;
+        }
+
+        // Don't do anything special if this symbol doesn't require
+        // modifications
+        if (!needsModifiedEmitters(sym)) {
+            return defaultEmitters;
+        }
+
+        ArrayList<FunctionEmitter> modifiedEmitters = new ArrayList<FunctionEmitter>(defaultEmitters.size());
+
+        if (needsProcAddressWrapper(sym)) {
+            if (getProcAddressConfig().emitProcAddressTable()) {
+                // emit an entry in the GL proc address table for this method.
+                emitProcAddressTableEntryForString(getAliasedSymName(sym));
+            }
+        }
+        for (FunctionEmitter emitter : defaultEmitters) {
+            if (emitter instanceof JavaMethodBindingEmitter) {
+                generateModifiedEmitters((JavaMethodBindingEmitter)emitter, modifiedEmitters);
+            } else if (emitter instanceof CMethodBindingEmitter) {
+                generateModifiedEmitters((CMethodBindingEmitter) emitter, modifiedEmitters);
+            } else {
+                throw new RuntimeException("Unexpected emitter type: " + emitter.getClass().getName());
+            }
+        }
+
+        return modifiedEmitters;
     }
-    
-    // See whether we need a proc address entry for this one
-    boolean callThroughProcAddress = needsProcAddressWrapper(baseJavaEmitter.getBinding().getCSymbol());
-
-    ProcAddressJavaMethodBindingEmitter emitter =
-      new ProcAddressJavaMethodBindingEmitter(baseJavaEmitter,
-                                              callThroughProcAddress,
-                                              getProcAddressConfig().getProcAddressTableExpr(),
-                                              baseJavaEmitter.isForImplementingMethodCall(),
-                                              this);
-    emitters.add(emitter);
-
-    // If this emitter doesn't have a body (i.e., is a direct native
-    // call with no intervening argument processing), we need to force
-    // it to emit a body, and produce another one to act as the entry
-    // point
-    // FIXME: the negative test against the PRIVATE modifier is a
-    // nasty hack to prevent the ProcAddressJavaMethodBindingEmitter
-    // from incorrectly introducing method bodies to the private
-    // native implementing methods; want this to work at least for
-    // public and package-private methods
-    if (baseJavaEmitter.signatureOnly() &&
-        !baseJavaEmitter.hasModifier(JavaMethodBindingEmitter.PRIVATE) &&
-        baseJavaEmitter.hasModifier(JavaMethodBindingEmitter.NATIVE) &&
-        callThroughProcAddress) {
-      emitter.setEmitBody(true);
-      emitter.removeModifier(JavaMethodBindingEmitter.NATIVE);
-      emitter = new ProcAddressJavaMethodBindingEmitter(baseJavaEmitter,
-                                                        callThroughProcAddress,
-                                                        getProcAddressConfig().getProcAddressTableExpr(),
-                                                        true,
-                                                        this);
-      emitter.setForImplementingMethodCall(true);
-      emitters.add(emitter);
+
+    /**
+     * Returns the name of the typedef for a pointer to the function
+     * represented by the argument as defined by the ProcAddressNameExpr
+     * in the .cfg file. For example, in the OpenGL headers, if the
+     * argument is the function "glFuncName", the value returned will be
+     * "PFNGLFUNCNAMEPROC". This returns a valid string regardless of
+     * whether or not the typedef is actually defined.
+     */
+    protected String getFunctionPointerTypedefName(FunctionSymbol sym) {
+        return getProcAddressConfig().convertToFunctionPointerName(sym.getName());
     }
-  }
-
-  protected void generateModifiedEmitters(CMethodBindingEmitter baseCEmitter, List emitters)
-  {    
-    // See whether we need a proc address entry for this one
-    boolean callThroughProcAddress = needsProcAddressWrapper(baseCEmitter.getBinding().getCSymbol());
-    boolean forceProcAddress       = getProcAddressConfig().forceProcAddressGen(baseCEmitter.getBinding().getCSymbol().getName());
-    String  forcedCallingConvention = null;
-    if (forceProcAddress) {
-        forcedCallingConvention = getProcAddressConfig().getLocalProcAddressCallingConvention(baseCEmitter.getBinding().getCSymbol().getName());
+
+    //----------------------------------------------------------------------
+    // Internals only below this point
+    //
+
+  protected void generateModifiedEmitters(JavaMethodBindingEmitter baseJavaEmitter, List<FunctionEmitter> emitters) {
+        if (getConfig().manuallyImplement(baseJavaEmitter.getName())) {
+            // User will provide Java-side implementation of this routine;
+            // pass through any emitters which will produce signatures for
+            // it unmodified
+            emitters.add(baseJavaEmitter);
+            return;
+        }
+
+        // See whether we need a proc address entry for this one
+        boolean callThroughProcAddress = needsProcAddressWrapper(baseJavaEmitter.getBinding().getCSymbol());
+
+        ProcAddressJavaMethodBindingEmitter emitter =
+                new ProcAddressJavaMethodBindingEmitter(baseJavaEmitter,
+                callThroughProcAddress,
+                getProcAddressConfig().getProcAddressTableExpr(),
+                baseJavaEmitter.isForImplementingMethodCall(),
+                this);
+        emitters.add(emitter);
+
+        // If this emitter doesn't have a body (i.e., is a direct native
+        // call with no intervening argument processing), we need to force
+        // it to emit a body, and produce another one to act as the entry
+        // point
+        // FIXME: the negative test against the PRIVATE modifier is a
+        // nasty hack to prevent the ProcAddressJavaMethodBindingEmitter
+        // from incorrectly introducing method bodies to the private
+        // native implementing methods; want this to work at least for
+        // public and package-private methods
+        if (baseJavaEmitter.signatureOnly()
+                && !baseJavaEmitter.hasModifier(JavaMethodBindingEmitter.PRIVATE)
+                && baseJavaEmitter.hasModifier(JavaMethodBindingEmitter.NATIVE)
+                && callThroughProcAddress) {
+            emitter.setEmitBody(true);
+            emitter.removeModifier(JavaMethodBindingEmitter.NATIVE);
+            emitter = new ProcAddressJavaMethodBindingEmitter(baseJavaEmitter,
+                    callThroughProcAddress,
+                    getProcAddressConfig().getProcAddressTableExpr(),
+                    true,
+                    this);
+            emitter.setForImplementingMethodCall(true);
+            emitters.add(emitter);
+        }
     }
-    // Note that we don't care much about the naming of the C argument
-    // variables so to keep things simple we ignore the buffer object
-    // property for the binding
-
-    // The C-side JNI binding for this particular function will have an
-    // extra final argument, which is the address (the OpenGL procedure
-    // address) of the function it needs to call
-    ProcAddressCMethodBindingEmitter res = new ProcAddressCMethodBindingEmitter(baseCEmitter,
-                                                                                callThroughProcAddress,
-                                                                                forceProcAddress,
-                                                                                forcedCallingConvention,
-                                                                                this);
-    MessageFormat exp = baseCEmitter.getReturnValueCapacityExpression();
-    if (exp != null) {
-      res.setReturnValueCapacityExpression(exp);
+
+    protected void generateModifiedEmitters(CMethodBindingEmitter baseCEmitter, List<FunctionEmitter> emitters) {
+        // See whether we need a proc address entry for this one
+        boolean callThroughProcAddress = needsProcAddressWrapper(baseCEmitter.getBinding().getCSymbol());
+        boolean forceProcAddress = getProcAddressConfig().forceProcAddressGen(baseCEmitter.getBinding().getCSymbol().getName());
+        String forcedCallingConvention = null;
+        if (forceProcAddress) {
+            forcedCallingConvention = getProcAddressConfig().getLocalProcAddressCallingConvention(baseCEmitter.getBinding().getCSymbol().getName());
+        }
+        // Note that we don't care much about the naming of the C argument
+        // variables so to keep things simple we ignore the buffer object
+        // property for the binding
+
+        // The C-side JNI binding for this particular function will have an
+        // extra final argument, which is the address (the OpenGL procedure
+        // address) of the function it needs to call
+        ProcAddressCMethodBindingEmitter res = new ProcAddressCMethodBindingEmitter(baseCEmitter,
+                callThroughProcAddress,
+                forceProcAddress,
+                forcedCallingConvention,
+                this);
+        MessageFormat exp = baseCEmitter.getReturnValueCapacityExpression();
+        if (exp != null) {
+            res.setReturnValueCapacityExpression(exp);
+        }
+        emitters.add(res);
     }
-    emitters.add(res);
-  }
-    
-  private String getAliasedSymName(FunctionSymbol sym) {
-    String symName = getConfig().getJavaSymbolRename(sym.getName());
-    if(null==symName) symName=sym.getName();
-    return symName;
-  }
-
-  protected boolean needsProcAddressWrapper(FunctionSymbol sym)
-  {
-    String symName = getAliasedSymName(sym);
-
-    ProcAddressConfiguration config = getProcAddressConfig();
-
-    // We should only generate code to call through a function pointer
-    // if the symbol has an associated function pointer typedef.
-    String funcPointerTypedefName = getFunctionPointerTypedefName(sym);
-    boolean shouldWrap = typedefDictionary.containsKey(funcPointerTypedefName);
-    //System.err.println(funcPointerTypedefName + " defined: " + shouldWrap);      
-
-    if (config.skipProcAddressGen(symName)) {
-      shouldWrap = false;
+
+    private String getAliasedSymName(FunctionSymbol sym) {
+        String symName = getConfig().getJavaSymbolRename(sym.getName());
+        if (null == symName) {
+            symName = sym.getName();
+        }
+        return symName;
     }
-    
-    if (config.forceProcAddressGen(symName)) {
-      shouldWrap = true;
+
+    protected boolean needsProcAddressWrapper(FunctionSymbol sym) {
+        String symName = getAliasedSymName(sym);
+
+        ProcAddressConfiguration config = getProcAddressConfig();
+
+        // We should only generate code to call through a function pointer
+        // if the symbol has an associated function pointer typedef.
+        String funcPointerTypedefName = getFunctionPointerTypedefName(sym);
+        boolean shouldWrap = typedefDictionary.containsKey(funcPointerTypedefName);
+        //System.err.println(funcPointerTypedefName + " defined: " + shouldWrap);
+
+        if (config.skipProcAddressGen(symName)) {
+            shouldWrap = false;
+        }
+
+        if (config.forceProcAddressGen(symName)) {
+            shouldWrap = true;
+        }
+
+        if (shouldWrap) {
+            // Hoist argument names from function pointer if not supplied in prototype
+            Type funcPointerType = typedefDictionary.get(funcPointerTypedefName);
+            if (funcPointerType != null) {
+                FunctionType typedef = funcPointerType.asPointer().getTargetType().asFunction();
+                FunctionType fun = sym.getType();
+                int numarg = typedef.getNumArguments();
+                for (int i = 0; i < numarg; i++) {
+                    if (fun.getArgumentName(i) == null) {
+                        fun.setArgumentName(i, typedef.getArgumentName(i));
+                    }
+                }
+            }
+        }
+
+        return shouldWrap;
     }
-    
-    if (shouldWrap)
-    {
-      // Hoist argument names from function pointer if not supplied in prototype
-      Type funcPointerType = typedefDictionary.get(funcPointerTypedefName);
-      if (funcPointerType != null) {
-        FunctionType typedef = funcPointerType.asPointer().getTargetType().asFunction();
-        FunctionType fun = sym.getType();
-        int numarg = typedef.getNumArguments();
-        for (int i =0; i < numarg; i++) {
-          if (fun.getArgumentName(i) == null)
-            fun.setArgumentName(i,typedef.getArgumentName(i));
-          }
-      }
+
+    protected void beginProcAddressTable() throws Exception {
+        tableClassPackage = getProcAddressConfig().tableClassPackage();
+        tableClassName = getProcAddressConfig().tableClassName();
+
+        // Table defaults to going into the impl directory unless otherwise overridden
+        String implPackageName = tableClassPackage;
+        if (implPackageName == null) {
+            implPackageName = getImplPackageName();
+        }
+        String jImplRoot =
+                getJavaOutputDir() + File.separator
+                + CodeGenUtils.packageAsPath(implPackageName);
+
+        tableWriter = openFile(jImplRoot + File.separator + tableClassName + ".java");
+        emittedTableEntries = new HashSet<String>();
+
+        CodeGenUtils.emitAutogeneratedWarning(tableWriter, this);
+
+        tableWriter.println("package " + implPackageName + ";");
+        tableWriter.println();
+        for (String imporT : getConfig().imports()) {
+            tableWriter.println("import " + imporT + ";");
+        }
+        tableWriter.println();
+
+        tableWriter.println("/**");
+        tableWriter.println(" * This table is a cache of pointers to the dynamically-linkable C");
+        tableWriter.println(" * functions this autogenerated Java binding has exposed. Some");
+        tableWriter.println(" * libraries such as OpenGL, OpenAL and others define function pointer");
+        tableWriter.println(" * signatures rather than statically linkable entry points for the");
+        tableWriter.println(" * purposes of being able to query at run-time whether a particular");
+        tableWriter.println(" * extension is available. This table acts as a cache of these");
+        tableWriter.println(" * function pointers. Each function pointer is typically looked up at");
+        tableWriter.println(" * run-time by a platform-dependent mechanism such as dlsym(),");
+        tableWriter.println(" * wgl/glXGetProcAddress(), or alGetProcAddress(). The associated");
+        tableWriter.println(" * autogenerated Java and C code accesses the fields in this table to");
+        tableWriter.println(" * call the various functions. If the field containing the function");
+        tableWriter.println(" * pointer is 0, the function is considered to be unavailable and can");
+        tableWriter.println(" * not be called.");
+        tableWriter.println(" */");
+        tableWriter.println("public class " + tableClassName + " implements com.jogamp.gluegen.runtime.ProcAddressTable");
+        tableWriter.println("{");
+
+        for (String string : getProcAddressConfig().getForceProcAddressGen()) {
+            emitProcAddressTableEntryForString(string);
+        }
     }
-    
-    return shouldWrap;
-  }
-
-  protected void beginProcAddressTable() throws Exception
-  {
-    tableClassPackage = getProcAddressConfig().tableClassPackage();
-    tableClassName    = getProcAddressConfig().tableClassName();
-
-    // Table defaults to going into the impl directory unless otherwise overridden
-    String implPackageName = tableClassPackage;
-    if (implPackageName == null) {
-      implPackageName = getImplPackageName();
+
+    protected void endProcAddressTable() throws Exception {
+        PrintWriter w = tableWriter;
+
+        w.println("  /**");
+        w.println("   * This is a convenience method to get (by name) the native function");
+        w.println("   * pointer for a given function. It lets you avoid having to");
+        w.println("   * manually compute the &quot;" + PROCADDRESS_VAR_PREFIX + " + ");
+        w.println("   * &lt;functionName&gt;&quot; member variable name and look it up via");
+        w.println("   * reflection; it also will throw an exception if you try to get the");
+        w.println("   * address of an unknown function, or one that is statically linked");
+        w.println("   * and therefore does not have a function pointer in this table.");
+        w.println("   *");
+        w.println("   * @throws RuntimeException if the function pointer was not found in");
+        w.println("   *   this table, either because the function was unknown or because");
+        w.println("   *   it was statically linked.");
+        w.println("   */");
+        w.println("  public long getAddressFor(String functionName) {");
+        w.println("    String addressFieldName = " + getProcAddressConfig().gluegenRuntimePackage() + ".ProcAddressHelper.PROCADDRESS_VAR_PREFIX + functionName;");
+        w.println("    try { ");
+        w.println("      java.lang.reflect.Field addressField = getClass().getField(addressFieldName);");
+        w.println("      return addressField.getLong(this);");
+        w.println("    } catch (Exception e) {");
+        w.println("      // The user is calling a bogus function or one which is not");
+        w.println("      // runtime linked");
+        w.println("      throw new RuntimeException(");
+        w.println("          \"WARNING: Address query failed for \\\"\" + functionName +");
+        w.println("          \"\\\"; it's either statically linked or is not a known \" +");
+        w.println("          \"function\", e);");
+        w.println("    } ");
+        w.println("  }");
+
+        w.println("} // end of class " + tableClassName);
+        w.flush();
+        w.close();
     }
-    String jImplRoot =
-      getJavaOutputDir() + File.separator +
-      CodeGenUtils.packageAsPath(implPackageName);
-
-    tableWriter = openFile(jImplRoot + File.separator + tableClassName + ".java");
-    emittedTableEntries = new HashSet();
-
-    CodeGenUtils.emitAutogeneratedWarning(tableWriter, this);
-    
-    tableWriter.println("package " + implPackageName + ";");
-    tableWriter.println();
-    for (Iterator iter = getConfig().imports().iterator(); iter.hasNext(); ) {
-      tableWriter.println("import " + ((String) iter.next()) + ";");
+
+    protected void emitProcAddressTableEntryForString(String str) {
+        // Deal gracefully with forced proc address generation in the face
+        // of having the function pointer typedef in the header file too
+        if (emittedTableEntries.contains(str)) {
+            return;
+        }
+        emittedTableEntries.add(str);
+        tableWriter.print("  public long ");
+        tableWriter.print(PROCADDRESS_VAR_PREFIX);
+        tableWriter.print(str);
+        tableWriter.println(";");
     }
-    tableWriter.println();
-
-    tableWriter.println("/**");
-    tableWriter.println(" * This table is a cache of pointers to the dynamically-linkable C");
-    tableWriter.println(" * functions this autogenerated Java binding has exposed. Some");
-    tableWriter.println(" * libraries such as OpenGL, OpenAL and others define function pointer");
-    tableWriter.println(" * signatures rather than statically linkable entry points for the");
-    tableWriter.println(" * purposes of being able to query at run-time whether a particular");
-    tableWriter.println(" * extension is available. This table acts as a cache of these");
-    tableWriter.println(" * function pointers. Each function pointer is typically looked up at");
-    tableWriter.println(" * run-time by a platform-dependent mechanism such as dlsym(),");
-    tableWriter.println(" * wgl/glXGetProcAddress(), or alGetProcAddress(). The associated");
-    tableWriter.println(" * autogenerated Java and C code accesses the fields in this table to");
-    tableWriter.println(" * call the various functions. If the field containing the function");
-    tableWriter.println(" * pointer is 0, the function is considered to be unavailable and can");
-    tableWriter.println(" * not be called.");
-    tableWriter.println(" */");
-    tableWriter.println("public class " + tableClassName + " implements com.jogamp.gluegen.runtime.ProcAddressTable");
-    tableWriter.println("{");
-
-    for (Iterator iter = getProcAddressConfig().getForceProcAddressGen().iterator(); iter.hasNext(); ) {
-      emitProcAddressTableEntryForString((String) iter.next());
+
+    protected ProcAddressConfiguration getProcAddressConfig() {
+        return (ProcAddressConfiguration) getConfig();
     }
-  }
-
-  protected void endProcAddressTable() throws Exception
-  {
-    PrintWriter w = tableWriter;
-
-    w.println("  /**");
-    w.println("   * This is a convenience method to get (by name) the native function");
-    w.println("   * pointer for a given function. It lets you avoid having to");
-    w.println("   * manually compute the &quot;" + PROCADDRESS_VAR_PREFIX + " + ");
-    w.println("   * &lt;functionName&gt;&quot; member variable name and look it up via");
-    w.println("   * reflection; it also will throw an exception if you try to get the");
-    w.println("   * address of an unknown function, or one that is statically linked");
-    w.println("   * and therefore does not have a function pointer in this table.");
-    w.println("   *");
-    w.println("   * @throws RuntimeException if the function pointer was not found in");
-    w.println("   *   this table, either because the function was unknown or because");
-    w.println("   *   it was statically linked.");
-    w.println("   */");
-    w.println("  public long getAddressFor(String functionName) {");
-    w.println("    String addressFieldName = " + getProcAddressConfig().gluegenRuntimePackage() + ".ProcAddressHelper.PROCADDRESS_VAR_PREFIX + functionName;");
-    w.println("    try { ");
-    w.println("      java.lang.reflect.Field addressField = getClass().getField(addressFieldName);");
-    w.println("      return addressField.getLong(this);");
-    w.println("    } catch (Exception e) {");
-    w.println("      // The user is calling a bogus function or one which is not");
-    w.println("      // runtime linked");
-    w.println("      throw new RuntimeException(");
-    w.println("          \"WARNING: Address query failed for \\\"\" + functionName +");
-    w.println("          \"\\\"; it's either statically linked or is not a known \" +");
-    w.println("          \"function\", e);");
-    w.println("    } ");
-    w.println("  }");
-
-    w.println("} // end of class " + tableClassName);
-    w.flush();
-    w.close();
-  }
-
-  protected void emitProcAddressTableEntryForString(String str)
-  {
-    // Deal gracefully with forced proc address generation in the face
-    // of having the function pointer typedef in the header file too
-    if (emittedTableEntries.contains(str))
-      return;
-    emittedTableEntries.add(str);
-    tableWriter.print("  public long ");
-    tableWriter.print(PROCADDRESS_VAR_PREFIX);
-    tableWriter.print(str);
-    tableWriter.println(";");
-  }
-
-  protected ProcAddressConfiguration getProcAddressConfig() {
-    return (ProcAddressConfiguration) getConfig();
-  }
 }
diff --git a/src/java/com/sun/gluegen/procaddress/ProcAddressJavaMethodBindingEmitter.java b/src/java/com/sun/gluegen/procaddress/ProcAddressJavaMethodBindingEmitter.java
index 2dda752..5a30ee5 100755
--- a/src/java/com/sun/gluegen/procaddress/ProcAddressJavaMethodBindingEmitter.java
+++ b/src/java/com/sun/gluegen/procaddress/ProcAddressJavaMethodBindingEmitter.java
@@ -36,118 +36,115 @@
  * Sun gratefully acknowledges that this software was originally authored
  * and developed by Kenneth Bradley Russell and Christopher John Kline.
  */
-
 package com.sun.gluegen.procaddress;
 
 import java.io.*;
-import java.util.*;
 import com.sun.gluegen.*;
-import com.sun.gluegen.cgram.types.*;
 
 /** A specialization of JavaMethodBindingEmitter with knowledge of how
-    to call through a function pointer. */
-
+to call through a function pointer. */
 public class ProcAddressJavaMethodBindingEmitter extends JavaMethodBindingEmitter {
-  private final CommentEmitter commentEmitterForWrappedMethod =
-    new WrappedMethodCommentEmitter();
-
-  protected boolean callThroughProcAddress;
-  protected String getProcAddressTableExpr;
-  protected boolean changeNameAndArguments;
-  protected ProcAddressEmitter emitter;
-  
-  public ProcAddressJavaMethodBindingEmitter(JavaMethodBindingEmitter methodToWrap,
-                                             boolean callThroughProcAddress,
-                                             String  getProcAddressTableExpr,
-                                             boolean changeNameAndArguments,
-                                             ProcAddressEmitter emitter) {
-    super(methodToWrap);
-    this.callThroughProcAddress = callThroughProcAddress;
-    this.getProcAddressTableExpr = getProcAddressTableExpr;
-    this.changeNameAndArguments = changeNameAndArguments;
-    this.emitter = emitter;
-    if (callThroughProcAddress) {
-      setCommentEmitter(new WrappedMethodCommentEmitter());
+
+    protected boolean callThroughProcAddress;
+    protected boolean changeNameAndArguments;
+    
+    protected String getProcAddressTableExpr;
+    protected ProcAddressEmitter emitter;
+
+    public ProcAddressJavaMethodBindingEmitter(JavaMethodBindingEmitter methodToWrap, boolean callThroughProcAddress,
+            String getProcAddressTableExpr, boolean changeNameAndArguments, ProcAddressEmitter emitter) {
+
+        super(methodToWrap);
+
+        this.callThroughProcAddress = callThroughProcAddress;
+        this.getProcAddressTableExpr = getProcAddressTableExpr;
+        this.changeNameAndArguments = changeNameAndArguments;
+        this.emitter = emitter;
+
+        if (callThroughProcAddress) {
+            setCommentEmitter(new WrappedMethodCommentEmitter());
+        }
+
+        if (methodToWrap.getBinding().hasContainingType()) {
+            throw new IllegalArgumentException(
+                    "Cannot create proc. address wrapper; method has containing type: \""
+                    + methodToWrap.getBinding() + "\"");
+        }
     }
 
-    if (methodToWrap.getBinding().hasContainingType())
-    {
-      throw new IllegalArgumentException(
-        "Cannot create proc. address wrapper; method has containing type: \"" +
-        methodToWrap.getBinding() + "\"");
+    public ProcAddressJavaMethodBindingEmitter(ProcAddressJavaMethodBindingEmitter methodToWrap) {
+        this(methodToWrap, methodToWrap.callThroughProcAddress, methodToWrap.getProcAddressTableExpr,
+                methodToWrap.changeNameAndArguments, methodToWrap.emitter);
     }
-  }
-
-  public ProcAddressJavaMethodBindingEmitter(ProcAddressJavaMethodBindingEmitter methodToWrap) {
-    this(methodToWrap,
-         methodToWrap.callThroughProcAddress,
-         methodToWrap.getProcAddressTableExpr,
-         methodToWrap.changeNameAndArguments,
-         methodToWrap.emitter);
-  }
-
-  public String getName() {
-    String res = super.getName();
-    if (changeNameAndArguments) {
-      return ProcAddressEmitter.WRAP_PREFIX + res;
+
+    @Override
+    public String getName() {
+        String res = super.getName();
+        if (changeNameAndArguments) {
+            return ProcAddressEmitter.WRAP_PREFIX + res;
+        }
+        return res;
     }
-    return res;
-  }
-
-  protected int emitArguments(PrintWriter writer) {
-    int numEmitted = super.emitArguments(writer);
-    if (callThroughProcAddress) {
-      if (changeNameAndArguments) {
-        if (numEmitted > 0) {
-          writer.print(", ");
+
+    @Override
+    protected int emitArguments(PrintWriter writer) {
+        int numEmitted = super.emitArguments(writer);
+        if (callThroughProcAddress) {
+            if (changeNameAndArguments) {
+                if (numEmitted > 0) {
+                    writer.print(", ");
+                }
+
+                writer.print("long procAddress");
+                ++numEmitted;
+            }
         }
 
-        writer.print("long procAddress");
-        ++numEmitted;
-      }
+        return numEmitted;
     }
-          
-    return numEmitted;
-  }
-
-  protected String getImplMethodName() {
-    String name = super.getImplMethodName();
-    if (callThroughProcAddress) {
-      return ProcAddressEmitter.WRAP_PREFIX + name;
+
+    @Override
+    protected String getImplMethodName() {
+        String name = super.getImplMethodName();
+        if (callThroughProcAddress) {
+            return ProcAddressEmitter.WRAP_PREFIX + name;
+        }
+        return name;
     }
-    return name;
-  }
-
-  protected void emitPreCallSetup(MethodBinding binding, PrintWriter writer) {
-    super.emitPreCallSetup(binding, writer);
-
-    if (callThroughProcAddress) {
-      String procAddressVariable =
-        ProcAddressEmitter.PROCADDRESS_VAR_PREFIX + binding.getName();
-      writer.println("    final long __addr_ = " + getProcAddressTableExpr + "." + procAddressVariable + ";");
-      writer.println("    if (__addr_ == 0) {");
-      writer.println("      throw new " + emitter.unsupportedExceptionType() + "(\"Method \\\"" + binding.getName() + "\\\" not available\");");
-      writer.println("    }");
+
+    @Override
+    protected void emitPreCallSetup(MethodBinding binding, PrintWriter writer) {
+        super.emitPreCallSetup(binding, writer);
+
+        if (callThroughProcAddress) {
+            String procAddressVariable = ProcAddressEmitter.PROCADDRESS_VAR_PREFIX + binding.getName();
+            writer.println("    final long __addr_ = " + getProcAddressTableExpr + "." + procAddressVariable + ";");
+            writer.println("    if (__addr_ == 0) {");
+            writer.println("      throw new " + emitter.unsupportedExceptionType() + "(\"Method \\\"" + binding.getName() + "\\\" not available\");");
+            writer.println("    }");
+        }
     }
-  }
-
-  protected int emitCallArguments(MethodBinding binding, PrintWriter writer) {
-    int numEmitted = super.emitCallArguments(binding, writer);
-    if (callThroughProcAddress) {
-      if (numEmitted > 0) {
-        writer.print(", ");
-      }
-      writer.print("__addr_");
-      ++numEmitted;
+
+    @Override
+    protected int emitCallArguments(MethodBinding binding, PrintWriter writer) {
+        int numEmitted = super.emitCallArguments(binding, writer);
+        if (callThroughProcAddress) {
+            if (numEmitted > 0) {
+                writer.print(", ");
+            }
+            writer.print("__addr_");
+            ++numEmitted;
+        }
+
+        return numEmitted;
     }
 
-    return numEmitted;
-  }
+    /** This class emits the comment for the wrapper method */
+    public class WrappedMethodCommentEmitter extends JavaMethodBindingEmitter.DefaultCommentEmitter {
 
-  /** This class emits the comment for the wrapper method */
-  public class WrappedMethodCommentEmitter extends JavaMethodBindingEmitter.DefaultCommentEmitter {
-    protected void emitBeginning(FunctionEmitter methodEmitter, PrintWriter writer) {
-      writer.print("Entry point (through function pointer) to C language function: <br> ");
+        @Override
+        protected void emitBeginning(FunctionEmitter methodEmitter, PrintWriter writer) {
+            writer.print("Entry point (through function pointer) to C language function: <br> ");
+        }
     }
-  }
 }