diff options
Diffstat (limited to 'src/java')
| -rw-r--r-- | src/java/com/jogamp/gluegen/CMethodBindingEmitter.java | 42 | ||||
| -rw-r--r-- | src/java/com/jogamp/gluegen/JavaCallbackEmitter.java | 338 | ||||
| -rw-r--r-- | src/java/com/jogamp/gluegen/JavaConfiguration.java | 21 | ||||
| -rw-r--r-- | src/java/com/jogamp/gluegen/JavaEmitter.java | 71 | ||||
| -rw-r--r-- | src/java/com/jogamp/gluegen/JavaType.java | 18 |
5 files changed, 338 insertions, 152 deletions
diff --git a/src/java/com/jogamp/gluegen/CMethodBindingEmitter.java b/src/java/com/jogamp/gluegen/CMethodBindingEmitter.java index e20a1cb..cbd33fd 100644 --- a/src/java/com/jogamp/gluegen/CMethodBindingEmitter.java +++ b/src/java/com/jogamp/gluegen/CMethodBindingEmitter.java @@ -116,7 +116,7 @@ public class CMethodBindingEmitter extends FunctionEmitter { // We need this in order to compute sizes of certain types protected MachineDataInfo machDesc; - private final CMethodBindingEmitter jcbCMethodEmitter; + private final CMethodBindingEmitter jcbFuncCMethodEmitter; private final JavaCallbackEmitter javaCallbackEmitter; /** @@ -154,13 +154,13 @@ public class CMethodBindingEmitter extends FunctionEmitter { final JavaCallbackInfo javaCallback = cfg.setFuncToJavaCallbackMap.get(binding.getName()); if( null != javaCallback ) { // jcbNativeBasename = CodeGenUtils.capitalizeString( javaCallback.setFuncName+javaCallback.cbSimpleClazzName.replace("_", "") ); - jcbCMethodEmitter = new CMethodBindingEmitter(javaCallback.cbFuncBinding, - unit, javaPackageName, javaClassName, isOverloadedBinding, - isJavaMethodStatic, forImplementingMethodCall, - forIndirectBufferAndArrayImplementation, machDesc, configuration); + jcbFuncCMethodEmitter = new CMethodBindingEmitter(javaCallback.cbFuncBinding, + unit, javaPackageName, javaClassName, isOverloadedBinding, + isJavaMethodStatic, forImplementingMethodCall, + forIndirectBufferAndArrayImplementation, machDesc, configuration); javaCallbackEmitter = new JavaCallbackEmitter(cfg, binding, javaCallback, null); } else { - jcbCMethodEmitter = null; + jcbFuncCMethodEmitter = null; javaCallbackEmitter = null; } setCommentEmitter(defaultCommentEmitter); @@ -415,7 +415,7 @@ public class CMethodBindingEmitter extends FunctionEmitter { @Override protected void emitAdditionalCode() { if( null != javaCallbackEmitter ) { - javaCallbackEmitter.emitCAdditionalCode(unit, jcbCMethodEmitter); + javaCallbackEmitter.emitCAdditionalCode(unit, jcbFuncCMethodEmitter); } } @@ -984,9 +984,11 @@ public class CMethodBindingEmitter extends FunctionEmitter { unit.emit(") + " + byteOffsetArgName(i) + ")"); } } else { - if (javaArgType.isString()) { unit.emit(STRING_CHARS_PREFIX); } + if ( javaArgType.isString() ) { + unit.emit(STRING_CHARS_PREFIX); + } unit.emit(binding.getArgumentName(i)); - if( null != javaCallbackEmitter ) { + if( !javaArgType.isString() && null != javaCallbackEmitter ) { javaCallbackEmitter.emitCOptArgumentSuffix(unit, i); } } @@ -1107,11 +1109,14 @@ public class CMethodBindingEmitter extends FunctionEmitter { unit.addTailCode(CCodeUnit.NewDirectByteBufferCopyUnitCode); } else if (javaType.isNIOBuffer() || javaType.isCompoundTypeWrapper()) { if( addLocalVar ) { - unit.emit(" "+javaType.jniTypeName()+" "+javaArgName+" = "); + unit.emitln(" "+javaType.jniTypeName()+" "+javaArgName+";"); } else { - unit.emit(" "+javaArgName+" = "); + unit.emitln(" "+javaArgName+";"); } - unit.emit("(NULL == "+cArgName+") ? NULL : (*env)->NewDirectByteBuffer(env, (void *)"+cArgName+", "); + unit.emitln(" if(NULL == "+cArgName+") {"); + unit.emitln(" "+javaArgName+" = NULL;"); + unit.emitln(" } else {"); + unit.emit (" "+javaArgName+" = (*env)->NewDirectByteBuffer(env, (void *)"+cArgName+", "); // See whether capacity has been specified if ( isReturnVal && returnValueCapacityExpression != null) { @@ -1168,13 +1173,14 @@ public class CMethodBindingEmitter extends FunctionEmitter { "value for function \"" + binding.getName() + "\". " + wmsg + " (sizeof(" + cType.getCName() + ")): " + binding); } } - unit.emitln(" /** "); - unit.emitln(" * mode: "+mode+", arg #"+argIdx); - unit.emitln(" * cType: "+cType.getDebugString()); - unit.emitln(" * cTargetType: "+cTargetType.getDebugString()); - unit.emitln(" * javaType: "+javaType.getDebugString()); - unit.emitln(" */"); + unit.emitln(" /** "); + unit.emitln(" * mode: "+mode+", arg #"+argIdx); + unit.emitln(" * cType: "+cType.getDebugString()); + unit.emitln(" * cTargetType: "+cTargetType.getDebugString()); + unit.emitln(" * javaType: "+javaType.getDebugString()); + unit.emitln(" */"); } + unit.emitln(" }"); } else if (javaType.isString()) { final boolean pascalString = javaType.isPascalStringVariant(); final String lenArgName; diff --git a/src/java/com/jogamp/gluegen/JavaCallbackEmitter.java b/src/java/com/jogamp/gluegen/JavaCallbackEmitter.java index dbd38aa..01ffe8f 100644 --- a/src/java/com/jogamp/gluegen/JavaCallbackEmitter.java +++ b/src/java/com/jogamp/gluegen/JavaCallbackEmitter.java @@ -30,6 +30,8 @@ package com.jogamp.gluegen; import com.jogamp.gluegen.JavaConfiguration.JavaCallbackInfo; import com.jogamp.gluegen.cgram.types.Type; +import java.nio.ByteBuffer; + public final class JavaCallbackEmitter { final JavaConfiguration cfg; final MethodBinding binding; @@ -45,6 +47,8 @@ public final class JavaCallbackEmitter { final JavaType cbFuncJavaReturnType; final String jcbNextIDVarName; + final boolean userParamDefined; + final String setFuncCBArgName; final Type setFuncUserParamCType; final JavaType setFuncUserParamJType; @@ -77,13 +81,24 @@ public final class JavaCallbackEmitter { jcbNextIDVarName = "NEXT_"+capIfaceName+"_ID"; setFuncCBArgName = binding.getArgumentName(javaCallback.setFuncCBParamIdx); - setFuncUserParamCType = mb.getCArgumentType(javaCallback.setFuncUserParamIdx); - setFuncUserParamJType = mb.getJavaArgumentType(javaCallback.setFuncUserParamIdx); - setFuncUserParamTypeName = setFuncUserParamJType.getName(); - setFuncUserParamArgName = binding.getArgumentName(javaCallback.setFuncUserParamIdx); - userParamIsKey = info.setFuncKeyIndices.contains(info.setFuncUserParamIdx); - if( !setFuncUserParamJType.isLong() ) { + userParamDefined = javaCallback.setFuncUserParamIdx >= 0; + if( !userParamDefined ) { + setFuncUserParamCType = null; + setFuncUserParamJType = null; + setFuncUserParamTypeName = null; + setFuncUserParamArgName = null; + + userParamIsKey = false; + } else { + setFuncUserParamCType = mb.getCArgumentType(javaCallback.setFuncUserParamIdx); + setFuncUserParamJType = mb.getJavaArgumentType(javaCallback.setFuncUserParamIdx); + setFuncUserParamTypeName = setFuncUserParamJType.getName(); + setFuncUserParamArgName = binding.getArgumentName(javaCallback.setFuncUserParamIdx); + + userParamIsKey = info.setFuncKeyIndices.contains(info.setFuncUserParamIdx); + } + if( null != setFuncUserParamJType && !setFuncUserParamJType.isLong() ) { if( setFuncUserParamJType.isCompoundTypeWrapper() ) { userParamIsCompound = true; userParamIsMappedToID = false; @@ -99,16 +114,20 @@ public final class JavaCallbackEmitter { userParamIDMapInstanceName = null; } - if( userParamIsCompound ) { - userParamClassName = setFuncUserParamTypeName; - } else if( null != javaCallback.userParamClassName ) { - userParamClassName = javaCallback.userParamClassName; + if( userParamDefined ) { + if( userParamIsCompound ) { + userParamClassName = setFuncUserParamTypeName; + } else if( null != javaCallback.userParamClassName ) { + userParamClassName = javaCallback.userParamClassName; + } else { + userParamClassName = "Object"; + } } else { - userParamClassName = "Object"; + userParamClassName = null; } if( null != javaCallback.customKeyClassName ) { - customKeyClass = true;; + customKeyClass = true; KeyClassName = javaCallback.customKeyClassName; useDataMap = true; } else { @@ -135,9 +154,11 @@ public final class JavaCallbackEmitter { emitJavaBriefAPIDoc(unit, "Returns "+info.cbFuncTypeName+" callback ", "mapped to ", "", "for "); unit.emitln(" public "+info.cbFuncTypeName+" get"+capIfaceName+"("+KeyClassName+" key);"); unit.emitln(); - emitJavaBriefAPIDoc(unit, "Returns user-param ", "mapped to ", "", "for "); - unit.emitln(" public "+userParamClassName+" get"+capIfaceName+"UserParam("+KeyClassName+" key);"); - unit.emitln(); + if( userParamDefined ) { + emitJavaBriefAPIDoc(unit, "Returns user-param ", "mapped to ", "", "for "); + unit.emitln(" public "+userParamClassName+" get"+capIfaceName+"UserParam("+KeyClassName+" key);"); + unit.emitln(); + } emitJavaBriefAPIDoc(unit, "Releases all callback data ", "mapped via ", "", "skipping toolkit API. Favor passing `null` callback ref to "); unit.emitln(" public int releaseAll"+capIfaceName+"();"); unit.emitln(); @@ -151,9 +172,11 @@ public final class JavaCallbackEmitter { emitJavaBriefAPIDoc(unit, "Returns "+info.cbFuncTypeName+" callback ", "mapped to ", "", "for "); unit.emitln(" public "+info.cbFuncTypeName+" get"+capIfaceName+"();"); unit.emitln(); - emitJavaBriefAPIDoc(unit, "Returns user-param ", "mapped to ", "", "for "); - unit.emitln(" public "+userParamClassName+" get"+capIfaceName+"UserParam();"); - unit.emitln(); + if( userParamDefined ) { + emitJavaBriefAPIDoc(unit, "Returns user-param ", "mapped to ", "", "for "); + unit.emitln(" public "+userParamClassName+" get"+capIfaceName+"UserParam();"); + unit.emitln(); + } emitJavaBriefAPIDoc(unit, "Releases callback data ", "", "", "skipping toolkit API. Favor passing `null` callback ref to "); unit.emitln(" public void release"+capIfaceName+"();"); unit.emitln(); @@ -189,14 +212,16 @@ public final class JavaCallbackEmitter { unit.emitln(" }"); unit.emitln(); - emitJavaBriefAPIDoc(unit, "Returns user-param ", "mapped to ", "", "for "); - unit.emitln(" public final "+userParamClassName+" get"+capIfaceName+"UserParam("+KeyClassName+" key) {"); - unit.emitln(" synchronized( "+lockInstanceName+" ) {"); - unit.emitln(" final "+DataClassName+" value = "+dataMapInstanceName+".get(key);"); - unit.emitln(" return null != value ? value.param : null;"); - unit.emitln(" }"); - unit.emitln(" }"); - unit.emitln(); + if( userParamDefined ) { + emitJavaBriefAPIDoc(unit, "Returns user-param ", "mapped to ", "", "for "); + unit.emitln(" public final "+userParamClassName+" get"+capIfaceName+"UserParam("+KeyClassName+" key) {"); + unit.emitln(" synchronized( "+lockInstanceName+" ) {"); + unit.emitln(" final "+DataClassName+" value = "+dataMapInstanceName+".get(key);"); + unit.emitln(" return null != value ? value.param : null;"); + unit.emitln(" }"); + unit.emitln(" }"); + unit.emitln(); + } emitJavaBriefAPIDoc(unit, "Releases all callback data ", "mapped via ", "", "skipping toolkit API. Favor passing `null` callback ref to "); unit.emitln(" public final int releaseAll"+capIfaceName+"() {"); unit.emitln(" synchronized( "+lockInstanceName+" ) {"); @@ -242,14 +267,16 @@ public final class JavaCallbackEmitter { unit.emitln(" }"); unit.emitln(); - emitJavaBriefAPIDoc(unit, "Returns user-param ", "mapped to ", "", "for "); - unit.emitln(" public final "+userParamClassName+" get"+capIfaceName+"UserParam() {"); - unit.emitln(" synchronized( "+lockInstanceName+" ) {"); - unit.emitln(" final "+DataClassName+" value = "+dataInstanceName+";"); - unit.emitln(" return null != value ? value.param : null;"); - unit.emitln(" }"); - unit.emitln(" }"); - unit.emitln(); + if( userParamDefined ) { + emitJavaBriefAPIDoc(unit, "Returns user-param ", "mapped to ", "", "for "); + unit.emitln(" public final "+userParamClassName+" get"+capIfaceName+"UserParam() {"); + unit.emitln(" synchronized( "+lockInstanceName+" ) {"); + unit.emitln(" final "+DataClassName+" value = "+dataInstanceName+";"); + unit.emitln(" return null != value ? value.param : null;"); + unit.emitln(" }"); + unit.emitln(" }"); + unit.emitln(); + } emitJavaBriefAPIDoc(unit, "Releases callback data ", "", "", "skipping toolkit API. Favor passing `null` callback ref to "); unit.emitln(" public final void release"+capIfaceName+"() {"); @@ -359,7 +386,9 @@ public final class JavaCallbackEmitter { unit.emitln(" &&"); unit.emit (" "); } - if( jType.isPrimitive() || idx == info.setFuncUserParamIdx ) { + if( jType.isCompoundTypeWrapper() ) { + unit.emit(name+".getDirectBufferAddress() == o2."+name+".getDirectBufferAddress()"); + } else if( jType.isPrimitive() || idx == info.setFuncUserParamIdx ) { unit.emit(name+" == o2."+name); } else { unit.emit(name+".equals( o2."+name+" )"); @@ -392,6 +421,8 @@ public final class JavaCallbackEmitter { } else { unit.emitln(name+";"); } + } else if( jType.isCompoundTypeWrapper() ) { + unit.emitln("HashUtil.getAddrHash32_EqualDist( "+name+".getDirectBufferAddress() );"); } else { if( idx == info.setFuncUserParamIdx ) { unit.emitln("System.identityHashCode( "+name+" );"); @@ -416,23 +447,32 @@ public final class JavaCallbackEmitter { private final void emitJavaDataClass(final CodeUnit unit) { unit.emitln(" private static class "+DataClassName+" {"); - unit.emitln(" // userParamArgCType "+setFuncUserParamCType); - unit.emitln(" // userParamArgJType "+setFuncUserParamJType); - unit.emitln(" final "+info.cbFuncTypeName+" func;"); - if( userParamIsMappedToID ) { - unit.emitln(" final long paramID;"); - } - unit.emitln(" final "+setFuncUserParamTypeName+" param;"); - unit.emit (" "+DataClassName+"(final "+info.cbFuncTypeName+" func, "); - if( userParamIsMappedToID ) { - unit.emit("final long paramID, "); - } - unit.emitln("final "+setFuncUserParamTypeName+" param) {"); + unit.emitln(" final " + info.cbFuncTypeName + " func;"); + if( userParamDefined ) { + unit.emitln(" // userParamArgCType "+setFuncUserParamCType); + unit.emitln(" // userParamArgJType "+setFuncUserParamJType); + unit.emitln(" final "+setFuncUserParamTypeName+" param;"); + if( userParamIsMappedToID ) { + unit.emitln(" final long paramID;"); + } + } else { + unit.emitln(" // No user param defined."); + } + unit.emit (" "+DataClassName+"(final "+info.cbFuncTypeName+" func"); + if( userParamDefined ) { + if( userParamIsMappedToID ) { + unit.emit(", final long paramID"); + } + unit.emit(", final "+setFuncUserParamTypeName+" param"); + } + unit.emitln(") {"); unit.emitln(" this.func = func;"); - if( userParamIsMappedToID ) { - unit.emitln(" this.paramID = paramID;"); + if( userParamDefined ) { + if( userParamIsMappedToID ) { + unit.emitln(" this.paramID = paramID;"); + } + unit.emitln(" this.param = param;"); } - unit.emitln(" this.param = param;"); unit.emitln(" }"); unit.emitln(" }"); } @@ -445,7 +485,7 @@ public final class JavaCallbackEmitter { if( idx == info.cbFuncUserParamIdx ) { buf.append("J"); } else { - buf.append(jType.getDescriptor()); + buf.append(jType.getDescriptor(cfg)); } return true; } else { @@ -453,45 +493,60 @@ public final class JavaCallbackEmitter { } } ); buf.append(")"); - buf.append(cbFuncJavaReturnType.getDescriptor()); + buf.append(cbFuncJavaReturnType.getDescriptor(cfg)); return buf.toString(); } public final int appendJavaAdditionalJNIParameter(final StringBuilder buf) { - buf.append("Class<?> staticCBClazz, String callbackSignature, long nativeUserParam"); + buf.append("Class<?> staticCBClazz, String callbackSignature"); + if( !userParamDefined ) { + return 2; + } + buf.append(", long nativeUserParam"); return 3; } public final int appendJavaAdditionalJNIArguments(final StringBuilder buf) { - buf.append("this.getClass(), \"" + getJavaStaticCallbackSignature()+ "\", nativeUserParam"); + buf.append("this.getClass(), \"" + getJavaStaticCallbackSignature() + "\""); + if( !userParamDefined ) { + return 2; + } + buf.append(", nativeUserParam"); return 3; } public void emitJavaSetFuncPreCall(final CodeUnit unit) { - unit.emitln(" final long nativeUserParam;"); + if( userParamDefined ) { + unit.emitln(" final long nativeUserParam;"); + } unit.emitln(" synchronized( "+lockInstanceName+" ) {"); - if( setFuncUserParamJType.isLong() ) { - unit.emitln(" nativeUserParam = "+setFuncUserParamArgName+";"); - } else { - unit.emitln(" if( null != "+setFuncUserParamArgName+" ) {"); - if( setFuncUserParamJType.isCompoundTypeWrapper() ) { - // userParamIsCompound == true - unit.emitln(" nativeUserParam = "+setFuncUserParamArgName+".getDirectBufferAddress();"); + if( userParamDefined ) { + if( setFuncUserParamJType.isLong() ) { + unit.emitln(" nativeUserParam = "+setFuncUserParamArgName+";"); } else { - // userParamIsMappedToID == true - unit.emitln(" nativeUserParam = "+jcbNextIDVarName+"++;"); - unit.emitln(" if( 0 >= "+jcbNextIDVarName+" ) { "+jcbNextIDVarName+" = 1; }"); + unit.emitln(" if( null != "+setFuncUserParamArgName+" ) {"); + if( setFuncUserParamJType.isCompoundTypeWrapper() ) { + // userParamIsCompound == true + unit.emitln(" nativeUserParam = "+setFuncUserParamArgName+".getDirectBufferAddress();"); + } else { + // userParamIsMappedToID == true + unit.emitln(" nativeUserParam = "+jcbNextIDVarName+"++;"); + unit.emitln(" if( 0 >= "+jcbNextIDVarName+" ) { "+jcbNextIDVarName+" = 1; }"); + } + unit.emitln(" } else {"); + unit.emitln(" nativeUserParam = 0;"); + unit.emitln(" }"); } - unit.emitln(" } else {"); - unit.emitln(" nativeUserParam = 0;"); - unit.emitln(" }"); } unit.emitln(" if( null != "+setFuncCBArgName+" ) {"); unit.emit (" add"+capIfaceName+"("+binding.getJavaCallSelectArguments(new StringBuilder(), info.setFuncKeyIndices, true).toString()+ - "new "+DataClassName+"("+setFuncCBArgName+", "); - if( userParamIsMappedToID ) { - unit.emit("nativeUserParam, "); + "new "+DataClassName+"("+setFuncCBArgName); + if( userParamDefined ) { + if( userParamIsMappedToID ) { + unit.emit(", nativeUserParam"); + } + unit.emit(", "+setFuncUserParamArgName); } - unit.emitln(setFuncUserParamArgName+"));"); + unit.emitln("));"); unit.emitln(" } else { "); unit.emitln(" // release a previously mapped instance "); if( useDataMap ) { @@ -529,17 +584,21 @@ public final class JavaCallbackEmitter { } ); unit.emitln(") {"); final boolean useParamLocal[] = { false }; - if( mapNativePtrToCompound[0] ) { - unit.emitln(" final "+origUserParamJType[0]+" "+info.cbFuncUserParamName+" = "+origUserParamJType[0]+".derefPointer(nativeUserParam);"); - useParamLocal[0] = true; - } else if( userParamIsMappedToID && userParamIsKey ) { - unit.emitln(" final "+userParamClassName+" "+info.cbFuncUserParamName+";"); + if( userParamDefined ) { + if( mapNativePtrToCompound[0] ) { + unit.emitln(" final "+origUserParamJType[0]+" "+info.cbFuncUserParamName+" = "+origUserParamJType[0]+".derefPointer(nativeUserParam);"); + useParamLocal[0] = true; + } else if( userParamIsMappedToID && userParamIsKey ) { + unit.emitln(" final "+userParamClassName+" "+info.cbFuncUserParamName+";"); + } } unit.emitln(" final "+DataClassName+" value;"); unit.emitln(" synchronized( "+lockInstanceName+" ) {"); - if( userParamIsMappedToID && userParamIsKey && !mapNativePtrToCompound[0] ) { - unit.emitln(" "+info.cbFuncUserParamName+" = ("+userParamClassName+") "+userParamIDMapInstanceName+".get(nativeUserParam);"); - useParamLocal[0] = true; + if( userParamDefined ) { + if( userParamIsMappedToID && userParamIsKey && !mapNativePtrToCompound[0] ) { + unit.emitln(" "+info.cbFuncUserParamName+" = ("+userParamClassName+") "+userParamIDMapInstanceName+".get(nativeUserParam);"); + useParamLocal[0] = true; + } } if( useDataMap ) { unit.emitln(" final "+KeyClassName+" key = new "+KeyClassName+"("+info.cbFuncBinding.getJavaCallSelectArguments(new StringBuilder(), info.cbFuncKeyIndices, false).toString()+");"); @@ -584,7 +643,11 @@ public final class JavaCallbackEmitter { // public int appendCAdditionalParameter(final StringBuilder buf) { - buf.append(", jclass staticCBClazz, jstring jcallbackSignature, jlong jnativeUserParam"); + buf.append(", jclass staticCBClazz, jstring jcallbackSignature"); + if( !userParamDefined ) { + return 2; + } + buf.append(", jlong jnativeUserParam"); return 3; } @@ -597,7 +660,9 @@ public final class JavaCallbackEmitter { public void appendCAdditionalJNIDescriptor(final StringBuilder buf) { JavaType.appendJNIDescriptor(buf, Class.class, false); // to account for the additional 'jclass staticCBClazz' parameter JavaType.appendJNIDescriptor(buf, String.class, false); // to account for the additional 'jstring jcallbackSignature' parameter - JavaType.appendJNIDescriptor(buf, long.class, false); // to account for the additional 'long nativeUserParam' parameter + if( userParamDefined ) { + JavaType.appendJNIDescriptor(buf, long.class, false); // to account for the additional 'long nativeUserParam' parameter + } } public void emitCSetFuncPreCall(final CodeUnit unit) { @@ -607,15 +672,22 @@ public final class JavaCallbackEmitter { final String staticBindingClazzVarName = "staticCBClazz"+jcbNativeBasename; final String staticBindingMethodIDVarName = "staticCBMethod"+jcbNativeBasename; final String cbFuncArgName = binding.getArgumentName(info.setFuncCBParamIdx); - final String userParamTypeName = info.cbFuncUserParamType.getCName(); - final String userParamArgName = binding.getArgumentName(info.setFuncUserParamIdx); final String nativeCBFuncVarName = cbFuncArgName+"_native"; - final String nativeUserParamVarName = userParamArgName+"_native"; + final String userParamTypeName, nativeUserParamVarName; + if( userParamDefined ) { + userParamTypeName = info.cbFuncUserParamType.getCName(); + nativeUserParamVarName = binding.getArgumentName(info.setFuncUserParamIdx)+"_native"; + } else { + userParamTypeName = null; + nativeUserParamVarName = null; + } unit.emitln(); unit.emitln(" // JavaCallback handling"); unit.emitln(" if( NULL == staticCBClazz ) { (*env)->FatalError(env, \"NULL staticCBClazz passed to '"+jcbFriendlyBasename+"'\"); }"); unit.emitln(" "+info.cbFuncTypeName+" "+nativeCBFuncVarName+";"); - unit.emitln(" "+userParamTypeName+"* "+nativeUserParamVarName+";"); + if( userParamDefined ) { + unit.emitln(" "+userParamTypeName+"* "+nativeUserParamVarName+";"); + } unit.emitln(" if( NULL != "+cbFuncArgName+" ) {"); unit.emitln(" if( NULL == "+staticBindingClazzVarName+" || NULL == "+staticBindingMethodIDVarName+" ) {"); unit.emitln(" jclass staticCBClazz2 = (*env)->NewGlobalRef(env, staticCBClazz);"); @@ -632,30 +704,79 @@ public final class JavaCallbackEmitter { unit.emitln(" "+staticBindingClazzVarName+" = staticCBClazz2;"); unit.emitln(" "+staticBindingMethodIDVarName+" = cbMethodID;"); unit.emitln(" }"); + final JavaType bbjt = JavaType.createForClass(ByteBuffer.class); + for (int i = 0; i < info.cbFuncBinding.getNumArguments(); i++) { + final String baseArgName = CodeGenUtils.capitalizeString( info.cbFuncBinding.getArgumentName(i) ); + final JavaType currentJavaType = info.cbFuncBinding.getJavaArgumentType(i); + if( i != info.cbFuncUserParamIdx && currentJavaType.isCompoundTypeWrapper() ) { + final String staticBindingClazzArgVarName = "staticCBArg" + baseArgName + "Clazz"+jcbNativeBasename; + final String staticBindingMethodIDArgVarName = "staticCBArg" + baseArgName + "Method"+jcbNativeBasename; + unit.emitln(" if( NULL == "+staticBindingClazzArgVarName+" || NULL == "+staticBindingMethodIDArgVarName+" ) {"); + final String argClassDescriptor = currentJavaType.getDescriptor(cfg); + final String argClassRef = currentJavaType.getName(cfg); + final String argClassLocation = argClassRef.replace(".", "/"); + unit.emitln(" jclass "+staticBindingClazzArgVarName+"2 = (*env)->FindClass(env, \""+argClassLocation+"\");"); + unit.emitln(" if( NULL == "+staticBindingClazzArgVarName+"2 ) { (*env)->FatalError(env, \"Failed FindClass("+argClassLocation+") in '"+jcbFriendlyBasename+"'\"); }"); + unit.emitln(" jmethodID "+staticBindingMethodIDArgVarName+"2 = (*env)->GetStaticMethodID(env, "+staticBindingClazzArgVarName+"2, \"create\", \"("+bbjt.getDescriptor()+")"+argClassDescriptor+"\");"); + unit.emitln(" if( NULL == "+staticBindingMethodIDArgVarName+"2 ) {"); + unit.emitln(" char cmsg[400];"); + unit.emitln(" snprintf(cmsg, 400, \"Failed GetStaticMethodID of '"+argClassRef+".create("+bbjt.getDescriptor()+")"+argClassDescriptor+" in "+jcbFriendlyBasename+"'\");"); + unit.emitln(" (*env)->FatalError(env, cmsg);"); + unit.emitln(" }"); + unit.emitln(" "+staticBindingClazzArgVarName+" = "+staticBindingClazzArgVarName+"2;"); + unit.emitln(" "+staticBindingMethodIDArgVarName+" = "+staticBindingMethodIDArgVarName+"2;"); + unit.emitln(" }"); + } + } unit.emitln(" "+nativeCBFuncVarName+" = func"+jcbNativeBasename+";"); - unit.emitln(" "+nativeUserParamVarName+" = ("+userParamTypeName+"*) jnativeUserParam;"); + if( userParamDefined ) { + unit.emitln(" "+nativeUserParamVarName+" = ("+userParamTypeName+"*) jnativeUserParam;"); + } unit.emitln(" } else {"); unit.emitln(" "+nativeCBFuncVarName+" = NULL;"); - unit.emitln(" "+nativeUserParamVarName+" = NULL;"); + if( userParamDefined ) { + unit.emitln(" "+nativeUserParamVarName+" = NULL;"); + } unit.emitln(" }"); unit.emitln(); } - public void emitCAdditionalCode(final CodeUnit unit, final CMethodBindingEmitter jcbCMethodEmitter) { + /** + * Emit addition C code, i.e. global varialbles and static callback invocation + * @param unit output C code unit + * @param jcbFuncCMethodEmitter only used to access {@link CMethodBindingEmitter#emitBodyMapCToJNIType(int, boolean)}, a non-ideal hack! (FIXME) + */ + public void emitCAdditionalCode(final CodeUnit unit, final CMethodBindingEmitter jcbFuncCMethodEmitter) { final String jcbNativeBasename = CodeGenUtils.capitalizeString( info.setFuncName ); final String jcbFriendlyBasename = info.setFuncName+"("+info.cbSimpleClazzName+")"; final String staticBindingClazzVarName = "staticCBClazz"+jcbNativeBasename; final String staticBindingMethodIDVarName = "staticCBMethod"+jcbNativeBasename; final String staticCallbackName = "func"+jcbNativeBasename; - // final Type userParamType = javaCallback.cbFuncBinding.getCArgumentType(javaCallback.cbFuncUserParamIdx); - final String userParamTypeName = info.cbFuncUserParamType.getCName(); - final String userParamArgName = info.cbFuncBinding.getArgumentName(info.cbFuncUserParamIdx); + final String userParamTypeName, userParamArgName; + if( userParamDefined ) { + // final Type userParamType = javaCallback.cbFuncBinding.getCArgumentType(javaCallback.cbFuncUserParamIdx); + userParamTypeName = info.cbFuncUserParamType.getCName(); + userParamArgName = info.cbFuncBinding.getArgumentName(info.cbFuncUserParamIdx); + } else { + userParamTypeName = null; + userParamArgName = null; + } final Type cReturnType = info.cbFuncBinding.getCReturnType(); final JavaType jretType = info.cbFuncBinding.getJavaReturnType(); unit.emitln(); unit.emitln("static jclass "+staticBindingClazzVarName+" = NULL;"); unit.emitln("static jmethodID "+staticBindingMethodIDVarName+" = NULL;"); + for (int i = 0; i < info.cbFuncBinding.getNumArguments(); i++) { + final String baseArgName = CodeGenUtils.capitalizeString( info.cbFuncBinding.getArgumentName(i) ); + final JavaType currentJavaType = info.cbFuncBinding.getJavaArgumentType(i); + if( i != info.cbFuncUserParamIdx && currentJavaType.isCompoundTypeWrapper() ) { + final String staticBindingClazzArgVarName = "staticCBArg" + baseArgName + "Clazz"+jcbNativeBasename; + final String staticBindingMethodIDArgVarName = "staticCBArg" + baseArgName + "Method"+jcbNativeBasename; + unit.emitln("static jclass "+staticBindingClazzArgVarName+" = NULL;"); + unit.emitln("static jmethodID "+staticBindingMethodIDArgVarName+" = NULL;"); + } + } unit.emitln(); // javaCallback.cbFuncCEmitter.emitSignature(); unit.emit("static "+cReturnType.getCName()+" "+staticCallbackName+"("); @@ -668,6 +789,16 @@ public final class JavaCallbackEmitter { unit.emitln(" JNIEnv* env = JVMUtil_GetJNIEnv(1 /* daemon */, &detachJVM);"); unit.emitln(" jclass cbClazz = "+staticBindingClazzVarName+";"); unit.emitln(" jmethodID cbMethod = "+staticBindingMethodIDVarName+";"); + for (int i = 0; i < info.cbFuncBinding.getNumArguments(); i++) { + final String baseArgName = CodeGenUtils.capitalizeString( info.cbFuncBinding.getArgumentName(i) ); + final JavaType currentJavaType = info.cbFuncBinding.getJavaArgumentType(i); + if( i != info.cbFuncUserParamIdx && currentJavaType.isCompoundTypeWrapper() ) { + final String staticBindingClazzArgVarName = "staticCBArg" + baseArgName + "Clazz"+jcbNativeBasename; + final String staticBindingMethodIDArgVarName = "staticCBArg" + baseArgName + "Method"+jcbNativeBasename; + unit.emitln(" jclass cbClazzArg" + baseArgName+" = "+staticBindingClazzArgVarName+";"); + unit.emitln(" jmethodID cbMethodArg" + baseArgName+" = "+staticBindingMethodIDArgVarName+";"); + } + } unit.emitln(" if( NULL == env || NULL == cbClazz || NULL == cbMethod ) {"); if( !cReturnType.isVoid() ) { unit.emitln(" return 0;"); @@ -678,10 +809,12 @@ public final class JavaCallbackEmitter { // javaCallback.cbFuncCEmitter.emitBodyVariableDeclarations(); // javaCallback.cbFuncCEmitter.emitBodyUserVariableDeclarations(); // javaCallback.cbFuncCEmitter.emitBodyVariablePreCallSetup(); - emitJavaCallbackBodyCToJavaPreCall(jcbCMethodEmitter); + emitJavaCallbackBodyCToJavaPreCall(jcbFuncCMethodEmitter); // javaCallback.cbFuncCEmitter.emitBodyCallCFunction(); - unit.emitln(" "+userParamTypeName+"* "+userParamArgName+"_jni = ("+userParamTypeName+"*) "+userParamArgName+";"); + if( userParamDefined ) { + unit.emitln(" "+userParamTypeName+"* "+userParamArgName+"_jni = ("+userParamTypeName+"*) "+userParamArgName+";"); + } unit.emitln(" // C Params: "+info.cbFuncBinding.getCParameterList(new StringBuilder(), false, null).toString()); unit.emitln(" // J Params: "+info.cbFuncBinding.getJavaParameterList(new StringBuilder()).toString()); @@ -699,7 +832,7 @@ public final class JavaCallbackEmitter { } unit.emit("(*env)->CallStatic" + CodeGenUtils.capitalizeString( jretType.getName() ) +"Method(env, cbClazz, cbMethod, "); // javaCallback.cbFuncCEmitter.emitBodyPassCArguments(); - emitJavaCallbackBodyPassJavaArguments(unit, jcbCMethodEmitter.binding, null); //"NULL"); + emitJavaCallbackBodyPassJavaArguments(unit); unit.emitln(");"); unit.emitln(" if( (*env)->ExceptionCheck(env) ) {"); unit.emitln(" fprintf(stderr, \"Info: Callback '"+jcbFriendlyBasename+"': Exception in Java Callback caught:\\n\");"); @@ -717,7 +850,7 @@ public final class JavaCallbackEmitter { unit.emitln(); } - /* pp */ int emitJavaCallbackBodyCToJavaPreCall(final CMethodBindingEmitter ce) { + private int emitJavaCallbackBodyCToJavaPreCall(final CMethodBindingEmitter ce) { int count = 0; for (int i = 0; i < ce.binding.getNumArguments(); i++) { if( i == info.cbFuncUserParamIdx ) { @@ -730,18 +863,21 @@ public final class JavaCallbackEmitter { return count; } - /* pp */ int emitJavaCallbackBodyPassJavaArguments(final CodeUnit unit, final MethodBinding binding, final String userParamVarName) { + private int emitJavaCallbackBodyPassJavaArguments(final CodeUnit unit) { int count = 0; boolean needsComma = false; - for (int i = 0; i < binding.getNumArguments(); i++) { + for (int i = 0; i < info.cbFuncBinding.getNumArguments(); i++) { if (needsComma) { unit.emit(", "); needsComma = false; } - if( i == info.cbFuncUserParamIdx && null != userParamVarName ) { - unit.emit( userParamVarName ); + final String baseArgName = info.cbFuncBinding.getArgumentName(i); + final JavaType currentJavaType = info.cbFuncBinding.getJavaArgumentType(i); + if( i != info.cbFuncUserParamIdx && currentJavaType.isCompoundTypeWrapper() ) { + final String cBaseArgName = CodeGenUtils.capitalizeString( baseArgName ); + unit.emit( "(*env)->CallStaticObjectMethod(env, cbClazzArg" + cBaseArgName + ", cbMethodArg" + cBaseArgName + ", " + baseArgName + "_jni)" ); } else { - unit.emit( binding.getArgumentName(i) + "_jni" ); + unit.emit( baseArgName + "_jni" ); } needsComma = true; ++count; diff --git a/src/java/com/jogamp/gluegen/JavaConfiguration.java b/src/java/com/jogamp/gluegen/JavaConfiguration.java index f5242b8..95e1480 100644 --- a/src/java/com/jogamp/gluegen/JavaConfiguration.java +++ b/src/java/com/jogamp/gluegen/JavaConfiguration.java @@ -2423,6 +2423,8 @@ public class JavaConfiguration { final String cbFuncUserParamName; final Type cbFuncUserParamType; + final boolean cbUserParamIsDefined; + final String setFuncName; final List<Integer> setFuncKeyIndices; final int setFuncUserParamIdx; @@ -2442,7 +2444,8 @@ public class JavaConfiguration { this.staticCBMethodSignature = staticCBMethodSignature; this.cbFuncType = cbFuncType; this.cbFuncBinding = cbFuncBinding; - { + this.cbUserParamIsDefined = setFuncUserParamIdx >= 0; + if( cbUserParamIsDefined ) { int paramIdx = -2; Type paramType = null; String paramName = null; @@ -2456,10 +2459,14 @@ public class JavaConfiguration { } } this.cbFuncUserParamIdx = paramIdx; - this.cbFuncKeyIndices = cbFuncKeyIndices; this.cbFuncUserParamName = paramName; this.cbFuncUserParamType = paramType; + } else { + this.cbFuncUserParamIdx = -1; + this.cbFuncUserParamName = null; + this.cbFuncUserParamType = null; } + this.cbFuncKeyIndices = cbFuncKeyIndices; this.setFuncName = setFuncName; this.setFuncKeyIndices = setFuncKeyIndices; this.setFuncUserParamIdx = setFuncUserParamIdx; @@ -2499,9 +2506,9 @@ public class JavaConfiguration { @Override public String toString() { - return String.format("JavaCallbackInfo[cbFunc[%s%s, userParam[idx %d, '%s', %s, keys %s], set[%s(ok %b, cbIdx %d, upIdx %d, keys %s], Class[UserParam '%s', Key '%s'], %s]", + return String.format("JavaCallbackInfo[cbFunc[%s%s, userParam[defined %b, idx %d, '%s', %s, keys %s], set[%s(ok %b, cbIdx %d, upIdx %d, keys %s], Class[UserParam '%s', Key '%s'], %s]", cbFuncTypeName, staticCBMethodSignature, - cbFuncUserParamIdx, cbFuncUserParamName, cbFuncUserParamType.getSignature(null).toString(), cbFuncKeyIndices.toString(), + cbUserParamIsDefined, cbFuncUserParamIdx, cbFuncUserParamName, cbUserParamIsDefined ? cbFuncUserParamType.getSignature(null).toString() : null, cbFuncKeyIndices.toString(), setFuncName, setFuncProcessed, setFuncCBParamIdx, setFuncUserParamIdx, setFuncKeyIndices.toString(), userParamClassName, customKeyClassName, cbFuncType.toString(cbFuncTypeName, false, true)); @@ -2511,4 +2518,10 @@ public class JavaConfiguration { /* pp */ final Map<String, JavaCallbackInfo> setFuncToJavaCallbackMap = new HashMap<String, JavaCallbackInfo>(); final Set<String> emittedJavaCallbackUserParamClasses = new HashSet<String>(); + /** Returns true if a method binding requires specific java callback code */ + final boolean requiresJavaCallbackCode(final String bindingName) { + final JavaCallbackInfo jcbi = setFuncToJavaCallbackMap.get(bindingName); + return null != jcbi && !jcbi.cbUserParamIsDefined; + } + } diff --git a/src/java/com/jogamp/gluegen/JavaEmitter.java b/src/java/com/jogamp/gluegen/JavaEmitter.java index 8310cda..fb310a9 100644 --- a/src/java/com/jogamp/gluegen/JavaEmitter.java +++ b/src/java/com/jogamp/gluegen/JavaEmitter.java @@ -465,9 +465,11 @@ public class JavaEmitter implements GlueEmitter { final boolean isUnimplemented = cfg.isUnimplemented(cSymbol); final List<String> prologue = cfg.javaPrologueForMethod(binding, false, false); final List<String> epilogue = cfg.javaEpilogueForMethod(binding, false, false); + final boolean needsJavaCallbackCode = cfg.requiresJavaCallbackCode( binding.getName() ); final boolean needsBody = isUnimplemented || binding.needsNIOWrappingOrUnwrapping() || binding.signatureUsesJavaPrimitiveArrays() || + needsJavaCallbackCode || null != prologue || null != epilogue; @@ -531,6 +533,7 @@ public class JavaEmitter implements GlueEmitter { final boolean hasPrologueOrEpilogue = cfg.javaPrologueForMethod(binding, false, false) != null || cfg.javaEpilogueForMethod(binding, false, false) != null ; + final boolean needsJavaCallbackCode = cfg.requiresJavaCallbackCode( binding.getName() ); if ( !cfg.isUnimplemented( cSymbol ) ) { // If we already generated a public native entry point for this @@ -541,7 +544,7 @@ public class JavaEmitter implements GlueEmitter { // the private native entry point for it along with the version // taking only NIO buffers if ( !binding.signatureUsesJavaPrimitiveArrays() && - ( binding.needsNIOWrappingOrUnwrapping() || hasPrologueOrEpilogue ) + ( binding.needsNIOWrappingOrUnwrapping() || hasPrologueOrEpilogue || needsJavaCallbackCode ) ) { final CodeUnit unit = (cfg.allStatic() ? javaUnit() : javaImplUnit()); @@ -588,7 +591,7 @@ public class JavaEmitter implements GlueEmitter { cfg.implClassName(), true, // NOTE: we always disambiguate with a suffix now, so this is optional cfg.allStatic(), - (binding.needsNIOWrappingOrUnwrapping() || hasPrologueOrEpilogue), + (binding.needsNIOWrappingOrUnwrapping() || hasPrologueOrEpilogue || needsJavaCallbackCode), !cfg.useNIODirectOnly(binding.getName()), machDescJava, getConfig()); prepCEmitter(binding.getName(), binding.getJavaReturnType(), cEmitter); @@ -1140,6 +1143,20 @@ public class JavaEmitter implements GlueEmitter { field + "\" in type \"" + structCTypeName + "\")", fieldType.getASTLocusTag()); } + if( !immutableField && !fieldType.isConst() ) { + // Setter + generateSetterSignature(javaUnit, MethodAccess.PUBLIC, false, false, fieldName, fieldType, Ownership.Parent, containingJTypeName, CodeGenUtils.capitalizeString(fieldName), null, fieldType.getName(), null, false, false, null, null, null); + javaUnit.emitln(" {"); + javaUnit.emitln(" final ByteBuffer bb = src.getBuffer();"); + javaUnit.emitln(" final int size = "+fieldName+"_size[mdIdx];"); + javaUnit.emitln(" final byte[] content = new byte[size];"); + javaUnit.emitln(" bb.get(content, 0, size);"); + javaUnit.emitln(" accessor.setBytesAt("+fieldName+"_offset[mdIdx], content);"); + javaUnit.emitln(" return this;"); + javaUnit.emitln(" }"); + javaUnit.emitln(); + } + // Getter generateGetterSignature(javaUnit, false, false, fieldName, fieldType, Ownership.Parent, fieldType.getName(), CodeGenUtils.capitalizeString(fieldName), null, false, false, null, null); javaUnit.emitln(" {"); javaUnit.emitln(" return " + fieldType.getName() + ".create( accessor.slice( " + @@ -1528,11 +1545,11 @@ public class JavaEmitter implements GlueEmitter { methodSignature.append("("); for(int i=0; i<mb.getNumArguments(); ++i) { final JavaType t = mb.getJavaArgumentType(i); - methodSignature.append(t.getDescriptor()); + methodSignature.append(t.getDescriptor(cfg)); } methodSignature.append(")"); final JavaType rt = mb.getJavaReturnType(); - methodSignature.append(rt.getDescriptor()); + methodSignature.append(rt.getDescriptor(cfg)); } // JavaTypes representing C pointers in the initial @@ -3131,8 +3148,7 @@ public class JavaEmitter implements GlueEmitter { final Type cArgType = sym.getArgumentType(i); final String cArgName = sym.getArgumentName(i); JavaType mappedType = typeToJavaType(cArgType, curMachDesc); - // System.out.println("C arg type -> \"" + cArgType + "\"" ); - // System.out.println(" Java -> \"" + mappedType + "\"" ); + int mapMode = 0; if( null != jcbi && jcbi.cbFuncTypeName.equals( cArgType.getName() ) && ( !jcbi.setFuncProcessed || i == jcbi.setFuncCBParamIdx ) ) @@ -3140,47 +3156,58 @@ public class JavaEmitter implements GlueEmitter { // Replace JavaCallback type with generated interface name jcbiSetFuncCBParamIdx=i; mappedType = JavaType.createForNamedClass( jcbi.cbFQClazzName ); + mapMode = 10; } else if( null != jcbi && i == jcbi.setFuncUserParamIdx && cArgType.isPointer() ) { // Replace userParam argument '<userParamType>*' if 'void*' with Object if( cArgType.getTargetType().isVoid() ) { if( jcbi.cbFuncUserParamType.isCompound() ) { mappedType = JavaType.createForClass(long.class); + mapMode = 20; } else if( null != jcbi.userParamClassName ) { mappedType = JavaType.createForNamedClass( jcbi.userParamClassName ); + mapMode = 21; } else { mappedType = JavaType.forObjectClass(); + mapMode = 22; } + } else { + // fallthrough intended } - } else if ( stringArgIndices != null && stringArgIndices.contains(i) ) { + } + if ( 0 == mapMode && stringArgIndices != null && stringArgIndices.contains(i) ) { // Take into account any ArgumentIsString configuration directives that apply // System.out.println("Forcing conversion of " + binding.getName() + " arg #" + i + " from byte[] to String "); - if (mappedType.isCVoidPointerType() || - mappedType.isCCharPointerType() || - mappedType.isCShortPointerType() || - mappedType.isNIOPointerBuffer() || - (mappedType.isArray() && - (mappedType.getJavaClass() == ArrayTypes.byteBufferArrayClass) || - (mappedType.getJavaClass() == ArrayTypes.shortBufferArrayClass))) { + if ( mappedType.isCVoidPointerType() || + mappedType.isCCharPointerType() || + mappedType.isCShortPointerType() || + mappedType.isNIOPointerBuffer() || + ( mappedType.isArray() && + ( mappedType.getJavaClass() == ArrayTypes.byteBufferArrayClass ) || + ( mappedType.getJavaClass() == ArrayTypes.shortBufferArrayClass ) ) ) + { // convert mapped type from: // void*, byte[], and short[] to String // ByteBuffer[] and ShortBuffer[] to String[] final boolean pascalString = cfg.pascalStringLengthIndex(sym, i) >= 0; if (mappedType.isArray() || mappedType.isNIOPointerBuffer()) { mappedType = javaStringType(ArrayTypes.stringArrayClass, pascalString); + mapMode = 30; } else { mappedType = javaStringType(String.class, pascalString); + mapMode = 31; } - } - else { - throw new GlueGenException( - "Cannot apply ArgumentIsString configuration directive to " + - "argument " + i + " of \"" + sym + "\": argument type is not " + - "a \"void*\", \"char *\", \"short *\", \"char**\", or \"short**\" equivalent", - sym.getASTLocusTag()); + } else { + mapMode = 99; + throw new GlueGenException( + "Cannot apply ArgumentIsString configuration directive to " + + "argument " + i + " of \"" + sym + "\": argument type is not " + + "a \"void*\", \"char *\", \"short *\", \"char**\", or \"short**\" equivalent", + sym.getASTLocusTag()); } } javaArgumentTypes.add(mappedType); - //System.out.println("During binding of [" + sym + "], added mapping from C type: " + cArgType + " to Java type: " + mappedType); + LOG.log(INFO, "BindFunc: {0}: added mapping ({1}) for {2} from C type: {3} to Java type: {4}", + sym.getName(), mapMode, cArgName, cArgType, mappedType); } if( null != jcbi ) { jcbi.setFuncProcessed(sym.getType(), jcbiSetFuncCBParamIdx); diff --git a/src/java/com/jogamp/gluegen/JavaType.java b/src/java/com/jogamp/gluegen/JavaType.java index 6fb9a17..d58eca5 100644 --- a/src/java/com/jogamp/gluegen/JavaType.java +++ b/src/java/com/jogamp/gluegen/JavaType.java @@ -282,6 +282,10 @@ public class JavaType { * Returns the Java type name corresponding to this type. */ public String getName() { + return getName(null); + } + + public String getName(final JavaConfiguration cfg) { if (clazz != null) { if (clazz.isArray()) { return arrayName(clazz); @@ -289,29 +293,29 @@ public class JavaType { return clazz.getName(); } if( clazzName != null ) { - return clazzName; + return (null != cfg ? (cfg.packageForStruct(clazzName) + ".") : "") + clazzName; } if (elementType != null) { return elementType.getName(); } - return structName; + return (null != cfg ? (cfg.packageForStruct(clazzName) + ".") : "") + structName; } /** * Returns the descriptor (internal type signature) corresponding to this type. */ public String getDescriptor() { - // FIXME: this is not completely accurate at this point (for - // example, it knows nothing about the packages for compound - // types) + return getDescriptor(null); + } + public String getDescriptor(final JavaConfiguration cfg) { if (clazz != null) { return descriptor(clazz); } if( null != clazzName ) { - return descriptor(clazzName); + return descriptor((null != cfg ? (cfg.packageForStruct(clazzName) + ".") : "") + clazzName); } if( null != structName ) { - return descriptor(structName); + return descriptor((null != cfg ? (cfg.packageForStruct(structName) + ".") : "") + structName); } if (elementType != null) { if(elementType.getName()==null) { |