diff options
Diffstat (limited to 'src/java/com/sun/gluegen/MethodBinding.java')
| -rw-r--r-- | src/java/com/sun/gluegen/MethodBinding.java | 639 |
1 files changed, 0 insertions, 639 deletions
diff --git a/src/java/com/sun/gluegen/MethodBinding.java b/src/java/com/sun/gluegen/MethodBinding.java deleted file mode 100644 index 7b3984e..0000000 --- a/src/java/com/sun/gluegen/MethodBinding.java +++ /dev/null @@ -1,639 +0,0 @@ -/* - * 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.sun.gluegen; - -import com.sun.gluegen.cgram.types.FunctionSymbol; -import com.sun.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(); - } -} - |