summaryrefslogtreecommitdiffstats
path: root/src/java/com/sun/gluegen/procaddress
diff options
context:
space:
mode:
authorSven Gothel <sgothel@jausoft.com>2010-03-31 23:32:39 +0200
committerSven Gothel <sgothel@jausoft.com>2010-03-31 23:32:39 +0200
commite37c383c4a09432fff009e81d572c8a92b42eef6 (patch)
tree9ebb8bacc940a3460be1639ad771f8e5d98ad012 /src/java/com/sun/gluegen/procaddress
parent73829c38665c57052bf703ae58a2bd1dc7dc4625 (diff)
parent22262166e07de99ae0d4557e4f87e3bd1c5cd6dd (diff)
Merged with latest of mbien
Diffstat (limited to 'src/java/com/sun/gluegen/procaddress')
-rwxr-xr-xsrc/java/com/sun/gluegen/procaddress/ProcAddressCMethodBindingEmitter.java279
-rwxr-xr-xsrc/java/com/sun/gluegen/procaddress/ProcAddressConfiguration.java456
-rwxr-xr-xsrc/java/com/sun/gluegen/procaddress/ProcAddressEmitter.java636
-rwxr-xr-xsrc/java/com/sun/gluegen/procaddress/ProcAddressJavaMethodBindingEmitter.java185
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 &quot;" + PROCADDRESS_VAR_PREFIX + " + ");
+ w.println(" * &lt;functionName&gt;&quot; member variable name and look it up via");
+ w.println(" * reflection; it also will throw an exception if you try to get the");
+ w.println(" * address of an unknown function, or one that is statically linked");
+ w.println(" * and therefore does not have a function pointer in this table.");
+ w.println(" *");
+ w.println(" * @throws RuntimeException if the function pointer was not found in");
+ w.println(" * this table, either because the function was unknown or because");
+ w.println(" * it was statically linked.");
+ w.println(" */");
+ w.println(" public long getAddressFor(String functionName) {");
+ w.println(" String addressFieldName = " + getProcAddressConfig().gluegenRuntimePackage() + ".ProcAddressHelper.PROCADDRESS_VAR_PREFIX + functionName;");
+ w.println(" try { ");
+ w.println(" java.lang.reflect.Field addressField = getClass().getField(addressFieldName);");
+ w.println(" return addressField.getLong(this);");
+ w.println(" } catch (Exception e) {");
+ w.println(" // The user is calling a bogus function or one which is not");
+ w.println(" // runtime linked");
+ w.println(" throw new RuntimeException(");
+ w.println(" \"WARNING: Address query failed for \\\"\" + functionName +");
+ w.println(" \"\\\"; it's either statically linked or is not a known \" +");
+ w.println(" \"function\", e);");
+ w.println(" } ");
+ w.println(" }");
+
+ w.println("} // end of class " + tableClassName);
+ w.flush();
+ w.close();
}
- String jImplRoot =
- getJavaOutputDir() + File.separator +
- CodeGenUtils.packageAsPath(implPackageName);
-
- tableWriter = openFile(jImplRoot + File.separator + tableClassName + ".java");
- emittedTableEntries = new HashSet();
-
- CodeGenUtils.emitAutogeneratedWarning(tableWriter, this);
-
- tableWriter.println("package " + implPackageName + ";");
- tableWriter.println();
- for (Iterator iter = getConfig().imports().iterator(); iter.hasNext(); ) {
- tableWriter.println("import " + ((String) iter.next()) + ";");
+
+ protected void emitProcAddressTableEntryForString(String str) {
+ // Deal gracefully with forced proc address generation in the face
+ // of having the function pointer typedef in the header file too
+ if (emittedTableEntries.contains(str)) {
+ return;
+ }
+ emittedTableEntries.add(str);
+ tableWriter.print(" public long ");
+ tableWriter.print(PROCADDRESS_VAR_PREFIX);
+ tableWriter.print(str);
+ tableWriter.println(";");
}
- tableWriter.println();
-
- tableWriter.println("/**");
- tableWriter.println(" * This table is a cache of pointers to the dynamically-linkable C");
- tableWriter.println(" * functions this autogenerated Java binding has exposed. Some");
- tableWriter.println(" * libraries such as OpenGL, OpenAL and others define function pointer");
- tableWriter.println(" * signatures rather than statically linkable entry points for the");
- tableWriter.println(" * purposes of being able to query at run-time whether a particular");
- tableWriter.println(" * extension is available. This table acts as a cache of these");
- tableWriter.println(" * function pointers. Each function pointer is typically looked up at");
- tableWriter.println(" * run-time by a platform-dependent mechanism such as dlsym(),");
- tableWriter.println(" * wgl/glXGetProcAddress(), or alGetProcAddress(). The associated");
- tableWriter.println(" * autogenerated Java and C code accesses the fields in this table to");
- tableWriter.println(" * call the various functions. If the field containing the function");
- tableWriter.println(" * pointer is 0, the function is considered to be unavailable and can");
- tableWriter.println(" * not be called.");
- tableWriter.println(" */");
- tableWriter.println("public class " + tableClassName + " implements com.jogamp.gluegen.runtime.ProcAddressTable");
- tableWriter.println("{");
-
- for (Iterator iter = getProcAddressConfig().getForceProcAddressGen().iterator(); iter.hasNext(); ) {
- emitProcAddressTableEntryForString((String) iter.next());
+
+ protected ProcAddressConfiguration getProcAddressConfig() {
+ return (ProcAddressConfiguration) getConfig();
}
- }
-
- protected void endProcAddressTable() throws Exception
- {
- PrintWriter w = tableWriter;
-
- w.println(" /**");
- w.println(" * This is a convenience method to get (by name) the native function");
- w.println(" * pointer for a given function. It lets you avoid having to");
- w.println(" * manually compute the &quot;" + PROCADDRESS_VAR_PREFIX + " + ");
- w.println(" * &lt;functionName&gt;&quot; member variable name and look it up via");
- w.println(" * reflection; it also will throw an exception if you try to get the");
- w.println(" * address of an unknown function, or one that is statically linked");
- w.println(" * and therefore does not have a function pointer in this table.");
- w.println(" *");
- w.println(" * @throws RuntimeException if the function pointer was not found in");
- w.println(" * this table, either because the function was unknown or because");
- w.println(" * it was statically linked.");
- w.println(" */");
- w.println(" public long getAddressFor(String functionName) {");
- w.println(" String addressFieldName = " + getProcAddressConfig().gluegenRuntimePackage() + ".ProcAddressHelper.PROCADDRESS_VAR_PREFIX + functionName;");
- w.println(" try { ");
- w.println(" java.lang.reflect.Field addressField = getClass().getField(addressFieldName);");
- w.println(" return addressField.getLong(this);");
- w.println(" } catch (Exception e) {");
- w.println(" // The user is calling a bogus function or one which is not");
- w.println(" // runtime linked");
- w.println(" throw new RuntimeException(");
- w.println(" \"WARNING: Address query failed for \\\"\" + functionName +");
- w.println(" \"\\\"; it's either statically linked or is not a known \" +");
- w.println(" \"function\", e);");
- w.println(" } ");
- w.println(" }");
-
- w.println("} // end of class " + tableClassName);
- w.flush();
- w.close();
- }
-
- protected void emitProcAddressTableEntryForString(String str)
- {
- // Deal gracefully with forced proc address generation in the face
- // of having the function pointer typedef in the header file too
- if (emittedTableEntries.contains(str))
- return;
- emittedTableEntries.add(str);
- tableWriter.print(" public long ");
- tableWriter.print(PROCADDRESS_VAR_PREFIX);
- tableWriter.print(str);
- tableWriter.println(";");
- }
-
- protected ProcAddressConfiguration getProcAddressConfig() {
- return (ProcAddressConfiguration) getConfig();
- }
}
diff --git a/src/java/com/sun/gluegen/procaddress/ProcAddressJavaMethodBindingEmitter.java b/src/java/com/sun/gluegen/procaddress/ProcAddressJavaMethodBindingEmitter.java
index 2dda752..5a30ee5 100755
--- a/src/java/com/sun/gluegen/procaddress/ProcAddressJavaMethodBindingEmitter.java
+++ b/src/java/com/sun/gluegen/procaddress/ProcAddressJavaMethodBindingEmitter.java
@@ -36,118 +36,115 @@
* Sun gratefully acknowledges that this software was originally authored
* and developed by Kenneth Bradley Russell and Christopher John Kline.
*/
-
package com.sun.gluegen.procaddress;
import java.io.*;
-import java.util.*;
import com.sun.gluegen.*;
-import com.sun.gluegen.cgram.types.*;
/** A specialization of JavaMethodBindingEmitter with knowledge of how
- to call through a function pointer. */
-
+to call through a function pointer. */
public class ProcAddressJavaMethodBindingEmitter extends JavaMethodBindingEmitter {
- private final CommentEmitter commentEmitterForWrappedMethod =
- new WrappedMethodCommentEmitter();
-
- protected boolean callThroughProcAddress;
- protected String getProcAddressTableExpr;
- protected boolean changeNameAndArguments;
- protected ProcAddressEmitter emitter;
-
- public ProcAddressJavaMethodBindingEmitter(JavaMethodBindingEmitter methodToWrap,
- boolean callThroughProcAddress,
- String getProcAddressTableExpr,
- boolean changeNameAndArguments,
- ProcAddressEmitter emitter) {
- super(methodToWrap);
- this.callThroughProcAddress = callThroughProcAddress;
- this.getProcAddressTableExpr = getProcAddressTableExpr;
- this.changeNameAndArguments = changeNameAndArguments;
- this.emitter = emitter;
- if (callThroughProcAddress) {
- setCommentEmitter(new WrappedMethodCommentEmitter());
+
+ protected boolean callThroughProcAddress;
+ protected boolean changeNameAndArguments;
+
+ protected String getProcAddressTableExpr;
+ protected ProcAddressEmitter emitter;
+
+ public ProcAddressJavaMethodBindingEmitter(JavaMethodBindingEmitter methodToWrap, boolean callThroughProcAddress,
+ String getProcAddressTableExpr, boolean changeNameAndArguments, ProcAddressEmitter emitter) {
+
+ super(methodToWrap);
+
+ this.callThroughProcAddress = callThroughProcAddress;
+ this.getProcAddressTableExpr = getProcAddressTableExpr;
+ this.changeNameAndArguments = changeNameAndArguments;
+ this.emitter = emitter;
+
+ if (callThroughProcAddress) {
+ setCommentEmitter(new WrappedMethodCommentEmitter());
+ }
+
+ if (methodToWrap.getBinding().hasContainingType()) {
+ throw new IllegalArgumentException(
+ "Cannot create proc. address wrapper; method has containing type: \""
+ + methodToWrap.getBinding() + "\"");
+ }
}
- if (methodToWrap.getBinding().hasContainingType())
- {
- throw new IllegalArgumentException(
- "Cannot create proc. address wrapper; method has containing type: \"" +
- methodToWrap.getBinding() + "\"");
+ public ProcAddressJavaMethodBindingEmitter(ProcAddressJavaMethodBindingEmitter methodToWrap) {
+ this(methodToWrap, methodToWrap.callThroughProcAddress, methodToWrap.getProcAddressTableExpr,
+ methodToWrap.changeNameAndArguments, methodToWrap.emitter);
}
- }
-
- public ProcAddressJavaMethodBindingEmitter(ProcAddressJavaMethodBindingEmitter methodToWrap) {
- this(methodToWrap,
- methodToWrap.callThroughProcAddress,
- methodToWrap.getProcAddressTableExpr,
- methodToWrap.changeNameAndArguments,
- methodToWrap.emitter);
- }
-
- public String getName() {
- String res = super.getName();
- if (changeNameAndArguments) {
- return ProcAddressEmitter.WRAP_PREFIX + res;
+
+ @Override
+ public String getName() {
+ String res = super.getName();
+ if (changeNameAndArguments) {
+ return ProcAddressEmitter.WRAP_PREFIX + res;
+ }
+ return res;
}
- return res;
- }
-
- protected int emitArguments(PrintWriter writer) {
- int numEmitted = super.emitArguments(writer);
- if (callThroughProcAddress) {
- if (changeNameAndArguments) {
- if (numEmitted > 0) {
- writer.print(", ");
+
+ @Override
+ protected int emitArguments(PrintWriter writer) {
+ int numEmitted = super.emitArguments(writer);
+ if (callThroughProcAddress) {
+ if (changeNameAndArguments) {
+ if (numEmitted > 0) {
+ writer.print(", ");
+ }
+
+ writer.print("long procAddress");
+ ++numEmitted;
+ }
}
- writer.print("long procAddress");
- ++numEmitted;
- }
+ return numEmitted;
}
-
- return numEmitted;
- }
-
- protected String getImplMethodName() {
- String name = super.getImplMethodName();
- if (callThroughProcAddress) {
- return ProcAddressEmitter.WRAP_PREFIX + name;
+
+ @Override
+ protected String getImplMethodName() {
+ String name = super.getImplMethodName();
+ if (callThroughProcAddress) {
+ return ProcAddressEmitter.WRAP_PREFIX + name;
+ }
+ return name;
}
- return name;
- }
-
- protected void emitPreCallSetup(MethodBinding binding, PrintWriter writer) {
- super.emitPreCallSetup(binding, writer);
-
- if (callThroughProcAddress) {
- String procAddressVariable =
- ProcAddressEmitter.PROCADDRESS_VAR_PREFIX + binding.getName();
- writer.println(" final long __addr_ = " + getProcAddressTableExpr + "." + procAddressVariable + ";");
- writer.println(" if (__addr_ == 0) {");
- writer.println(" throw new " + emitter.unsupportedExceptionType() + "(\"Method \\\"" + binding.getName() + "\\\" not available\");");
- writer.println(" }");
+
+ @Override
+ protected void emitPreCallSetup(MethodBinding binding, PrintWriter writer) {
+ super.emitPreCallSetup(binding, writer);
+
+ if (callThroughProcAddress) {
+ String procAddressVariable = ProcAddressEmitter.PROCADDRESS_VAR_PREFIX + binding.getName();
+ writer.println(" final long __addr_ = " + getProcAddressTableExpr + "." + procAddressVariable + ";");
+ writer.println(" if (__addr_ == 0) {");
+ writer.println(" throw new " + emitter.unsupportedExceptionType() + "(\"Method \\\"" + binding.getName() + "\\\" not available\");");
+ writer.println(" }");
+ }
}
- }
-
- protected int emitCallArguments(MethodBinding binding, PrintWriter writer) {
- int numEmitted = super.emitCallArguments(binding, writer);
- if (callThroughProcAddress) {
- if (numEmitted > 0) {
- writer.print(", ");
- }
- writer.print("__addr_");
- ++numEmitted;
+
+ @Override
+ protected int emitCallArguments(MethodBinding binding, PrintWriter writer) {
+ int numEmitted = super.emitCallArguments(binding, writer);
+ if (callThroughProcAddress) {
+ if (numEmitted > 0) {
+ writer.print(", ");
+ }
+ writer.print("__addr_");
+ ++numEmitted;
+ }
+
+ return numEmitted;
}
- return numEmitted;
- }
+ /** This class emits the comment for the wrapper method */
+ public class WrappedMethodCommentEmitter extends JavaMethodBindingEmitter.DefaultCommentEmitter {
- /** This class emits the comment for the wrapper method */
- public class WrappedMethodCommentEmitter extends JavaMethodBindingEmitter.DefaultCommentEmitter {
- protected void emitBeginning(FunctionEmitter methodEmitter, PrintWriter writer) {
- writer.print("Entry point (through function pointer) to C language function: <br> ");
+ @Override
+ protected void emitBeginning(FunctionEmitter methodEmitter, PrintWriter writer) {
+ writer.print("Entry point (through function pointer) to C language function: <br> ");
+ }
}
- }
}