Renamed com.sun.gluegen -> com.jogamp.gluegen

1 files changed, 0 insertions, 1950 deletions

diff --git a/src/java/com/sun/gluegen/JavaEmitter.java b/src/java/com/sun/gluegen/JavaEmitter.java
deleted file mode 100644
index 5fc07b0..0000000
--- a/src/java/com/sun/gluegen/JavaEmitter.java
+++ /dev/null
@@ -1,1950 +0,0 @@
-/*
- * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
- * Copyright (c) 2010 JogAmp Community. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- * - Redistribution of source code must retain the above copyright
- *   notice, this list of conditions and the following disclaimer.
- *
- * - Redistribution in binary form must reproduce the above copyright
- *   notice, this list of conditions and the following disclaimer in the
- *   documentation and/or other materials provided with the distribution.
- *
- * Neither the name of Sun Microsystems, Inc. or the names of
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * This software is provided "AS IS," without a warranty of any kind. ALL
- * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
- * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
- * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
- * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
- * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
- * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
- * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
- * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
- * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
- * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
- * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
- *
- * You acknowledge that this software is not designed or intended for use
- * in the design, construction, operation or maintenance of any nuclear
- * facility.
- *
- * Sun gratefully acknowledges that this software was originally authored
- * and developed by Kenneth Bradley Russell and Christopher John Kline.
- */
-
-package com.sun.gluegen;
-
-import com.jogamp.common.nio.Buffers;
-import com.jogamp.common.os.DynamicLookupHelper;
-import java.io.*;
-import java.util.*;
-import java.text.MessageFormat;
-
-import com.sun.gluegen.cgram.types.*;
-import java.nio.Buffer;
-import java.util.logging.Logger;
-
-import static java.util.logging.Level.*;
-import static com.sun.gluegen.JavaEmitter.MethodAccess.*;
-
-// PROBLEMS:
-//  - what if something returns 'const int *'? Could we
-//    return an IntBuffer that has read-only behavior? Or do we copy the array
-//    (but we don't know its size!). What do we do if it returns a non-const
-//    int*? Should the user be allowed to write back to the returned pointer?
-//
-//  - Non-const array types must be properly released with JNI_COMMIT
-//    in order to see side effects if the array was copied.
-
-
-public class JavaEmitter implements GlueEmitter {
-
-  private StructLayout layout;
-  private TypeDictionary typedefDictionary;
-  private TypeDictionary structDictionary;
-  private Map<Type, Type> canonMap;
-  protected JavaConfiguration cfg;
-
-  /**
-   * Style of code emission. Can emit everything into one class
-   * (AllStatic), separate interface and implementing classes
-   * (InterfaceAndImpl), only the interface (InterfaceOnly), or only
-   * the implementation (ImplOnly).
-   */
-  public enum EmissionStyle {AllStatic, InterfaceAndImpl, InterfaceOnly, ImplOnly};
-
-  /**
-   * Access control for emitted Java methods.
-   */
-  public enum MethodAccess {PUBLIC, PROTECTED, PRIVATE, PACKAGE_PRIVATE, PUBLIC_ABSTRACT}
-
-  private PrintWriter javaWriter; // Emits either interface or, in AllStatic mode, everything
-  private PrintWriter javaImplWriter; // Only used in non-AllStatic modes for impl class
-  private PrintWriter cWriter;
-  private MachineDescription machDesc32;
-  private MachineDescription machDesc64;
-
-  protected final static Logger LOG = Logger.getLogger(JavaEmitter.class.getPackage().getName());
-
-  public void readConfigurationFile(String filename) throws Exception {
-    cfg = createConfig();
-    cfg.read(filename);
-  }
-
-  public void setMachineDescription(MachineDescription md32, MachineDescription md64) {
-
-    if ((md32 == null) && (md64 == null)) {
-      throw new RuntimeException("Must specify at least one MachineDescription");
-    }
-
-    machDesc32 = md32;
-    machDesc64 = md64;
-  }
-
-  class ConstantRenamer implements SymbolFilter {
-
-    private List<ConstantDefinition> constants;
-
-    public void filterSymbols(List<ConstantDefinition> constants, List<FunctionSymbol> functions) {
-      this.constants = constants;
-      doWork();
-    }
-
-    public List<ConstantDefinition> getConstants() {
-      return constants;
-    }
-
-    public List<FunctionSymbol> getFunctions() {
-      return null;
-    }
-
-    private void doWork() {
-      List<ConstantDefinition> newConstants = new ArrayList<ConstantDefinition>();
-      JavaConfiguration cfg = getConfig();
-      for (ConstantDefinition def : constants) {
-        def.rename(cfg.getJavaSymbolRename(def.getName()));
-        newConstants.add(def);
-      }
-      constants = newConstants;
-    }
-  }
-
-    public void beginEmission(GlueEmitterControls controls) throws IOException {
-
-        // Request emission of any structs requested
-        for (String structs : cfg.forcedStructs()) {
-            controls.forceStructEmission(structs);
-        }
-
-        if (!cfg.structsOnly()) {
-            try {
-                openWriters();
-            } catch (Exception e) {
-                throw new RuntimeException("Unable to open files for writing", e);
-            }
-            emitAllFileHeaders();
-
-            // Handle renaming of constants
-            controls.runSymbolFilter(new ConstantRenamer());
-        }
-    }
-
-    public void endEmission() {
-        if (!cfg.structsOnly()) {
-            emitAllFileFooters();
-
-            try {
-                closeWriters();
-            } catch (Exception e) {
-                throw new RuntimeException("Unable to close open files", e);
-            }
-        }
-    }
-
-  public void beginDefines() throws Exception {
-    if ((cfg.allStatic() || cfg.emitInterface()) && !cfg.structsOnly()) {
-      javaWriter().println();
-    }
-  }
-
-  protected static int getJavaRadix(String name, String value)  {
-    // FIXME: need to handle when type specifier is in last char (e.g.,
-    // "1.0d or 2759L", because parseXXX() methods don't allow the type
-    // specifier character in the string.
-    //
-    //char lastChar = value.charAt(value.length()-1);
-
-    try {
-      // see if it's a long or int
-      int radix;
-      String parseValue;
-      // FIXME: are you allowed to specify hex/octal constants with
-      // negation, e.g. "-0xFF" or "-056"? If so, need to modify the
-      // following "if(..)" checks and parseValue computation
-      if (value.startsWith("0x") || value.startsWith("0X")) {
-        radix = 16;
-        parseValue = value.substring(2);
-      }
-      else if (value.startsWith("0") && value.length() > 1) {
-        // TODO: is "0" the prefix in C to indicate octal???
-        radix = 8;
-        parseValue = value.substring(1);
-      }
-      else {
-        radix = 10;
-        parseValue = value;
-      }
-      //System.err.println("parsing " + value + " as long w/ radix " + radix);
-      long longVal = Long.parseLong(parseValue, radix);
-      return radix;
-    } catch (NumberFormatException e) {
-      try {
-        // see if it's a double or float
-        double dVal = Double.parseDouble(value);
-        return 10;
-      } catch (NumberFormatException e2) {
-        throw new RuntimeException(
-          "Cannot emit define \""+name+"\": value \""+value+
-          "\" cannot be assigned to a int, long, float, or double", e2);
-      }
-    }
-  }
-
-  protected static Object getJavaValue(String name, String value) {
-
-    // "calculates" the result type of a simple expression
-    // example: (2+3)-(2.0f-3.0) -> Double
-    // example: (1 << 2) -> Integer
-
-    Scanner scanner = new Scanner(value).useDelimiter("[+-/*/></(/)]");
-
-    Object resultType = null;
-
-    while (scanner.hasNext()) {
-
-        String t = scanner.next().trim();
-
-        if(0<t.length()) {
-            Object type = getJavaValue2(name, t);
-
-            //fast path
-            if(type instanceof Double)
-                return type;
-
-            if(resultType != null) {
-
-                if(resultType instanceof Integer) {
-                    if(type instanceof Long || type instanceof Float || type instanceof Double)
-                        resultType = type;
-                }else if(resultType instanceof Long) {
-                    if(type instanceof Float || type instanceof Double)
-                        resultType = type;
-                }else if(resultType instanceof Float) {
-                    if(type instanceof Float)
-                        resultType = type;
-                }
-            }else{
-                resultType = type;
-            }
-
-            //fast path
-            if(resultType instanceof Double)
-                return type;
-        }
-    }
-
-    return resultType;
-  }
-
-  private static Object getJavaValue2(String name, String value) {
-    // FIXME: need to handle when type specifier is in last char (e.g.,
-    // "1.0d or 2759L", because parseXXX() methods don't allow the type
-    // specifier character in the string.
-    //
-    char lastChar = value.charAt(value.length()-1);
-
-    try {
-      // see if it's a long or int
-      int radix;
-      String parseValue;
-      // FIXME: are you allowed to specify hex/octal constants with
-      // negation, e.g. "-0xFF" or "-056"? If so, need to modify the
-      // following "if(..)" checks and parseValue computation
-      if (value.startsWith("0x") || value.startsWith("0X")) {
-        radix = 16;
-        parseValue = value.substring(2);
-      } else if (value.startsWith("0") && value.length() > 1) {
-        // TODO: is "0" the prefix in C to indicate octal???
-        radix = 8;
-        parseValue = value.substring(1);
-      } else {
-        radix = 10;
-        parseValue = value;
-      }
-      if(lastChar == 'u' || lastChar == 'U') {
-          parseValue = parseValue.substring(0, parseValue.length()-1);
-      }
-
-      //System.err.println("parsing " + value + " as long w/ radix " + radix);
-      long longVal = Long.parseLong(parseValue, radix);
-      // if constant is small enough, store it as an int instead of a long
-      if (longVal > Integer.MIN_VALUE && longVal < Integer.MAX_VALUE) {
-        return (int)longVal;
-      }
-      return longVal;
-
-    } catch (NumberFormatException e) {
-      try {
-        // see if it's a double or float
-        double dVal = Double.parseDouble(value);
-        double absVal = Math.abs(dVal);
-        // if constant is small enough, store it as a float instead of a double
-        if (absVal < Float.MIN_VALUE || absVal > Float.MAX_VALUE) {
-            return new Double(dVal);
-        }
-        return new Float((float) dVal);
-      } catch (NumberFormatException e2) {
-        throw new RuntimeException(
-          "Cannot emit define \""+name+"\": value \""+value+
-          "\" cannot be assigned to a int, long, float, or double", e2);
-      }
-    }
-  }
-
-
-  protected static String getJavaType(String name, String value) {
-    Object oval = getJavaValue(name, value);
-    return getJavaType(name, oval);
-  }
-
-  protected static String getJavaType(String name, Object oval) {
-    if(oval instanceof Integer) {
-        return "int";
-    } else if(oval instanceof Long) {
-        return "long";
-    } else if(oval instanceof Float) {
-        return "float";
-    } else if(oval instanceof Double) {
-        return "double";
-    }
-
-    throw new RuntimeException(
-      "Cannot emit define (2) \""+name+"\": value \""+oval+
-      "\" cannot be assigned to a int, long, float, or double");
-  }
-
-  public void emitDefine(ConstantDefinition def, String optionalComment) throws Exception  {
-
-    if (cfg.allStatic() || cfg.emitInterface()) {
-      // TODO: Some defines (e.g., GL_DOUBLE_EXT in gl.h) are defined in terms
-      // of other defines -- should we emit them as references to the original
-      // define (not even sure if the lexer supports this)? Right now they're
-      // emitted as the numeric value of the original definition. If we decide
-      // emit them as references we'll also have to emit them in the correct
-      // order. It's probably not an issue right now because the emitter
-      // currently only emits only numeric defines -- if it handled #define'd
-      // objects it would make a bigger difference.
-
-      String name = def.getName();
-      String value = def.getValue();
-
-      if (!cfg.shouldIgnoreInInterface(name)) {
-        String type = getJavaType(name, value);
-        if (optionalComment != null && optionalComment.length() != 0) {
-          javaWriter().println("  /** " + optionalComment + " */");
-        }
-        String suffix = "";
-        if(!value.endsWith(")")) {
-            if (type.equals("float") && !value.endsWith("f")) {
-                suffix = "f";
-            }else if(value.endsWith("u") || value.endsWith("U")) {
-                value = value.substring(0, value.length()-1);
-            }
-        }
-
-        javaWriter().println("  public static final " + type + " " + name + " = " + value + suffix + ";");
-      }
-    }
-  }
-
-  public void endDefines() throws Exception {
-  }
-
-  public void beginFunctions(TypeDictionary typedefDictionary,
-                             TypeDictionary structDictionary,
-                             Map<Type, Type> canonMap) throws Exception {
-
-    this.typedefDictionary = typedefDictionary;
-    this.structDictionary  = structDictionary;
-    this.canonMap          = canonMap;
-
-    if ((cfg.allStatic() || cfg.emitInterface()) && !cfg.structsOnly()) {
-      javaWriter().println();
-    }
-  }
-
-  public Iterator<FunctionSymbol> emitFunctions(List<FunctionSymbol> originalCFunctions) throws Exception {
-
-    // Sometimes headers will have the same function prototype twice, once
-    // with the argument names and once without. We'll remember the signatures
-    // we've already processed we don't generate duplicate bindings.
-    //
-    // Note: this code assumes that on the equals() method in FunctionSymbol
-    // only considers function name and argument types (i.e., it does not
-    // consider argument *names*) when comparing FunctionSymbols for equality
-    Set<FunctionSymbol> funcsToBindSet = new HashSet<FunctionSymbol>(100);
-    for (FunctionSymbol cFunc : originalCFunctions) {
-      if (!funcsToBindSet.contains(cFunc)) {
-        funcsToBindSet.add(cFunc);
-      }
-    }
-
-    //    validateFunctionsToBind(funcsToBindSet);
-
-    ArrayList<FunctionSymbol> funcsToBind = new ArrayList<FunctionSymbol>(funcsToBindSet);
-    // sort functions to make them easier to find in native code
-    Collections.sort(funcsToBind, new Comparator<FunctionSymbol>() {
-            public int compare(FunctionSymbol o1, FunctionSymbol o2) {
-                return o1.getName().compareTo(o2.getName());
-            }
-        });
-
-    // Bind all the C funcs to Java methods
-    HashSet<MethodBinding> methodBindingSet = new HashSet<MethodBinding>();
-    ArrayList<FunctionEmitter> methodBindingEmitters = new ArrayList<FunctionEmitter>(2*funcsToBind.size());
-    for (FunctionSymbol cFunc : funcsToBind) {
-      // Check to see whether this function should be ignored
-      if (!cfg.shouldIgnoreInImpl(cFunc.getName())) {
-          methodBindingEmitters.addAll(generateMethodBindingEmitters(methodBindingSet, cFunc));
-      }
-
-    }
-
-    // Emit all the methods
-    for (FunctionEmitter emitter : methodBindingEmitters) {
-      try {
-        if (!emitter.isInterface() || !cfg.shouldIgnoreInInterface(emitter.getName())) {
-            emitter.emit();
-            emitter.getDefaultOutput().println(); // put newline after method body
-        }
-      } catch (Exception e) {
-        throw new RuntimeException(
-            "Error while emitting binding for \"" + emitter.getName() + "\"", e);
-      }
-    }
-
-    // Return the list of FunctionSymbols that we generated gluecode for
-    return funcsToBind.iterator();
-  }
-
-  /**
-   * Create the object that will read and store configuration information for
-   * this JavaEmitter.
-   */
-  protected JavaConfiguration createConfig() {
-    return new JavaConfiguration();
-  }
-
-  /**
-   * Get the configuration information for this JavaEmitter.
-   */
-  protected JavaConfiguration getConfig() {
-    return cfg;
-  }
-
-  /**
-   * Generates the public emitters for this MethodBinding which will
-   * produce either simply signatures (for the interface class, if
-   * any) or function definitions with or without a body (depending on
-   * whether or not the implementing function can go directly to
-   * native code because it doesn't need any processing of the
-   * outgoing arguments).
-   */
-  protected void generatePublicEmitters(MethodBinding binding,
-                                        List<FunctionEmitter> allEmitters,
-                                        boolean signatureOnly) {
-    PrintWriter writer = ((signatureOnly || cfg.allStatic()) ? javaWriter() : javaImplWriter());
-
-    if (cfg.manuallyImplement(binding.getName()) && !signatureOnly) {
-      // We only generate signatures for manually-implemented methods;
-      // user provides the implementation
-      return;
-    }
-
-    MethodAccess accessControl = cfg.accessControl(binding.getName());
-    // We should not emit anything except public APIs into interfaces
-    if (signatureOnly && (accessControl != PUBLIC)) {
-      return;
-    }
-
-    // It's possible we may not need a body even if signatureOnly is
-    // set to false; for example, if the routine doesn't take any
-    // arrays or buffers as arguments
-    boolean isUnimplemented = cfg.isUnimplemented(binding.getName());
-    List<String> prologue = cfg.javaPrologueForMethod(binding, false, false);
-    List<String> epilogue = cfg.javaEpilogueForMethod(binding, false, false);
-    boolean needsBody = (isUnimplemented ||
-                         (binding.needsNIOWrappingOrUnwrapping() ||
-                          binding.signatureUsesJavaPrimitiveArrays()) ||
-                         (prologue != null) ||
-                         (epilogue != null));
-
-    JavaMethodBindingEmitter emitter =
-      new JavaMethodBindingEmitter(binding,
-                                   writer,
-                                   cfg.runtimeExceptionType(),
-                                   cfg.unsupportedExceptionType(),
-                                   !signatureOnly && needsBody,
-                                   cfg.tagNativeBinding(),
-                                   false,
-                                   cfg.nioDirectOnly(binding.getName()),
-                                   false,
-                                   false,
-                                   false,
-                                   isUnimplemented,
-                                   signatureOnly,
-                                   cfg);
-    switch (accessControl) {
-      case PUBLIC:     emitter.addModifier(JavaMethodBindingEmitter.PUBLIC); break;
-      case PROTECTED:  emitter.addModifier(JavaMethodBindingEmitter.PROTECTED); break;
-      case PRIVATE:    emitter.addModifier(JavaMethodBindingEmitter.PRIVATE); break;
-      default: break; // package-private adds no modifiers
-    }
-    if (cfg.allStatic()) {
-      emitter.addModifier(JavaMethodBindingEmitter.STATIC);
-    }
-    if (!isUnimplemented && !needsBody && !signatureOnly) {
-      emitter.addModifier(JavaMethodBindingEmitter.NATIVE);
-    }
-    emitter.setReturnedArrayLengthExpression(cfg.returnedArrayLength(binding.getName()));
-    emitter.setPrologue(prologue);
-    emitter.setEpilogue(epilogue);
-    allEmitters.add(emitter);
-  }
-
-  /**
-   * Generates the private emitters for this MethodBinding. On the
-   * Java side these will simply produce signatures for native
-   * methods. On the C side these will create the emitters which will
-   * write the JNI code to interface to the functions. We need to be
-   * careful to make the signatures all match up and not produce too
-   * many emitters which would lead to compilation errors from
-   * creating duplicated methods / functions.
-   */
-  protected void generatePrivateEmitters(MethodBinding binding,
-                                         List<FunctionEmitter> allEmitters) {
-    if (cfg.manuallyImplement(binding.getName())) {
-      // Don't produce emitters for the implementation class
-      return;
-    }
-
-    boolean hasPrologueOrEpilogue =
-        ((cfg.javaPrologueForMethod(binding, false, false) != null) ||
-         (cfg.javaEpilogueForMethod(binding, false, false) != null));
-
-    // If we already generated a public native entry point for this
-    // method, don't emit another one
-    if (!cfg.isUnimplemented(binding.getName()) &&
-        (binding.needsNIOWrappingOrUnwrapping() ||
-         binding.signatureUsesJavaPrimitiveArrays() ||
-         hasPrologueOrEpilogue)) {
-      PrintWriter writer = (cfg.allStatic() ? javaWriter() : javaImplWriter());
-
-      // If the binding uses primitive arrays, we are going to emit
-      // the private native entry point for it along with the version
-      // taking only NIO buffers
-      if (!binding.signatureUsesJavaPrimitiveArrays()) {
-        // (Always) emit the entry point taking only direct buffers
-        JavaMethodBindingEmitter emitter =
-          new JavaMethodBindingEmitter(binding,
-                                       writer,
-                                       cfg.runtimeExceptionType(),
-                                       cfg.unsupportedExceptionType(),
-                                       false,
-                                       cfg.tagNativeBinding(),
-                                       true,
-                                       cfg.nioDirectOnly(binding.getName()),
-                                       true,
-                                       true,
-                                       false,
-                                       false,
-                                       false,
-                                       cfg);
-        emitter.addModifier(JavaMethodBindingEmitter.PRIVATE);
-        if (cfg.allStatic()) {
-          emitter.addModifier(JavaMethodBindingEmitter.STATIC);
-        }
-        emitter.addModifier(JavaMethodBindingEmitter.NATIVE);
-        emitter.setReturnedArrayLengthExpression(cfg.returnedArrayLength(binding.getName()));
-        allEmitters.add(emitter);
-      }
-    }
-
-    // Now generate the C emitter(s). We need to produce one for every
-    // Java native entry point (public or private). The only
-    // situations where we don't produce one are (a) when the method
-    // is unimplemented, and (b) when the signature contains primitive
-    // arrays, since the latter is handled by the method binding
-    // variant taking only NIO Buffers.
-    if (!cfg.isUnimplemented(binding.getName()) &&
-        !binding.signatureUsesJavaPrimitiveArrays()) {
-      CMethodBindingEmitter cEmitter;
-      // Generate a binding without mixed access (NIO-direct, -indirect, array)
-      cEmitter =
-          new CMethodBindingEmitter(binding,
-                                    cWriter(),
-                                    cfg.implPackageName(),
-                                    cfg.implClassName(),
-                                    true, // NOTE: we always disambiguate with a suffix now, so this is optional
-                                    cfg.allStatic(),
-                                    (binding.needsNIOWrappingOrUnwrapping() || hasPrologueOrEpilogue),
-                                    !cfg.nioDirectOnly(binding.getName()),
-                                    machDesc64);
-      prepCEmitter(binding, cEmitter);
-      allEmitters.add(cEmitter);
-    }
-  }
-
-  protected void prepCEmitter(MethodBinding binding, CMethodBindingEmitter cEmitter) 
-  {
-      // See whether we need an expression to help calculate the
-      // length of any return type
-      JavaType javaReturnType = binding.getJavaReturnType();
-      if (javaReturnType.isNIOBuffer() ||
-          javaReturnType.isCompoundTypeWrapper()) {
-        // See whether capacity has been specified
-        String capacity = cfg.returnValueCapacity(binding.getName());
-        if (capacity != null) {
-          cEmitter.setReturnValueCapacityExpression( new MessageFormat(capacity) );
-        }
-      } else if (javaReturnType.isArray() ||
-                 javaReturnType.isArrayOfCompoundTypeWrappers()) {
-        // NOTE: adding a check here because the CMethodBindingEmitter
-        // also doesn't yet handle returning scalar arrays. In order
-        // to implement this, return the type as a Buffer instead
-        // (i.e., IntBuffer, FloatBuffer) and add code as necessary.
-        if (javaReturnType.isPrimitiveArray()) {
-          throw new RuntimeException("Primitive array return types not yet supported");
-        }
-
-        // See whether length has been specified
-        String len = cfg.returnValueLength(binding.getName());
-        if (len != null) {
-          cEmitter.setReturnValueLengthExpression( new MessageFormat(len) );
-        }
-      }
-      cEmitter.setTemporaryCVariableDeclarations(cfg.temporaryCVariableDeclarations(binding.getName()));
-      cEmitter.setTemporaryCVariableAssignments(cfg.temporaryCVariableAssignments(binding.getName()));
-  }
-
-  /**
-   * Generate all appropriate Java bindings for the specified C function
-   * symbols.
-   */
-  protected List<? extends FunctionEmitter> generateMethodBindingEmitters(Set<MethodBinding> methodBindingSet, FunctionSymbol sym) throws Exception {
-
-    ArrayList<FunctionEmitter> allEmitters = new ArrayList<FunctionEmitter>();
-
-    try {
-      // Get Java binding for the function
-      MethodBinding mb = bindFunction(sym, null, null, machDesc64);
-
-      // JavaTypes representing C pointers in the initial
-      // MethodBinding have not been lowered yet to concrete types
-      List<MethodBinding> bindings = expandMethodBinding(mb);
-
-      for (MethodBinding binding : bindings) {
-
-        if(!methodBindingSet.add(binding)) {
-            // skip .. already exisiting binding ..
-            continue;
-        }
-
-        if (cfg.allStatic() && binding.hasContainingType()) {
-          // This should not currently happen since structs are emitted using a different mechanism
-          throw new IllegalArgumentException("Cannot create binding in AllStatic mode because method has containing type: \"" +
-                                             binding + "\"");
-        }
-
-        // The structure of the generated glue code looks something like this:
-        // Simple method (no arrays, void pointers, etc.):
-        //   Interface class:
-        //     public void fooMethod();
-        //   Implementation class:
-        //     public native void fooMethod();
-        //
-        // Method taking void* argument:
-        //   Interface class:
-        //     public void fooMethod(Buffer arg);
-        //   Implementation class:
-        //     public void fooMethod(Buffer arg) {
-        //       ... bounds checks, etc. ...
-        //
-        //       boolean arg_direct = arg != null && Buffers.isDirect(arg);
-        //
-        //       fooMethod0(arg_direct?arg:Buffers.getArray(arg),
-        //                  arg_direct?Buffers.getDirectBufferByteOffset(arg):Buffers.getIndirectBufferByteOffset(arg),
-        //                  arg_direct,
-        //                  ... );
-        //     }
-        //     private native void fooMethod1(Object arg, int arg_byte_offset, boolean arg_is_direct, ...);
-        //
-        // Method taking primitive array argument:
-        //   Interface class:
-        //     public void fooMethod(int[] arg, int arg_offset);
-        //     public void fooMethod(IntBuffer arg);
-        //   Implementing class:
-        //     public void fooMethod(int[] arg, int arg_offset) {
-        //       ... range checks, etc. ...
-        //       fooMethod1(arg, SIZEOF_INT * arg_offset);
-        //     }
-        //     public void fooMethod(IntBuffer arg) {
-        //       ... bounds checks, etc. ...
-        //
-        //       boolean arg_direct = BufferFactory.isDirect(arg);
-        //
-        //       fooMethod1(arg_direct?arg:BufferFactory.getArray(arg),
-        //                  arg_direct?BufferFactory.getDirectBufferByteOffset(arg):BufferFactory.getIndirectBufferByteOffset(arg),
-        //                  arg_direct,
-        //                  ... );
-        //     }
-        //     private native void fooMethod1(Object arg, int arg_byte_offset, boolean arg_is_direct, ...);
-        //
-        // Note in particular that the public entry point taking an
-        // array is merely a special case of the indirect buffer case.
-
-        if (cfg.emitInterface()) {
-          generatePublicEmitters(binding, allEmitters, true);
-        }
-        if (cfg.emitImpl()) {
-          generatePublicEmitters(binding, allEmitters, false);
-          generatePrivateEmitters(binding, allEmitters);
-        }
-      } // end iteration over expanded bindings
-    } catch (Exception e) {
-      throw new RuntimeException("Error while generating bindings for \"" + sym + "\"", e);
-    }
-
-    return allEmitters;
-  }
-
-
-  public void endFunctions() throws Exception {
-    if (!cfg.structsOnly()) {
-        if (cfg.allStatic() || cfg.emitInterface()) {
-            emitCustomJavaCode(javaWriter(), cfg.className());
-        }
-        if (!cfg.allStatic() && cfg.emitImpl()) {
-            emitCustomJavaCode(javaImplWriter(), cfg.implClassName());
-        }
-    }
-  }
-
-  public void beginStructLayout() throws Exception {}
-  public void layoutStruct(CompoundType t) throws Exception {
-    getLayout().layout(t);
-  }
-  public void endStructLayout() throws Exception {}
-
-  public void beginStructs(TypeDictionary typedefDictionary,
-                           TypeDictionary structDictionary,
-                           Map<Type, Type> canonMap) throws Exception {
-    this.typedefDictionary = typedefDictionary;
-    this.structDictionary  = structDictionary;
-    this.canonMap          = canonMap;
-  }
-
-  public void emitStruct(CompoundType structType, String alternateName) throws Exception {
-    // Emit abstract base class delegating to 32-bit or 64-bit implementations
-    emitStructImpl(structType, alternateName, machDesc32, machDesc64, true, false);
-    // Emit concrete implementing class for each variant
-    emitStructImpl(structType, alternateName, machDesc32, machDesc64, false, true);
-    emitStructImpl(structType, alternateName, machDesc32, machDesc64, false, false);
-  }
-
-  public void emitStructImpl(CompoundType structType,
-                             String alternateName,
-                             MachineDescription md32,
-                             MachineDescription md64,
-                             boolean doBaseClass,
-                             boolean do32Bit) throws Exception {
-    String name = structType.getName();
-    if (name == null && alternateName != null) {
-      name = alternateName;
-    }
-
-    if (name == null) {
-        LOG.log(WARNING, "skipping emission of unnamed struct \"{0}\"", structType);
-        return;
-    }
-
-    if (cfg.shouldIgnoreInInterface(name)) {
-      return;
-    }
-
-    Type containingCType = canonicalize(new PointerType(SizeThunk.POINTER, structType, 0));
-    JavaType containingType = typeToJavaType(containingCType, false, null);
-    if (!containingType.isCompoundTypeWrapper()) {
-      return;
-    }
-    String containingTypeName = containingType.getName();
-
-    if ((md32 == null) || (md64 == null)) {
-      throw new RuntimeException("Must supply both 32- and 64-bit MachineDescriptions to emitStructImpl");
-    }
-    String suffix = "";
-
-    // The "external" MachineDescription is the one used to determine
-    // the sizes of the primitive types seen in the public API. For
-    // example, if a C long is an element of a struct, it is the size
-    // of a Java int on a 32-bit machine but the size of a Java long
-    // on a 64-bit machine. To support both of these sizes with the
-    // same API, the abstract base class must take and return a Java
-    // long from the setter and getter for this field. However the
-    // implementation on a 32-bit platform must downcast this to an
-    // int and set only an int's worth of data in the struct. The
-    // "internal" MachineDescription is the one used to determine how
-    // much data to set in or get from the struct and exactly from
-    // where it comes.
-    //
-    // Note that the 64-bit MachineDescription is always used as the
-    // external MachineDescription.
-
-    MachineDescription extMachDesc = md64;
-    MachineDescription intMachDesc = null;
-
-    if (!doBaseClass) {
-      if (do32Bit) {
-        intMachDesc = md32;
-        suffix = "32";
-      } else {
-        intMachDesc = md64;
-        suffix = "64";
-      }
-    }
-
-    boolean needsNativeCode = false;
-    // Native code for calls through function pointers gets emitted
-    // into the abstract base class; Java code which accesses fields
-    // gets emitted into the concrete classes
-    if (doBaseClass) {
-      for (int i = 0; i < structType.getNumFields(); i++) {
-        if (structType.getField(i).getType().isFunctionPointer()) {
-          needsNativeCode = true;
-          break;
-        }
-      }
-    }
-
-    String structClassPkg = cfg.packageForStruct(name);
-    PrintWriter writer = null;
-    PrintWriter newWriter = null;
-    try  {
-      writer = openFile(
-        cfg.javaOutputDir() + File.separator +
-        CodeGenUtils.packageAsPath(structClassPkg) +
-        File.separator + containingTypeName + suffix + ".java");
-      CodeGenUtils.emitAutogeneratedWarning(writer, this);
-      if (needsNativeCode) {
-        String nRoot = cfg.nativeOutputDir();
-        if (cfg.nativeOutputUsesJavaHierarchy()) {
-          nRoot += File.separator + CodeGenUtils.packageAsPath(cfg.packageName());
-        }
-        newWriter = openFile(nRoot + File.separator + containingTypeName + "_JNI.c");
-        CodeGenUtils.emitAutogeneratedWarning(newWriter, this);
-        emitCHeader(newWriter, containingTypeName);
-      }
-    } catch(Exception e)   {
-      throw new RuntimeException("Unable to open files for emission of struct class", e);
-    }
-
-    writer.println();
-    writer.println("package " + structClassPkg + ";");
-    writer.println();
-    writer.println("import java.nio.*;");
-    writer.println();
-
-    writer.println("import " + cfg.gluegenRuntimePackage() + ".*;");
-    writer.println("import " + DynamicLookupHelper.class.getPackage().getName() + ".*;");
-    writer.println("import " + Buffers.class.getPackage().getName() + ".*;");
-    writer.println();
-    List<String> imports = cfg.imports();
-    for (String str : imports) {
-      writer.print("import ");
-      writer.print(str);
-      writer.println(";");
-    }
-    writer.println();
-    List<String> javadoc = cfg.javadocForClass(containingTypeName);
-    for (String doc : javadoc) {
-      writer.println(doc);
-    }
-    writer.print((doBaseClass ? "public " : "") + (doBaseClass ? "abstract " : "") + "class " + containingTypeName + suffix + " ");
-    if (!doBaseClass) {
-      writer.print("extends " + containingTypeName + " ");
-    }
-    boolean firstIteration = true;
-    List<String> userSpecifiedInterfaces = cfg.implementedInterfaces(containingTypeName);
-    for (String userInterface : userSpecifiedInterfaces) {
-      if (firstIteration) {
-        writer.print("implements ");
-      }
-      firstIteration = false;
-      writer.print(userInterface);
-      writer.print(" ");
-    }
-    writer.println("{");
-    writer.println();
-    if (doBaseClass) {
-      writer.println("  StructAccessor accessor;");
-      writer.println();
-    }
-
-    writer.println("  public static int size() {");
-    if (doBaseClass) {
-      writer.println("    if (Platform.is32Bit()) {");
-      writer.println("      return " + containingTypeName + "32" + ".size();");
-      writer.println("    } else {");
-      writer.println("      return " + containingTypeName + "64" + ".size();");
-      writer.println("    }");
-    } else {
-      writer.println("    return " + structType.getSize(intMachDesc) + ";");
-    }
-    writer.println("  }");
-    writer.println();
-    if (doBaseClass) {
-      writer.println("  public static " + containingTypeName + " create() {");
-      writer.println("    return create(Buffers.newDirectByteBuffer(size()));");
-      writer.println("  }");
-      writer.println();
-      writer.println("  public static " + containingTypeName + " create(java.nio.ByteBuffer buf) {");
-      writer.println("    if (Platform.is32Bit()) {");
-      writer.println("      return new " + containingTypeName + "32(buf);");
-      writer.println("    } else {");
-      writer.println("      return new " + containingTypeName + "64(buf);");
-      writer.println("    }");
-      writer.println("  }");
-      writer.println();
-      writer.println("  " + containingTypeName + "(java.nio.ByteBuffer buf) {");
-      writer.println("    accessor = new StructAccessor(buf);");
-      writer.println("  }");
-      writer.println();
-      writer.println("  public java.nio.ByteBuffer getBuffer() {");
-      writer.println("    return accessor.getBuffer();");
-      writer.println("  }");
-    } else {
-      writer.println("  " + containingTypeName + suffix + "(java.nio.ByteBuffer buf) {");
-      writer.println("    super(buf);");
-      writer.println("  }");
-      writer.println();
-    }
-    for (int i = 0; i < structType.getNumFields(); i++) {
-
-      Field field = structType.getField(i);
-      Type fieldType = field.getType();
-
-      if (!cfg.shouldIgnoreInInterface(name + " " + field.getName())) {
-
-        String renamed = cfg.getJavaSymbolRename(field.getName());
-        String fieldName = renamed==null ? field.getName() : renamed;
-
-        if (fieldType.isFunctionPointer()) {
-
-          if (doBaseClass) {
-            try {
-              // Emit method call and associated native code
-              FunctionType   funcType     = fieldType.asPointer().getTargetType().asFunction();
-              FunctionSymbol funcSym      = new FunctionSymbol(fieldName, funcType);
-              MethodBinding  binding      = bindFunction(funcSym, containingType, containingCType, machDesc64);
-              binding.findThisPointer(); // FIXME: need to provide option to disable this on per-function basis
-              writer.println();
-
-              // Emit public Java entry point for calling this function pointer
-              JavaMethodBindingEmitter emitter =
-                new JavaMethodBindingEmitter(binding,
-                                             writer,
-                                             cfg.runtimeExceptionType(),
-                                             cfg.unsupportedExceptionType(),
-                                             true,
-                                             cfg.tagNativeBinding(),
-                                             false,
-                                             true, // FIXME: should unify this with the general emission code
-                                             false,
-                                             false, // FIXME: should unify this with the general emission code
-                                             false, // FIXME: should unify this with the general emission code
-                                             false, // FIXME: should unify this with the general emission code
-                                             false,
-                                             cfg);
-              emitter.addModifier(JavaMethodBindingEmitter.PUBLIC);
-              emitter.emit();
-
-              // Emit private native Java entry point for calling this function pointer
-              emitter =
-                new JavaMethodBindingEmitter(binding,
-                                             writer,
-                                             cfg.runtimeExceptionType(),
-                                             cfg.unsupportedExceptionType(),
-                                             false,
-                                             cfg.tagNativeBinding(),
-                                             true,
-                                             true, // FIXME: should unify this with the general emission code
-                                             true,
-                                             true, // FIXME: should unify this with the general emission code
-                                             false, // FIXME: should unify this with the general emission code
-                                             false, // FIXME: should unify this with the general emission code
-                                             false,
-                                             cfg);
-              emitter.addModifier(JavaMethodBindingEmitter.PRIVATE);
-              emitter.addModifier(JavaMethodBindingEmitter.NATIVE);
-              emitter.emit();
-
-              // Emit (private) C entry point for calling this function pointer
-              CMethodBindingEmitter cEmitter =
-                new CMethodBindingEmitter(binding,
-                                          newWriter,
-                                          structClassPkg,
-                                          containingTypeName,
-                                          true, // FIXME: this is optional at this point
-                                          false,
-                                          true,
-                                          false, // FIXME: should unify this with the general emission code
-                                          machDesc64);
-              prepCEmitter(binding, cEmitter);
-              cEmitter.emit();
-            } catch (Exception e) {
-              System.err.println("While processing field " + field + " of type " + name + ":");
-              throw(e);
-            }
-          }
-        } else if (fieldType.isCompound()) {
-          // FIXME: will need to support this at least in order to
-          // handle the union in jawt_Win32DrawingSurfaceInfo (fabricate
-          // a name?)
-          if (fieldType.getName() == null) {
-            throw new RuntimeException("Anonymous structs as fields not supported yet (field \"" +
-                                       field + "\" in type \"" + name + "\")");
-          }
-
-          writer.println();
-          generateGetterSignature(writer, doBaseClass, fieldType.getName(), capitalizeString(fieldName));
-          if (doBaseClass) {
-            writer.println(";");
-          } else {
-            writer.println(" {");
-            writer.println("    return " + fieldType.getName() + ".create(accessor.slice(" +
-                           field.getOffset(intMachDesc) + ", " + fieldType.getSize(intMachDesc) + "));");
-            writer.println("  }");
-          }
-
-        } else if (fieldType.isArray()) {
-
-            Type baseElementType = field.getType().asArray().getBaseElementType();
-
-            if(!baseElementType.isPrimitive())
-                break;
-
-            String paramType = typeToJavaType(baseElementType, false, extMachDesc).getName();
-            String capitalized = capitalizeString(fieldName);
-
-            int slot = -1;
-            if(!doBaseClass) {
-              slot = slot(fieldType, (int) field.getOffset(intMachDesc), intMachDesc);
-            }
-
-            // Setter
-            writer.println();
-            generateSetterSignature(writer, doBaseClass, containingTypeName, capitalized, paramType+"[]");
-            if (doBaseClass) {
-              writer.println(";");
-            } else {
-              writer.println(" {");
-              writer.print  ("    accessor.set" + capitalizeString(paramType) + "sAt(" + slot + ", ");
-              writer.println("val);");
-              writer.println("    return this;");
-              writer.println("  }");
-            }
-            writer.println();
-            // Getter
-            generateGetterSignature(writer, doBaseClass, paramType+"[]", capitalized);
-            if (doBaseClass) {
-              writer.println(";");
-            } else {
-              writer.println(" {");
-              writer.print  ("    return ");
-              writer.println("accessor.get" + capitalizeString(paramType) + "sAt(" + slot + ", new " +paramType+"["+fieldType.asArray().getLength()+"]);");
-              writer.println("  }");
-            }
-
-        } else {
-          JavaType internalJavaType = null;
-          JavaType externalJavaType = null;
-
-          try {
-            externalJavaType = typeToJavaType(fieldType, false, extMachDesc);
-            if (!doBaseClass) {
-              internalJavaType = typeToJavaType(fieldType, false, intMachDesc);
-            }
-          } catch (Exception e) {
-            System.err.println("Error occurred while creating accessor for field \"" +
-                               field.getName() + "\" in type \"" + name + "\"");
-            throw(e);
-          }
-          if (externalJavaType.isPrimitive()) {
-            // Primitive type
-            String externalJavaTypeName = null;
-            String internalJavaTypeName = null;
-            externalJavaTypeName = externalJavaType.getName();
-            if (!doBaseClass) {
-              internalJavaTypeName = internalJavaType.getName();
-            }
-            if (isOpaque(fieldType)) {
-              externalJavaTypeName = compatiblePrimitiveJavaTypeName(fieldType, externalJavaType, extMachDesc);
-              if (!doBaseClass) {
-                internalJavaTypeName = compatiblePrimitiveJavaTypeName(fieldType, internalJavaType, intMachDesc);
-              }
-            }
-            String capitalized = null;
-            if (!doBaseClass) {
-              capitalized = capitalizeString(internalJavaTypeName);
-            }
-            int slot = -1;
-            if (!doBaseClass) {
-              slot = slot(fieldType, (int) field.getOffset(intMachDesc), intMachDesc);
-            }
-            writer.println();
-            String capitalizedFieldName = capitalizeString(fieldName);
-            // Setter
-            generateSetterSignature(writer, doBaseClass, containingTypeName, capitalizedFieldName, externalJavaTypeName);
-            if (doBaseClass) {
-              writer.println(";");
-            } else {
-              writer.println(" {");
-              writer.print  ("    accessor.set" + capitalized + "At(" + slot + ", ");
-              if (!externalJavaTypeName.equals(internalJavaTypeName)) {
-                writer.print("(" + internalJavaTypeName + ") ");
-              }
-              writer.println("val);");
-              writer.println("    return this;");
-              writer.println("  }");
-            }
-            writer.println();
-            // Getter
-            generateGetterSignature(writer, doBaseClass, externalJavaTypeName, capitalizedFieldName);
-            if (doBaseClass) {
-              writer.println(";");
-            } else {
-              writer.println(" {");
-              writer.print  ("    return ");
-              if (!externalJavaTypeName.equals(internalJavaTypeName)) {
-                writer.print("(" + externalJavaTypeName + ") ");
-              }
-              writer.println("accessor.get" + capitalized + "At(" + slot + ");");
-              writer.println("  }");
-            }
-          } else {
-            // FIXME
-            LOG.log(WARNING, "Complicated fields (field \"{0}\" of type \"{1}\") not implemented yet", new Object[]{field, name});
-            //          throw new RuntimeException("Complicated fields (field \"" + field + "\" of type \"" + t +
-            //                                     "\") not implemented yet");
-          }
-        }
-      }
-    }
-    if (doBaseClass) {
-      emitCustomJavaCode(writer, containingTypeName);
-    }
-    writer.println("}");
-    writer.flush();
-    writer.close();
-    if (needsNativeCode) {
-      newWriter.flush();
-      newWriter.close();
-    }
-  }
-  public void endStructs() throws Exception {}
-
-  public static int addStrings2Buffer(StringBuilder buf, String sep, String first, Collection<String> col) {
-    int num = 0;
-    if(null==buf) {
-        buf = new StringBuilder();
-    }
-
-    Iterator<String> iter = col.iterator();
-    if(null!=first) {
-        buf.append(first);
-        if( iter.hasNext() ) {
-            buf.append(sep);
-        }
-        num++;
-    }
-    while( iter.hasNext() ) {
-        buf.append(iter.next());
-        if( iter.hasNext() ) {
-            buf.append(sep);
-        }
-        num++;
-    }
-    return num;
-  }
-
-  //----------------------------------------------------------------------
-  // Internals only below this point
-  //
-
-    private void generateGetterSignature(PrintWriter writer, boolean baseClass, String returnTypeName, String capitalizedFieldName) {
-        writer.print("  public " + (baseClass ? "abstract " : "") + returnTypeName + " get" + capitalizedFieldName + "()");
-    }
-
-    private void generateSetterSignature(PrintWriter writer, boolean baseClass, String returnTypeName, String capitalizedFieldName, String paramTypeName) {
-        writer.print("  public " + (baseClass ? "abstract " : "") + returnTypeName + " set" + capitalizedFieldName + "(" + paramTypeName + " val)");
-    }
-
-  private JavaType typeToJavaType(Type cType, boolean outgoingArgument, MachineDescription curMachDesc) {
-    // Recognize JNIEnv* case up front
-    PointerType opt = cType.asPointer();
-    if ((opt != null) &&
-        (opt.getTargetType().getName() != null) &&
-        (opt.getTargetType().getName().equals("JNIEnv"))) {
-      return JavaType.createForJNIEnv();
-    }
-    Type t = cType;
-
-    // Opaque specifications override automatic conversions
-    // in case the identity is being used .. not if ptr-ptr
-    TypeInfo info = cfg.typeInfo(t, typedefDictionary);
-    if (info != null) {
-      boolean isPointerPointer = false;
-      if (t.pointerDepth() > 0 || t.arrayDimension() > 0) {
-        Type targetType; // target type
-        if (t.isPointer()) {
-          // t is <type>*, we need to get <type>
-          targetType = t.asPointer().getTargetType();
-        } else {
-          // t is <type>[], we need to get <type>
-          targetType = t.asArray().getElementType();
-        }
-        if (t.pointerDepth() == 2 || t.arrayDimension() == 2) {
-          // Get the target type of the target type (targetType was computer earlier
-          // as to be a pointer to the target type, so now we need to get its
-          // target type)
-          if (targetType.isPointer()) {
-            isPointerPointer = true;
-
-            // t is<type>**, targetType is <type>*, we need to get <type>
-            Type bottomType = targetType.asPointer().getTargetType();
-            LOG.log(INFO, "Opaque Type: {0}, targetType: {1}, bottomType: {2} is ptr-ptr", new Object[]{t, targetType, bottomType});
-          }
-        }
-      }
-      if(!isPointerPointer) {
-          return info.javaType();
-      }
-    }
-
-    if (t.isInt() || t.isEnum()) {
-      switch ((int) t.getSize(curMachDesc)) {
-       case 1:  return javaType(Byte.TYPE);
-       case 2:  return javaType(Short.TYPE);
-       case 4:  return javaType(Integer.TYPE);
-       case 8:  return javaType(Long.TYPE);
-       default: throw new RuntimeException("Unknown integer type of size " +
-                                           t.getSize(curMachDesc) + " and name " + t.getName());
-      }
-    } else if (t.isFloat()) {
-      return javaType(Float.TYPE);
-    } else if (t.isDouble()) {
-      return javaType(Double.TYPE);
-    } else if (t.isVoid()) {
-      return javaType(Void.TYPE);
-    } else {
-      if (t.pointerDepth() > 0 || t.arrayDimension() > 0) {
-        Type targetType; // target type
-        if (t.isPointer()) {
-          // t is <type>*, we need to get <type>
-          targetType = t.asPointer().getTargetType();
-        } else {
-          // t is <type>[], we need to get <type>
-          targetType = t.asArray().getElementType();
-        }
-
-        // Handle Types of form pointer-to-type or array-of-type, like
-        // char* or int[]; these are expanded out into Java primitive
-        // arrays, NIO buffers, or both in expandMethodBinding
-        if (t.pointerDepth() == 1 || t.arrayDimension() == 1) {
-          if (targetType.isVoid()) {
-            return JavaType.createForVoidPointer();
-          } else if (targetType.isInt()) {
-            // size_t and intptr_t is always a PointerBuffer since size is arch dependent
-            if ("size_t".equals(targetType.getName()) || "intptr_t".equals(targetType.getName())) {
-              return JavaType.forNIOPointerBufferClass();
-            }
-            switch ((int) targetType.getSize(curMachDesc)) {
-              case 1:  return JavaType.createForCCharPointer();
-              case 2:  return JavaType.createForCShortPointer();
-              case 4:  return JavaType.createForCInt32Pointer();
-              case 8:  return JavaType.createForCInt64Pointer();
-              default: throw new RuntimeException("Unknown integer array type of size " +
-                                                  t.getSize(curMachDesc) + " and name " + t.getName());
-            }
-          } else if (targetType.isFloat()) {
-            return JavaType.createForCFloatPointer();
-          } else if (targetType.isDouble()) {
-            return JavaType.createForCDoublePointer();
-          } else if (targetType.isCompound()) {
-            if (t.isArray()) {
-              throw new RuntimeException("Arrays of compound types not handled yet");
-            }
-            // Special cases for known JNI types (in particular for converting jawt.h)
-            if (t.getName() != null &&
-                t.getName().equals("jobject")) {
-              return javaType(java.lang.Object.class);
-            }
-
-            String name = targetType.getName();
-            if (name == null) {
-              // Try containing pointer type for any typedefs
-              name = t.getName();
-              if (name == null) {
-                throw new RuntimeException("Couldn't find a proper type name for pointer type " + t);
-              }
-            }
-
-            return JavaType.createForCStruct(cfg.renameJavaType(name));
-          } else {
-            throw new RuntimeException("Don't know how to convert pointer/array type \"" +
-                                       t + "\"");
-          }
-        }
-        // Handle Types of form pointer-to-pointer-to-type or
-        // array-of-arrays-of-type, like char** or int[][]
-        else if (t.pointerDepth() == 2 || t.arrayDimension() == 2) {
-          // Get the target type of the target type (targetType was computer earlier
-          // as to be a pointer to the target type, so now we need to get its
-          // target type)
-          Type bottomType;
-          if (targetType.isPointer()) {
-            // t is<type>**, targetType is <type>*, we need to get <type>
-            bottomType = targetType.asPointer().getTargetType();
-            return JavaType.forNIOPointerBufferClass();
-          } else {
-            // t is<type>[][], targetType is <type>[], we need to get <type>
-            bottomType = targetType.asArray().getElementType();
-            LOG.log(WARNING, "typeToJavaType(ptr-ptr): {0}, targetType: {1}, bottomType: {2} -> Unhandled!", new Object[]{t, targetType, bottomType});
-          }
-
-          // Warning: The below code is not backed up by an implementation,
-          //          the only working variant is a ptr-ptr type which results in a PointerBuffer.
-          //
-          if (bottomType.isPrimitive()) {
-            if (bottomType.isInt()) {
-              switch ((int) bottomType.getSize(curMachDesc)) {
-                case 1: return javaType(ArrayTypes.byteBufferArrayClass);
-                case 2: return javaType(ArrayTypes.shortBufferArrayClass);
-                case 4: return javaType(ArrayTypes.intBufferArrayClass);
-                case 8: return javaType(ArrayTypes.longBufferArrayClass);
-                default: throw new RuntimeException("Unknown two-dimensional integer array type of element size " +
-                                                    bottomType.getSize(curMachDesc) + " and name " + bottomType.getName());
-              }
-            } else if (bottomType.isFloat()) {
-              return javaType(ArrayTypes.floatBufferArrayClass);
-            } else if (bottomType.isDouble()) {
-              return javaType(ArrayTypes.doubleBufferArrayClass);
-            } else {
-              throw new RuntimeException("Unexpected primitive type " + bottomType.getName() +
-                                         " in two-dimensional array");
-            }
-          } else if (bottomType.isVoid()) {
-            return javaType(ArrayTypes.bufferArrayClass);
-          } else if (targetType.isPointer() && (targetType.pointerDepth() == 1) &&
-                     targetType.asPointer().getTargetType().isCompound()) {
-            // Array of pointers; convert as array of StructAccessors
-            return JavaType.createForCArray(bottomType);
-          } else {
-            throw new RuntimeException(
-              "Could not convert C type \"" + t + "\" " +
-              "to appropriate Java type; need to add more support for " +
-              "depth=2 pointer/array types [debug info: targetType=\"" +
-              targetType + "\"]");
-          }
-        } else {
-          // can't handle this type of pointer/array argument
-          throw new RuntimeException(
-            "Could not convert C pointer/array \"" + t + "\" to " +
-            "appropriate Java type; types with pointer/array depth " +
-            "greater than 2 are not yet supported [debug info: " +
-            "pointerDepth=" + t.pointerDepth() + " arrayDimension=" +
-            t.arrayDimension() + " targetType=\"" + targetType + "\"]");
-        }
-
-      } else {
-        throw new RuntimeException(
-          "Could not convert C type \"" + t + "\" (class " +
-          t.getClass().getName() + ") to appropriate Java type");
-      }
-    }
-  }
-
-  private static boolean isIntegerType(Class<?> c) {
-    return ((c == Byte.TYPE) ||
-            (c == Short.TYPE) ||
-            (c == Character.TYPE) ||
-            (c == Integer.TYPE) ||
-            (c == Long.TYPE));
-  }
-
-  private int slot(Type t, int byteOffset, MachineDescription curMachDesc) {
-    if (t.isInt()) {
-      switch ((int) t.getSize(curMachDesc)) {
-       case 1:
-       case 2:
-       case 4:
-       case 8:  return byteOffset / (int) t.getSize(curMachDesc);
-       default: throw new RuntimeException("Illegal type");
-      }
-    } else if (t.isFloat()) {
-      return byteOffset / 4;
-    } else if (t.isDouble()) {
-      return byteOffset / 8;
-    } else if (t.isPointer()) {
-      return byteOffset / curMachDesc.pointerSizeInBytes();
-    } else if (t.isArray()) {
-      return slot(t.asArray().getBaseElementType(), byteOffset, curMachDesc);
-    } else {
-      throw new RuntimeException("Illegal type " + t);
-    }
-  }
-
-  private StructLayout getLayout() {
-    if (layout == null) {
-      layout = StructLayout.createForCurrentPlatform();
-    }
-    return layout;
-  }
-
-  protected PrintWriter openFile(String filename) throws IOException {
-    //System.out.println("Trying to open: " + filename);
-    File file = new File(filename);
-    String parentDir = file.getParent();
-    if (parentDir != null)
-    {
-      File pDirFile = new File(parentDir);
-      pDirFile.mkdirs();
-    }
-    return new PrintWriter(new BufferedWriter(new FileWriter(file)));
-  }
-
-  private boolean isOpaque(Type type) {
-    return (cfg.typeInfo(type, typedefDictionary) != null);
-  }
-
-  private String compatiblePrimitiveJavaTypeName(Type fieldType,
-                                                 JavaType javaType,
-                                                 MachineDescription curMachDesc) {
-    Class<?> c = javaType.getJavaClass();
-    if (!isIntegerType(c)) {
-      // FIXME
-      throw new RuntimeException("Can't yet handle opaque definitions of structs' fields to non-integer types (byte, short, int, long, etc.)");
-    }
-    switch ((int) fieldType.getSize(curMachDesc)) {
-      case 1:  return "byte";
-      case 2:  return "short";
-      case 4:  return "int";
-      case 8:  return "long";
-      default: throw new RuntimeException("Can't handle opaque definitions if the starting type isn't compatible with integral types");
-    }
-  }
-
-  private void openWriters() throws IOException {
-    String jRoot = null;
-    if (cfg.allStatic() || cfg.emitInterface()) {
-      jRoot = cfg.javaOutputDir() + File.separator +
-        CodeGenUtils.packageAsPath(cfg.packageName());
-    }
-    String jImplRoot = null;
-    if (!cfg.allStatic()) {
-      jImplRoot =
-        cfg.javaOutputDir() + File.separator +
-        CodeGenUtils.packageAsPath(cfg.implPackageName());
-    }
-    String nRoot = cfg.nativeOutputDir();
-    if (cfg.nativeOutputUsesJavaHierarchy())
-    {
-      nRoot +=
-        File.separator + CodeGenUtils.packageAsPath(cfg.packageName());
-    }
-
-    if (cfg.allStatic() || cfg.emitInterface()) {
-      javaWriter = openFile(jRoot + File.separator + cfg.className() + ".java");
-    }
-    if (!cfg.allStatic() && cfg.emitImpl()) {
-      javaImplWriter = openFile(jImplRoot + File.separator + cfg.implClassName() + ".java");
-    }
-    if (cfg.emitImpl()) {
-      cWriter = openFile(nRoot + File.separator + cfg.implClassName() + "_JNI.c");
-    }
-
-    if (javaWriter != null) {
-      CodeGenUtils.emitAutogeneratedWarning(javaWriter, this);
-    }
-    if (javaImplWriter != null) {
-      CodeGenUtils.emitAutogeneratedWarning(javaImplWriter, this);
-    }
-    if (cWriter != null) {
-      CodeGenUtils.emitAutogeneratedWarning(cWriter, this);
-    }
-  }
-
-  protected PrintWriter javaWriter() {
-    if (!cfg.allStatic() && !cfg.emitInterface()) {
-      throw new InternalError("Should not call this");
-    }
-    return javaWriter;
-  }
-
-  protected PrintWriter javaImplWriter() {
-    if (cfg.allStatic() || !cfg.emitImpl()) {
-      throw new InternalError("Should not call this");
-    }
-    return javaImplWriter;
-  }
-
-  protected PrintWriter cWriter() {
-    if (!cfg.emitImpl()) {
-      throw new InternalError("Should not call this");
-    }
-    return cWriter;
-  }
-
-  private void closeWriter(PrintWriter writer) throws IOException {
-    writer.flush();
-    writer.close();
-  }
-
-  private void closeWriters() throws IOException {
-    if (javaWriter != null) {
-      closeWriter(javaWriter);
-    }
-    if (javaImplWriter != null) {
-      closeWriter(javaImplWriter);
-    }
-    if (cWriter != null) {
-      closeWriter(cWriter);
-    }
-    javaWriter = null;
-    javaImplWriter = null;
-    cWriter = null;
-  }
-
-  /**
-   * Returns the value that was specified by the configuration directive
-   * "JavaOutputDir", or the default if none was specified.
-   */
-  protected String getJavaOutputDir() {
-    return cfg.javaOutputDir();
-  }
-
-  /**
-   * Returns the value that was specified by the configuration directive
-   * "Package", or the default if none was specified.
-   */
-  protected String getJavaPackageName() {
-    return cfg.packageName();
-  }
-
-  /**
-   * Returns the value that was specified by the configuration directive
-   * "ImplPackage", or the default if none was specified.
-   */
-  protected String getImplPackageName() {
-    return cfg.implPackageName();
-  }
-
-  /**
-   * Emit all the strings specified in the "CustomJavaCode" parameters of
-   * the configuration file.
-   */
-  protected void emitCustomJavaCode(PrintWriter writer, String className) throws Exception  {
-    List<String> code = cfg.customJavaCodeForClass(className);
-    if (code.isEmpty())
-      return;
-
-    writer.println();
-    writer.println("  // --- Begin CustomJavaCode .cfg declarations");
-    for (String line : code) {
-      writer.println(line);
-    }
-    writer.println("  // ---- End CustomJavaCode .cfg declarations");
-  }
-
-  /**
-   * Write out any header information for the output files (class declaration
-   * and opening brace, import statements, etc).
-   */
-  protected void emitAllFileHeaders() throws IOException {
-    try {
-        List<String> imports = new ArrayList<String>(cfg.imports());
-        imports.add(cfg.gluegenRuntimePackage()+".*");
-        imports.add(DynamicLookupHelper.class.getPackage().getName()+".*");
-        imports.add(Buffers.class.getPackage().getName()+".*");
-        imports.add(Buffer.class.getPackage().getName()+".*");
-
-      if (cfg.allStatic() || cfg.emitInterface()) {
-
-        String[] interfaces;
-        List<String> userSpecifiedInterfaces = null;
-        if (cfg.emitInterface()) {
-          userSpecifiedInterfaces = cfg.extendedInterfaces(cfg.className());
-        } else {
-          userSpecifiedInterfaces = cfg.implementedInterfaces(cfg.className());
-        }
-        interfaces = new String[userSpecifiedInterfaces.size()];
-        userSpecifiedInterfaces.toArray(interfaces);
-
-        final List<String> intfDocs = cfg.javadocForClass(cfg.className());
-        CodeGenUtils.EmissionCallback docEmitter =
-          new CodeGenUtils.EmissionCallback() {
-            public void emit(PrintWriter w) {
-              for (Iterator iter = intfDocs.iterator(); iter.hasNext(); ) {
-                w.println((String) iter.next());
-              }
-            }
-          };
-
-        String[] accessModifiers = null;
-        if(cfg.accessControl(cfg.className()) == PUBLIC_ABSTRACT) {
-            accessModifiers = new String[] { "public", "abstract" };
-        } else {
-            accessModifiers = new String[] { "public" };
-        }
-
-        CodeGenUtils.emitJavaHeaders(
-          javaWriter,
-          cfg.packageName(),
-          cfg.className(),
-          cfg.allStatic() ? true : false,
-          imports,
-          accessModifiers,
-          interfaces,
-          cfg.extendedParentClass(cfg.className()),
-          docEmitter);
-      }
-
-      if (!cfg.allStatic() && cfg.emitImpl()) {
-        final List<String> implDocs = cfg.javadocForClass(cfg.implClassName());
-        CodeGenUtils.EmissionCallback docEmitter =
-          new CodeGenUtils.EmissionCallback() {
-            public void emit(PrintWriter w) {
-              for (Iterator iter = implDocs.iterator(); iter.hasNext(); ) {
-                w.println((String) iter.next());
-              }
-            }
-          };
-
-        String[] interfaces;
-        List<String> userSpecifiedInterfaces = null;
-        userSpecifiedInterfaces = cfg.implementedInterfaces(cfg.implClassName());
-        int additionalNum = 0;
-        if (cfg.className() != null) {
-          additionalNum = 1;
-        }
-        interfaces = new String[additionalNum + userSpecifiedInterfaces.size()];
-        userSpecifiedInterfaces.toArray(interfaces);
-        if (additionalNum == 1) {
-          interfaces[userSpecifiedInterfaces.size()] = cfg.className();
-        }
-
-        String[] accessModifiers = null;
-        if(cfg.accessControl(cfg.implClassName()) == PUBLIC_ABSTRACT) {
-            accessModifiers = new String[] { "public", "abstract" };
-        } else {
-            accessModifiers = new String[] { "public" };
-        }
-
-        CodeGenUtils.emitJavaHeaders(
-          javaImplWriter,
-          cfg.implPackageName(),
-          cfg.implClassName(),
-          true,
-          imports,
-          accessModifiers,
-          interfaces,
-          cfg.extendedParentClass(cfg.implClassName()),
-          docEmitter);
-      }
-
-      if (cfg.emitImpl()) {
-        emitCHeader(cWriter(), cfg.implClassName());
-      }
-    } catch (Exception e) {
-      throw new RuntimeException(
-        "Error emitting all file headers: cfg.allStatic()=" + cfg.allStatic() +
-        " cfg.emitImpl()=" + cfg.emitImpl() + " cfg.emitInterface()=" + cfg.emitInterface(),
-        e);
-    }
-
-  }
-
-  protected void emitCHeader(PrintWriter cWriter, String className) {
-    cWriter.println("#include <jni.h>");
-    cWriter.println("#include <stdlib.h>");
-    cWriter.println();
-
-    if (getConfig().emitImpl()) {
-      cWriter.println("#include <assert.h>");
-      cWriter.println();
-    }
-
-    for (String code : cfg.customCCode()) {
-      cWriter.println(code);
-    }
-    cWriter.println();
-  }
-
-  /**
-   * Write out any footer information for the output files (closing brace of
-   * class definition, etc).
-   */
-  protected void emitAllFileFooters(){
-    if (cfg.allStatic() || cfg.emitInterface()) {
-      javaWriter().println();
-      javaWriter().println("} // end of class " + cfg.className());
-    }
-    if (!cfg.allStatic() && cfg.emitImpl())  {
-      javaImplWriter().println();
-      javaImplWriter().println("} // end of class " + cfg.implClassName());
-    }
-  }
-
-  private JavaType javaType(Class<?> c) {
-    return JavaType.createForClass(c);
-  }
-
-  /** Maps the C types in the specified function to Java types through
-      the MethodBinding interface. Note that the JavaTypes in the
-      returned MethodBinding are "intermediate" JavaTypes (some
-      potentially representing C pointers rather than true Java types)
-      and must be lowered to concrete Java types before creating
-      emitters for them. */
-  private MethodBinding bindFunction(FunctionSymbol sym,
-                                     JavaType containingType,
-                                     Type containingCType,
-                                     MachineDescription curMachDesc) {
-
-    MethodBinding binding = new MethodBinding(sym, containingType, containingCType);
-
-    binding.renameMethodName(cfg.getJavaSymbolRename(sym.getName()));
-
-    // System.out.println("bindFunction(0) "+sym.getReturnType());
-
-    if (cfg.returnsString(binding.getName())) {
-      PointerType prt = sym.getReturnType().asPointer();
-      if (prt == null ||
-          prt.getTargetType().asInt() == null ||
-          prt.getTargetType().getSize(curMachDesc) != 1) {
-        throw new RuntimeException(
-          "Cannot apply ReturnsString configuration directive to \"" + sym +
-          "\". ReturnsString requires native method to have return type \"char *\"");
-      }
-      binding.setJavaReturnType(javaType(java.lang.String.class));
-    } else {
-      binding.setJavaReturnType(typeToJavaType(sym.getReturnType(), false, curMachDesc));
-    }
-
-    // System.out.println("bindFunction(1) "+binding.getJavaReturnType());
-
-    // List of the indices of the arguments in this function that should be
-    // converted from byte[] or short[] to String
-    List<Integer> stringArgIndices = cfg.stringArguments(binding.getName());
-
-    for (int i = 0; i < sym.getNumArguments(); i++) {
-      Type cArgType = sym.getArgumentType(i);
-      JavaType mappedType = typeToJavaType(cArgType, true, curMachDesc);
-      // System.out.println("C arg type -> \"" + cArgType + "\"" );
-      // System.out.println("      Java -> \"" + mappedType + "\"" );
-
-      // Take into account any ArgumentIsString configuration directives that apply
-      if (stringArgIndices != null && stringArgIndices.contains(i)) {
-        // System.out.println("Forcing conversion of " + binding.getName() + " arg #" + i + " from byte[] to String ");
-        if (mappedType.isCVoidPointerType() ||
-            mappedType.isCCharPointerType() ||
-            mappedType.isCShortPointerType() ||
-            mappedType.isNIOPointerBuffer() ||
-            (mappedType.isArray() &&
-             (mappedType.getJavaClass() == ArrayTypes.byteBufferArrayClass) ||
-             (mappedType.getJavaClass() == ArrayTypes.shortBufferArrayClass))) {
-          // convert mapped type from:
-          //   void*, byte[], and short[] to String
-          //   ByteBuffer[] and ShortBuffer[] to String[]
-          if (mappedType.isArray() || mappedType.isNIOPointerBuffer()) {
-            mappedType = javaType(ArrayTypes.stringArrayClass);
-          } else {
-            mappedType = javaType(String.class);
-          }
-        }
-        else {
-        throw new RuntimeException(
-          "Cannot apply ArgumentIsString configuration directive to " +
-          "argument " + i + " of \"" + sym + "\": argument type is not " +
-          "a \"void*\", \"char *\", \"short *\", \"char**\", or \"short**\" equivalent");
-        }
-      }
-      binding.addJavaArgumentType(mappedType);
-      //System.out.println("During binding of [" + sym + "], added mapping from C type: " + cArgType + " to Java type: " + mappedType);
-    }
-
-    // System.out.println("---> " + binding);
-    // System.out.println("    ---> " + binding.getCSymbol());
-    // System.out.println("bindFunction(3) "+binding);
-    return binding;
-  }
-
-  private MethodBinding lowerMethodBindingPointerTypes(MethodBinding inputBinding,
-                                                       boolean convertToArrays,
-                                                       boolean[] canProduceArrayVariant) {
-    MethodBinding result = inputBinding;
-    boolean arrayPossible = false;
-
-    // System.out.println("lowerMethodBindingPointerTypes(0): "+result);
-
-    for (int i = 0; i < inputBinding.getNumArguments(); i++) {
-      JavaType t = inputBinding.getJavaArgumentType(i);
-      if (t.isCPrimitivePointerType()) {
-        if (t.isCVoidPointerType()) {
-          // These are always bound to java.nio.Buffer
-          result = result.replaceJavaArgumentType(i, JavaType.forNIOBufferClass());
-        } else if (t.isCCharPointerType()) {
-          arrayPossible = true;
-          if (convertToArrays) {
-            result = result.replaceJavaArgumentType(i, javaType(ArrayTypes.byteArrayClass));
-          } else {
-            result = result.replaceJavaArgumentType(i, JavaType.forNIOByteBufferClass());
-          }
-        } else if (t.isCShortPointerType()) {
-          arrayPossible = true;
-          if (convertToArrays) {
-            result = result.replaceJavaArgumentType(i, javaType(ArrayTypes.shortArrayClass));
-          } else {
-            result = result.replaceJavaArgumentType(i, JavaType.forNIOShortBufferClass());
-          }
-        } else if (t.isCInt32PointerType()) {
-          arrayPossible = true;
-          if (convertToArrays) {
-            result = result.replaceJavaArgumentType(i, javaType(ArrayTypes.intArrayClass));
-          } else {
-            result = result.replaceJavaArgumentType(i, JavaType.forNIOIntBufferClass());
-          }
-        } else if (t.isCInt64PointerType()) {
-          arrayPossible = true;
-          if (convertToArrays) {
-            result = result.replaceJavaArgumentType(i, javaType(ArrayTypes.longArrayClass));
-          } else {
-            result = result.replaceJavaArgumentType(i, JavaType.forNIOInt64BufferClass());
-          }
-        } else if (t.isCFloatPointerType()) {
-          arrayPossible = true;
-          if (convertToArrays) {
-            result = result.replaceJavaArgumentType(i, javaType(ArrayTypes.floatArrayClass));
-          } else {
-            result = result.replaceJavaArgumentType(i, JavaType.forNIOFloatBufferClass());
-          }
-        } else if (t.isCDoublePointerType()) {
-          arrayPossible = true;
-          if (convertToArrays) {
-            result = result.replaceJavaArgumentType(i, javaType(ArrayTypes.doubleArrayClass));
-          } else {
-            result = result.replaceJavaArgumentType(i, JavaType.forNIODoubleBufferClass());
-          }
-        } else {
-          throw new RuntimeException("Unknown C pointer type " + t);
-        }
-      }
-    }
-
-    // System.out.println("lowerMethodBindingPointerTypes(1): "+result);
-
-    // Always return primitive pointer types as NIO buffers
-    JavaType t = result.getJavaReturnType();
-    if (t.isCPrimitivePointerType()) {
-      if (t.isCVoidPointerType()) {
-        result = result.replaceJavaArgumentType(-1, JavaType.forNIOByteBufferClass());
-      } else if (t.isCCharPointerType()) {
-        result = result.replaceJavaArgumentType(-1, JavaType.forNIOByteBufferClass());
-      } else if (t.isCShortPointerType()) {
-        result = result.replaceJavaArgumentType(-1, JavaType.forNIOShortBufferClass());
-      } else if (t.isCInt32PointerType()) {
-        result = result.replaceJavaArgumentType(-1, JavaType.forNIOIntBufferClass());
-      } else if (t.isCInt64PointerType()) {
-        result = result.replaceJavaArgumentType(-1, JavaType.forNIOInt64BufferClass());
-      } else if (t.isCFloatPointerType()) {
-        result = result.replaceJavaArgumentType(-1, JavaType.forNIOFloatBufferClass());
-      } else if (t.isCDoublePointerType()) {
-        result = result.replaceJavaArgumentType(-1, JavaType.forNIODoubleBufferClass());
-      } else {
-        throw new RuntimeException("Unknown C pointer type " + t);
-      }
-    }
-
-    // System.out.println("lowerMethodBindingPointerTypes(2): "+result);
-
-    if (canProduceArrayVariant != null) {
-      canProduceArrayVariant[0] = arrayPossible;
-    }
-
-    return result;
-  }
-
-  // Expands a MethodBinding containing C primitive pointer types into
-  // multiple variants taking Java primitive arrays and NIO buffers, subject
-  // to the per-function "NIO only" rule in the configuration file
-  protected List<MethodBinding> expandMethodBinding(MethodBinding binding) {
-
-    List<MethodBinding> result = new ArrayList<MethodBinding>();
-    // Indicates whether it is possible to produce an array variant
-    // Prevents e.g. char* -> String conversions from emitting two entry points
-    boolean[] canProduceArrayVariant = new boolean[1];
-
-    if (binding.signatureUsesCPrimitivePointers() ||
-        binding.signatureUsesCVoidPointers() ||
-        binding.signatureUsesCArrays()) {
-
-      result.add(lowerMethodBindingPointerTypes(binding, false, canProduceArrayVariant));
-
-      // FIXME: should add new configuration flag for this
-      if (canProduceArrayVariant[0] && (binding.signatureUsesCPrimitivePointers() || binding.signatureUsesCArrays()) &&
-          !cfg.nioDirectOnly(binding.getName()) && !cfg.nioOnly(binding.getName())) {
-        result.add(lowerMethodBindingPointerTypes(binding, true, null));
-      }
-    } else {
-      result.add(binding);
-    }
-
-    return result;
-  }
-
-  private String resultName() {
-    return "_res";
-  }
-
-  private Type canonicalize(Type t) {
-    Type res = canonMap.get(t);
-    if (res != null) {
-      return res;
-    }
-    canonMap.put(t, t);
-    return t;
-  }
-
-  /**
-   * Converts first letter to upper case.
-   */
-  private final String capitalizeString(String string) {
-      return Character.toUpperCase(string.charAt(0)) + string.substring(1);
-  }
-
-}