diff options
Diffstat (limited to 'src/java')
9 files changed, 678 insertions, 640 deletions
diff --git a/src/java/com/jogamp/gluegen/CMethodBindingEmitter.java b/src/java/com/jogamp/gluegen/CMethodBindingEmitter.java index 7c88c37..caeede8 100644 --- a/src/java/com/jogamp/gluegen/CMethodBindingEmitter.java +++ b/src/java/com/jogamp/gluegen/CMethodBindingEmitter.java @@ -1,4 +1,5 @@ /* + * Copyright (c) 2010-2023 JogAmp Community. All rights reserved. * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved. * * Redistribution and use in source and binary forms, with or without @@ -39,15 +40,18 @@ package com.jogamp.gluegen; -import java.util.*; -import java.io.*; +import java.io.PrintWriter; import java.text.MessageFormat; +import java.util.List; import com.jogamp.common.os.MachineDataInfo; import com.jogamp.gluegen.Logging.LoggerIf; -import com.jogamp.gluegen.cgram.types.*; +import com.jogamp.gluegen.cgram.types.ArrayType; +import com.jogamp.gluegen.cgram.types.FunctionSymbol; +import com.jogamp.gluegen.cgram.types.PointerType; +import com.jogamp.gluegen.cgram.types.Type; -/** Emits the C-side component of the Java<->C JNI binding. */ +/** Emits the C-side component of the Java<->C JNI binding to its {@link CodeUnit}, see {@link FunctionEmitter}. */ public class CMethodBindingEmitter extends FunctionEmitter { protected static final CommentEmitter defaultCommentEmitter = new DefaultCommentEmitter(); @@ -58,8 +62,6 @@ public class CMethodBindingEmitter extends FunctionEmitter { protected final LoggerIf LOG; - protected MethodBinding binding; - /** Name of the package in which the corresponding Java method resides.*/ private final String packageName; @@ -117,7 +119,7 @@ public class CMethodBindingEmitter extends FunctionEmitter { * being bound. */ public CMethodBindingEmitter(final MethodBinding binding, - final PrintWriter output, + final CodeUnit unit, final String javaPackageName, final String javaClassName, final boolean isOverloadedBinding, @@ -127,14 +129,13 @@ public class CMethodBindingEmitter extends FunctionEmitter { final MachineDataInfo machDesc, final JavaConfiguration configuration) { - super(output, false, configuration); + super(binding, unit, false, configuration); LOG = Logging.getLogger(CMethodBindingEmitter.class.getPackage().getName(), CMethodBindingEmitter.class.getSimpleName()); assert(binding != null); assert(javaClassName != null); assert(javaPackageName != null); - this.binding = binding; this.packageName = javaPackageName; this.className = javaClassName; this.isOverloadedBinding = isOverloadedBinding; @@ -147,8 +148,6 @@ public class CMethodBindingEmitter extends FunctionEmitter { setCommentEmitter(defaultCommentEmitter); } - public final MethodBinding getBinding() { return binding; } - @Override public String getInterfaceName() { return binding.getInterfaceName(); @@ -308,21 +307,21 @@ public class CMethodBindingEmitter extends FunctionEmitter { @Override - protected void emitReturnType(final PrintWriter writer) { - writer.print("JNIEXPORT "); - writer.print(binding.getJavaReturnType().jniTypeName()); - writer.print(" JNICALL"); + protected void emitReturnType() { + unit.emit("JNIEXPORT "); + unit.emit(binding.getJavaReturnType().jniTypeName()); + unit.emit(" JNICALL"); } @Override - protected void emitName(final PrintWriter writer) { - writer.println(); // start name on new line - writer.print(JavaEmitter.getJNIMethodNamePrefix(getJavaPackageName(), getJavaClassName())); - writer.print("_"); + protected void emitName() { + unit.emitln(); // start name on new line + unit.emit(JavaEmitter.getJNIMethodNamePrefix(getJavaPackageName(), getJavaClassName())); + unit.emit("_"); if (isOverloadedBinding) { - writer.print(jniMangle(binding)); + unit.emit(jniMangle(binding)); } else { - writer.print(JavaEmitter.jniMangle(getImplName())); + unit.emit(JavaEmitter.jniMangle(getImplName())); } } @@ -338,20 +337,24 @@ public class CMethodBindingEmitter extends FunctionEmitter { } @Override - protected int emitArguments(final PrintWriter writer) { - writer.print("JNIEnv *env, "); + protected int emitArguments() { + unit.emit("JNIEnv *env, "); int numEmitted = 1; // initially just the JNIEnv if (isJavaMethodStatic && !binding.hasContainingType()) { - writer.print("jclass"); + unit.emit("jclass"); } else { - writer.print("jobject"); + unit.emit("jobject"); } - writer.print(" _unused"); + unit.emit(" _unused"); ++numEmitted; + if( binding.isReturnCompoundByValue() ) { + unit.emit(", jclass _clazzBuffers"); + ++numEmitted; + } if (binding.hasContainingType()) { // "this" argument always comes down in argument 0 as direct buffer - writer.print(", jobject " + JavaMethodBindingEmitter.javaThisArgumentName()); + unit.emit(", jobject " + JavaMethodBindingEmitter.javaThisArgumentName()); } for (int i = 0; i < binding.getNumArguments(); i++) { final JavaType javaArgType = binding.getJavaArgumentType(i); @@ -365,20 +368,20 @@ public class CMethodBindingEmitter extends FunctionEmitter { if (javaArgType.isJNIEnv() || binding.isArgumentThisPointer(i)) { continue; } - writer.print(", "); - writer.print(javaArgType.jniTypeName()); - writer.print(" "); - writer.print(binding.getArgumentName(i)); + unit.emit(", "); + unit.emit(javaArgType.jniTypeName()); + unit.emit(" "); + unit.emit(binding.getArgumentName(i)); ++numEmitted; if (javaArgType.isPrimitiveArray() || javaArgType.isNIOBuffer()) { - writer.print(", jint " + byteOffsetArgName(i)); + unit.emit(", jint " + byteOffsetArgName(i)); if(forIndirectBufferAndArrayImplementation) { - writer.print(", jboolean " + isNIOArgName(i)); + unit.emit(", jboolean " + isNIOArgName(i)); } } else if (javaArgType.isNIOBufferArray()) { - writer.print(", jintArray " + + unit.emit(", jintArray " + byteOffsetArrayArgName(i)); } } @@ -387,25 +390,24 @@ public class CMethodBindingEmitter extends FunctionEmitter { @Override - protected void emitBody(final PrintWriter writer) { - writer.println(" {"); -// writer.println("printf(\" - - - - "+ getName() + getImplSuffix() +" - - - -\\n\");"); - emitBodyVariableDeclarations(writer); - emitBodyUserVariableDeclarations(writer); - emitBodyVariablePreCallSetup(writer); - emitBodyCallCFunction(writer); - emitBodyUserVariableAssignments(writer); - emitBodyVariablePostCallCleanup(writer); - emitBodyReturnResult(writer); - writer.println("}"); - writer.println(); + protected void emitBody() { + unit.emitln(" {"); +// unit().emitln("printf(\" - - - - "+ getName() + getImplSuffix() +" - - - -\\n\");"); + emitBodyVariableDeclarations(); + emitBodyUserVariableDeclarations(); + emitBodyVariablePreCallSetup(); + emitBodyCallCFunction(); + emitBodyUserVariableAssignments(); + emitBodyVariablePostCallCleanup(); + emitBodyReturnResult(); + unit.emitln("}"); + unit.emitln(); } - protected void emitBodyVariableDeclarations(final PrintWriter writer) { + protected void emitBodyVariableDeclarations() { // Emit declarations for all pointer and String conversion variables if (binding.hasContainingType()) { - emitPointerDeclaration(writer, - binding.getContainingType(), + emitPointerDeclaration(binding.getContainingType(), binding.getContainingCType(), CMethodBindingEmitter.cThisArgumentName(), null); @@ -423,20 +425,19 @@ public class CMethodBindingEmitter extends FunctionEmitter { final String convName = pointerConversionArgumentName(javaArgName); // handle array/buffer argument types final boolean needsDataCopy = - emitPointerDeclaration(writer, - type, + emitPointerDeclaration(type, binding.getCArgumentType(i), convName, javaArgName); if (needsDataCopy && !emittedDataCopyTemps) { // emit loop counter and array length variables used during data // copy - writer.println(" jobject _tmpObj;"); - writer.println(" int _copyIndex;"); - writer.println(" jsize _tmpArrayLen;"); + unit.emitln(" jobject _tmpObj;"); + unit.emitln(" int _copyIndex;"); + unit.emitln(" jsize _tmpArrayLen;"); // Pointer to the data in the Buffer, taking the offset into account if(type.isNIOBufferArray()) { - writer.println(" int * _offsetHandle = NULL;"); + unit.emitln(" int * _offsetHandle = NULL;"); } emittedDataCopyTemps = true; @@ -444,13 +445,13 @@ public class CMethodBindingEmitter extends FunctionEmitter { } else if (type.isString()) { final Type cType = binding.getCArgumentType(i); if (isUTF8Type(cType)) { - writer.print(" const char* "); + unit.emit(" const char* "); } else { - writer.print(" jchar* "); + unit.emit(" jchar* "); } - writer.print(STRING_CHARS_PREFIX); - writer.print(binding.getArgumentName(i)); - writer.println(" = NULL;"); + unit.emit(STRING_CHARS_PREFIX); + unit.emit(binding.getArgumentName(i)); + unit.emitln(" = NULL;"); } } @@ -460,27 +461,27 @@ public class CMethodBindingEmitter extends FunctionEmitter { final JavaType javaReturnType = binding.getJavaReturnType(); if (!cReturnType.isVoid()) { - writer.print(" "); + unit.emit(" "); // Note we respect const/volatile in the function return type. // However, we cannot have it 'const' for our local variable. // See cast in emitBodyCallCFunction(..)! - writer.print(binding.getCSymbol().getReturnType().getCName(false)); - writer.println(" _res;"); + unit.emit(binding.getCSymbol().getReturnType().getCName(false)); + unit.emitln(" _res;"); if (javaReturnType.isNIOByteBufferArray() || javaReturnType.isArrayOfCompoundTypeWrappers()) { - writer.print(" int "); - writer.print(arrayResLength); - writer.println(";"); - writer.print(" int "); - writer.print(arrayIdx); - writer.println(";"); - writer.print(" jobjectArray "); - writer.print(arrayRes); - writer.println(";"); + unit.emit(" int "); + unit.emit(arrayResLength); + unit.emitln(";"); + unit.emit(" int "); + unit.emit(arrayIdx); + unit.emitln(";"); + unit.emit(" jobjectArray "); + unit.emit(arrayRes); + unit.emitln(";"); } else if (javaReturnType.isArray()) { - writer.print(" int "); - writer.print(arrayResLength); - writer.println(";"); + unit.emit(" int "); + unit.emit(arrayResLength); + unit.emitln(";"); final Class<?> componentType = javaReturnType.getJavaClass().getComponentType(); if (componentType.isArray()) { @@ -489,22 +490,22 @@ public class CMethodBindingEmitter extends FunctionEmitter { final String javaTypeName = componentType.getName(); final String javaArrayTypeName = "j" + javaTypeName + "Array"; - writer.print(" "); - writer.print(javaArrayTypeName); - writer.print(" "); - writer.print(arrayRes); - writer.println(";"); + unit.emit(" "); + unit.emit(javaArrayTypeName); + unit.emit(" "); + unit.emit(arrayRes); + unit.emitln(";"); } } } /** Emits the user-defined C variable declarations from the TemporaryCVariableDeclarations directive in the .cfg file. */ - protected void emitBodyUserVariableDeclarations(final PrintWriter writer) { + protected void emitBodyUserVariableDeclarations() { if (temporaryCVariableDeclarations != null) { for (final String val : temporaryCVariableDeclarations) { - writer.print(" "); - writer.println(val); + unit.emit(" "); + unit.emitln(val); } } } @@ -545,13 +546,13 @@ public class CMethodBindingEmitter extends FunctionEmitter { * emitBodyVariableDeclarations(), PRIOR TO calling the actual C * function. */ - protected void emitBodyVariablePreCallSetup(final PrintWriter writer) { + protected void emitBodyVariablePreCallSetup() { // Convert all Buffers to pointers first so we don't have to // call ReleasePrimitiveArrayCritical for any arrays if any // incoming buffers aren't direct if (binding.hasContainingType()) { - emitPointerConversion(writer, binding, + emitPointerConversion(binding, binding.getContainingType(), binding.getContainingCType(), JavaMethodBindingEmitter.javaThisArgumentName(), @@ -570,7 +571,7 @@ public class CMethodBindingEmitter extends FunctionEmitter { if (javaArgType.isCompoundTypeWrapper() || (javaArgType.isNIOBuffer() && !forIndirectBufferAndArrayImplementation ) ) { - emitPointerConversion(writer, binding, javaArgType, + emitPointerConversion(binding, javaArgType, binding.getCArgumentType(i), javaArgName, pointerConversionArgumentName(javaArgName), byteOffsetArgName(i)); @@ -579,7 +580,7 @@ public class CMethodBindingEmitter extends FunctionEmitter { ( javaArgType.isNIOBuffer() && forIndirectBufferAndArrayImplementation ) ) { final boolean needsDataCopy = javaArgTypeNeedsDataCopy(javaArgType); - writer.println(" if ( NULL != " + javaArgName + " ) {"); + unit.emitln(" if ( NULL != " + javaArgName + " ) {"); final Type cArgType = binding.getCArgumentType(i); String cArgTypeName = cArgType.getCName(); @@ -587,17 +588,17 @@ public class CMethodBindingEmitter extends FunctionEmitter { final String convName = pointerConversionArgumentName(javaArgName); if (!needsDataCopy) { - writer.print(" "); - writer.print(convName); - writer.print(" = ("); + unit.emit(" "); + unit.emit(convName); + unit.emit(" = ("); if (javaArgType.isStringArray()) { // java-side type is String[] cArgTypeName = "jstring *"; } - writer.print(cArgTypeName); - writer.print(") ( JNI_TRUE == " + isNIOArgName(i) + " ? "); - writer.print(" (*env)->GetDirectBufferAddress(env, " + javaArgName + ") : "); - writer.print(" (*env)->GetPrimitiveArrayCritical(env, " + javaArgName + ", NULL) );"); + unit.emit(cArgTypeName); + unit.emit(") ( JNI_TRUE == " + isNIOArgName(i) + " ? "); + unit.emit(" (*env)->GetDirectBufferAddress(env, " + javaArgName + ") : "); + unit.emit(" (*env)->GetPrimitiveArrayCritical(env, " + javaArgName + ", NULL) );"); } else { // Handle the case where the array elements are of a type that needs a // data copy operation to convert from the java memory model to the C @@ -618,16 +619,16 @@ public class CMethodBindingEmitter extends FunctionEmitter { "\": support for non-const ptr-to-ptr types not implemented: "+binding, binding.getCSymbol().getASTLocusTag()); } - writer.println(); - writer.println(" /* Copy contents of " + javaArgName + " into " + convName + "_copy */"); + unit.emitln(); + unit.emitln(" /* Copy contents of " + javaArgName + " into " + convName + "_copy */"); // get length of array being copied final String arrayLenName = "_tmpArrayLen"; - writer.print(" "); - writer.print(arrayLenName); - writer.print(" = (*env)->GetArrayLength(env, "); - writer.print(javaArgName); - writer.println(");"); + unit.emit(" "); + unit.emit(arrayLenName); + unit.emit(" = (*env)->GetArrayLength(env, "); + unit.emit(javaArgName); + unit.emitln(");"); // allocate an array to hold each element final Type cArgElementType, cArgElementType2; @@ -666,7 +667,6 @@ public class CMethodBindingEmitter extends FunctionEmitter { } } emitMalloc( - writer, convName+"_copy", cArgElementType.getCName(), cArgType.isBaseTypeConst(), @@ -679,33 +679,31 @@ public class CMethodBindingEmitter extends FunctionEmitter { // GetObjectArrayElement while in a critical section. May // need to do another loop and add in the offsets. if (javaArgType.isNIOBufferArray()) { - writer.println + unit.emitln (" _offsetHandle = (int *) (*env)->GetPrimitiveArrayCritical(env, " + byteOffsetArrayArgName(i) + ", NULL);"); } // process each element in the array - writer.println(" for (_copyIndex = 0; _copyIndex < "+arrayLenName+"; ++_copyIndex) {"); + unit.emitln(" for (_copyIndex = 0; _copyIndex < "+arrayLenName+"; ++_copyIndex) {"); // get each array element - writer.println(" /* get each element of the array argument \"" + javaArgName + "\" */"); - writer.print(" _tmpObj = (*env)->GetObjectArrayElement(env, "); - writer.print(javaArgName); - writer.println(", _copyIndex);"); + unit.emitln(" /* get each element of the array argument \"" + javaArgName + "\" */"); + unit.emit(" _tmpObj = (*env)->GetObjectArrayElement(env, "); + unit.emit(javaArgName); + unit.emitln(", _copyIndex);"); if (javaArgType.isStringArray()) { - writer.print(" "); - emitGetStringChars(writer, - "(jstring) _tmpObj", + unit.emit(" "); + emitGetStringChars("(jstring) _tmpObj", convName+"_copy[_copyIndex]", isUTF8Type(cArgType), true); } else if (javaArgType.isNIOBufferArray()) { /* We always assume an integer "byte offset" argument follows any Buffer in the method binding. */ - emitGetDirectBufferAddress(writer, - "_tmpObj", + emitGetDirectBufferAddress("_tmpObj", cArgElementType.getCName(), convName + "_copy[_copyIndex]", true, @@ -714,8 +712,7 @@ public class CMethodBindingEmitter extends FunctionEmitter { // These come down in similar fashion to an array of NIO // Buffers only we do not pass down any integer byte // offset argument - emitGetDirectBufferAddress(writer, - "_tmpObj", + emitGetDirectBufferAddress("_tmpObj", cArgElementType.getCName(), "("+convName + "_copy + _copyIndex)", false /* !receivingIsPtrPtr -> linear layout -> use memcpy */, @@ -730,10 +727,8 @@ public class CMethodBindingEmitter extends FunctionEmitter { // assign it to the appropriate elements at pointer depth 1? // Probably depends on const-ness of the argument. // Malloc enough space to hold a copy of each sub-array - writer.print(" "); - emitMalloc( - writer, - convName+"_copy[_copyIndex]", + unit.emit(" "); + emitMalloc(convName+"_copy[_copyIndex]", cArgElementType2.getCName(), // assumes cArgPtrType is ptr-to-ptr-to-primitive !! cArgType.isBaseTypeConst(), "(*env)->GetArrayLength(env, _tmpObj)", @@ -746,22 +741,22 @@ public class CMethodBindingEmitter extends FunctionEmitter { } } - writer.println(" }"); + unit.emitln(" }"); if (javaArgType.isNIOBufferArray()) { - writer.println + unit.emitln (" (*env)->ReleasePrimitiveArrayCritical(env, " + byteOffsetArrayArgName(i) + ", _offsetHandle, JNI_ABORT);"); } - writer.println(); + unit.emitln(); } // end of data copy - writer.println(" }"); + unit.emitln(" }"); } else if (javaArgType.isString()) { - emitGetStringChars(writer, javaArgName, + emitGetStringChars(javaArgName, STRING_CHARS_PREFIX + javaArgName, isUTF8Type(binding.getCArgumentType(i)), false); @@ -774,7 +769,7 @@ public class CMethodBindingEmitter extends FunctionEmitter { * Code to clean up any variables that were declared in * emitBodyVariableDeclarations(), AFTER calling the actual C function. */ - protected void emitBodyVariablePostCallCleanup(final PrintWriter writer) { + protected void emitBodyVariablePostCallCleanup() { // Release primitive arrays and temporary UTF8 strings if necessary for (int i = 0; i < binding.getNumArguments(); i++) { @@ -794,13 +789,13 @@ public class CMethodBindingEmitter extends FunctionEmitter { final String convName = pointerConversionArgumentName(javaArgName); if (!needsDataCopy) { - writer.println(" if ( JNI_FALSE == " + isNIOArgName(i) + " && NULL != " + javaArgName + " ) {"); + unit.emitln(" if ( JNI_FALSE == " + isNIOArgName(i) + " && NULL != " + javaArgName + " ) {"); // Release array final String modeFlag = cArgType.isBaseTypeConst() ? "JNI_ABORT" : "0" ; - writer.print(" (*env)->ReleasePrimitiveArrayCritical(env, " + javaArgName + ", " + convName + ", "+modeFlag+");"); + unit.emit(" (*env)->ReleasePrimitiveArrayCritical(env, " + javaArgName + ", " + convName + ", "+modeFlag+");"); } else { - writer.println(" if ( NULL != " + javaArgName + " ) {"); + unit.emitln(" if ( NULL != " + javaArgName + " ) {"); // clean up the case where the array elements are of a type that needed // a data copy operation to convert from the java memory model to the @@ -815,16 +810,15 @@ public class CMethodBindingEmitter extends FunctionEmitter { // method for details). if (javaArgType.isArrayOfCompoundTypeWrappers()) { // This is the only form of cleanup we handle right now - writer.println(" _tmpArrayLen = (*env)->GetArrayLength(env, " + javaArgName + ");"); - writer.println(" for (_copyIndex = 0; _copyIndex < _tmpArrayLen; ++_copyIndex) {"); - writer.println(" _tmpObj = (*env)->GetObjectArrayElement(env, " + javaArgName + ", _copyIndex);"); - emitReturnDirectBufferAddress(writer, - "_tmpObj", - cArgType.asArray().getBaseElementType().getCName(), - "("+convName + "_copy + _copyIndex)", - false /* receivingIsPtrPtr */, - null); - writer.println(" }"); + unit.emitln(" _tmpArrayLen = (*env)->GetArrayLength(env, " + javaArgName + ");"); + unit.emitln(" for (_copyIndex = 0; _copyIndex < _tmpArrayLen; ++_copyIndex) {"); + unit.emitln(" _tmpObj = (*env)->GetObjectArrayElement(env, " + javaArgName + ", _copyIndex);"); + emitReturnDirectBufferAddress("_tmpObj", + cArgType.asArray().getBaseElementType().getCName(), + "("+convName + "_copy + _copyIndex)", + false /* receivingIsPtrPtr */, + null); + unit.emitln(" }"); } else { throw new GlueGenException( "Cannot clean up copied data for ptr-to-ptr arg type \"" + cArgType.getDebugString() + @@ -833,7 +827,7 @@ public class CMethodBindingEmitter extends FunctionEmitter { } } - writer.println(" /* Clean up " + convName + "_copy */"); + unit.emitln(" /* Clean up " + convName + "_copy */"); // Only need to perform cleanup for individual array // elements if they are not direct buffers @@ -841,11 +835,11 @@ public class CMethodBindingEmitter extends FunctionEmitter { !javaArgType.isArrayOfCompoundTypeWrappers()) { // Re-fetch length of array that was copied final String arrayLenName = "_tmpArrayLen"; - writer.print(" "); - writer.print(arrayLenName); - writer.print(" = (*env)->GetArrayLength(env, "); - writer.print(javaArgName); - writer.println(");"); + unit.emit(" "); + unit.emit(arrayLenName); + unit.emit(" = (*env)->GetArrayLength(env, "); + unit.emit(javaArgName); + unit.emitln(");"); // free each element final PointerType cArgPtrType = cArgType.asPointer(); @@ -857,61 +851,61 @@ public class CMethodBindingEmitter extends FunctionEmitter { } // process each element in the array - writer.println(" for (_copyIndex = 0; _copyIndex < " + arrayLenName +"; ++_copyIndex) {"); + unit.emitln(" for (_copyIndex = 0; _copyIndex < " + arrayLenName +"; ++_copyIndex) {"); // get each array element - writer.println(" /* free each element of " +convName +"_copy */"); - writer.print(" _tmpObj = (*env)->GetObjectArrayElement(env, "); - writer.print(javaArgName); - writer.println(", _copyIndex);"); + unit.emitln(" /* free each element of " +convName +"_copy */"); + unit.emit(" _tmpObj = (*env)->GetObjectArrayElement(env, "); + unit.emit(javaArgName); + unit.emitln(", _copyIndex);"); if (javaArgType.isStringArray()) { - writer.print(" (*env)->ReleaseStringUTFChars(env, "); - writer.print("(jstring) _tmpObj"); - writer.print(", "); - writer.print(convName+"_copy[_copyIndex]"); - writer.println(");"); + unit.emit(" (*env)->ReleaseStringUTFChars(env, "); + unit.emit("(jstring) _tmpObj"); + unit.emit(", "); + unit.emit(convName+"_copy[_copyIndex]"); + unit.emitln(");"); } else { throw new GlueGenException( "Cannot yet handle type \"" + cArgType.getDebugString() + "\"; need to add support for cleaning up copied ptr-to-ptr-to-primitiveType subarrays", binding.getCSymbol().getASTLocusTag()); } - writer.println(" }"); + unit.emitln(" }"); } // free the main array - writer.print(" free((void*) "); - writer.print(convName+"_copy"); - writer.println(");"); + unit.emit(" free((void*) "); + unit.emit(convName+"_copy"); + unit.emitln(");"); } // end of cleaning up copied data - writer.println(" }"); + unit.emitln(" }"); } else if (javaArgType.isString()) { - writer.println(" if ( NULL != " + javaArgName + " ) {"); + unit.emitln(" if ( NULL != " + javaArgName + " ) {"); if (isUTF8Type(cArgType)) { - writer.print(" (*env)->ReleaseStringUTFChars(env, "); - writer.print(javaArgName); - writer.print(", " + STRING_CHARS_PREFIX); - writer.print(javaArgName); - writer.println(");"); + unit.emit(" (*env)->ReleaseStringUTFChars(env, "); + unit.emit(javaArgName); + unit.emit(", " + STRING_CHARS_PREFIX); + unit.emit(javaArgName); + unit.emitln(");"); } else { - writer.println(" free((void*) " + STRING_CHARS_PREFIX + javaArgName + ");"); + unit.emitln(" free((void*) " + STRING_CHARS_PREFIX + javaArgName + ");"); } - writer.println(" }"); + unit.emitln(" }"); } } } /** Returns the number of arguments passed so calling code knows whether to print a comma */ - protected int emitBodyPassCArguments(final PrintWriter writer) { + protected int emitBodyPassCArguments() { for (int i = 0; i < binding.getNumArguments(); i++) { if (i != 0) { - writer.print(", "); + unit.emit(", "); } final JavaType javaArgType = binding.getJavaArgumentType(i); // Handle case where only param is void. @@ -923,40 +917,40 @@ public class CMethodBindingEmitter extends FunctionEmitter { } if (javaArgType.isJNIEnv()) { - writer.print("env"); + unit.emit("env"); } else if (binding.isArgumentThisPointer(i)) { - writer.print(CMethodBindingEmitter.cThisArgumentName()); + unit.emit(CMethodBindingEmitter.cThisArgumentName()); } else { - writer.print("("); + unit.emit("("); final Type cArgType = binding.getCArgumentType(i); final boolean needsDataCopy = javaArgTypeNeedsDataCopy(javaArgType); final boolean needsArrayOffset = !needsDataCopy && ( javaArgType.isArray() || javaArgType.isArrayOfCompoundTypeWrappers() || ( javaArgType.isNIOBuffer() && forIndirectBufferAndArrayImplementation ) ); - writer.print(cArgType.getCName(true)); - writer.print(") "); + unit.emit(cArgType.getCName(true)); + unit.emit(") "); if (cArgType.isPointer() && javaArgType.isPrimitive()) { - writer.print("(intptr_t) "); + unit.emit("(intptr_t) "); } if (javaArgType.isArray() || javaArgType.isNIOBuffer() || javaArgType.isCompoundTypeWrapper() || javaArgType.isArrayOfCompoundTypeWrappers()) { if( needsArrayOffset ) { - writer.print("(((char *) "); + unit.emit("(((char *) "); } else if( !cArgType.isPointer() && javaArgType.isCompoundTypeWrapper() ) { // FIXME: Compound call-by-value - writer.print("*"); + unit.emit("*"); } - writer.print(pointerConversionArgumentName(binding.getArgumentName(i))); + unit.emit(pointerConversionArgumentName(binding.getArgumentName(i))); if ( needsDataCopy ) { - writer.print("_copy"); + unit.emit("_copy"); } if( needsArrayOffset ) { - writer.print(") + " + byteOffsetArgName(i) + ")"); + unit.emit(") + " + byteOffsetArgName(i) + ")"); } } else { - if (javaArgType.isString()) { writer.print(STRING_CHARS_PREFIX); } - writer.print(binding.getArgumentName(i)); + if (javaArgType.isString()) { unit.emit(STRING_CHARS_PREFIX); } + unit.emit(binding.getArgumentName(i)); } } } @@ -974,9 +968,9 @@ public class CMethodBindingEmitter extends FunctionEmitter { isCStructFunctionPointer = v; } - protected void emitBodyCallCFunction(final PrintWriter writer) { + protected void emitBodyCallCFunction() { // Make the call to the actual C function - writer.print(" "); + unit.emit(" "); // WARNING: this code assumes that the return type has already been // typedef-resolved. @@ -986,32 +980,32 @@ public class CMethodBindingEmitter extends FunctionEmitter { // Note we respect const/volatile in the function return type. // However, we cannot have it 'const' for our local variable. // See return type in emitBodyVariableDeclarations(..)! - writer.print("_res = ("); - writer.print(cReturnType.getCName(false)); - writer.print(") "); + unit.emit("_res = ("); + unit.emit(cReturnType.getCName(false)); + unit.emit(") "); } if ( isCStructFunctionPointer && binding.hasContainingType() ) { // Call through function pointer - writer.print(CMethodBindingEmitter.cThisArgumentName() + "->"); + unit.emit(CMethodBindingEmitter.cThisArgumentName() + "->"); } - writer.print(getNativeName()); - writer.print("("); - emitBodyPassCArguments(writer); - writer.println(");"); + unit.emit(getNativeName()); + unit.emit("("); + emitBodyPassCArguments(); + unit.emitln(");"); } /** Emits the user-defined C variable assignments from the TemporaryCVariableAssignments directive in the .cfg file. */ - protected void emitBodyUserVariableAssignments(final PrintWriter writer) { + protected void emitBodyUserVariableAssignments() { if (temporaryCVariableAssignments != null) { for (final String val : temporaryCVariableAssignments) { - writer.print(" "); - writer.println(val); + unit.emit(" "); + unit.emitln(val); } } } - protected void emitBodyReturnResult(final PrintWriter writer) + protected void emitBodyReturnResult() { // WARNING: this code assumes that the return type has already been // typedef-resolved. @@ -1021,28 +1015,29 @@ public class CMethodBindingEmitter extends FunctionEmitter { if (!cReturnType.isVoid()) { final JavaType javaReturnType = binding.getJavaReturnType(); if (javaReturnType.isPrimitive()) { - writer.print(" return "); + unit.emit(" return "); if (cReturnType.isPointer()) { // Pointer being converted to int or long: cast this result // (through intptr_t to avoid compiler warnings with gcc) - writer.print("(" + javaReturnType.jniTypeName() + ") (intptr_t) "); + unit.emit("(" + javaReturnType.jniTypeName() + ") (intptr_t) "); } - writer.println("_res;"); - } else if ( !cReturnType.isPointer() && javaReturnType.isCompoundTypeWrapper() ) { // FIXME: Compound call-by-value + unit.emitln("_res;"); + } else if ( !cReturnType.isPointer() && javaReturnType.isCompoundTypeWrapper() ) { // isReturnCompoundByValue() final String returnSizeOf; if (returnValueCapacityExpression != null) { returnSizeOf = returnValueCapacityExpression.format(argumentNameArray()); } else { returnSizeOf = "sizeof(" + cReturnType.getCName() + ")"; } - writer.println(" return JVMUtil_NewDirectByteBufferCopy(env, &_res, "+returnSizeOf+");"); + unit.emitln(" return JVMUtil_NewDirectByteBufferCopy(env, _clazzBuffers, &_res, "+returnSizeOf+");"); + unit.addTailCode(CCodeUnit.NewDirectByteBufferCopyUnitCode); } else if (javaReturnType.isNIOBuffer() || javaReturnType.isCompoundTypeWrapper()) { - writer.println(" if (NULL == _res) return NULL;"); - writer.print(" return (*env)->NewDirectByteBuffer(env, (void *)_res, "); + unit.emitln(" if (NULL == _res) return NULL;"); + unit.emit(" return (*env)->NewDirectByteBuffer(env, (void *)_res, "); // See whether capacity has been specified if (returnValueCapacityExpression != null) { - writer.println( returnValueCapacityExpression.format( argumentNameArray() ) + ");"); + unit.emitln( returnValueCapacityExpression.format( argumentNameArray() ) + ");"); } else { final Type cReturnTargetType = cReturnType.isPointer() ? cReturnType.getTargetType() : null; int mode = 0; @@ -1062,22 +1057,22 @@ public class CMethodBindingEmitter extends FunctionEmitter { binding.getCSymbol().getASTLocusTag() ); } - writer.println("sizeof(" + cReturnTargetType.getCName() + ") );"); + unit.emitln("sizeof(" + cReturnTargetType.getCName() + ") );"); mode = 10; } else if( cReturnTargetType.asCompound().getNumFields() == 0 ) { // anonymous struct pointer: pass pointer - writer.println("sizeof(" + cReturnType.getCName() + ") );"); + unit.emitln("sizeof(" + cReturnType.getCName() + ") );"); mode = 11; } } if( 0 == mode ) { if( cReturnTargetType.isPrimitive() ) { // primitive pointer: pass primitive - writer.println("sizeof(" + cReturnTargetType.getCName() + ") );"); + unit.emitln("sizeof(" + cReturnTargetType.getCName() + ") );"); mode = 20; } else if( cReturnTargetType.isVoid() ) { // void pointer: pass pointer - writer.println("sizeof(" + cReturnType.getCName() + ") );"); + unit.emitln("sizeof(" + cReturnType.getCName() + ") );"); mode = 21; } } @@ -1085,37 +1080,37 @@ public class CMethodBindingEmitter extends FunctionEmitter { if( 0 == mode ) { if( null != cfg.typeInfo(cReturnType) ) { // javaReturnType.isOpaqued() covered above via isPrimitive() // Opaque - writer.println("sizeof(" + cReturnType.getCName() + ") );"); + unit.emitln("sizeof(" + cReturnType.getCName() + ") );"); mode = 88; } else { final String wmsg = "Assumed return size of equivalent C return type"; - writer.println("sizeof(" + cReturnType.getCName() + ") ); // WARNING: "+wmsg); + unit.emitln("sizeof(" + cReturnType.getCName() + ") ); // WARNING: "+wmsg); mode = 99; LOG.warning(binding.getCSymbol().getASTLocusTag(), "No capacity specified for java.nio.Buffer return " + "value for function \"" + binding.getName() + "\". " + wmsg + " (sizeof(" + cReturnType.getCName() + ")): " + binding); } } - writer.println(" /** "); - writer.println(" * mode: "+mode); - writer.println(" * cReturnType: "+cReturnType.getDebugString()); - writer.println(" * cReturnTargetType: "+cReturnTargetType.getDebugString()); - writer.println(" * javaReturnType: "+javaReturnType.getDebugString()); - writer.println(" */"); + unit.emitln(" /** "); + unit.emitln(" * mode: "+mode); + unit.emitln(" * cReturnType: "+cReturnType.getDebugString()); + unit.emitln(" * cReturnTargetType: "+cReturnTargetType.getDebugString()); + unit.emitln(" * javaReturnType: "+javaReturnType.getDebugString()); + unit.emitln(" */"); } } else if (javaReturnType.isString()) { - writer.println(" if (NULL == _res) return NULL;"); - writer.println(" return (*env)->NewStringUTF(env, (const char *)_res);"); + unit.emitln(" if (NULL == _res) return NULL;"); + unit.emitln(" return (*env)->NewStringUTF(env, (const char *)_res);"); } else if (javaReturnType.isArrayOfCompoundTypeWrappers() || (javaReturnType.isArray() && javaReturnType.isNIOByteBufferArray())) { - writer.println(" if (NULL == _res) return NULL;"); + unit.emitln(" if (NULL == _res) return NULL;"); if (returnValueLengthExpression == null) { throw new GlueGenException("Error while generating C code: no length specified for array returned from function " + binding, binding.getCSymbol().getASTLocusTag()); } - writer.println(" " + arrayResLength + " = " + returnValueLengthExpression.format(argumentNameArray()) + ";"); - writer.println(" " + arrayRes + " = (*env)->NewObjectArray(env, " + arrayResLength + ", (*env)->FindClass(env, \"java/nio/ByteBuffer\"), NULL);"); - writer.println(" for (" + arrayIdx + " = 0; " + arrayIdx + " < " + arrayResLength + "; " + arrayIdx + "++) {"); + unit.emitln(" " + arrayResLength + " = " + returnValueLengthExpression.format(argumentNameArray()) + ";"); + unit.emitln(" " + arrayRes + " = (*env)->NewObjectArray(env, " + arrayResLength + ", (*env)->FindClass(env, \"java/nio/ByteBuffer\"), NULL);"); + unit.emitln(" for (" + arrayIdx + " = 0; " + arrayIdx + " < " + arrayResLength + "; " + arrayIdx + "++) {"); final Type retType = binding.getCSymbol().getReturnType(); Type pointerType; if (retType.isPointer()) { @@ -1123,10 +1118,10 @@ public class CMethodBindingEmitter extends FunctionEmitter { } else { pointerType = retType.asArray().getBaseElementType(); } - writer.println(" (*env)->SetObjectArrayElement(env, " + arrayRes + ", " + arrayIdx + + unit.emitln(" (*env)->SetObjectArrayElement(env, " + arrayRes + ", " + arrayIdx + ", (*env)->NewDirectByteBuffer(env, (void *)_res[" + arrayIdx + "], sizeof(" + pointerType.getCName() + ")));"); - writer.println(" }"); - writer.println(" return " + arrayRes + ";"); + unit.emitln(" }"); + unit.emitln(" return " + arrayRes + ";"); } else if (javaReturnType.isArray()) { // FIXME: must have user provide length of array in .cfg file // by providing a constant value, input parameter, or @@ -1140,23 +1135,23 @@ public class CMethodBindingEmitter extends FunctionEmitter { // FIXME: This is approximately what will be required here // - //writer.print(" "); - //writer.print(arrayRes); - //writer.print(" = (*env)->New"); - //writer.print(capitalizedComponentType); - //writer.print("Array(env, "); - //writer.print(arrayResLength); - //writer.println(");"); - //writer.print(" (*env)->Set"); - //writer.print(capitalizedComponentType); - //writer.print("ArrayRegion(env, "); - //writer.print(arrayRes); - //writer.print(", 0, "); - //writer.print(arrayResLength); - //writer.println(", _res);"); - //writer.print(" return "); - //writer.print(arrayRes); - //writer.println(";"); + //unit().emit(" "); + //unit().emit(arrayRes); + //unit().emit(" = (*env)->New"); + //unit().emit(capitalizedComponentType); + //unit().emit("Array(env, "); + //unit().emit(arrayResLength); + //unit().emitln(");"); + //unit().emit(" (*env)->Set"); + //unit().emit(capitalizedComponentType); + //unit().emit("ArrayRegion(env, "); + //unit().emit(arrayRes); + //unit().emit(", 0, "); + //unit().emit(arrayResLength); + //unit().emitln(", _res);"); + //unit().emit(" return "); + //unit().emit(arrayRes); + //unit().emitln(";"); } else { throw new GlueGenException("Unhandled return type: "+javaReturnType.getDebugString()+" for "+binding, binding.getCSymbol().getReturnType().getASTLocusTag()); @@ -1173,6 +1168,9 @@ public class CMethodBindingEmitter extends FunctionEmitter { buf.append(JavaEmitter.jniMangle(getImplName())); buf.append(getImplSuffix()); buf.append("__"); + if (binding.isReturnCompoundByValue()) { + jniMangle(Class.class, buf, true); + } if (binding.hasContainingType()) { // "this" argument always comes down in argument 0 as direct buffer jniMangle(java.nio.ByteBuffer.class, buf, true); @@ -1276,77 +1274,74 @@ public class CMethodBindingEmitter extends FunctionEmitter { } } - private void emitOutOfMemoryCheck(final PrintWriter writer, final String varName, final String errorMessage) { - writer.println(" if ( NULL == " + varName + " ) {"); - writer.println(" (*env)->ThrowNew(env, (*env)->FindClass(env, \"java/lang/OutOfMemoryError\"),"); - writer.print(" \"" + errorMessage); - writer.print(" in native dispatcher for \\\""); - writer.print(getInterfaceName()); - writer.println("\\\"\");"); - writer.print(" return"); + private void emitOutOfMemoryCheck(final String varName, final String errorMessage) { + unit.emitln(" if ( NULL == " + varName + " ) {"); + unit.emitln(" (*env)->ThrowNew(env, (*env)->FindClass(env, \"java/lang/OutOfMemoryError\"),"); + unit.emit(" \"" + errorMessage); + unit.emit(" in native dispatcher for \\\""); + unit.emit(getInterfaceName()); + unit.emitln("\\\"\");"); + unit.emit(" return"); if (!binding.getJavaReturnType().isVoid()) { - writer.print(" 0"); + unit.emit(" 0"); } - writer.println(";"); - writer.println(" }"); + unit.emitln(";"); + unit.emitln(" }"); } - private void emitMalloc(final PrintWriter writer, - final String targetVarName, + private void emitMalloc(final String targetVarName, final String elementTypeString, final boolean elementTypeIsConst, final String numElementsExpression, final String mallocFailureErrorString) { - writer.print(" "); - writer.print(targetVarName); - writer.print(" = ("); + unit.emit(" "); + unit.emit(targetVarName); + unit.emit(" = ("); if(elementTypeIsConst) { - writer.print("const "); + unit.emit("const "); } - writer.print(elementTypeString); - writer.print(" *) malloc("); - writer.print(numElementsExpression); - writer.print(" * sizeof("); - writer.print(elementTypeString); - writer.println("));"); + unit.emit(elementTypeString); + unit.emit(" *) malloc("); + unit.emit(numElementsExpression); + unit.emit(" * sizeof("); + unit.emit(elementTypeString); + unit.emitln("));"); // Catch memory allocation failure - emitOutOfMemoryCheck( writer, targetVarName, mallocFailureErrorString); + emitOutOfMemoryCheck( targetVarName, mallocFailureErrorString); } - private void emitCalloc(final PrintWriter writer, - final String targetVarName, + private void emitCalloc(final String targetVarName, final String elementTypeString, final String numElementsExpression, final String mallocFailureErrorString) { - writer.print(" "); - writer.print(targetVarName); - writer.print(" = ("); - writer.print(elementTypeString); - writer.print(" *) calloc("); - writer.print(numElementsExpression); - writer.print(", sizeof("); - writer.print(elementTypeString); - writer.println("));"); + unit.emit(" "); + unit.emit(targetVarName); + unit.emit(" = ("); + unit.emit(elementTypeString); + unit.emit(" *) calloc("); + unit.emit(numElementsExpression); + unit.emit(", sizeof("); + unit.emit(elementTypeString); + unit.emitln("));"); // Catch memory allocation failure - emitOutOfMemoryCheck( writer, targetVarName, mallocFailureErrorString); + emitOutOfMemoryCheck( targetVarName, mallocFailureErrorString); } - private void emitGetStringChars(final PrintWriter writer, - final String sourceVarName, + private void emitGetStringChars(final String sourceVarName, final String receivingVarName, final boolean isUTF8, final boolean emitElseClause) { - writer.println(" if ( NULL != " + sourceVarName + " ) {"); + unit.emitln(" if ( NULL != " + sourceVarName + " ) {"); if (isUTF8) { - writer.print(" "); - writer.print(receivingVarName); - writer.print(" = (*env)->GetStringUTFChars(env, "); - writer.print(sourceVarName); - writer.println(", (jboolean*)NULL);"); + unit.emit(" "); + unit.emit(receivingVarName); + unit.emit(" = (*env)->GetStringUTFChars(env, "); + unit.emit(sourceVarName); + unit.emitln(", (jboolean*)NULL);"); // Catch memory allocation failure in the event that the VM didn't pin // the String and failed to allocate a copy - emitOutOfMemoryCheck( writer, receivingVarName, "Failed to get UTF-8 chars for argument \\\""+sourceVarName+"\\\""); + emitOutOfMemoryCheck( receivingVarName, "Failed to get UTF-8 chars for argument \\\""+sourceVarName+"\\\""); } else { // The UTF-16 case is basically Windows specific. Unix platforms // tend to use only the UTF-8 encoding. On Windows the problem @@ -1355,82 +1350,78 @@ public class CMethodBindingEmitter extends FunctionEmitter { // null-terminated Unicode string. For this reason we explicitly // calloc our buffer, including the null terminator, and use // GetStringRegion to fetch the string's characters. - emitCalloc(writer, - receivingVarName, + emitCalloc(receivingVarName, "jchar", "(*env)->GetStringLength(env, " + sourceVarName + ") + 1", "Could not allocate temporary buffer for copying string argument \\\""+sourceVarName+"\\\""); - writer.println(" (*env)->GetStringRegion(env, " + sourceVarName + ", 0, (*env)->GetStringLength(env, " + sourceVarName + "), " + receivingVarName + ");"); + unit.emitln(" (*env)->GetStringRegion(env, " + sourceVarName + ", 0, (*env)->GetStringLength(env, " + sourceVarName + "), " + receivingVarName + ");"); } - writer.print(" }"); + unit.emit(" }"); if (emitElseClause) { - writer.print(" else {"); - writer.print(" "); - writer.print(receivingVarName); - writer.println(" = NULL;"); - writer.println(" }"); + unit.emit(" else {"); + unit.emit(" "); + unit.emit(receivingVarName); + unit.emitln(" = NULL;"); + unit.emitln(" }"); } else { - writer.println(); + unit.emitln(); } } - private void emitGetDirectBufferAddress(final PrintWriter writer, - final String sourceVarName, + private void emitGetDirectBufferAddress(final String sourceVarName, final String receivingVarTypeString, final String receivingVarName, final boolean receivingIsPtrPtr, final String byteOffsetVarName, final boolean emitElseClause) { - writer.println(" if ( NULL != " + sourceVarName + " ) {"); - writer.print(" "); - writer.print(" "); + unit.emitln(" if ( NULL != " + sourceVarName + " ) {"); + unit.emit(" "); + unit.emit(" "); if( receivingIsPtrPtr ) { - writer.print(receivingVarName+" = ("+receivingVarTypeString+") (((char*) (*env)->GetDirectBufferAddress(env, "+sourceVarName+"))"); - writer.println(" + " + ((byteOffsetVarName != null) ? byteOffsetVarName : "0") + ");"); + unit.emit(receivingVarName+" = ("+receivingVarTypeString+") (((char*) (*env)->GetDirectBufferAddress(env, "+sourceVarName+"))"); + unit.emitln(" + " + ((byteOffsetVarName != null) ? byteOffsetVarName : "0") + ");"); } else { // linear layout -> use memcpy - writer.println("memcpy((void *)"+receivingVarName+", (*env)->GetDirectBufferAddress(env, "+sourceVarName+"), sizeof("+receivingVarTypeString+"));"); + unit.emitln("memcpy((void *)"+receivingVarName+", (*env)->GetDirectBufferAddress(env, "+sourceVarName+"), sizeof("+receivingVarTypeString+"));"); } if (emitElseClause) { - writer.println(" } else {"); - writer.print(" "); - writer.print(" "); + unit.emitln(" } else {"); + unit.emit(" "); + unit.emit(" "); if( receivingIsPtrPtr ) { - writer.print(receivingVarName); - writer.println(" = NULL;"); + unit.emit(receivingVarName); + unit.emitln(" = NULL;"); } else { - writer.println("memset((void *)"+receivingVarName+", 0, sizeof("+receivingVarTypeString+"));"); + unit.emitln("memset((void *)"+receivingVarName+", 0, sizeof("+receivingVarTypeString+"));"); } } - writer.println(" }"); - writer.println(); + unit.emitln(" }"); + unit.emitln(); } - private void emitReturnDirectBufferAddress(final PrintWriter writer, - final String sourceVarName, - final String receivingVarTypeString, - final String receivingVarName, - final boolean receivingIsPtrPtr, - final String byteOffsetVarName) { - writer.print(" "); - writer.print(" "); + private void emitReturnDirectBufferAddress(final String sourceVarName, + final String receivingVarTypeString, + final String receivingVarName, + final boolean receivingIsPtrPtr, + final String byteOffsetVarName) { + unit.emit(" "); + unit.emit(" "); if( receivingIsPtrPtr ) { - writer.print("(((char*) (*env)->GetDirectBufferAddress(env, "+sourceVarName+"))"); - writer.println(" + " + ((byteOffsetVarName != null) ? byteOffsetVarName : "0") + ") = "+receivingVarName+";"); + unit.emit("(((char*) (*env)->GetDirectBufferAddress(env, "+sourceVarName+"))"); + unit.emitln(" + " + ((byteOffsetVarName != null) ? byteOffsetVarName : "0") + ") = "+receivingVarName+";"); throw new RuntimeException("incomplete implementation"); // FIXME doesn't work, currently unused } else { // linear layout -> use memcpy - writer.println("memcpy((*env)->GetDirectBufferAddress(env, "+sourceVarName+"), "+receivingVarName+", sizeof("+receivingVarTypeString+"));"); + unit.emitln("memcpy((*env)->GetDirectBufferAddress(env, "+sourceVarName+"), "+receivingVarName+", sizeof("+receivingVarTypeString+"));"); } - writer.println(); + unit.emitln(); } // Note: if the data in the Type needs to be converted from the Java memory // model to the C memory model prior to calling any C-side functions, then // an extra variable named XXX_copy (where XXX is the value of the // cVariableName argument) will be emitted and TRUE will be returned. - private boolean emitPointerDeclaration(final PrintWriter writer, - final JavaType javaType, + private boolean emitPointerDeclaration(final JavaType javaType, final Type cType, final String cVariableName, final String javaArgumentName) { @@ -1472,17 +1463,17 @@ public class CMethodBindingEmitter extends FunctionEmitter { ptrTypeString = cType.getCName(); } - writer.print(" "); + unit.emit(" "); if (!needsDataCopy) { // declare the pointer variable - writer.print(ptrTypeString); + unit.emit(ptrTypeString); if( !cType.isPointer() && javaType.isCompoundTypeWrapper() ) { // FIXME: Compound call-by-value - writer.print(" * "); + unit.emit(" * "); } else { - writer.print(" "); + unit.emit(" "); } - writer.print(cVariableName); - writer.println(" = NULL;"); + unit.emit(cVariableName); + unit.emitln(" = NULL;"); } else { // Declare a variable to hold a copy of the argument data in which the // incoming data has been properly laid out in memory to match the C @@ -1494,27 +1485,26 @@ public class CMethodBindingEmitter extends FunctionEmitter { cElementTypeName = cPtrType.getTargetType().asPointer().getCName(); } if (cType.isBaseTypeConst()) { - writer.print("const "); + unit.emit("const "); } - writer.print(cElementTypeName+" *"); + unit.emit(cElementTypeName+" *"); } else { if (cType.isBaseTypeConst()) { - writer.print("const "); + unit.emit("const "); } - writer.print(ptrTypeString); + unit.emit(ptrTypeString); } - writer.print(" "); - writer.print(cVariableName); - writer.print("_copy = NULL; /* copy of data in "); - writer.print(javaArgumentName); - writer.println(", laid out according to C memory model */"); + unit.emit(" "); + unit.emit(cVariableName); + unit.emit("_copy = NULL; /* copy of data in "); + unit.emit(javaArgumentName); + unit.emitln(", laid out according to C memory model */"); } return needsDataCopy; } - private void emitPointerConversion(final PrintWriter writer, - final MethodBinding binding, + private void emitPointerConversion(final MethodBinding binding, final JavaType type, final Type cType, final String incomingArgumentName, @@ -1531,8 +1521,7 @@ public class CMethodBindingEmitter extends FunctionEmitter { } else { cVariableType = cType.getCName(); } - emitGetDirectBufferAddress(writer, - incomingArgumentName, + emitGetDirectBufferAddress(incomingArgumentName, cVariableType, cVariableName, true, diff --git a/src/java/com/jogamp/gluegen/FunctionEmitter.java b/src/java/com/jogamp/gluegen/FunctionEmitter.java index bfbb73b..a089a41 100644 --- a/src/java/com/jogamp/gluegen/FunctionEmitter.java +++ b/src/java/com/jogamp/gluegen/FunctionEmitter.java @@ -1,4 +1,5 @@ /* + * Copyright (c) 2010-2023 JogAmp Community. All rights reserved. * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved. * * Redistribution and use in source and binary forms, with or without @@ -39,12 +40,14 @@ package com.jogamp.gluegen; -import java.util.*; -import java.io.*; +import java.util.ArrayList; +import java.util.Iterator; import com.jogamp.gluegen.cgram.types.FunctionSymbol; -import com.jogamp.gluegen.cgram.types.Type; +/** + * Generic function emitter to produce C (JNI) or Java code stubs to its {@link CodeUnit}, invoking a native function as described via {@link MethodBinding}. + */ public abstract class FunctionEmitter { public static final EmissionModifier STATIC = new EmissionModifier("static"); @@ -52,18 +55,20 @@ public abstract class FunctionEmitter { private final boolean isInterface; private final ArrayList<EmissionModifier> modifiers; private CommentEmitter commentEmitter = null; - private final PrintWriter defaultOutput; + protected final MethodBinding binding; + protected final CodeUnit unit; // Only present to provide more clear comments protected final JavaConfiguration cfg; /** * Constructs the FunctionEmitter with a CommentEmitter that emits nothing. */ - public FunctionEmitter(final PrintWriter defaultOutput, final boolean isInterface, final JavaConfiguration configuration) { - assert(defaultOutput != null); + public FunctionEmitter(final MethodBinding binding, final CodeUnit unit, final boolean isInterface, final JavaConfiguration configuration) { + assert(unit != null); this.isInterface = isInterface; this.modifiers = new ArrayList<EmissionModifier>(); - this.defaultOutput = defaultOutput; + this.binding = binding; + this.unit = unit; this.cfg = configuration; } @@ -74,13 +79,15 @@ public abstract class FunctionEmitter { isInterface = arg.isInterface; modifiers = new ArrayList<EmissionModifier>(arg.modifiers); commentEmitter = arg.commentEmitter; - defaultOutput = arg.defaultOutput; + binding = arg.binding; + unit = arg.unit; cfg = arg.cfg; } - public boolean isInterface() { return isInterface; } + public final boolean isInterface() { return isInterface; } - public PrintWriter getDefaultOutput() { return defaultOutput; } + public final MethodBinding getBinding() { return binding; } + public final CodeUnit getUnit() { return unit; } public void addModifiers(final Iterator<EmissionModifier> mi) { while (mi.hasNext()) { @@ -104,31 +111,18 @@ public abstract class FunctionEmitter { public abstract FunctionSymbol getCSymbol(); /** - * Emit the function to the specified output (instead of the default - * output). - */ - public void emit(final PrintWriter output) { - emitDocComment(output); - //output.println(" // Emitter: " + getClass().getName()); - emitSignature(output); - emitBody(output); - } - - /** - * Emit the function to the default output (the output that was passed to - * the constructor) + * Emit the function to the {@link #getUnit()} */ public final void emit() { - emit(getDefaultOutput()); + emitDocComment(); + //output.println(" // Emitter: " + getClass().getName()); + emitSignature(); + emitBody(); } - /** Returns, as a String, whatever {@link #emit} would output. */ @Override public String toString() { - final StringWriter sw = new StringWriter(500); - final PrintWriter w = new PrintWriter(sw); - emit(w); - return sw.toString(); + return getClass().getSimpleName()+"["+binding.toString()+"]"; } /** @@ -145,47 +139,47 @@ public abstract class FunctionEmitter { */ public CommentEmitter getCommentEmitter() { return commentEmitter; } - protected void emitDocComment(final PrintWriter writer) { + protected void emitDocComment() { if (commentEmitter != null) { - writer.print(getBaseIndentString()); //indent + unit.emit(getBaseIndentString()); //indent - writer.print(getCommentStartString()); + unit.emit(getCommentStartString()); - commentEmitter.emit(this, writer); + commentEmitter.emit(this, unit.output); - writer.print(getBaseIndentString()); //indent + unit.emit(getBaseIndentString()); //indent - writer.println(getCommentEndString()); + unit.emitln(getCommentEndString()); } } - protected void emitSignature(final PrintWriter writer) { + protected void emitSignature() { - writer.print(getBaseIndentString()); // indent method + unit.emit(getBaseIndentString()); // indent method - final int numEmitted = emitModifiers(writer); + final int numEmitted = emitModifiers(); if (numEmitted > 0) { - writer.print(" "); + unit.emit(" "); } - emitReturnType(writer); - writer.print(" "); + emitReturnType(); + unit.emit(" "); - emitName(writer); - writer.print("("); + emitName(); + unit.emit("("); - emitArguments(writer); - writer.print(")"); + emitArguments(); + unit.emit(")"); } - protected int emitModifiers(final PrintWriter writer) { + protected int emitModifiers() { int numEmitted = 0; for (final Iterator<EmissionModifier> it = getModifiers(); it.hasNext(); ) { - writer.print(it.next()); + unit.emit(it.next().toString()); ++numEmitted; if (it.hasNext()) { - writer.print(" "); + unit.emit(" "); } } return numEmitted; @@ -196,11 +190,11 @@ public abstract class FunctionEmitter { protected String getCommentStartString() { return "/* "; } protected String getCommentEndString() { return " */"; } - protected abstract void emitReturnType(PrintWriter writer); - protected abstract void emitName(PrintWriter writer); + protected abstract void emitReturnType(); + protected abstract void emitName(); /** Returns the number of arguments emitted. */ - protected abstract int emitArguments(PrintWriter writer); - protected abstract void emitBody(PrintWriter writer); + protected abstract int emitArguments(); + protected abstract void emitBody(); public static class EmissionModifier { diff --git a/src/java/com/jogamp/gluegen/JavaMethodBindingEmitter.java b/src/java/com/jogamp/gluegen/JavaMethodBindingEmitter.java index d3fca14..e7903fe 100644 --- a/src/java/com/jogamp/gluegen/JavaMethodBindingEmitter.java +++ b/src/java/com/jogamp/gluegen/JavaMethodBindingEmitter.java @@ -1,4 +1,5 @@ /* + * Copyright (c) 2010-2023 JogAmp Community. All rights reserved. * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved. * * Redistribution and use in source and binary forms, with or without @@ -52,9 +53,7 @@ import java.util.Iterator; import java.util.List; import java.util.Set; -/** - * An emitter that emits only the interface for a Java<->C JNI binding. - */ +/** Emits the Java-side component (interface and.or implementation) of the Java<->C JNI binding to its {@link CodeUnit}, see {@link FunctionEmitter}. */ public class JavaMethodBindingEmitter extends FunctionEmitter { public static final EmissionModifier PUBLIC = new EmissionModifier("public"); @@ -69,7 +68,6 @@ public class JavaMethodBindingEmitter extends FunctionEmitter { protected final CommentEmitter defaultInterfaceCommentEmitter = new InterfaceCommentEmitter(); protected final boolean tagNativeBinding; protected final boolean useNIODirectOnly; - protected final MethodBinding binding; // Exception type raised in the generated code if runtime checks fail private final String runtimeExceptionType; @@ -101,7 +99,7 @@ public class JavaMethodBindingEmitter extends FunctionEmitter { private static final String COMPOUND_ARRAY_SUFFIX = "_buf_array_copy"; public JavaMethodBindingEmitter(final MethodBinding binding, - final PrintWriter output, + final CodeUnit unit, final String runtimeExceptionType, final String unsupportedExceptionType, final boolean emitBody, @@ -115,8 +113,7 @@ public class JavaMethodBindingEmitter extends FunctionEmitter { final boolean isInterface, final boolean isNativeMethod, final boolean isPrivateNativeMethod, final JavaConfiguration configuration) { - super(output, isInterface, configuration); - this.binding = binding; + super(binding, unit, isInterface, configuration); this.runtimeExceptionType = runtimeExceptionType; this.unsupportedExceptionType = unsupportedExceptionType; this.emitBody = emitBody; @@ -139,7 +136,6 @@ public class JavaMethodBindingEmitter extends FunctionEmitter { public JavaMethodBindingEmitter(final JavaMethodBindingEmitter arg) { super(arg); - binding = arg.binding; runtimeExceptionType = arg.runtimeExceptionType; unsupportedExceptionType = arg.unsupportedExceptionType; emitBody = arg.emitBody; @@ -158,8 +154,6 @@ public class JavaMethodBindingEmitter extends FunctionEmitter { returnedArrayLengthExpressionOnlyForComments = arg.returnedArrayLengthExpressionOnlyForComments; } - public final MethodBinding getBinding() { return binding; } - public boolean isNativeMethod() { return isNativeMethod; } public boolean isPrivateNativeMethod() { return isPrivateNativeMethod; } public boolean isForDirectBufferImplementation() { return forDirectBufferImplementation; } @@ -263,8 +257,8 @@ public class JavaMethodBindingEmitter extends FunctionEmitter { } @Override - protected void emitReturnType(final PrintWriter writer) { - writer.print(getReturnTypeString(false)); + protected void emitReturnType() { + unit.emit(getReturnTypeString(false)); } protected String erasedTypeString(final JavaType type, final boolean skipBuffers) { @@ -336,25 +330,33 @@ public class JavaMethodBindingEmitter extends FunctionEmitter { } @Override - protected void emitName(final PrintWriter writer) { + protected void emitName() { if (isPrivateNativeMethod) { - writer.print(getNativeImplMethodName()); + unit.emit(getNativeImplMethodName()); } else if( isInterface()) { - writer.print(getInterfaceName()); + unit.emit(getInterfaceName()); } else { - writer.print(getImplName()); + unit.emit(getImplName()); } } @Override - protected int emitArguments(final PrintWriter writer) { + protected int emitArguments() { boolean needComma = false; int numEmitted = 0; + if( hasModifier(JavaMethodBindingEmitter.NATIVE) && binding.isReturnCompoundByValue() ) { + unit.emit("final Class<?> _clazzBuffers"); + ++numEmitted; + needComma = true; + } if (isPrivateNativeMethod && binding.hasContainingType()) { // Always emit outgoing "this" argument - writer.print("ByteBuffer "); - writer.print(javaThisArgumentName()); + if (needComma) { + unit.emit(", "); + } + unit.emit("ByteBuffer "); + unit.emit(javaThisArgumentName()); ++numEmitted; needComma = true; } @@ -378,12 +380,12 @@ public class JavaMethodBindingEmitter extends FunctionEmitter { } if (needComma) { - writer.print(", "); + unit.emit(", "); } - writer.print(erasedTypeString(type, false)); - writer.print(" "); - writer.print(getArgumentName(i)); + unit.emit(erasedTypeString(type, false)); + unit.emit(" "); + unit.emit(getArgumentName(i)); ++numEmitted; needComma = true; @@ -391,12 +393,12 @@ public class JavaMethodBindingEmitter extends FunctionEmitter { // Add Buffer and array index offset arguments after each associated argument if (forDirectBufferImplementation || forIndirectBufferAndArrayImplementation) { if (type.isNIOBuffer()) { - writer.print(", int " + byteOffsetArgName(i)); + unit.emit(", int " + byteOffsetArgName(i)); if(!useNIODirectOnly) { - writer.print(", boolean " + isNIOArgName(i)); + unit.emit(", boolean " + isNIOArgName(i)); } } else if (type.isNIOBufferArray()) { - writer.print(", int[] " + byteOffsetArrayArgName(i)); + unit.emit(", int[] " + byteOffsetArrayArgName(i)); } } @@ -405,7 +407,7 @@ public class JavaMethodBindingEmitter extends FunctionEmitter { if(useNIOOnly) { throw new RuntimeException("NIO[Direct]Only "+binding+" is set, but "+getArgumentName(i)+" is a primitive array"); } - writer.print(", int " + offsetArgName(i)); + unit.emit(", int " + offsetArgName(i)); } } return numEmitted; @@ -441,46 +443,46 @@ public class JavaMethodBindingEmitter extends FunctionEmitter { } @Override - protected void emitBody(final PrintWriter writer) { + protected void emitBody() { if (!emitBody) { - writer.println(';'); + unit.emitln(";"); } else { final MethodBinding mBinding = getBinding(); - writer.println(" {"); - writer.println(); + unit.emitln(" {"); + unit.emitln(); if (isUnimplemented) { - writer.println(" throw new " + getUnsupportedExceptionType() + "(\"Unimplemented\");"); + unit.emitln(" throw new " + getUnsupportedExceptionType() + "(\"Unimplemented\");"); } else { - emitPrologueOrEpilogue(prologue, writer); - emitPreCallSetup(mBinding, writer); + emitPrologueOrEpilogue(prologue); + emitPreCallSetup(mBinding); //emitReturnVariableSetup(binding, writer); - emitReturnVariableSetupAndCall(mBinding, writer); + emitReturnVariableSetupAndCall(mBinding); } - writer.println(" }"); + unit.emitln(" }"); } } - protected void emitPrologueOrEpilogue(final List<String> code, final PrintWriter writer) { + protected void emitPrologueOrEpilogue(final List<String> code) { if (code != null) { final String[] argumentNames = argumentNameArray(); for (final String str : code) { try { final MessageFormat fmt = new MessageFormat(str); - writer.println(" " + fmt.format(argumentNames)); + unit.emitln(" " + fmt.format(argumentNames)); } catch (final IllegalArgumentException e) { // (Poorly) handle case where prologue / epilogue contains blocks of code with braces - writer.println(" " + str); + unit.emitln(" " + str); } } } } - protected void emitPreCallSetup(final MethodBinding binding, final PrintWriter writer) { - emitArrayLengthAndNIOBufferChecks(binding, writer); - emitCompoundArrayCopies(binding, writer); + protected void emitPreCallSetup(final MethodBinding binding) { + emitArrayLengthAndNIOBufferChecks(binding); + emitCompoundArrayCopies(binding); } - protected void emitArrayLengthAndNIOBufferChecks(final MethodBinding binding, final PrintWriter writer) { + protected void emitArrayLengthAndNIOBufferChecks(final MethodBinding binding) { // Check lengths of any incoming arrays if necessary for (int i = 0; i < binding.getNumArguments(); i++) { final Type type = binding.getCArgumentType(i); @@ -489,58 +491,58 @@ public class JavaMethodBindingEmitter extends FunctionEmitter { // Simply add a range check upfront final ArrayType arrayType = type.asArray(); if (javaType.isNIOBuffer()) { - writer.println(" if ( Buffers.remainingElem("+getArgumentName(i)+") < " + arrayType.getLength() + ")"); + unit.emitln(" if ( Buffers.remainingElem("+getArgumentName(i)+") < " + arrayType.getLength() + ")"); } else { - writer.println(" if ( "+getArgumentName(i)+".length < " + arrayType.getLength() + ")"); + unit.emitln(" if ( "+getArgumentName(i)+".length < " + arrayType.getLength() + ")"); } - writer.print(" throw new " + getRuntimeExceptionType() + + unit.emit(" throw new " + getRuntimeExceptionType() + "(\"Array \\\"" + getArgumentName(i) + "\\\" length (\" + "); if (javaType.isNIOBuffer()) { - writer.print("Buffers.remainingElem("+getArgumentName(i)+")"); + unit.emit("Buffers.remainingElem("+getArgumentName(i)+")"); } else { - writer.print(getArgumentName(i)+".length"); + unit.emit(getArgumentName(i)+".length"); } - writer.println("+ \") was less than the required (" + arrayType.getLength() + ")\");"); + unit.emitln("+ \") was less than the required (" + arrayType.getLength() + ")\");"); } if (javaType.isNIOBuffer()) { if (useNIODirectOnly) { - writer.println(" if (!Buffers.isDirect(" + getArgumentName(i) + "))"); - writer.println(" throw new " + getRuntimeExceptionType() + "(\"Argument \\\"" + + unit.emitln(" if (!Buffers.isDirect(" + getArgumentName(i) + "))"); + unit.emitln(" throw new " + getRuntimeExceptionType() + "(\"Argument \\\"" + getArgumentName(i) + "\\\" is not a direct buffer\");"); } else { - writer.println(" final boolean " + isNIOArgName(i) + " = Buffers.isDirect(" + getArgumentName(i) + ");"); + unit.emitln(" final boolean " + isNIOArgName(i) + " = Buffers.isDirect(" + getArgumentName(i) + ");"); } } else if (javaType.isNIOBufferArray()) { // All buffers passed down in an array of NIO buffers must be direct final String argName = getArgumentName(i); final String arrayName = byteOffsetArrayArgName(i); - writer.println(" final int[] " + arrayName + " = new int[" + argName + ".length];"); + unit.emitln(" final int[] " + arrayName + " = new int[" + argName + ".length];"); // Check direct buffer properties of all buffers within - writer.println(" if (" + argName + " != null) {"); - writer.println(" for (int _ctr = 0; _ctr < " + argName + ".length; _ctr++) {"); - writer.println(" if (!Buffers.isDirect(" + argName + "[_ctr])) {"); - writer.println(" throw new " + getRuntimeExceptionType() + + unit.emitln(" if (" + argName + " != null) {"); + unit.emitln(" for (int _ctr = 0; _ctr < " + argName + ".length; _ctr++) {"); + unit.emitln(" if (!Buffers.isDirect(" + argName + "[_ctr])) {"); + unit.emitln(" throw new " + getRuntimeExceptionType() + "(\"Element \" + _ctr + \" of argument \\\"" + getArgumentName(i) + "\\\" was not a direct buffer\");"); - writer.println(" }"); + unit.emitln(" }"); // get the Buffer Array offset values and save them into another array to send down to JNI - writer.print (" " + arrayName + "[_ctr] = Buffers.getDirectBufferByteOffset("); - writer.println(argName + "[_ctr]);"); - writer.println(" }"); - writer.println(" }"); + unit.emit (" " + arrayName + "[_ctr] = Buffers.getDirectBufferByteOffset("); + unit.emitln(argName + "[_ctr]);"); + unit.emitln(" }"); + unit.emitln(" }"); } else if (javaType.isPrimitiveArray()) { final String argName = getArgumentName(i); final String offsetArg = offsetArgName(i); - writer.println(" if(" + argName + " != null && " + argName + ".length <= " + offsetArg + ")"); - writer.print (" throw new " + getRuntimeExceptionType()); - writer.println("(\"array offset argument \\\"" + offsetArg + "\\\" (\" + " + offsetArg + + unit.emitln(" if(" + argName + " != null && " + argName + ".length <= " + offsetArg + ")"); + unit.emit (" throw new " + getRuntimeExceptionType()); + unit.emitln("(\"array offset argument \\\"" + offsetArg + "\\\" (\" + " + offsetArg + " + \") equals or exceeds array length (\" + " + argName + ".length + \")\");"); } } } - protected void emitCompoundArrayCopies(final MethodBinding binding, final PrintWriter writer) { + protected void emitCompoundArrayCopies(final MethodBinding binding) { // If the method binding uses outgoing arrays of compound type // wrappers, we need to generate a temporary copy of this array // into a ByteBuffer[] for processing by the native code @@ -550,73 +552,81 @@ public class JavaMethodBindingEmitter extends FunctionEmitter { if (javaType.isArrayOfCompoundTypeWrappers()) { final String argName = getArgumentName(i); final String tempArrayName = argName + COMPOUND_ARRAY_SUFFIX; - writer.println(" final ByteBuffer[] " + tempArrayName + " = new ByteBuffer[" + argName + ".length];"); - writer.println(" for (int _ctr = 0; _ctr < + " + argName + ".length; _ctr++) {"); - writer.println(" " + javaType.getName() + " _tmp = " + argName + "[_ctr];"); - writer.println(" " + tempArrayName + "[_ctr] = ((_tmp == null) ? null : _tmp.getBuffer());"); - writer.println(" }"); + unit.emitln(" final ByteBuffer[] " + tempArrayName + " = new ByteBuffer[" + argName + ".length];"); + unit.emitln(" for (int _ctr = 0; _ctr < + " + argName + ".length; _ctr++) {"); + unit.emitln(" " + javaType.getName() + " _tmp = " + argName + "[_ctr];"); + unit.emitln(" " + tempArrayName + "[_ctr] = ((_tmp == null) ? null : _tmp.getBuffer());"); + unit.emitln(" }"); } } } } - protected void emitCall(final MethodBinding binding, final PrintWriter writer) { - writer.print(getNativeImplMethodName()); - writer.print("("); - emitCallArguments(binding, writer); - writer.print(");"); + protected void emitCall(final MethodBinding binding) { + unit.emit(getNativeImplMethodName()); + unit.emit("("); + emitCallArguments(binding); + unit.emit(");"); } - protected void emitReturnVariableSetupAndCall(final MethodBinding binding, final PrintWriter writer) { - writer.print(" "); + protected void emitReturnVariableSetupAndCall(final MethodBinding binding) { + unit.emit(" "); final JavaType returnType = binding.getJavaReturnType(); boolean needsResultAssignment = false; if (!returnType.isVoid()) { if (returnType.isCompoundTypeWrapper() || returnType.isNIOBuffer()) { - writer.println("final ByteBuffer _res;"); + unit.emitln("final ByteBuffer _res;"); needsResultAssignment = true; } else if (returnType.isArrayOfCompoundTypeWrappers()) { - writer.println("final ByteBuffer[] _res;"); + unit.emitln("final ByteBuffer[] _res;"); needsResultAssignment = true; } else if (((epilogue != null) && (epilogue.size() > 0)) || binding.signatureUsesArraysOfCompoundTypeWrappers()) { - writer.print("final "); - emitReturnType(writer); - writer.println(" _res;"); + unit.emit("final "); + emitReturnType(); + unit.emitln(" _res;"); needsResultAssignment = true; } } if (needsResultAssignment) { - writer.print(" _res = "); + unit.emit(" _res = "); } else { - writer.print(" "); + unit.emit(" "); if (!returnType.isVoid()) { - writer.print("return "); + unit.emit("return "); } } - emitCall(binding, writer); - writer.println(); + emitCall(binding); + unit.emitln(); - emitPostCallCleanup(binding, writer); - emitPrologueOrEpilogue(epilogue, writer); + emitPostCallCleanup(binding); + emitPrologueOrEpilogue(epilogue); if (needsResultAssignment) { - emitCallResultReturn(binding, writer); + emitCallResultReturn(binding); } } - protected int emitCallArguments(final MethodBinding binding, final PrintWriter writer) { + protected int emitCallArguments(final MethodBinding binding) { boolean needComma = false; int numArgsEmitted = 0; + if( binding.isReturnCompoundByValue() ) { + unit.emit("com.jogamp.common.nio.Buffers.class"); + needComma = true; + ++numArgsEmitted; + } if (binding.hasContainingType()) { // Emit this pointer assert(binding.getContainingType().isCompoundTypeWrapper()); - writer.print("getBuffer()"); + if (needComma) { + unit.emit(", "); + } + unit.emit("getBuffer()"); needComma = true; ++numArgsEmitted; } @@ -635,81 +645,81 @@ public class JavaMethodBindingEmitter extends FunctionEmitter { } if (needComma) { - writer.print(", "); + unit.emit(", "); } if (type.isCompoundTypeWrapper()) { - writer.print("(("); + unit.emit("(("); } if (type.isNIOBuffer()) { if(type.isNIOPointerBuffer()) { if (useNIODirectOnly) { - writer.print( getArgumentName(i)+ " != null ? " + getArgumentName(i) + ".getBuffer() : null"); + unit.emit( getArgumentName(i)+ " != null ? " + getArgumentName(i) + ".getBuffer() : null"); } else { - writer.print( isNIOArgName(i) + " ? ( " + getArgumentName(i)+ " != null ? " + getArgumentName(i) + ".getBuffer() : null )"); - writer.print( " : Buffers.getArray(" + getArgumentName(i) + ")" ); + unit.emit( isNIOArgName(i) + " ? ( " + getArgumentName(i)+ " != null ? " + getArgumentName(i) + ".getBuffer() : null )"); + unit.emit( " : Buffers.getArray(" + getArgumentName(i) + ")" ); } } else { if (useNIODirectOnly) { - writer.print( getArgumentName(i) ); + unit.emit( getArgumentName(i) ); } else { - writer.print( isNIOArgName(i) + " ? " + getArgumentName(i) + " : Buffers.getArray(" + getArgumentName(i) + ")" ); + unit.emit( isNIOArgName(i) + " ? " + getArgumentName(i) + " : Buffers.getArray(" + getArgumentName(i) + ")" ); } } } else if (type.isArrayOfCompoundTypeWrappers()) { - writer.print(getArgumentName(i) + COMPOUND_ARRAY_SUFFIX); + unit.emit(getArgumentName(i) + COMPOUND_ARRAY_SUFFIX); } else { - writer.print(getArgumentName(i)); + unit.emit(getArgumentName(i)); } if (type.isCompoundTypeWrapper()) { - writer.print(" == null) ? null : "); - writer.print(getArgumentName(i)); - writer.print(".getBuffer())"); + unit.emit(" == null) ? null : "); + unit.emit(getArgumentName(i)); + unit.emit(".getBuffer())"); } if (type.isNIOBuffer()) { if (useNIODirectOnly) { - writer.print( ", Buffers.getDirectBufferByteOffset(" + getArgumentName(i) + ")"); + unit.emit( ", Buffers.getDirectBufferByteOffset(" + getArgumentName(i) + ")"); } else { - writer.print( ", " + isNIOArgName(i) + " ? Buffers.getDirectBufferByteOffset(" + getArgumentName(i) + ")"); - writer.print( " : Buffers.getIndirectBufferByteOffset(" + getArgumentName(i) + ")"); + unit.emit( ", " + isNIOArgName(i) + " ? Buffers.getDirectBufferByteOffset(" + getArgumentName(i) + ")"); + unit.emit( " : Buffers.getIndirectBufferByteOffset(" + getArgumentName(i) + ")"); } } else if (type.isNIOBufferArray()) { - writer.print(", " + byteOffsetArrayArgName(i)); + unit.emit(", " + byteOffsetArrayArgName(i)); } else if (type.isPrimitiveArray()) { if(type.isFloatArray()) { - writer.print(", Buffers.SIZEOF_FLOAT * "); + unit.emit(", Buffers.SIZEOF_FLOAT * "); } else if(type.isDoubleArray()) { - writer.print(", Buffers.SIZEOF_DOUBLE * "); + unit.emit(", Buffers.SIZEOF_DOUBLE * "); } else if(type.isByteArray()) { - writer.print(", "); + unit.emit(", "); } else if(type.isLongArray()) { - writer.print(", Buffers.SIZEOF_LONG * "); + unit.emit(", Buffers.SIZEOF_LONG * "); } else if(type.isShortArray()) { - writer.print(", Buffers.SIZEOF_SHORT * "); + unit.emit(", Buffers.SIZEOF_SHORT * "); } else if(type.isIntArray()) { - writer.print(", Buffers.SIZEOF_INT * "); + unit.emit(", Buffers.SIZEOF_INT * "); } else { throw new GlueGenException("Unsupported type for calculating array offset argument for " + getArgumentName(i) + " -- error occurred while processing Java glue code for " + getCSymbol().getAliasedString(), getCSymbol().getASTLocusTag()); } - writer.print(offsetArgName(i)); + unit.emit(offsetArgName(i)); } if (type.isNIOBuffer()) { if (!useNIODirectOnly) { - writer.print( ", " + isNIOArgName(i) ); + unit.emit( ", " + isNIOArgName(i) ); } } else if (type.isPrimitiveArray()) { if (useNIOOnly) { throw new GlueGenException("NIO[Direct]Only "+binding+" is set, but "+getArgumentName(i)+" is a primitive array", getCSymbol().getASTLocusTag()); } - writer.print( ", false"); + unit.emit( ", false"); } needComma = true; @@ -718,7 +728,7 @@ public class JavaMethodBindingEmitter extends FunctionEmitter { return numArgsEmitted; } - protected void emitPostCallCleanup(final MethodBinding binding, final PrintWriter writer) { + protected void emitPostCallCleanup(final MethodBinding binding) { if (binding.signatureUsesArraysOfCompoundTypeWrappers()) { // For each such array, we need to take the ByteBuffer[] that // came back from the C method invocation and wrap the @@ -727,65 +737,65 @@ public class JavaMethodBindingEmitter extends FunctionEmitter { final JavaType javaArgType = binding.getJavaArgumentType(i); if ( javaArgType.isArrayOfCompoundTypeWrappers() && !javaArgType.getElementCType().isBaseTypeConst() ) { final String argName = binding.getArgumentName(i); - writer.println(" for (int _ctr = 0; _ctr < " + argName + ".length; _ctr++) {"); - writer.println(" if ((" + argName + "[_ctr] == null && " + argName + COMPOUND_ARRAY_SUFFIX + "[_ctr] == null) ||"); - writer.println(" (" + argName + "[_ctr] != null && " + argName + "[_ctr].getBuffer() == " + argName + COMPOUND_ARRAY_SUFFIX + "[_ctr])) {"); - writer.println(" // No copy back needed"); - writer.println(" } else {"); - writer.println(" if (" + argName + COMPOUND_ARRAY_SUFFIX + "[_ctr] == null) {"); - writer.println(" " + argName + "[_ctr] = null;"); - writer.println(" } else {"); - writer.println(" " + argName + "[_ctr] = " + javaArgType.getName() + ".create(" + argName + COMPOUND_ARRAY_SUFFIX + "[_ctr]);"); - writer.println(" }"); - writer.println(" }"); - writer.println(" }"); + unit.emitln(" for (int _ctr = 0; _ctr < " + argName + ".length; _ctr++) {"); + unit.emitln(" if ((" + argName + "[_ctr] == null && " + argName + COMPOUND_ARRAY_SUFFIX + "[_ctr] == null) ||"); + unit.emitln(" (" + argName + "[_ctr] != null && " + argName + "[_ctr].getBuffer() == " + argName + COMPOUND_ARRAY_SUFFIX + "[_ctr])) {"); + unit.emitln(" // No copy back needed"); + unit.emitln(" } else {"); + unit.emitln(" if (" + argName + COMPOUND_ARRAY_SUFFIX + "[_ctr] == null) {"); + unit.emitln(" " + argName + "[_ctr] = null;"); + unit.emitln(" } else {"); + unit.emitln(" " + argName + "[_ctr] = " + javaArgType.getName() + ".create(" + argName + COMPOUND_ARRAY_SUFFIX + "[_ctr]);"); + unit.emitln(" }"); + unit.emitln(" }"); + unit.emitln(" }"); } } } } - protected void emitCallResultReturn(final MethodBinding binding, final PrintWriter writer) { + protected void emitCallResultReturn(final MethodBinding binding) { final JavaType returnType = binding.getJavaReturnType(); if (returnType.isCompoundTypeWrapper()) { // Details are handled in JavaEmitter's struct handling! - writer.println(" if (_res == null) return null;"); - writer.println(" return " + returnType.getName() + ".create(Buffers.nativeOrder(_res));"); + unit.emitln(" if (_res == null) return null;"); + unit.emitln(" return " + returnType.getName() + ".create(Buffers.nativeOrder(_res));"); } else if (returnType.isNIOBuffer()) { - writer.println(" if (_res == null) return null;"); - writer.println(" Buffers.nativeOrder(_res);"); + unit.emitln(" if (_res == null) return null;"); + unit.emitln(" Buffers.nativeOrder(_res);"); if (!returnType.isNIOByteBuffer()) { // See whether we have to expand pointers to longs if (getBinding().getCReturnType().pointerDepth() >= 2) { if (returnType.isNIOPointerBuffer()) { - writer.println(" return PointerBuffer.wrap(_res);"); + unit.emitln(" return PointerBuffer.wrap(_res);"); } else if (returnType.isNIOLongBuffer()) { - writer.println(" return _res.asLongBuffer();"); + unit.emitln(" return _res.asLongBuffer();"); } else { throw new GlueGenException("While emitting glue code for " + getCSymbol().getAliasedString() + ": can not legally make pointers opaque to anything but PointerBuffer or LongBuffer/long", getCSymbol().getASTLocusTag()); } } else if (getBinding().getCReturnType().pointerDepth() == 1 && returnType.isNIOLongBuffer()) { - writer.println(" return _res.asLongBuffer();"); + unit.emitln(" return _res.asLongBuffer();"); } else { final String returnTypeName = returnType.getName().substring("java.nio.".length()); - writer.println(" return _res.as" + returnTypeName + "();"); + unit.emitln(" return _res.as" + returnTypeName + "();"); } } else { - writer.println(" return _res;"); + unit.emitln(" return _res;"); } } else if (returnType.isArrayOfCompoundTypeWrappers()) { - writer.println(" if (_res == null) return null;"); - writer.println(" final " + getReturnTypeString(false) + " _retarray = new " + getReturnTypeString(true) + "[_res.length];"); - writer.println(" for (int _count = 0; _count < _res.length; _count++) {"); - writer.println(" _retarray[_count] = " + getReturnTypeString(true) + ".create(_res[_count]);"); - writer.println(" }"); - writer.println(" return _retarray;"); + unit.emitln(" if (_res == null) return null;"); + unit.emitln(" final " + getReturnTypeString(false) + " _retarray = new " + getReturnTypeString(true) + "[_res.length];"); + unit.emitln(" for (int _count = 0; _count < _res.length; _count++) {"); + unit.emitln(" _retarray[_count] = " + getReturnTypeString(true) + ".create(_res[_count]);"); + unit.emitln(" }"); + unit.emitln(" return _retarray;"); } else { // Assume it's a primitive type or other type we don't have to // do any conversion on - writer.println(" return _res;"); + unit.emitln(" return _res;"); } } diff --git a/src/java/com/jogamp/gluegen/MethodBinding.java b/src/java/com/jogamp/gluegen/MethodBinding.java index 95a10c6..efa938f 100644 --- a/src/java/com/jogamp/gluegen/MethodBinding.java +++ b/src/java/com/jogamp/gluegen/MethodBinding.java @@ -1,4 +1,5 @@ /* + * Copyright (c) 2010-2023 JogAmp Community. All rights reserved. * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved. * * Redistribution and use in source and binary forms, with or without @@ -155,6 +156,17 @@ public class MethodBinding { return sym.getArgumentType(i); } + public final boolean isReturnCompoundByValue() { + final Type cReturnType = getCReturnType(); + if (cReturnType.isVoid()) { + return false; + } + if (javaReturnType.isPrimitive()) { + return false; + } + return !cReturnType.isPointer() && javaReturnType.isCompoundTypeWrapper(); + } + /** Returns the {@link FunctionSymbol}. */ public FunctionSymbol getCSymbol() { return sym; diff --git a/src/java/com/jogamp/gluegen/cgram/types/CompoundType.java b/src/java/com/jogamp/gluegen/cgram/types/CompoundType.java index 56bcdda..fea2446 100644 --- a/src/java/com/jogamp/gluegen/cgram/types/CompoundType.java +++ b/src/java/com/jogamp/gluegen/cgram/types/CompoundType.java @@ -179,6 +179,16 @@ public abstract class CompoundType extends MemoryLayoutType implements Cloneable return fields.get(i); } + /** Returns the <i>name</i> matching field of this type. */ + public Field getField(final String name) { + for(final Field f : fields ) { + if( f.getName().equals(name) ) { + return f; + } + } + return null; + } + /** Adds a field to this type. */ public void addField(final Field f) { if (bodyParsed) { diff --git a/src/java/com/jogamp/gluegen/procaddress/ProcAddressCMethodBindingEmitter.java b/src/java/com/jogamp/gluegen/procaddress/ProcAddressCMethodBindingEmitter.java index 37a39e1..c3c374f 100644 --- a/src/java/com/jogamp/gluegen/procaddress/ProcAddressCMethodBindingEmitter.java +++ b/src/java/com/jogamp/gluegen/procaddress/ProcAddressCMethodBindingEmitter.java @@ -1,4 +1,5 @@ /* + * Copyright (c) 2010-2023 JogAmp Community. All rights reserved. * Copyright (c) 2003-2005 Sun Microsystems, Inc. All Rights Reserved. * * Redistribution and use in source and binary forms, with or without @@ -40,12 +41,11 @@ package com.jogamp.gluegen.procaddress; import com.jogamp.gluegen.CMethodBindingEmitter; -import com.jogamp.gluegen.MethodBinding; import com.jogamp.gluegen.JavaType; - -import java.io.*; - -import com.jogamp.gluegen.cgram.types.*; +import com.jogamp.gluegen.MethodBinding; +import com.jogamp.gluegen.cgram.types.FunctionSymbol; +import com.jogamp.gluegen.cgram.types.PointerType; +import com.jogamp.gluegen.cgram.types.Type; public class ProcAddressCMethodBindingEmitter extends CMethodBindingEmitter { @@ -74,7 +74,7 @@ public class ProcAddressCMethodBindingEmitter extends CMethodBindingEmitter { } } }, - methodToWrap.getDefaultOutput(), + methodToWrap.getUnit(), methodToWrap.getJavaPackageName(), methodToWrap.getJavaClassName(), methodToWrap.getIsOverloadedBinding(), @@ -102,14 +102,14 @@ public class ProcAddressCMethodBindingEmitter extends CMethodBindingEmitter { } @Override - protected int emitArguments(final PrintWriter writer) { - int numEmitted = super.emitArguments(writer); + protected int emitArguments() { + int numEmitted = super.emitArguments(); if (callThroughProcAddress) { if (numEmitted > 0) { - writer.print(", "); + unit.emit(", "); } - writer.print(procAddressJavaTypeName); - writer.print(" procAddress"); + unit.emit(procAddressJavaTypeName); + unit.emit(" procAddress"); ++numEmitted; } @@ -117,7 +117,7 @@ public class ProcAddressCMethodBindingEmitter extends CMethodBindingEmitter { } @Override - protected void emitBodyVariableDeclarations(final PrintWriter writer) { + protected void emitBodyVariableDeclarations() { if (callThroughProcAddress) { // create variable for the function pointer with the right type, and set // it to the value of the passed-in proc address @@ -138,23 +138,23 @@ public class ProcAddressCMethodBindingEmitter extends CMethodBindingEmitter { } final PointerType funcPtrType = new PointerType(null, cSym.getType(), 0); - writer.print(" typedef "); - writer.print(funcPtrType.toString(funcPointerTypedefLocalName, localTypedefCallingConvention)); - writer.println(";"); + unit.emit(" typedef "); + unit.emit(funcPtrType.toString(funcPointerTypedefLocalName, localTypedefCallingConvention)); + unit.emitln(";"); - writer.print(" "); - writer.print(funcPointerTypedefName); // Uses public typedef if available! - writer.print(" ptr_"); - writer.print(getNativeName()); - writer.println(";"); + unit.emit(" "); + unit.emit(funcPointerTypedefName); // Uses public typedef if available! + unit.emit(" ptr_"); + unit.emit(getNativeName()); + unit.emitln(";"); } - super.emitBodyVariableDeclarations(writer); + super.emitBodyVariableDeclarations(); } @Override - protected void emitBodyVariablePreCallSetup(final PrintWriter writer) { - super.emitBodyVariablePreCallSetup(writer); + protected void emitBodyVariablePreCallSetup() { + super.emitBodyVariablePreCallSetup(); if (callThroughProcAddress) { // set the function pointer to the value of the passed-in procAddress @@ -171,25 +171,25 @@ public class ProcAddressCMethodBindingEmitter extends CMethodBindingEmitter { final String ptrVarName = "ptr_" + getNativeName(); if (hasProcAddrTypedef) { - writer.println(" // implicit type validation of "+funcPointerTypedefLocalName+" -> "+funcPointerTypedefName); + unit.emitln(" // implicit type validation of "+funcPointerTypedefLocalName+" -> "+funcPointerTypedefName); } - writer.print(" "); - writer.print(ptrVarName); - writer.print(" = ("); - writer.print(funcPointerTypedefLocalName); - writer.println(") (intptr_t) procAddress;"); + unit.emit(" "); + unit.emit(ptrVarName); + unit.emit(" = ("); + unit.emit(funcPointerTypedefLocalName); + unit.emitln(") (intptr_t) procAddress;"); - writer.println(" assert(" + ptrVarName + " != NULL);"); + unit.emitln(" assert(" + ptrVarName + " != NULL);"); } } @Override - protected void emitBodyCallCFunction(final PrintWriter writer) { + protected void emitBodyCallCFunction() { if (!callThroughProcAddress) { - super.emitBodyCallCFunction(writer); + super.emitBodyCallCFunction(); } else { // Make the call to the actual C function - writer.print(" "); + unit.emit(" "); // WARNING: this code assumes that the return type has already been // typedef-resolved. @@ -199,9 +199,9 @@ public class ProcAddressCMethodBindingEmitter extends CMethodBindingEmitter { // Note we respect const/volatile in the function return type. // However, we cannot have it 'const' for our local variable. // See return type in CMethodBindingEmitter.emitBodyVariableDeclarations(..)! - writer.print("_res = ("); - writer.print(cReturnType.getCName(false)); - writer.print(") "); + unit.emit("_res = ("); + unit.emit(cReturnType.getCName(false)); + unit.emit(") "); } final MethodBinding mBinding = getBinding(); if (mBinding.hasContainingType()) { @@ -211,12 +211,12 @@ public class ProcAddressCMethodBindingEmitter extends CMethodBindingEmitter { } // call throught the run-time function pointer - writer.print("(* ptr_"); - writer.print(getNativeName()); - writer.print(") "); - writer.print("("); - emitBodyPassCArguments(writer); - writer.println(");"); + unit.emit("(* ptr_"); + unit.emit(getNativeName()); + unit.emit(") "); + unit.emit("("); + emitBodyPassCArguments(); + unit.emitln(");"); } } diff --git a/src/java/com/jogamp/gluegen/procaddress/ProcAddressEmitter.java b/src/java/com/jogamp/gluegen/procaddress/ProcAddressEmitter.java index ec29b08..b812416 100644 --- a/src/java/com/jogamp/gluegen/procaddress/ProcAddressEmitter.java +++ b/src/java/com/jogamp/gluegen/procaddress/ProcAddressEmitter.java @@ -1,6 +1,6 @@ /* + * Copyright (c) 2010-2023 JogAmp Community. All rights reserved. * Copyright (c) 2003-2005 Sun Microsystems, Inc. All Rights Reserved. - * Copyright (c) 2013 JogAmp Community. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are @@ -40,7 +40,6 @@ package com.jogamp.gluegen.procaddress; import java.io.File; -import java.io.PrintWriter; import java.text.MessageFormat; import java.util.ArrayList; import java.util.HashSet; @@ -52,6 +51,7 @@ import java.util.logging.Level; import com.jogamp.gluegen.CMethodBindingEmitter; import com.jogamp.gluegen.CodeGenUtils; import com.jogamp.gluegen.FunctionEmitter; +import com.jogamp.gluegen.JavaCodeUnit; import com.jogamp.gluegen.JavaConfiguration; import com.jogamp.gluegen.JavaEmitter; import com.jogamp.gluegen.JavaMethodBindingEmitter; @@ -72,7 +72,7 @@ public class ProcAddressEmitter extends JavaEmitter { public static final String PROCADDRESS_VAR_PREFIX = "_addressof_"; protected static final String WRAP_PREFIX = "dispatch_"; private TypeDictionary typedefDictionary; - protected PrintWriter tableWriter; + protected JavaCodeUnit tableJavaUnit; protected Set<String> emittedTableEntries; protected String tableClassPackage; protected String tableClassName; @@ -307,47 +307,47 @@ public class ProcAddressEmitter extends JavaEmitter { final String jImplRoot = getJavaOutputDir() + File.separator + CodeGenUtils.packageAsPath(implPackageName); - tableWriter = openFile(jImplRoot + File.separator + tableClassName + ".java", tableClassName); - emittedTableEntries = new HashSet<String>(); + final String javaFileName = jImplRoot + File.separator + tableClassName + ".java"; + tableJavaUnit = openJavaUnit(javaFileName, implPackageName, tableClassName); - CodeGenUtils.emitAutogeneratedWarning(tableWriter, this); + emittedTableEntries = new HashSet<String>(); - tableWriter.println("package " + implPackageName + ";"); - tableWriter.println(); + tableJavaUnit.emitln("package " + implPackageName + ";"); + tableJavaUnit.emitln(); for (final String imporT : getConfig().imports()) { - tableWriter.println("import " + imporT + ";"); + tableJavaUnit.emitln("import " + imporT + ";"); } - tableWriter.println("import " + ProcAddressTable.class.getName() + ";"); - tableWriter.println("import com.jogamp.common.util.SecurityUtil;"); - tableWriter.println(); - - tableWriter.println("/**"); - tableWriter.println(" * This table is a cache of pointers to the dynamically-linkable C library."); - tableWriter.println(" * @see " + ProcAddressTable.class.getSimpleName()); - tableWriter.println(" */"); + tableJavaUnit.emitln("import " + ProcAddressTable.class.getName() + ";"); + tableJavaUnit.emitln("import com.jogamp.common.util.SecurityUtil;"); + tableJavaUnit.emitln(); + + tableJavaUnit.emitln("/**"); + tableJavaUnit.emitln(" * This table is a cache of pointers to the dynamically-linkable C library."); + tableJavaUnit.emitln(" * @see " + ProcAddressTable.class.getSimpleName()); + tableJavaUnit.emitln(" */"); for (int i = 0; accessModifiers != null && i < accessModifiers.length; ++i) { - tableWriter.print(accessModifiers[i]); - tableWriter.print(' '); + tableJavaUnit.emit(accessModifiers[i]); + tableJavaUnit.emit(" "); } - tableWriter.println("final class " + tableClassName + " extends "+ ProcAddressTable.class.getSimpleName() + " {"); - tableWriter.println(); + tableJavaUnit.emitln("final class " + tableClassName + " extends "+ ProcAddressTable.class.getSimpleName() + " {"); + tableJavaUnit.emitln(); for (final String string : getProcAddressConfig().getForceProcAddressGen()) { emitProcAddressTableEntryForString(string); } - tableWriter.println(); - tableWriter.println(" public "+tableClassName+"(){ super(); }"); - tableWriter.println(); - tableWriter.println(" public "+tableClassName+"("+FunctionAddressResolver.class.getName()+" resolver){ super(resolver); }"); - tableWriter.println(); + tableJavaUnit.emitln(); + tableJavaUnit.emitln(" public "+tableClassName+"(){ super(); }"); + tableJavaUnit.emitln(); + tableJavaUnit.emitln(" public "+tableClassName+"("+FunctionAddressResolver.class.getName()+" resolver){ super(resolver); }"); + tableJavaUnit.emitln(); } protected void endProcAddressTable() throws Exception { - tableWriter.println("} // end of class " + tableClassName); - tableWriter.flush(); - tableWriter.close(); + tableJavaUnit.emitln("} // end of class " + tableClassName); + tableJavaUnit.close(); + tableJavaUnit = null; } protected void emitProcAddressTableEntryForString(final String str) { @@ -357,10 +357,10 @@ public class ProcAddressEmitter extends JavaEmitter { return; } emittedTableEntries.add(str); - tableWriter.print(" /* pp */ long "); - tableWriter.print(PROCADDRESS_VAR_PREFIX); - tableWriter.print(str); - tableWriter.println(";"); + tableJavaUnit.emit(" /* pp */ long "); + tableJavaUnit.emit(PROCADDRESS_VAR_PREFIX); + tableJavaUnit.emit(str); + tableJavaUnit.emitln(";"); } protected ProcAddressConfiguration getProcAddressConfig() { diff --git a/src/java/com/jogamp/gluegen/procaddress/ProcAddressJavaMethodBindingEmitter.java b/src/java/com/jogamp/gluegen/procaddress/ProcAddressJavaMethodBindingEmitter.java index 5298a8d..0d5de1c 100644 --- a/src/java/com/jogamp/gluegen/procaddress/ProcAddressJavaMethodBindingEmitter.java +++ b/src/java/com/jogamp/gluegen/procaddress/ProcAddressJavaMethodBindingEmitter.java @@ -1,4 +1,5 @@ /* + * Copyright (c) 2010-2023 JogAmp Community. All rights reserved. * Copyright (c) 2003-2005 Sun Microsystems, Inc. All Rights Reserved. * * Redistribution and use in source and binary forms, with or without @@ -90,15 +91,15 @@ public class ProcAddressJavaMethodBindingEmitter extends JavaMethodBindingEmitte } @Override - protected int emitArguments(final PrintWriter writer) { - int numEmitted = super.emitArguments(writer); + protected int emitArguments() { + int numEmitted = super.emitArguments(); if (callThroughProcAddress) { if (changeNameAndArguments) { if (numEmitted > 0) { - writer.print(", "); + unit.emit(", "); } - writer.print("long procAddress"); + unit.emit("long procAddress"); ++numEmitted; } } @@ -116,27 +117,27 @@ public class ProcAddressJavaMethodBindingEmitter extends JavaMethodBindingEmitte } @Override - protected void emitPreCallSetup(final MethodBinding binding, final PrintWriter writer) { - super.emitPreCallSetup(binding, writer); + protected void emitPreCallSetup(final MethodBinding binding) { + super.emitPreCallSetup(binding); if (callThroughProcAddress) { final String procAddressVariable = ProcAddressEmitter.PROCADDRESS_VAR_PREFIX + binding.getNativeName(); - writer.println(" final long __addr_ = " + getProcAddressTableExpr + "." + procAddressVariable + ";"); - writer.println(" if (__addr_ == 0) {"); - writer.format(" throw new %s(String.format(\"Method \\\"%%s\\\" not available\", \"%s\"));%n", + unit.emitln(" final long __addr_ = " + getProcAddressTableExpr + "." + procAddressVariable + ";"); + unit.emitln(" if (__addr_ == 0) {"); + unit.emitf(" throw new %s(String.format(\"Method \\\"%%s\\\" not available\", \"%s\"));%n", emitter.unsupportedExceptionType(), binding.getName()); - writer.println(" }"); + unit.emitln(" }"); } } @Override - protected int emitCallArguments(final MethodBinding binding, final PrintWriter writer) { - int numEmitted = super.emitCallArguments(binding, writer); + protected int emitCallArguments(final MethodBinding binding) { + int numEmitted = super.emitCallArguments(binding); if (callThroughProcAddress) { if (numEmitted > 0) { - writer.print(", "); + unit.emit(", "); } - writer.print("__addr_"); + unit.emit("__addr_"); ++numEmitted; } diff --git a/src/java/com/jogamp/gluegen/structgen/CStructAnnotationProcessor.java b/src/java/com/jogamp/gluegen/structgen/CStructAnnotationProcessor.java index 45293f8..13bf418 100644 --- a/src/java/com/jogamp/gluegen/structgen/CStructAnnotationProcessor.java +++ b/src/java/com/jogamp/gluegen/structgen/CStructAnnotationProcessor.java @@ -28,7 +28,9 @@ package com.jogamp.gluegen.structgen; import com.jogamp.common.util.PropertyAccess; +import com.jogamp.gluegen.CCodeUnit; import com.jogamp.gluegen.GlueGen; +import com.jogamp.gluegen.JavaCodeUnit; import com.jogamp.gluegen.JavaEmitter; import java.io.BufferedReader; @@ -282,12 +284,10 @@ public class CStructAnnotationProcessor extends AbstractProcessor { public static class AnnotationProcessorJavaStructEmitter extends JavaEmitter { - @Override - protected PrintWriter openFile(final String filename, final String simpleClassName) throws IOException { - + private boolean filter(final String simpleClassName) { if( generatedStructs.contains(simpleClassName) ) { System.err.println("skipping -> " + simpleClassName); - return null; + return false; } // look for recursive generated structs... keep it DRY @@ -296,9 +296,31 @@ public class CStructAnnotationProcessor extends AbstractProcessor { System.err.println("generating -> " + simpleClassName); generatedStructs.add(simpleClassName); } - return super.openFile(filename, simpleClassName); + return true; + } + + @Override + protected CCodeUnit openCUnit(final String filename, final String cUnitName) throws IOException { + if( !filter(cUnitName) ) { + return null; + } + return super.openCUnit(filename, cUnitName); } + /** + * @param filename the class's full filename to open w/ write access + * @param packageName the package name of the class + * @param simpleClassName the simple class name, i.e. w/o package name or c-file basename + * @param generator informal optional object that is creating this unit, used to be mentioned in a warning message if not null. + * @throws IOException + */ + @Override + protected JavaCodeUnit openJavaUnit(final String filename, final String packageName, final String simpleClassName) throws IOException { + if( !filter(simpleClassName) ) { + return null; + } + return super.openJavaUnit(filename, packageName, simpleClassName); + } } } |