diff options
Diffstat (limited to 'src/java/com/sun/gluegen/procaddress')
4 files changed, 778 insertions, 778 deletions
diff --git a/src/java/com/sun/gluegen/procaddress/ProcAddressCMethodBindingEmitter.java b/src/java/com/sun/gluegen/procaddress/ProcAddressCMethodBindingEmitter.java index b7fac1b..a951c42 100755 --- a/src/java/com/sun/gluegen/procaddress/ProcAddressCMethodBindingEmitter.java +++ b/src/java/com/sun/gluegen/procaddress/ProcAddressCMethodBindingEmitter.java @@ -40,165 +40,170 @@ package com.sun.gluegen.procaddress; import java.io.*; -import java.util.*; import com.sun.gluegen.*; import com.sun.gluegen.cgram.types.*; public class ProcAddressCMethodBindingEmitter extends CMethodBindingEmitter { + private boolean callThroughProcAddress; private boolean needsLocalTypedef; + private String localTypedefCallingConvention; - private static String procAddressJavaTypeName = - JavaType.createForClass(Long.TYPE).jniTypeName(); + + private static final String procAddressJavaTypeName = JavaType.createForClass(Long.TYPE).jniTypeName(); private ProcAddressEmitter emitter; - public ProcAddressCMethodBindingEmitter(CMethodBindingEmitter methodToWrap, - final boolean callThroughProcAddress, - boolean needsLocalTypedef, - String localTypedefCallingConvention, - ProcAddressEmitter emitter) { - super( - new MethodBinding(methodToWrap.getBinding()) { - public String getName() { - if (callThroughProcAddress) { - return ProcAddressEmitter.WRAP_PREFIX + super.getName(); - } else { - return super.getName(); - } + public ProcAddressCMethodBindingEmitter(CMethodBindingEmitter methodToWrap, final boolean callThroughProcAddress, + boolean needsLocalTypedef, String localTypedefCallingConvention, ProcAddressEmitter emitter) { + + super( + new MethodBinding(methodToWrap.getBinding()) { + @Override + public String getName() { + if (callThroughProcAddress) { + return ProcAddressEmitter.WRAP_PREFIX + super.getName(); + } else { + return super.getName(); + } + } + }, + methodToWrap.getDefaultOutput(), + methodToWrap.getJavaPackageName(), + methodToWrap.getJavaClassName(), + methodToWrap.getIsOverloadedBinding(), + methodToWrap.getIsJavaMethodStatic(), + true, + methodToWrap.forIndirectBufferAndArrayImplementation(), + methodToWrap.getMachineDescription() + ); + + if (methodToWrap.getReturnValueCapacityExpression() != null) { + setReturnValueCapacityExpression(methodToWrap.getReturnValueCapacityExpression()); } - }, - methodToWrap.getDefaultOutput(), - methodToWrap.getJavaPackageName(), - methodToWrap.getJavaClassName(), - methodToWrap.getIsOverloadedBinding(), - methodToWrap.getIsJavaMethodStatic(), - true, - methodToWrap.forIndirectBufferAndArrayImplementation(), - methodToWrap.getMachineDescription() - ); - - if (methodToWrap.getReturnValueCapacityExpression() != null) { - setReturnValueCapacityExpression(methodToWrap.getReturnValueCapacityExpression()); - } - if (methodToWrap.getReturnValueLengthExpression() != null) { - setReturnValueLengthExpression(methodToWrap.getReturnValueLengthExpression()); + if (methodToWrap.getReturnValueLengthExpression() != null) { + setReturnValueLengthExpression(methodToWrap.getReturnValueLengthExpression()); + } + setTemporaryCVariableDeclarations(methodToWrap.getTemporaryCVariableDeclarations()); + setTemporaryCVariableAssignments(methodToWrap.getTemporaryCVariableAssignments()); + + setCommentEmitter(defaultCommentEmitter); + + this.callThroughProcAddress = callThroughProcAddress; + this.needsLocalTypedef = needsLocalTypedef; + this.localTypedefCallingConvention = localTypedefCallingConvention; + this.emitter = emitter; } - setTemporaryCVariableDeclarations(methodToWrap.getTemporaryCVariableDeclarations()); - setTemporaryCVariableAssignments (methodToWrap.getTemporaryCVariableAssignments ()); - - setCommentEmitter(defaultCommentEmitter); - this.callThroughProcAddress = callThroughProcAddress; - this.needsLocalTypedef = needsLocalTypedef; - this.localTypedefCallingConvention = localTypedefCallingConvention; - this.emitter = emitter; - } - - protected int emitArguments(PrintWriter writer) { - int numEmitted = super.emitArguments(writer); - if (callThroughProcAddress) { - if (numEmitted > 0) - { - writer.print(", "); + + @Override + protected int emitArguments(PrintWriter writer) { + int numEmitted = super.emitArguments(writer); + if (callThroughProcAddress) { + if (numEmitted > 0) { + writer.print(", "); + } + writer.print(procAddressJavaTypeName); + writer.print(" procAddress"); + ++numEmitted; } - writer.print(procAddressJavaTypeName); - writer.print(" procAddress"); - ++numEmitted; + + return numEmitted; } - return numEmitted; - } - - protected void emitBodyVariableDeclarations(PrintWriter writer) { - if (callThroughProcAddress) { - // create variable for the function pointer with the right type, and set - // it to the value of the passed-in proc address - FunctionSymbol cSym = getBinding().getCSymbol(); - String funcPointerTypedefName = - emitter.getFunctionPointerTypedefName(cSym); - - if (needsLocalTypedef) { - // We (probably) didn't get a typedef for this function - // pointer type in the header file; the user requested that we - // forcibly generate one. Here we force the emission of one. - PointerType funcPtrType = new PointerType(null, cSym.getType(), 0); - // Just for safety, emit this name slightly differently than - // the mangling would otherwise produce - funcPointerTypedefName = "_local_" + funcPointerTypedefName; - - writer.print(" typedef "); - writer.print(funcPtrType.toString(funcPointerTypedefName, localTypedefCallingConvention)); - writer.println(";"); - } - - writer.print(" "); - writer.print(funcPointerTypedefName); - writer.print(" ptr_"); - writer.print(cSym.getName()); - writer.println(";"); + @Override + protected void emitBodyVariableDeclarations(PrintWriter writer) { + if (callThroughProcAddress) { + // create variable for the function pointer with the right type, and set + // it to the value of the passed-in proc address + FunctionSymbol cSym = getBinding().getCSymbol(); + String funcPointerTypedefName = + emitter.getFunctionPointerTypedefName(cSym); + + if (needsLocalTypedef) { + // We (probably) didn't get a typedef for this function + // pointer type in the header file; the user requested that we + // forcibly generate one. Here we force the emission of one. + PointerType funcPtrType = new PointerType(null, cSym.getType(), 0); + // Just for safety, emit this name slightly differently than + // the mangling would otherwise produce + funcPointerTypedefName = "_local_" + funcPointerTypedefName; + + writer.print(" typedef "); + writer.print(funcPtrType.toString(funcPointerTypedefName, localTypedefCallingConvention)); + writer.println(";"); + } + + writer.print(" "); + writer.print(funcPointerTypedefName); + writer.print(" ptr_"); + writer.print(cSym.getName()); + writer.println(";"); + } + + super.emitBodyVariableDeclarations(writer); } - super.emitBodyVariableDeclarations(writer); - } + @Override + protected void emitBodyVariablePreCallSetup(PrintWriter writer) { + super.emitBodyVariablePreCallSetup(writer); - protected void emitBodyVariablePreCallSetup(PrintWriter writer) { - super.emitBodyVariablePreCallSetup(writer); + if (callThroughProcAddress) { + // set the function pointer to the value of the passed-in procAddress + FunctionSymbol cSym = getBinding().getCSymbol(); + String funcPointerTypedefName = emitter.getFunctionPointerTypedefName(cSym); + if (needsLocalTypedef) { + funcPointerTypedefName = "_local_" + funcPointerTypedefName; + } - if (callThroughProcAddress) { - // set the function pointer to the value of the passed-in procAddress - FunctionSymbol cSym = getBinding().getCSymbol(); - String funcPointerTypedefName = emitter.getFunctionPointerTypedefName(cSym); - if (needsLocalTypedef) { - funcPointerTypedefName = "_local_" + funcPointerTypedefName; - } + String ptrVarName = "ptr_" + cSym.getName(); - String ptrVarName = "ptr_" + cSym.getName(); - - writer.print(" "); - writer.print(ptrVarName); - writer.print(" = ("); - writer.print(funcPointerTypedefName); - writer.println(") (intptr_t) procAddress;"); + writer.print(" "); + writer.print(ptrVarName); + writer.print(" = ("); + writer.print(funcPointerTypedefName); + writer.println(") (intptr_t) procAddress;"); - writer.println(" assert(" + ptrVarName + " != NULL);"); + writer.println(" assert(" + ptrVarName + " != NULL);"); + } } - } - - protected void emitBodyCallCFunction(PrintWriter writer) { - if (!callThroughProcAddress) { - super.emitBodyCallCFunction(writer); - } else { - // Make the call to the actual C function - writer.print(" "); - - // WARNING: this code assumes that the return type has already been - // typedef-resolved. - Type cReturnType = binding.getCReturnType(); - - if (!cReturnType.isVoid()) { - writer.print("_res = "); - } - MethodBinding binding = getBinding(); - if (binding.hasContainingType()) { - // FIXME: this can and should be handled and unified with the - // associated code in the CMethodBindingEmitter - throw new IllegalStateException("Cannot call through function pointer because binding has containing type: " + binding); - } - - // call throught the run-time function pointer - writer.print("(* ptr_"); - writer.print(binding.getCSymbol().getName()); - writer.print(") "); - writer.print("("); - emitBodyPassCArguments(writer); - writer.println(");"); + + @Override + protected void emitBodyCallCFunction(PrintWriter writer) { + if (!callThroughProcAddress) { + super.emitBodyCallCFunction(writer); + } else { + // Make the call to the actual C function + writer.print(" "); + + // WARNING: this code assumes that the return type has already been + // typedef-resolved. + Type cReturnType = binding.getCReturnType(); + + if (!cReturnType.isVoid()) { + writer.print("_res = "); + } + MethodBinding mBinding = getBinding(); + if (mBinding.hasContainingType()) { + // FIXME: this can and should be handled and unified with the + // associated code in the CMethodBindingEmitter + throw new IllegalStateException("Cannot call through function pointer because binding has containing type: " + mBinding); + } + + // call throught the run-time function pointer + writer.print("(* ptr_"); + writer.print(mBinding.getCSymbol().getName()); + writer.print(") "); + writer.print("("); + emitBodyPassCArguments(writer); + writer.println(");"); + } } - } - protected String jniMangle(MethodBinding binding) { - StringBuffer buf = new StringBuffer(super.jniMangle(binding)); - if (callThroughProcAddress) { - jniMangle(Long.TYPE, buf, false); // to account for the additional _addr_ parameter + @Override + protected String jniMangle(MethodBinding binding) { + StringBuffer buf = new StringBuffer(super.jniMangle(binding)); + if (callThroughProcAddress) { + jniMangle(Long.TYPE, buf, false); // to account for the additional _addr_ parameter + } + return buf.toString(); } - return buf.toString(); - } } diff --git a/src/java/com/sun/gluegen/procaddress/ProcAddressConfiguration.java b/src/java/com/sun/gluegen/procaddress/ProcAddressConfiguration.java index 9409a1e..993f917 100755 --- a/src/java/com/sun/gluegen/procaddress/ProcAddressConfiguration.java +++ b/src/java/com/sun/gluegen/procaddress/ProcAddressConfiguration.java @@ -36,7 +36,6 @@ * Sun gratefully acknowledges that this software was originally authored * and developed by Kenneth Bradley Russell and Christopher John Kline. */ - package com.sun.gluegen.procaddress; import java.io.*; @@ -45,262 +44,279 @@ import java.util.*; import com.sun.gluegen.*; -public class ProcAddressConfiguration extends JavaConfiguration -{ - private boolean emitProcAddressTable = false; - private String tableClassPackage; - private String tableClassName = "ProcAddressTable"; - private Set/*<String>*/ skipProcAddressGen = new HashSet(); - private List/*<String>*/ forceProcAddressGen = new ArrayList(); - private Set/*<String>*/ forceProcAddressGenSet = new HashSet(); - private boolean forceProcAddressGen4All=false; - private String getProcAddressTableExpr; - private ConvNode procAddressNameConverter; - // This is needed only on Windows. Ideally we would modify the - // HeaderParser and PCPP to automatically pick up the calling - // convention from the headers - private Map/*<String,String>*/ localProcAddressCallingConventionMap = new HashMap(); - private String localProcAddressCallingConvention4All=null; - - protected void dispatch(String cmd, StringTokenizer tok, File file, String filename, int lineNo) throws IOException { - if (cmd.equalsIgnoreCase("EmitProcAddressTable")) - { - emitProcAddressTable = - readBoolean("EmitProcAddressTable", tok, filename, lineNo).booleanValue(); - } - else if (cmd.equalsIgnoreCase("ProcAddressTablePackage")) - { - tableClassPackage = readString("ProcAddressTablePackage", tok, filename, lineNo); - } - else if (cmd.equalsIgnoreCase("ProcAddressTableClassName")) - { - tableClassName = readString("ProcAddressTableClassName", tok, filename, lineNo); - } - else if (cmd.equalsIgnoreCase("SkipProcAddressGen")) - { - String sym = readString("SkipProcAddressGen", tok, filename, lineNo); - skipProcAddressGen.add(sym); - } - else if (cmd.equalsIgnoreCase("ForceProcAddressGen")) - { - String funcName = readString("ForceProcAddressGen", tok, filename, lineNo); - if(funcName.equals("__ALL__")) { - forceProcAddressGen4All=true; +public class ProcAddressConfiguration extends JavaConfiguration { + + private boolean emitProcAddressTable = false; + private boolean forceProcAddressGen4All = false; + + private String tableClassPackage; + private String tableClassName = "ProcAddressTable"; + private String getProcAddressTableExpr; + private String localProcAddressCallingConvention4All = null; + + private ConvNode procAddressNameConverter; + private final Set<String> skipProcAddressGen = new HashSet<String>(); + private final List<String> forceProcAddressGen = new ArrayList<String>(); + private final Set<String> forceProcAddressGenSet = new HashSet<String>(); + + // This is needed only on Windows. Ideally we would modify the + // HeaderParser and PCPP to automatically pick up the calling + // convention from the headers + private Map<String, String> localProcAddressCallingConventionMap = new HashMap<String, String>(); + + @Override + protected void dispatch(String cmd, StringTokenizer tok, File file, String filename, int lineNo) throws IOException { + if (cmd.equalsIgnoreCase("EmitProcAddressTable")) { + emitProcAddressTable = readBoolean("EmitProcAddressTable", tok, filename, lineNo).booleanValue(); + } else if (cmd.equalsIgnoreCase("ProcAddressTablePackage")) { + tableClassPackage = readString("ProcAddressTablePackage", tok, filename, lineNo); + } else if (cmd.equalsIgnoreCase("ProcAddressTableClassName")) { + tableClassName = readString("ProcAddressTableClassName", tok, filename, lineNo); + } else if (cmd.equalsIgnoreCase("SkipProcAddressGen")) { + String sym = readString("SkipProcAddressGen", tok, filename, lineNo); + skipProcAddressGen.add(sym); + } else if (cmd.equalsIgnoreCase("ForceProcAddressGen")) { + String funcName = readString("ForceProcAddressGen", tok, filename, lineNo); + if (funcName.equals("__ALL__")) { + forceProcAddressGen4All = true; + } else { + addForceProcAddressGen(funcName); + } + } else if (cmd.equalsIgnoreCase("GetProcAddressTableExpr")) { + getProcAddressTableExpr = readGetProcAddressTableExpr(tok, filename, lineNo); + } else if (cmd.equalsIgnoreCase("ProcAddressNameExpr")) { + readProcAddressNameExpr(tok, filename, lineNo); + } else if (cmd.equalsIgnoreCase("LocalProcAddressCallingConvention")) { + readLocalProcAddressCallingConvention(tok, filename, lineNo); } else { - addForceProcAddressGen( funcName ); + super.dispatch(cmd, tok, file, filename, lineNo); } - } - else if (cmd.equalsIgnoreCase("GetProcAddressTableExpr")) - { - getProcAddressTableExpr = readGetProcAddressTableExpr(tok, filename, lineNo); - } - else if (cmd.equalsIgnoreCase("ProcAddressNameExpr")) - { - readProcAddressNameExpr(tok, filename, lineNo); - } - else if (cmd.equalsIgnoreCase("LocalProcAddressCallingConvention")) - { - readLocalProcAddressCallingConvention(tok, filename, lineNo); - } - else - { - super.dispatch(cmd,tok,file,filename,lineNo); - } - } - - protected String readGetProcAddressTableExpr(StringTokenizer tok, String filename, int lineNo) { - try { - String restOfLine = tok.nextToken("\n\r\f"); - return restOfLine.trim(); - } catch (NoSuchElementException e) { - throw new RuntimeException("Error parsing \"GetProcAddressTableExpr\" command at line " + lineNo + - " in file \"" + filename + "\"", e); } - } - - protected void setProcAddressNameExpr(String expr) { - // Parse this into something allowing us to map from a function - // name to the typedef'ed function pointer name - List/*<String>*/ tokens = new ArrayList/*<String>*/(); - StringTokenizer tok1 = new StringTokenizer(expr); - while (tok1.hasMoreTokens()) { - String sstr = tok1.nextToken(); - StringTokenizer tok2 = new StringTokenizer(sstr, "$()", true); - while (tok2.hasMoreTokens()) { - tokens.add(tok2.nextToken()); - } + + protected String readGetProcAddressTableExpr(StringTokenizer tok, String filename, int lineNo) { + try { + String restOfLine = tok.nextToken("\n\r\f"); + return restOfLine.trim(); + } catch (NoSuchElementException e) { + throw new RuntimeException("Error parsing \"GetProcAddressTableExpr\" command at line " + lineNo + + " in file \"" + filename + "\"", e); + } } - // Now that the string is flattened out, convert it to nodes - procAddressNameConverter = makeConverter(tokens.iterator()); - if (procAddressNameConverter == null) { - throw new NoSuchElementException("Error creating converter from string"); + protected void setProcAddressNameExpr(String expr) { + // Parse this into something allowing us to map from a function + // name to the typedef'ed function pointer name + List<String> tokens = new ArrayList<String>(); + StringTokenizer tok1 = new StringTokenizer(expr); + while (tok1.hasMoreTokens()) { + String sstr = tok1.nextToken(); + StringTokenizer tok2 = new StringTokenizer(sstr, "$()", true); + while (tok2.hasMoreTokens()) { + tokens.add(tok2.nextToken()); + } + } + + // Now that the string is flattened out, convert it to nodes + procAddressNameConverter = makeConverter(tokens.iterator()); + if (procAddressNameConverter == null) { + throw new NoSuchElementException("Error creating converter from string"); + } } - } - - protected void readProcAddressNameExpr(StringTokenizer tok, String filename, int lineNo) { - try { - String restOfLine = tok.nextToken("\n\r\f"); - restOfLine = restOfLine.trim(); - setProcAddressNameExpr(restOfLine); - } catch (NoSuchElementException e) { - throw new RuntimeException("Error parsing \"ProcAddressNameExpr\" command at line " + lineNo + - " in file \"" + filename + "\"", e); + + protected void readProcAddressNameExpr(StringTokenizer tok, String filename, int lineNo) { + try { + String restOfLine = tok.nextToken("\n\r\f"); + restOfLine = restOfLine.trim(); + setProcAddressNameExpr(restOfLine); + } catch (NoSuchElementException e) { + throw new RuntimeException("Error parsing \"ProcAddressNameExpr\" command at line " + lineNo + + " in file \"" + filename + "\"", e); + } } - } - - protected void readLocalProcAddressCallingConvention(StringTokenizer tok, String filename, int lineNo) throws IOException { - try { - String functionName = tok.nextToken(); - String callingConvention = tok.nextToken(); - if(functionName.equals("__ALL__")) { - localProcAddressCallingConvention4All=callingConvention; - } else { - localProcAddressCallingConventionMap.put(functionName, callingConvention); - } - } catch (NoSuchElementException e) { - throw new RuntimeException("Error parsing \"LocalProcAddressCallingConvention\" command at line " + lineNo + - " in file \"" + filename + "\"", e); + + protected void readLocalProcAddressCallingConvention(StringTokenizer tok, String filename, int lineNo) throws IOException { + try { + String functionName = tok.nextToken(); + String callingConvention = tok.nextToken(); + if (functionName.equals("__ALL__")) { + localProcAddressCallingConvention4All = callingConvention; + } else { + localProcAddressCallingConventionMap.put(functionName, callingConvention); + } + } catch (NoSuchElementException e) { + throw new RuntimeException("Error parsing \"LocalProcAddressCallingConvention\" command at line " + lineNo + + " in file \"" + filename + "\"", e); + } } - } - - private static ConvNode makeConverter(Iterator/*<String>*/ iter) { - List/*<ConvNode>*/ result = new ArrayList/*<ConvNode>*/(); - while (iter.hasNext()) { - String str = (String) iter.next(); - if (str.equals("$")) { - String command = (String) iter.next(); - String openParen = (String) iter.next(); - if (!openParen.equals("(")) { - throw new NoSuchElementException("Expected \"(\""); + + private static ConvNode makeConverter(Iterator<String> iter) { + List<ConvNode> result = new ArrayList<ConvNode>(); + + while (iter.hasNext()) { + String str = iter.next(); + if (str.equals("$")) { + String command = iter.next(); + String openParen = iter.next(); + if (!openParen.equals("(")) { + throw new NoSuchElementException("Expected \"(\""); + } + boolean uppercase = false; + if (command.equalsIgnoreCase("UPPERCASE")) { + uppercase = true; + } else if (!command.equalsIgnoreCase("LOWERCASE")) { + throw new NoSuchElementException("Unknown ProcAddressNameExpr command \"" + command + "\""); + } + result.add(new CaseNode(uppercase, makeConverter(iter))); + } else if (str.equals(")")) { + // Fall through and return + } else if (str.indexOf('{') >= 0) { + result.add(new FormatNode(str)); + } else { + result.add(new ConstStringNode(str)); + } } - boolean uppercase = false; - if (command.equalsIgnoreCase("UPPERCASE")) { - uppercase = true; - } else if (!command.equalsIgnoreCase("LOWERCASE")) { - throw new NoSuchElementException("Unknown ProcAddressNameExpr command \"" + command + "\""); + if (result.isEmpty()) { + return null; + } else if (result.size() == 1) { + return result.get(0); + } else { + return new ConcatNode(result); } - result.add(new CaseNode(uppercase, makeConverter(iter))); - } else if (str.equals(")")) { - // Fall through and return - } else if (str.indexOf('{') >= 0) { - result.add(new FormatNode(str)); - } else { - result.add(new ConstStringNode(str)); - } } - if (result.size() == 0) { - return null; - } else if (result.size() == 1) { - return (ConvNode) result.get(0); - } else { - return new ConcatNode(result); + + /** Helper class for converting a function name to the typedef'ed + function pointer name */ + static abstract class ConvNode { + abstract String convert(String funcName); } - } - /** Helper class for converting a function name to the typedef'ed - function pointer name */ - static abstract class ConvNode { - abstract String convert(String funcName); - } + static class FormatNode extends ConvNode { + + private MessageFormat msgFmt; - static class FormatNode extends ConvNode { - private MessageFormat msgFmt; + FormatNode(String fmt) { + msgFmt = new MessageFormat(fmt); + } - FormatNode(String fmt) { - msgFmt = new MessageFormat(fmt); + String convert(String funcName) { + StringBuffer buf = new StringBuffer(); + msgFmt.format(new Object[]{funcName}, buf, null); + return buf.toString(); + } } - String convert(String funcName) { - StringBuffer buf = new StringBuffer(); - msgFmt.format(new Object[] { funcName }, buf, null); - return buf.toString(); + static class ConstStringNode extends ConvNode { + + private String str; + + ConstStringNode(String str) { + this.str = str; + } + + String convert(String funcName) { + return str; + } } - } - static class ConstStringNode extends ConvNode { - private String str; + static class ConcatNode extends ConvNode { - ConstStringNode(String str) { - this.str = str; + private List<ConvNode> children; + + ConcatNode(List<ConvNode> children) { + this.children = children; + } + + String convert(String funcName) { + StringBuilder res = new StringBuilder(); + for (ConvNode node : children) { + res.append(node.convert(funcName)); + } + return res.toString(); + } } - String convert(String funcName) { - return str; + static class CaseNode extends ConvNode { + + private boolean upperCase; + private ConvNode child; + + CaseNode(boolean upperCase, ConvNode child) { + this.upperCase = upperCase; + this.child = child; + } + + public String convert(String funcName) { + if (upperCase) { + return child.convert(funcName).toUpperCase(); + } else { + return child.convert(funcName).toLowerCase(); + } + } } - } - static class ConcatNode extends ConvNode { - private List/*<ConvNode>*/ children; + public boolean emitProcAddressTable() { + return emitProcAddressTable; + } - ConcatNode(List/*<ConvNode>*/ children) { - this.children = children; + public String tableClassPackage() { + return tableClassPackage; } - String convert(String funcName) { - StringBuffer res = new StringBuffer(); - for (Iterator iter = children.iterator(); iter.hasNext(); ) { - ConvNode node = (ConvNode) iter.next(); - res.append(node.convert(funcName)); - } - return res.toString(); + public String tableClassName() { + return tableClassName; } - } - static class CaseNode extends ConvNode { - private boolean upperCase; - private ConvNode child; + public boolean skipProcAddressGen(String name) { + return skipProcAddressGen.contains(name); + } - CaseNode(boolean upperCase, ConvNode child) { - this.upperCase = upperCase; - this.child = child; + public boolean isForceProcAddressGen4All() { + return forceProcAddressGen4All; } - public String convert(String funcName) { - if (upperCase) { - return child.convert(funcName).toUpperCase(); - } else { - return child.convert(funcName).toLowerCase(); - } + public List<String> getForceProcAddressGen() { + return forceProcAddressGen; } - } - - public boolean emitProcAddressTable() { return emitProcAddressTable; } - public String tableClassPackage() { return tableClassPackage; } - public String tableClassName() { return tableClassName; } - public boolean skipProcAddressGen (String name) { return skipProcAddressGen.contains(name); } - public boolean isForceProcAddressGen4All() { return forceProcAddressGen4All; } - public List getForceProcAddressGen() { return forceProcAddressGen; } - public String getProcAddressTableExpr() { - if (getProcAddressTableExpr == null) { - throw new RuntimeException("GetProcAddressTableExpr was not defined in .cfg file"); + + public String getProcAddressTableExpr() { + if (getProcAddressTableExpr == null) { + throw new RuntimeException("GetProcAddressTableExpr was not defined in .cfg file"); + } + return getProcAddressTableExpr; } - return getProcAddressTableExpr; - } - public String convertToFunctionPointerName(String funcName) { - if (procAddressNameConverter == null) { - throw new RuntimeException("ProcAddressNameExpr was not defined in .cfg file"); + + public String convertToFunctionPointerName(String funcName) { + if (procAddressNameConverter == null) { + throw new RuntimeException("ProcAddressNameExpr was not defined in .cfg file"); + } + return procAddressNameConverter.convert(funcName); } - return procAddressNameConverter.convert(funcName); - } - public boolean forceProcAddressGen(String funcName) { - return forceProcAddressGen4All || forceProcAddressGenSet.contains(funcName); - } + public boolean forceProcAddressGen(String funcName) { + return forceProcAddressGen4All || forceProcAddressGenSet.contains(funcName); + } - public void addForceProcAddressGen(String funcName) { + public void addForceProcAddressGen(String funcName) { forceProcAddressGen.add(funcName); forceProcAddressGenSet.add(funcName); - } - - public void addLocalProcAddressCallingConvention(String funcName, String callingConvention) { - localProcAddressCallingConventionMap.put(funcName, callingConvention); - } - - public String getLocalProcAddressCallingConvention(String funcName) { - if(isLocalProcAddressCallingConvention4All()) return getLocalProcAddressCallingConvention4All(); - return (String) localProcAddressCallingConventionMap.get(funcName); - } - public boolean isLocalProcAddressCallingConvention4All() { return localProcAddressCallingConvention4All!=null; } - public String getLocalProcAddressCallingConvention4All() { return localProcAddressCallingConvention4All; } + } + + public void addLocalProcAddressCallingConvention(String funcName, String callingConvention) { + localProcAddressCallingConventionMap.put(funcName, callingConvention); + } + + public String getLocalProcAddressCallingConvention(String funcName) { + if (isLocalProcAddressCallingConvention4All()) { + return getLocalProcAddressCallingConvention4All(); + } + return localProcAddressCallingConventionMap.get(funcName); + } + + public boolean isLocalProcAddressCallingConvention4All() { + return localProcAddressCallingConvention4All != null; + } + + public String getLocalProcAddressCallingConvention4All() { + return localProcAddressCallingConvention4All; + } } diff --git a/src/java/com/sun/gluegen/procaddress/ProcAddressEmitter.java b/src/java/com/sun/gluegen/procaddress/ProcAddressEmitter.java index 98ff860..c49e239 100755 --- a/src/java/com/sun/gluegen/procaddress/ProcAddressEmitter.java +++ b/src/java/com/sun/gluegen/procaddress/ProcAddressEmitter.java @@ -36,7 +36,6 @@ * Sun gratefully acknowledges that this software was originally authored * and developed by Kenneth Bradley Russell and Christopher John Kline. */ - package com.sun.gluegen.procaddress; import java.io.*; @@ -51,351 +50,334 @@ import com.jogamp.gluegen.runtime.*; * and Java code to allow dynamic lookups of the C entry points * associated with the Java methods. */ - -public class ProcAddressEmitter extends JavaEmitter -{ - public static final String PROCADDRESS_VAR_PREFIX = ProcAddressHelper.PROCADDRESS_VAR_PREFIX; - protected static final String WRAP_PREFIX = "dispatch_"; - private TypeDictionary typedefDictionary; - protected PrintWriter tableWriter; - protected Set emittedTableEntries; - protected String tableClassPackage; - protected String tableClassName; - - public void beginFunctions(TypeDictionary typedefDictionary, - TypeDictionary structDictionary, - Map canonMap) throws Exception - { - this.typedefDictionary = typedefDictionary; - - if (getProcAddressConfig().emitProcAddressTable()) - { - beginProcAddressTable(); +public class ProcAddressEmitter extends JavaEmitter { + + public static final String PROCADDRESS_VAR_PREFIX = ProcAddressHelper.PROCADDRESS_VAR_PREFIX; + protected static final String WRAP_PREFIX = "dispatch_"; + private TypeDictionary typedefDictionary; + protected PrintWriter tableWriter; + protected Set<String> emittedTableEntries; + protected String tableClassPackage; + protected String tableClassName; + + @Override + public void beginFunctions(TypeDictionary typedefDictionary, TypeDictionary structDictionary, Map<Type, Type> canonMap) throws Exception { + this.typedefDictionary = typedefDictionary; + + if (getProcAddressConfig().emitProcAddressTable()) { + beginProcAddressTable(); + } + super.beginFunctions(typedefDictionary, structDictionary, canonMap); } - super.beginFunctions(typedefDictionary, structDictionary, canonMap); - } - - public void endFunctions() throws Exception - { - if (getProcAddressConfig().emitProcAddressTable()) - { - endProcAddressTable(); + + @Override + public void endFunctions() throws Exception { + if (getProcAddressConfig().emitProcAddressTable()) { + endProcAddressTable(); + } + super.endFunctions(); } - super.endFunctions(); - } - - public void beginStructs(TypeDictionary typedefDictionary, - TypeDictionary structDictionary, - Map canonMap) throws Exception { - super.beginStructs(typedefDictionary, structDictionary, canonMap); - } - - public String runtimeExceptionType() { - return getConfig().runtimeExceptionType(); - } - - public String unsupportedExceptionType() { - return getConfig().unsupportedExceptionType(); - } - - protected JavaConfiguration createConfig() { - return new ProcAddressConfiguration(); - } - - protected List generateMethodBindingEmitters(HashSet/*<MethodBinding>*/ methodBindingSet, FunctionSymbol sym) throws Exception { - return generateMethodBindingEmittersImpl(methodBindingSet, sym); - } - - protected boolean needsModifiedEmitters(FunctionSymbol sym) { - if (!needsProcAddressWrapper(sym) || - getConfig().isUnimplemented(getAliasedSymName(sym))) { - return false; + + @Override + public void beginStructs(TypeDictionary typedefDictionary, TypeDictionary structDictionary, Map<Type, Type> canonMap) throws Exception { + super.beginStructs(typedefDictionary, structDictionary, canonMap); } - return true; - } + public String runtimeExceptionType() { + return getConfig().runtimeExceptionType(); + } - private List generateMethodBindingEmittersImpl(HashSet/*<MethodBinding>*/ methodBindingSet, FunctionSymbol sym) throws Exception { - List defaultEmitters = super.generateMethodBindingEmitters(methodBindingSet, sym); + public String unsupportedExceptionType() { + return getConfig().unsupportedExceptionType(); + } - // if the superclass didn't generate any bindings for the symbol, let's - // honor that (for example, the superclass might have caught an Ignore - // direction that matched the symbol's name). - if (defaultEmitters.isEmpty()) - { - return defaultEmitters; + @Override + protected JavaConfiguration createConfig() { + return new ProcAddressConfiguration(); } - - // Don't do anything special if this symbol doesn't require - // modifications - if (!needsModifiedEmitters(sym)) - { - return defaultEmitters; + + @Override + protected List<? extends FunctionEmitter> generateMethodBindingEmitters(Set<MethodBinding> methodBindingSet, FunctionSymbol sym) throws Exception { + return generateMethodBindingEmittersImpl(methodBindingSet, sym); } - ArrayList modifiedEmitters = new ArrayList(defaultEmitters.size()); + protected boolean needsModifiedEmitters(FunctionSymbol sym) { + if (!needsProcAddressWrapper(sym) + || getConfig().isUnimplemented(getAliasedSymName(sym))) { + return false; + } - if (needsProcAddressWrapper(sym)) { - if (getProcAddressConfig().emitProcAddressTable()) { - // emit an entry in the GL proc address table for this method. - emitProcAddressTableEntryForString(getAliasedSymName(sym)); - } + return true; } - - for (Iterator iter = defaultEmitters.iterator(); iter.hasNext(); ) - { - FunctionEmitter emitter = (FunctionEmitter) iter.next(); - if (emitter instanceof JavaMethodBindingEmitter) - { - generateModifiedEmitters((JavaMethodBindingEmitter) emitter, modifiedEmitters); - } - else if (emitter instanceof CMethodBindingEmitter) - { - generateModifiedEmitters((CMethodBindingEmitter) emitter, modifiedEmitters); - } - else - { - throw new RuntimeException("Unexpected emitter type: " + - emitter.getClass().getName()); - } - } - - return modifiedEmitters; - } - - /** - * Returns the name of the typedef for a pointer to the function - * represented by the argument as defined by the ProcAddressNameExpr - * in the .cfg file. For example, in the OpenGL headers, if the - * argument is the function "glFuncName", the value returned will be - * "PFNGLFUNCNAMEPROC". This returns a valid string regardless of - * whether or not the typedef is actually defined. - */ - protected String getFunctionPointerTypedefName(FunctionSymbol sym) { - return getProcAddressConfig().convertToFunctionPointerName(sym.getName()); - } - - //---------------------------------------------------------------------- - // Internals only below this point - // - - protected void generateModifiedEmitters(JavaMethodBindingEmitter baseJavaEmitter, List emitters) { - if (getConfig().manuallyImplement(baseJavaEmitter.getName())) { - // User will provide Java-side implementation of this routine; - // pass through any emitters which will produce signatures for - // it unmodified - emitters.add(baseJavaEmitter); - return; + + private List<? extends FunctionEmitter> generateMethodBindingEmittersImpl(Set<MethodBinding> methodBindingSet, FunctionSymbol sym) throws Exception { + List<? extends FunctionEmitter> defaultEmitters = super.generateMethodBindingEmitters(methodBindingSet, sym); + + // if the superclass didn't generate any bindings for the symbol, let's + // honor that (for example, the superclass might have caught an Ignore + // direction that matched the symbol's name). + if (defaultEmitters.isEmpty()) { + return defaultEmitters; + } + + // Don't do anything special if this symbol doesn't require + // modifications + if (!needsModifiedEmitters(sym)) { + return defaultEmitters; + } + + ArrayList<FunctionEmitter> modifiedEmitters = new ArrayList<FunctionEmitter>(defaultEmitters.size()); + + if (needsProcAddressWrapper(sym)) { + if (getProcAddressConfig().emitProcAddressTable()) { + // emit an entry in the GL proc address table for this method. + emitProcAddressTableEntryForString(getAliasedSymName(sym)); + } + } + for (FunctionEmitter emitter : defaultEmitters) { + if (emitter instanceof JavaMethodBindingEmitter) { + generateModifiedEmitters((JavaMethodBindingEmitter)emitter, modifiedEmitters); + } else if (emitter instanceof CMethodBindingEmitter) { + generateModifiedEmitters((CMethodBindingEmitter) emitter, modifiedEmitters); + } else { + throw new RuntimeException("Unexpected emitter type: " + emitter.getClass().getName()); + } + } + + return modifiedEmitters; } - - // See whether we need a proc address entry for this one - boolean callThroughProcAddress = needsProcAddressWrapper(baseJavaEmitter.getBinding().getCSymbol()); - - ProcAddressJavaMethodBindingEmitter emitter = - new ProcAddressJavaMethodBindingEmitter(baseJavaEmitter, - callThroughProcAddress, - getProcAddressConfig().getProcAddressTableExpr(), - baseJavaEmitter.isForImplementingMethodCall(), - this); - emitters.add(emitter); - - // If this emitter doesn't have a body (i.e., is a direct native - // call with no intervening argument processing), we need to force - // it to emit a body, and produce another one to act as the entry - // point - // FIXME: the negative test against the PRIVATE modifier is a - // nasty hack to prevent the ProcAddressJavaMethodBindingEmitter - // from incorrectly introducing method bodies to the private - // native implementing methods; want this to work at least for - // public and package-private methods - if (baseJavaEmitter.signatureOnly() && - !baseJavaEmitter.hasModifier(JavaMethodBindingEmitter.PRIVATE) && - baseJavaEmitter.hasModifier(JavaMethodBindingEmitter.NATIVE) && - callThroughProcAddress) { - emitter.setEmitBody(true); - emitter.removeModifier(JavaMethodBindingEmitter.NATIVE); - emitter = new ProcAddressJavaMethodBindingEmitter(baseJavaEmitter, - callThroughProcAddress, - getProcAddressConfig().getProcAddressTableExpr(), - true, - this); - emitter.setForImplementingMethodCall(true); - emitters.add(emitter); + + /** + * Returns the name of the typedef for a pointer to the function + * represented by the argument as defined by the ProcAddressNameExpr + * in the .cfg file. For example, in the OpenGL headers, if the + * argument is the function "glFuncName", the value returned will be + * "PFNGLFUNCNAMEPROC". This returns a valid string regardless of + * whether or not the typedef is actually defined. + */ + protected String getFunctionPointerTypedefName(FunctionSymbol sym) { + return getProcAddressConfig().convertToFunctionPointerName(sym.getName()); } - } - - protected void generateModifiedEmitters(CMethodBindingEmitter baseCEmitter, List emitters) - { - // See whether we need a proc address entry for this one - boolean callThroughProcAddress = needsProcAddressWrapper(baseCEmitter.getBinding().getCSymbol()); - boolean forceProcAddress = getProcAddressConfig().forceProcAddressGen(baseCEmitter.getBinding().getCSymbol().getName()); - String forcedCallingConvention = null; - if (forceProcAddress) { - forcedCallingConvention = getProcAddressConfig().getLocalProcAddressCallingConvention(baseCEmitter.getBinding().getCSymbol().getName()); + + //---------------------------------------------------------------------- + // Internals only below this point + // + + protected void generateModifiedEmitters(JavaMethodBindingEmitter baseJavaEmitter, List<FunctionEmitter> emitters) { + if (getConfig().manuallyImplement(baseJavaEmitter.getName())) { + // User will provide Java-side implementation of this routine; + // pass through any emitters which will produce signatures for + // it unmodified + emitters.add(baseJavaEmitter); + return; + } + + // See whether we need a proc address entry for this one + boolean callThroughProcAddress = needsProcAddressWrapper(baseJavaEmitter.getBinding().getCSymbol()); + + ProcAddressJavaMethodBindingEmitter emitter = + new ProcAddressJavaMethodBindingEmitter(baseJavaEmitter, + callThroughProcAddress, + getProcAddressConfig().getProcAddressTableExpr(), + baseJavaEmitter.isForImplementingMethodCall(), + this); + emitters.add(emitter); + + // If this emitter doesn't have a body (i.e., is a direct native + // call with no intervening argument processing), we need to force + // it to emit a body, and produce another one to act as the entry + // point + // FIXME: the negative test against the PRIVATE modifier is a + // nasty hack to prevent the ProcAddressJavaMethodBindingEmitter + // from incorrectly introducing method bodies to the private + // native implementing methods; want this to work at least for + // public and package-private methods + if (baseJavaEmitter.signatureOnly() + && !baseJavaEmitter.hasModifier(JavaMethodBindingEmitter.PRIVATE) + && baseJavaEmitter.hasModifier(JavaMethodBindingEmitter.NATIVE) + && callThroughProcAddress) { + emitter.setEmitBody(true); + emitter.removeModifier(JavaMethodBindingEmitter.NATIVE); + emitter = new ProcAddressJavaMethodBindingEmitter(baseJavaEmitter, + callThroughProcAddress, + getProcAddressConfig().getProcAddressTableExpr(), + true, + this); + emitter.setForImplementingMethodCall(true); + emitters.add(emitter); + } } - // Note that we don't care much about the naming of the C argument - // variables so to keep things simple we ignore the buffer object - // property for the binding - - // The C-side JNI binding for this particular function will have an - // extra final argument, which is the address (the OpenGL procedure - // address) of the function it needs to call - ProcAddressCMethodBindingEmitter res = new ProcAddressCMethodBindingEmitter(baseCEmitter, - callThroughProcAddress, - forceProcAddress, - forcedCallingConvention, - this); - MessageFormat exp = baseCEmitter.getReturnValueCapacityExpression(); - if (exp != null) { - res.setReturnValueCapacityExpression(exp); + + protected void generateModifiedEmitters(CMethodBindingEmitter baseCEmitter, List<FunctionEmitter> emitters) { + // See whether we need a proc address entry for this one + boolean callThroughProcAddress = needsProcAddressWrapper(baseCEmitter.getBinding().getCSymbol()); + boolean forceProcAddress = getProcAddressConfig().forceProcAddressGen(baseCEmitter.getBinding().getCSymbol().getName()); + String forcedCallingConvention = null; + if (forceProcAddress) { + forcedCallingConvention = getProcAddressConfig().getLocalProcAddressCallingConvention(baseCEmitter.getBinding().getCSymbol().getName()); + } + // Note that we don't care much about the naming of the C argument + // variables so to keep things simple we ignore the buffer object + // property for the binding + + // The C-side JNI binding for this particular function will have an + // extra final argument, which is the address (the OpenGL procedure + // address) of the function it needs to call + ProcAddressCMethodBindingEmitter res = new ProcAddressCMethodBindingEmitter(baseCEmitter, + callThroughProcAddress, + forceProcAddress, + forcedCallingConvention, + this); + MessageFormat exp = baseCEmitter.getReturnValueCapacityExpression(); + if (exp != null) { + res.setReturnValueCapacityExpression(exp); + } + emitters.add(res); } - emitters.add(res); - } - - private String getAliasedSymName(FunctionSymbol sym) { - String symName = getConfig().getJavaSymbolRename(sym.getName()); - if(null==symName) symName=sym.getName(); - return symName; - } - - protected boolean needsProcAddressWrapper(FunctionSymbol sym) - { - String symName = getAliasedSymName(sym); - - ProcAddressConfiguration config = getProcAddressConfig(); - - // We should only generate code to call through a function pointer - // if the symbol has an associated function pointer typedef. - String funcPointerTypedefName = getFunctionPointerTypedefName(sym); - boolean shouldWrap = typedefDictionary.containsKey(funcPointerTypedefName); - //System.err.println(funcPointerTypedefName + " defined: " + shouldWrap); - - if (config.skipProcAddressGen(symName)) { - shouldWrap = false; + + private String getAliasedSymName(FunctionSymbol sym) { + String symName = getConfig().getJavaSymbolRename(sym.getName()); + if (null == symName) { + symName = sym.getName(); + } + return symName; } - - if (config.forceProcAddressGen(symName)) { - shouldWrap = true; + + protected boolean needsProcAddressWrapper(FunctionSymbol sym) { + String symName = getAliasedSymName(sym); + + ProcAddressConfiguration config = getProcAddressConfig(); + + // We should only generate code to call through a function pointer + // if the symbol has an associated function pointer typedef. + String funcPointerTypedefName = getFunctionPointerTypedefName(sym); + boolean shouldWrap = typedefDictionary.containsKey(funcPointerTypedefName); + //System.err.println(funcPointerTypedefName + " defined: " + shouldWrap); + + if (config.skipProcAddressGen(symName)) { + shouldWrap = false; + } + + if (config.forceProcAddressGen(symName)) { + shouldWrap = true; + } + + if (shouldWrap) { + // Hoist argument names from function pointer if not supplied in prototype + Type funcPointerType = typedefDictionary.get(funcPointerTypedefName); + if (funcPointerType != null) { + FunctionType typedef = funcPointerType.asPointer().getTargetType().asFunction(); + FunctionType fun = sym.getType(); + int numarg = typedef.getNumArguments(); + for (int i = 0; i < numarg; i++) { + if (fun.getArgumentName(i) == null) { + fun.setArgumentName(i, typedef.getArgumentName(i)); + } + } + } + } + + return shouldWrap; } - - if (shouldWrap) - { - // Hoist argument names from function pointer if not supplied in prototype - Type funcPointerType = typedefDictionary.get(funcPointerTypedefName); - if (funcPointerType != null) { - FunctionType typedef = funcPointerType.asPointer().getTargetType().asFunction(); - FunctionType fun = sym.getType(); - int numarg = typedef.getNumArguments(); - for (int i =0; i < numarg; i++) { - if (fun.getArgumentName(i) == null) - fun.setArgumentName(i,typedef.getArgumentName(i)); - } - } + + protected void beginProcAddressTable() throws Exception { + tableClassPackage = getProcAddressConfig().tableClassPackage(); + tableClassName = getProcAddressConfig().tableClassName(); + + // Table defaults to going into the impl directory unless otherwise overridden + String implPackageName = tableClassPackage; + if (implPackageName == null) { + implPackageName = getImplPackageName(); + } + String jImplRoot = + getJavaOutputDir() + File.separator + + CodeGenUtils.packageAsPath(implPackageName); + + tableWriter = openFile(jImplRoot + File.separator + tableClassName + ".java"); + emittedTableEntries = new HashSet<String>(); + + CodeGenUtils.emitAutogeneratedWarning(tableWriter, this); + + tableWriter.println("package " + implPackageName + ";"); + tableWriter.println(); + for (String imporT : getConfig().imports()) { + tableWriter.println("import " + imporT + ";"); + } + tableWriter.println(); + + tableWriter.println("/**"); + tableWriter.println(" * This table is a cache of pointers to the dynamically-linkable C"); + tableWriter.println(" * functions this autogenerated Java binding has exposed. Some"); + tableWriter.println(" * libraries such as OpenGL, OpenAL and others define function pointer"); + tableWriter.println(" * signatures rather than statically linkable entry points for the"); + tableWriter.println(" * purposes of being able to query at run-time whether a particular"); + tableWriter.println(" * extension is available. This table acts as a cache of these"); + tableWriter.println(" * function pointers. Each function pointer is typically looked up at"); + tableWriter.println(" * run-time by a platform-dependent mechanism such as dlsym(),"); + tableWriter.println(" * wgl/glXGetProcAddress(), or alGetProcAddress(). The associated"); + tableWriter.println(" * autogenerated Java and C code accesses the fields in this table to"); + tableWriter.println(" * call the various functions. If the field containing the function"); + tableWriter.println(" * pointer is 0, the function is considered to be unavailable and can"); + tableWriter.println(" * not be called."); + tableWriter.println(" */"); + tableWriter.println("public class " + tableClassName + " implements com.jogamp.gluegen.runtime.ProcAddressTable"); + tableWriter.println("{"); + + for (String string : getProcAddressConfig().getForceProcAddressGen()) { + emitProcAddressTableEntryForString(string); + } } - - return shouldWrap; - } - - protected void beginProcAddressTable() throws Exception - { - tableClassPackage = getProcAddressConfig().tableClassPackage(); - tableClassName = getProcAddressConfig().tableClassName(); - - // Table defaults to going into the impl directory unless otherwise overridden - String implPackageName = tableClassPackage; - if (implPackageName == null) { - implPackageName = getImplPackageName(); + + protected void endProcAddressTable() throws Exception { + PrintWriter w = tableWriter; + + w.println(" /**"); + w.println(" * This is a convenience method to get (by name) the native function"); + w.println(" * pointer for a given function. It lets you avoid having to"); + w.println(" * manually compute the "" + PROCADDRESS_VAR_PREFIX + " + "); + w.println(" * <functionName>" member variable name and look it up via"); + w.println(" * reflection; it also will throw an exception if you try to get the"); + w.println(" * address of an unknown function, or one that is statically linked"); + w.println(" * and therefore does not have a function pointer in this table."); + w.println(" *"); + w.println(" * @throws RuntimeException if the function pointer was not found in"); + w.println(" * this table, either because the function was unknown or because"); + w.println(" * it was statically linked."); + w.println(" */"); + w.println(" public long getAddressFor(String functionName) {"); + w.println(" String addressFieldName = " + getProcAddressConfig().gluegenRuntimePackage() + ".ProcAddressHelper.PROCADDRESS_VAR_PREFIX + functionName;"); + w.println(" try { "); + w.println(" java.lang.reflect.Field addressField = getClass().getField(addressFieldName);"); + w.println(" return addressField.getLong(this);"); + w.println(" } catch (Exception e) {"); + w.println(" // The user is calling a bogus function or one which is not"); + w.println(" // runtime linked"); + w.println(" throw new RuntimeException("); + w.println(" \"WARNING: Address query failed for \\\"\" + functionName +"); + w.println(" \"\\\"; it's either statically linked or is not a known \" +"); + w.println(" \"function\", e);"); + w.println(" } "); + w.println(" }"); + + w.println("} // end of class " + tableClassName); + w.flush(); + w.close(); } - String jImplRoot = - getJavaOutputDir() + File.separator + - CodeGenUtils.packageAsPath(implPackageName); - - tableWriter = openFile(jImplRoot + File.separator + tableClassName + ".java"); - emittedTableEntries = new HashSet(); - - CodeGenUtils.emitAutogeneratedWarning(tableWriter, this); - - tableWriter.println("package " + implPackageName + ";"); - tableWriter.println(); - for (Iterator iter = getConfig().imports().iterator(); iter.hasNext(); ) { - tableWriter.println("import " + ((String) iter.next()) + ";"); + + protected void emitProcAddressTableEntryForString(String str) { + // Deal gracefully with forced proc address generation in the face + // of having the function pointer typedef in the header file too + if (emittedTableEntries.contains(str)) { + return; + } + emittedTableEntries.add(str); + tableWriter.print(" public long "); + tableWriter.print(PROCADDRESS_VAR_PREFIX); + tableWriter.print(str); + tableWriter.println(";"); } - tableWriter.println(); - - tableWriter.println("/**"); - tableWriter.println(" * This table is a cache of pointers to the dynamically-linkable C"); - tableWriter.println(" * functions this autogenerated Java binding has exposed. Some"); - tableWriter.println(" * libraries such as OpenGL, OpenAL and others define function pointer"); - tableWriter.println(" * signatures rather than statically linkable entry points for the"); - tableWriter.println(" * purposes of being able to query at run-time whether a particular"); - tableWriter.println(" * extension is available. This table acts as a cache of these"); - tableWriter.println(" * function pointers. Each function pointer is typically looked up at"); - tableWriter.println(" * run-time by a platform-dependent mechanism such as dlsym(),"); - tableWriter.println(" * wgl/glXGetProcAddress(), or alGetProcAddress(). The associated"); - tableWriter.println(" * autogenerated Java and C code accesses the fields in this table to"); - tableWriter.println(" * call the various functions. If the field containing the function"); - tableWriter.println(" * pointer is 0, the function is considered to be unavailable and can"); - tableWriter.println(" * not be called."); - tableWriter.println(" */"); - tableWriter.println("public class " + tableClassName + " implements com.jogamp.gluegen.runtime.ProcAddressTable"); - tableWriter.println("{"); - - for (Iterator iter = getProcAddressConfig().getForceProcAddressGen().iterator(); iter.hasNext(); ) { - emitProcAddressTableEntryForString((String) iter.next()); + + protected ProcAddressConfiguration getProcAddressConfig() { + return (ProcAddressConfiguration) getConfig(); } - } - - protected void endProcAddressTable() throws Exception - { - PrintWriter w = tableWriter; - - w.println(" /**"); - w.println(" * This is a convenience method to get (by name) the native function"); - w.println(" * pointer for a given function. It lets you avoid having to"); - w.println(" * manually compute the "" + PROCADDRESS_VAR_PREFIX + " + "); - w.println(" * <functionName>" member variable name and look it up via"); - w.println(" * reflection; it also will throw an exception if you try to get the"); - w.println(" * address of an unknown function, or one that is statically linked"); - w.println(" * and therefore does not have a function pointer in this table."); - w.println(" *"); - w.println(" * @throws RuntimeException if the function pointer was not found in"); - w.println(" * this table, either because the function was unknown or because"); - w.println(" * it was statically linked."); - w.println(" */"); - w.println(" public long getAddressFor(String functionName) {"); - w.println(" String addressFieldName = " + getProcAddressConfig().gluegenRuntimePackage() + ".ProcAddressHelper.PROCADDRESS_VAR_PREFIX + functionName;"); - w.println(" try { "); - w.println(" java.lang.reflect.Field addressField = getClass().getField(addressFieldName);"); - w.println(" return addressField.getLong(this);"); - w.println(" } catch (Exception e) {"); - w.println(" // The user is calling a bogus function or one which is not"); - w.println(" // runtime linked"); - w.println(" throw new RuntimeException("); - w.println(" \"WARNING: Address query failed for \\\"\" + functionName +"); - w.println(" \"\\\"; it's either statically linked or is not a known \" +"); - w.println(" \"function\", e);"); - w.println(" } "); - w.println(" }"); - - w.println("} // end of class " + tableClassName); - w.flush(); - w.close(); - } - - protected void emitProcAddressTableEntryForString(String str) - { - // Deal gracefully with forced proc address generation in the face - // of having the function pointer typedef in the header file too - if (emittedTableEntries.contains(str)) - return; - emittedTableEntries.add(str); - tableWriter.print(" public long "); - tableWriter.print(PROCADDRESS_VAR_PREFIX); - tableWriter.print(str); - tableWriter.println(";"); - } - - protected ProcAddressConfiguration getProcAddressConfig() { - return (ProcAddressConfiguration) getConfig(); - } } diff --git a/src/java/com/sun/gluegen/procaddress/ProcAddressJavaMethodBindingEmitter.java b/src/java/com/sun/gluegen/procaddress/ProcAddressJavaMethodBindingEmitter.java index 2dda752..5a30ee5 100755 --- a/src/java/com/sun/gluegen/procaddress/ProcAddressJavaMethodBindingEmitter.java +++ b/src/java/com/sun/gluegen/procaddress/ProcAddressJavaMethodBindingEmitter.java @@ -36,118 +36,115 @@ * Sun gratefully acknowledges that this software was originally authored * and developed by Kenneth Bradley Russell and Christopher John Kline. */ - package com.sun.gluegen.procaddress; import java.io.*; -import java.util.*; import com.sun.gluegen.*; -import com.sun.gluegen.cgram.types.*; /** A specialization of JavaMethodBindingEmitter with knowledge of how - to call through a function pointer. */ - +to call through a function pointer. */ public class ProcAddressJavaMethodBindingEmitter extends JavaMethodBindingEmitter { - private final CommentEmitter commentEmitterForWrappedMethod = - new WrappedMethodCommentEmitter(); - - protected boolean callThroughProcAddress; - protected String getProcAddressTableExpr; - protected boolean changeNameAndArguments; - protected ProcAddressEmitter emitter; - - public ProcAddressJavaMethodBindingEmitter(JavaMethodBindingEmitter methodToWrap, - boolean callThroughProcAddress, - String getProcAddressTableExpr, - boolean changeNameAndArguments, - ProcAddressEmitter emitter) { - super(methodToWrap); - this.callThroughProcAddress = callThroughProcAddress; - this.getProcAddressTableExpr = getProcAddressTableExpr; - this.changeNameAndArguments = changeNameAndArguments; - this.emitter = emitter; - if (callThroughProcAddress) { - setCommentEmitter(new WrappedMethodCommentEmitter()); + + protected boolean callThroughProcAddress; + protected boolean changeNameAndArguments; + + protected String getProcAddressTableExpr; + protected ProcAddressEmitter emitter; + + public ProcAddressJavaMethodBindingEmitter(JavaMethodBindingEmitter methodToWrap, boolean callThroughProcAddress, + String getProcAddressTableExpr, boolean changeNameAndArguments, ProcAddressEmitter emitter) { + + super(methodToWrap); + + this.callThroughProcAddress = callThroughProcAddress; + this.getProcAddressTableExpr = getProcAddressTableExpr; + this.changeNameAndArguments = changeNameAndArguments; + this.emitter = emitter; + + if (callThroughProcAddress) { + setCommentEmitter(new WrappedMethodCommentEmitter()); + } + + if (methodToWrap.getBinding().hasContainingType()) { + throw new IllegalArgumentException( + "Cannot create proc. address wrapper; method has containing type: \"" + + methodToWrap.getBinding() + "\""); + } } - if (methodToWrap.getBinding().hasContainingType()) - { - throw new IllegalArgumentException( - "Cannot create proc. address wrapper; method has containing type: \"" + - methodToWrap.getBinding() + "\""); + public ProcAddressJavaMethodBindingEmitter(ProcAddressJavaMethodBindingEmitter methodToWrap) { + this(methodToWrap, methodToWrap.callThroughProcAddress, methodToWrap.getProcAddressTableExpr, + methodToWrap.changeNameAndArguments, methodToWrap.emitter); } - } - - public ProcAddressJavaMethodBindingEmitter(ProcAddressJavaMethodBindingEmitter methodToWrap) { - this(methodToWrap, - methodToWrap.callThroughProcAddress, - methodToWrap.getProcAddressTableExpr, - methodToWrap.changeNameAndArguments, - methodToWrap.emitter); - } - - public String getName() { - String res = super.getName(); - if (changeNameAndArguments) { - return ProcAddressEmitter.WRAP_PREFIX + res; + + @Override + public String getName() { + String res = super.getName(); + if (changeNameAndArguments) { + return ProcAddressEmitter.WRAP_PREFIX + res; + } + return res; } - return res; - } - - protected int emitArguments(PrintWriter writer) { - int numEmitted = super.emitArguments(writer); - if (callThroughProcAddress) { - if (changeNameAndArguments) { - if (numEmitted > 0) { - writer.print(", "); + + @Override + protected int emitArguments(PrintWriter writer) { + int numEmitted = super.emitArguments(writer); + if (callThroughProcAddress) { + if (changeNameAndArguments) { + if (numEmitted > 0) { + writer.print(", "); + } + + writer.print("long procAddress"); + ++numEmitted; + } } - writer.print("long procAddress"); - ++numEmitted; - } + return numEmitted; } - - return numEmitted; - } - - protected String getImplMethodName() { - String name = super.getImplMethodName(); - if (callThroughProcAddress) { - return ProcAddressEmitter.WRAP_PREFIX + name; + + @Override + protected String getImplMethodName() { + String name = super.getImplMethodName(); + if (callThroughProcAddress) { + return ProcAddressEmitter.WRAP_PREFIX + name; + } + return name; } - return name; - } - - protected void emitPreCallSetup(MethodBinding binding, PrintWriter writer) { - super.emitPreCallSetup(binding, writer); - - if (callThroughProcAddress) { - String procAddressVariable = - ProcAddressEmitter.PROCADDRESS_VAR_PREFIX + binding.getName(); - writer.println(" final long __addr_ = " + getProcAddressTableExpr + "." + procAddressVariable + ";"); - writer.println(" if (__addr_ == 0) {"); - writer.println(" throw new " + emitter.unsupportedExceptionType() + "(\"Method \\\"" + binding.getName() + "\\\" not available\");"); - writer.println(" }"); + + @Override + protected void emitPreCallSetup(MethodBinding binding, PrintWriter writer) { + super.emitPreCallSetup(binding, writer); + + if (callThroughProcAddress) { + String procAddressVariable = ProcAddressEmitter.PROCADDRESS_VAR_PREFIX + binding.getName(); + writer.println(" final long __addr_ = " + getProcAddressTableExpr + "." + procAddressVariable + ";"); + writer.println(" if (__addr_ == 0) {"); + writer.println(" throw new " + emitter.unsupportedExceptionType() + "(\"Method \\\"" + binding.getName() + "\\\" not available\");"); + writer.println(" }"); + } } - } - - protected int emitCallArguments(MethodBinding binding, PrintWriter writer) { - int numEmitted = super.emitCallArguments(binding, writer); - if (callThroughProcAddress) { - if (numEmitted > 0) { - writer.print(", "); - } - writer.print("__addr_"); - ++numEmitted; + + @Override + protected int emitCallArguments(MethodBinding binding, PrintWriter writer) { + int numEmitted = super.emitCallArguments(binding, writer); + if (callThroughProcAddress) { + if (numEmitted > 0) { + writer.print(", "); + } + writer.print("__addr_"); + ++numEmitted; + } + + return numEmitted; } - return numEmitted; - } + /** This class emits the comment for the wrapper method */ + public class WrappedMethodCommentEmitter extends JavaMethodBindingEmitter.DefaultCommentEmitter { - /** This class emits the comment for the wrapper method */ - public class WrappedMethodCommentEmitter extends JavaMethodBindingEmitter.DefaultCommentEmitter { - protected void emitBeginning(FunctionEmitter methodEmitter, PrintWriter writer) { - writer.print("Entry point (through function pointer) to C language function: <br> "); + @Override + protected void emitBeginning(FunctionEmitter methodEmitter, PrintWriter writer) { + writer.print("Entry point (through function pointer) to C language function: <br> "); + } } - } } |