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

1 files changed, 639 insertions, 0 deletions

diff --git a/src/java/com/jogamp/gluegen/MethodBinding.java b/src/java/com/jogamp/gluegen/MethodBinding.java
new file mode 100644
index 0000000..a8d4b30
--- /dev/null
+++ b/src/java/com/jogamp/gluegen/MethodBinding.java
@@ -0,0 +1,639 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ *
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ *
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.gluegen;
+
+import com.jogamp.gluegen.cgram.types.FunctionSymbol;
+import com.jogamp.gluegen.cgram.types.Type;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+
+/** Represents the binding of a C function to a Java method. Also used
+    to represent calls through function pointers contained in
+    structs. */
+
+public class MethodBinding {
+
+  private FunctionSymbol sym;
+  private String         renamedMethodName;
+  private HashSet<String> aliasedNames;
+  private JavaType       javaReturnType;
+  private List<JavaType> javaArgumentTypes;
+  private boolean        computedSignatureProperties;
+  private boolean        argumentsUseNIO;
+  private boolean        signatureUsesNIO;
+  private boolean        signatureCanUseIndirectNIO;
+  private boolean        signatureUsesCompoundTypeWrappers;
+  private boolean        signatureUsesArraysOfCompoundTypeWrappers;
+  private boolean        signatureUsesCVoidPointers;
+  private boolean        signatureUsesCPrimitivePointers;
+  private boolean        signatureUsesCArrays;
+  private boolean        signatureUsesJavaPrimitiveArrays;
+  private JavaType       containingType;
+  private Type           containingCType;
+  private int            thisPointerIndex = -1;
+
+  /**
+   * Constructs a new MethodBinding that is an exact clone of the
+   * argument, including the java return type and java argument
+   * types. It's safe to modify this binding after construction.
+   */
+  public MethodBinding(MethodBinding bindingToCopy) {
+    this.sym = bindingToCopy.sym;
+
+    this.renamedMethodName                = bindingToCopy.renamedMethodName;
+    this.aliasedNames                     = new HashSet<String>(bindingToCopy.aliasedNames);
+    this.containingType                   = bindingToCopy.containingType;
+    this.containingCType                  = bindingToCopy.containingCType;
+    this.javaReturnType                   = bindingToCopy.javaReturnType;
+    this.javaArgumentTypes                = ( null != bindingToCopy.javaArgumentTypes ) ? new ArrayList<JavaType>(bindingToCopy.javaArgumentTypes) : null;
+    this.computedSignatureProperties      = bindingToCopy.computedSignatureProperties;
+    this.argumentsUseNIO                  = bindingToCopy.argumentsUseNIO;
+    this.signatureUsesNIO                 = bindingToCopy.signatureUsesNIO;
+    this.signatureCanUseIndirectNIO       = bindingToCopy.signatureCanUseIndirectNIO;
+    this.signatureUsesCompoundTypeWrappers = bindingToCopy.signatureUsesCompoundTypeWrappers;
+    this.signatureUsesArraysOfCompoundTypeWrappers = bindingToCopy.signatureUsesArraysOfCompoundTypeWrappers;
+    this.signatureUsesCVoidPointers       = bindingToCopy.signatureUsesCVoidPointers;
+    this.signatureUsesCPrimitivePointers  = bindingToCopy.signatureUsesCPrimitivePointers;
+    this.signatureUsesCArrays             = bindingToCopy.signatureUsesCArrays;
+    this.signatureUsesJavaPrimitiveArrays = bindingToCopy.signatureUsesJavaPrimitiveArrays;
+    this.thisPointerIndex                 = bindingToCopy.thisPointerIndex;
+  }
+
+  /** Constructor for calling a C function. */
+  public MethodBinding(FunctionSymbol sym) {
+    this.sym = sym;
+    this.aliasedNames = new HashSet<String>();
+  }
+
+  /** Constructor for calling a function pointer contained in a
+      struct. */
+  public MethodBinding(FunctionSymbol sym, JavaType containingType, Type containingCType) {
+    this.sym = sym;
+    this.containingType = containingType;
+    this.containingCType = containingCType;
+    this.aliasedNames = new HashSet<String>();
+  }
+
+    public void setJavaReturnType(JavaType type) {
+        javaReturnType = type;
+        computedSignatureProperties = false;
+    }
+
+    public void addJavaArgumentType(JavaType type) {
+        if (javaArgumentTypes == null) {
+            javaArgumentTypes = new ArrayList<JavaType>();
+        }
+        javaArgumentTypes.add(type);
+        computedSignatureProperties = false;
+    }
+
+    public JavaType getJavaReturnType() {
+        return javaReturnType;
+    }
+
+    public int getNumArguments() {
+        return sym.getNumArguments();
+    }
+
+    public JavaType getJavaArgumentType(int i) {
+        return javaArgumentTypes.get(i);
+    }
+
+    public Type getCReturnType() {
+        return sym.getReturnType();
+    }
+
+    public Type getCArgumentType(int i) {
+        return sym.getArgumentType(i);
+    }
+
+    public FunctionSymbol getCSymbol() {
+        return sym;
+    }
+
+    /** Returns either the argument name specified by the underlying
+    FunctionSymbol or a fabricated argument name based on the
+    position. Note that it is currently not guaranteed that there
+    are no namespace clashes with these fabricated argument
+    names. */
+    public String getArgumentName(int i) {
+        String ret = sym.getArgumentName(i);
+        if (ret != null) {
+            return ret;
+        }
+        return "arg" + i;
+    }
+
+    public String getOrigName() {
+        return sym.getName();
+    }
+
+    public String getName() {
+        // Defaults to same as C symbol unless renamed
+        if (renamedMethodName != null) {
+            return renamedMethodName;
+        }
+        return sym.getName();
+    }
+
+    /** Supports renaming C function in Java binding. */
+    public void renameMethodName(String name) {
+        if (null != name) {
+            renamedMethodName = name;
+            aliasedNames.add(sym.getName());
+        }
+    }
+
+    public void addAliasedName(String name) {
+        aliasedNames.add(name);
+    }
+
+    public Collection<String> getAliasedNames() {
+        return aliasedNames;
+    }
+
+  /** Creates a new MethodBinding replacing the specified Java
+      argument type with a new argument type. If argumentNumber is
+      less than 0 then replaces the return type. */
+  public MethodBinding replaceJavaArgumentType(int argumentNumber, JavaType newArgType) {
+
+    MethodBinding binding = (MethodBinding) clone();
+    binding.javaArgumentTypes = null;
+    if (argumentNumber < 0) {
+      binding.setJavaReturnType(newArgType);
+    } else {
+      binding.setJavaReturnType(javaReturnType);
+    }
+    for (int i = 0; i < getNumArguments(); i++) {
+      JavaType type = getJavaArgumentType(i);
+      if (i == argumentNumber) {
+        type = newArgType;
+      }
+      binding.addJavaArgumentType(type);
+    }
+    return binding;
+  }
+
+  /**
+   * Returns true if any of the outgoing arguments in the method's
+   * signature require conversion or checking due to the use of New
+   * I/O.
+   */
+  public boolean argumentsUseNIO() {
+    computeSignatureProperties();
+    return argumentsUseNIO;
+  }
+
+  /**
+   * Returns true if the return type or any of the outgoing arguments
+   * in the method's signature require conversion or checking due to
+   * the use of New I/O.
+   */
+  public boolean signatureUsesNIO() {
+    computeSignatureProperties();
+    return signatureUsesNIO;
+  }
+
+  /**
+   * Returns true if it is possible for any of the outgoing arguments
+   * to be indirect NIO buffers.
+   */
+  public boolean signatureCanUseIndirectNIO() {
+    computeSignatureProperties();
+    return signatureCanUseIndirectNIO;
+  }
+
+  /**
+   * Returns true if the return type or any of the outgoing arguments
+   * in the method's signature use "compound type wrappers", or
+   * NIO-based wrappers for C data structures.
+   */
+  public boolean signatureUsesCompoundTypeWrappers() {
+    computeSignatureProperties();
+    return signatureUsesCompoundTypeWrappers;
+  }
+
+  /**
+   * Returns true if the return type or any of the outgoing arguments
+   * in the method's signature use arrays of "compound type wrappers",
+   * or NIO-based wrappers for C data structures.
+   */
+  public boolean signatureUsesArraysOfCompoundTypeWrappers() {
+    computeSignatureProperties();
+    return signatureUsesArraysOfCompoundTypeWrappers;
+  }
+
+  /**
+   * Returns true if the function needs NIO-related
+   * wrapping/unwrapping or conversion of various arguments. Currently
+   * this returns the logical OR of signatureUsesNIO() and
+   * signatureUsesCompoundTypeWrappers().
+   */
+  public boolean needsNIOWrappingOrUnwrapping() {
+    return (signatureUsesNIO() || signatureUsesCompoundTypeWrappers());
+  }
+
+  /**
+   * Returns true if the return type or any of the outgoing arguments
+   * in the method's signature represent C void* pointers.
+   */
+  public boolean signatureUsesCVoidPointers() {
+    computeSignatureProperties();
+    return signatureUsesCVoidPointers;
+  }
+
+  /**
+   * Returns true if the return type or any of the outgoing arguments
+   * in the method's signature represent C primitive pointers.
+   */
+  public boolean signatureUsesCPrimitivePointers() {
+    computeSignatureProperties();
+    return signatureUsesCPrimitivePointers;
+  }
+
+  /**
+   * Returns true if the return type or any of the outgoing arguments
+   * in the method's signature represent C arrays.
+   */
+  public boolean signatureUsesCArrays() {
+    computeSignatureProperties();
+    return signatureUsesCArrays;
+  }
+
+  /**
+   * Returns true if the return type or any of the outgoing arguments
+   * in the method's signature represent Java primitive arrays.
+   */
+  public boolean signatureUsesJavaPrimitiveArrays() {
+    computeSignatureProperties();
+    return signatureUsesJavaPrimitiveArrays;
+  }
+
+  /**
+   * Computes summary information about the method's C and Java
+   * signatures.
+   */
+  protected void computeSignatureProperties() {
+    if (computedSignatureProperties)
+      return;
+
+    argumentsUseNIO = false;
+    signatureUsesNIO = false;
+    signatureCanUseIndirectNIO = false;
+    signatureUsesCompoundTypeWrappers = false;
+    signatureUsesArraysOfCompoundTypeWrappers = false;
+    signatureUsesCVoidPointers = false;
+    signatureUsesCPrimitivePointers = false;
+    signatureUsesCArrays = false;
+    signatureUsesJavaPrimitiveArrays = false;
+
+    if (javaReturnType.isCompoundTypeWrapper()) {
+      // Needs wrapping and/or setting of byte order (neither of which
+      // can be done easily from native code)
+      signatureUsesCompoundTypeWrappers = true;
+    }
+
+    if (javaReturnType.isNIOBuffer() ||
+        javaReturnType.isArrayOfCompoundTypeWrappers()) {
+      // Needs setting of byte order and possibly viewing as a
+      // different buffer type which can't be done easily from native
+      // code
+      signatureUsesNIO = true;
+    }
+
+    Type cRetType = sym.getReturnType();
+    if (cRetType.isArray()) {
+      // Needs checking of array lengths
+      signatureUsesCArrays = true;
+      if (cRetType.asArray().getElementType().isPrimitive()) {
+        signatureUsesCPrimitivePointers = true;
+      }
+    }
+
+    if (cRetType.isPointer()) {
+      if (cRetType.asPointer().getTargetType().isPrimitive()) {
+        signatureUsesCPrimitivePointers = true;
+      } else if (cRetType.asPointer().getTargetType().isVoid()) {
+        signatureUsesCVoidPointers = true;
+      }
+    }
+
+    for (int i = 0; i < getNumArguments(); i++) {
+      JavaType javaArgType = getJavaArgumentType(i);
+      Type cArgType = getCArgumentType(i);
+      if (javaArgType.isCompoundTypeWrapper()) {
+        // Needs unwrapping of accessors
+        signatureUsesCompoundTypeWrappers = true;
+      }
+
+      if (javaArgType.isArrayOfCompoundTypeWrappers()) {
+        // Needs to be duplicated and this array lowered to an array
+        // of Buffers for code emission
+        signatureUsesArraysOfCompoundTypeWrappers = true;
+      }
+
+      if (javaArgType.isNIOBuffer() ||
+          javaArgType.isNIOBufferArray()) {
+        // Needs checking of direct buffer property
+        signatureUsesNIO = true;
+        argumentsUseNIO = true;
+
+        if (javaArgType.isNIOBuffer()) {
+          // Potential conversion to indirect buffer
+          signatureCanUseIndirectNIO = true;
+        }
+      }
+
+      if (cArgType.isArray()) {
+        // Needs checking of array lengths
+        signatureUsesCArrays = true;
+        if (cArgType.asArray().getElementType().isPrimitive()) {
+          signatureUsesCPrimitivePointers = true;
+        }
+      }
+
+      if (cArgType.isPointer()) {
+        // Handle both real C primitive pointers and any constructions
+        // due to opaque directives
+        if (cArgType.asPointer().getTargetType().isPrimitive() ||
+            javaArgType.isCPrimitivePointerType()) {
+          signatureUsesCPrimitivePointers = true;
+        } else if (cArgType.asPointer().getTargetType().isVoid()) {
+          signatureUsesCVoidPointers = true;
+        }
+      }
+
+      if (javaArgType.isPrimitiveArray()) {
+        // Needs getPrimitiveArrayCritical or similar construct
+        // depending on native code calling convention
+        signatureUsesJavaPrimitiveArrays = true;
+      }
+    }
+
+    computedSignatureProperties = true;
+  }
+
+  /** Indicates whether this MethodBinding is for a function pointer
+      contained in a struct. */
+  public boolean hasContainingType() {
+    return (getContainingType() != null);
+  }
+
+  /** Retrieves the containing type of this MethodBinding if it is for
+      a function pointer contained in a struct. */
+  public JavaType getContainingType() {
+    return containingType;
+  }
+
+  /** Retrieves the containing C type of this MethodBinding if it is for
+      a function pointer contained in a struct. */
+  public Type getContainingCType() {
+    return containingCType;
+  }
+
+  /** Find the leftmost argument matching the type of the containing
+      type (for function pointer MethodBindings) and record that as a
+      "this" pointer, meaning that it does not need to be explicitly
+      passed at the Java level. */
+  public void findThisPointer() {
+    clearThisPointer();
+    for (int i = 0; i < getNumArguments(); i++) {
+      JavaType arg = getJavaArgumentType(i);
+      if (arg.equals(containingType)) {
+        thisPointerIndex = i;
+        break;
+      }
+
+      if (!arg.isJNIEnv()) {
+        break; // this pointer must be leftmost argument excluding JNIEnvs
+      }
+    }
+  }
+
+  /** Clears any record of a this pointer for this MethodBinding. */
+  public void clearThisPointer() {
+    thisPointerIndex = -1;
+  }
+
+  /** Indicates whether the <i>i</i>th argument to this MethodBinding
+      is actually a "this" pointer. */
+  public boolean isArgumentThisPointer(int i) {
+    return (thisPointerIndex == i);
+  }
+  @Override
+  public boolean equals(Object obj) {
+    if (obj == this) {
+      return true;
+    }
+
+    if (obj == null || ! (obj instanceof MethodBinding)) {
+      return false;
+    }
+
+    MethodBinding other = (MethodBinding)obj;
+    if ( !getName().equals(other.getName()) ||
+         !sym.getType().equals(other.sym.getType()) ) { return false; }
+    if (!(javaReturnType.equals(other.getJavaReturnType()))) { return false; }
+    if (containingCType != null &&
+        other.getContainingCType() != null &&
+        (!(containingCType.equals(other.getContainingCType())))) {
+        return false;
+      }
+    if (javaArgumentTypes.size() != other.javaArgumentTypes.size()) {
+      return false;
+    }
+
+    for (int i = 0; i < javaArgumentTypes.size(); ++i) {
+      Object typeThis = javaArgumentTypes.get(i);
+      Object typeOther = other.getJavaArgumentType(i);
+      if (!(typeThis.equals(typeOther))) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  @Override
+  public int hashCode() {
+    StringBuilder buf = new StringBuilder(200);
+    buf.append(getName());
+    buf.append(sym.getType().getName(true));
+    buf.append(getJavaReturnType().getName());
+    if (containingCType != null) {
+        buf.append(containingCType.getName(true));
+    }
+
+    for (int i = 0; i < getNumArguments(); i++) {
+      JavaType type = getJavaArgumentType(i);
+      if (type.isVoid()) {
+        // Make sure this is the only param to the method; if it isn't,
+        // there's something wrong with our parsing of the headers.
+        assert(getNumArguments() == 1);
+        continue;
+      }
+
+      buf.append(type.getName());
+    }
+    return buf.toString().hashCode();
+  }
+
+  /** Returns the signature of this binding. */
+  @Override
+  public String toString() {
+    StringBuilder buf = new StringBuilder(200);
+    buf.append(getJavaReturnType().getName());
+    buf.append(' ');
+    buf.append(getName());
+    buf.append('(');
+    boolean needComma = false;
+    for (int i = 0; i < getNumArguments(); i++) {
+      JavaType type = getJavaArgumentType(i);
+      if (type.isVoid()) {
+        // Make sure this is the only param to the method; if it isn't,
+        // there's something wrong with our parsing of the headers.
+        assert(getNumArguments() == 1);
+        continue;
+      }
+      if (type.isJNIEnv() || isArgumentThisPointer(i)) {
+        // Don't need to expose these at the Java level
+        continue;
+      }
+
+      if (needComma) {
+        buf.append(", ");
+      }
+
+      buf.append(type.getName());
+      buf.append(' ');
+      buf.append(getArgumentName(i));
+      needComma = true;
+    }
+    buf.append(')');
+    return buf.toString();
+  }
+
+  @Override
+  public final Object clone() {
+    return new MethodBinding(this);
+  }
+
+  /** Returns a String containing the descriptor (signature in
+      internal format) of this MethodBinding as it will be
+      emitted. This is used to disambiguate between overloadings when
+      manually specifying prologue and epilogue code, for example. */
+  public String getDescriptor(boolean forImplementingMethodCall,
+                              boolean eraseBufferAndArrayTypes) {
+    StringBuilder buf = new StringBuilder();
+
+    buf.append('(');
+
+    if (forImplementingMethodCall && hasContainingType()) {
+      // Always emit outgoing "this" argument
+      buf.append("Ljava/nio/ByteBuffer;");
+    }
+
+    for (int i = 0; i < getNumArguments(); i++) {
+      JavaType type = getJavaArgumentType(i);
+      if (type.isVoid()) {
+        // Make sure this is the only param to the method; if it isn't,
+        // there's something wrong with our parsing of the headers.
+        if (getNumArguments() != 1) {
+          throw new InternalError(
+            "\"void\" argument type found in " +
+            "multi-argument function \"" + this + "\"");
+        }
+        continue;
+      }
+
+      if (type.isJNIEnv() || isArgumentThisPointer(i)) {
+        // Don't need to expose these at the Java level
+        continue;
+      }
+
+      buf.append(erasedTypeDescriptor(type, eraseBufferAndArrayTypes, false));
+
+      // Add Buffer and array index offset arguments after each associated argument
+      if (forImplementingMethodCall) {
+        if (type.isNIOBuffer()) {
+          buf.append('I');
+        } else if (type.isNIOBufferArray()) {
+          buf.append("[I");
+        }
+      }
+
+      // Add offset argument after each primitive array
+      if (type.isPrimitiveArray()) {
+        buf.append('I');
+      }
+    }
+
+    buf.append(')');
+
+    // Emit return type for completeness even though we can't overload
+    // based solely on return type
+    buf.append(erasedTypeDescriptor(getJavaReturnType(), eraseBufferAndArrayTypes, false));
+
+    return buf.toString();
+  }
+
+  protected String erasedTypeDescriptor(JavaType type, boolean eraseBufferAndArrayTypes, boolean skipBuffers) {
+    if (eraseBufferAndArrayTypes) {
+      if (type.isNIOBuffer() ||
+          type.isPrimitiveArray()) {
+        if (!skipBuffers) {
+          // Direct buffers and arrays sent down as Object (but
+          // returned as e.g. ByteBuffer)
+          return "Ljava/lang/Object;";
+        }
+      } else if (type.isCompoundTypeWrapper()) {
+        // Compound type wrappers are unwrapped to ByteBuffer
+        return "Ljava/nio/ByteBuffer;";
+      } else if (type.isArrayOfCompoundTypeWrappers()) {
+        return "Ljava/nio/ByteBuffer;";
+      }
+    }
+    return type.getDescriptor();
+  }
+}
+