michael/lwjgl
michael
/
lwjgl
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Optimize generators

This commit is contained in:
Michael Pfaff 2022-09-08 07:10:40 -04:00
parent 632dac735a
commit 0ebbec4e7f
Signed by: michael
GPG Key ID: CF402C4A012AA9D4
16 changed files with 432 additions and 493 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/java/org/lwjgl/util/generator/FieldsGenerator.java
View File

@ -42,6 +42,7 @@ import javax.lang.model.type.TypeKind;
import javax.lang.model.type.TypeMirror;
public class FieldsGenerator {
private static final Object sync = new Object();
private static void validateField(VariableElement field) {
// Check if field is "public static final"
@ -69,7 +70,10 @@ public class FieldsGenerator {
throw new RuntimeException("Field " + field.getSimpleName() + " is not a primitive type or String");
}
Object field_value = field.getConstantValue();
Object field_value;
synchronized (sync) {
field_value = field.getConstantValue();
}
if ( field_value == null ) {
throw new RuntimeException("Field " + field.getSimpleName() + " has no initial value");
}
@ -124,4 +128,4 @@ public class FieldsGenerator {
}
}
}
}

3
src/java/org/lwjgl/util/generator/GeneratorProcessor.java
View File

@ -75,7 +75,8 @@ public class GeneratorProcessor extends AbstractProcessor {
try {
TypeMap type_map = (TypeMap)(Class.forName(typemap_classname).newInstance());
ElementFilter.typesIn(roundEnv.getRootElements()).stream().sequential().forEach(file -> {
//ElementFilter.typesIn(roundEnv.getRootElements()).stream().sequential().forEach(file -> {
ElementFilter.typesIn(roundEnv.getRootElements()).parallelStream().forEach(file -> {
try {
file.accept(new GeneratorVisitor(processingEnv, gen_java_path, gen_native_path, type_map, generate_error_checks, context_specific), null);
} catch (Exception e) {

200
src/java/org/lwjgl/util/generator/GeneratorVisitor.java
View File

@ -48,6 +48,7 @@ import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Collection;
import java.util.List;
import javax.annotation.processing.Messager;
import javax.annotation.processing.ProcessingEnvironment;
import javax.lang.model.element.*;
import javax.lang.model.type.TypeKind;
@ -135,14 +136,16 @@ public class GeneratorVisitor extends ElementKindVisitor6<Void, Void> {
}
private void validateTypes(ExecutableElement method, List<? extends AnnotationMirror> annotations, TypeMirror type_mirror) {
if (true) {
// TODO: remove if we reimplement validateType.
return;
}
String desc = Utils.getDescriptor(type_mirror);
if ( BUFFER_DESC.equals(desc) ) return;
for ( AnnotationMirror annotation : annotations ) {
NativeType native_type_annotation = NativeTypeTranslator.getAnnotation(annotation, NativeType.class);
if ( native_type_annotation != null ) {
Class<? extends Annotation> annotation_type = NativeTypeTranslator.getClassFromType(annotation.getAnnotationType());
String desc = Utils.getDescriptor(type_mirror);
if ( BUFFER_DESC.equals(desc) ) {
continue;
}
validateType(method, annotation_type, desc);
}
}
@ -205,34 +208,32 @@ public class GeneratorVisitor extends ElementKindVisitor6<Void, Void> {
private static void generateMethodNativePointers(PrintWriter writer, ExecutableElement method) {
if ( method.getAnnotation(Extern.class) == null ) {
writer.print("static ");
writer.append("static ");
}
writer.println(Utils.getTypedefName(method) + " " + method.getSimpleName() + ";");
writer.append(Utils.getTypedefName(method)).append(' ').append(method.getSimpleName()).append(";\n");
}
private void generateJavaSource(TypeElement d, PrintWriter java_writer) throws IOException {
java_writer.println("/* MACHINE GENERATED FILE, DO NOT EDIT */");
java_writer.println();
java_writer.append("package ").append(env.getElementUtils().getPackageOf(d).getQualifiedName().toString()).append(";\n");
java_writer.println();
java_writer.println("import org.lwjgl.*;");
java_writer.println("import java.nio.*;");
java_writer.append("/* MACHINE GENERATED FILE, DO NOT EDIT */\n\n");
java_writer.append("package ").append(env.getElementUtils().getPackageOf(d).getQualifiedName().toString()).append(";\n\n");
java_writer.append("import org.lwjgl.*;\n"
+ "import java.nio.*;\n");
Imports imports = d.getAnnotation(Imports.class);
if ( imports != null ) {
for ( String i : imports.value() ) {
java_writer.append("import ").append(i).append(";\n");
}
}
java_writer.println();
java_writer.append('\n');
Utils.printDocComment(java_writer, d, env);
if ( d.getAnnotation(Private.class) == null ) {
java_writer.print("public ");
java_writer.append("public ");
}
boolean is_final = Utils.isFinal(d);
if ( is_final ) {
java_writer.write("final ");
java_writer.append("final ");
}
java_writer.print("class " + Utils.getSimpleClassName(d));
java_writer.append("class ").append(Utils.getSimpleClassName(d));
List<? extends TypeMirror> super_interfaces = d.getInterfaces();
if ( super_interfaces.size() > 1 ) {
throw new RuntimeException(d + " extends more than one interface");
@ -241,19 +242,19 @@ public class GeneratorVisitor extends ElementKindVisitor6<Void, Void> {
TypeMirror super_interface = super_interfaces.iterator().next();
java_writer.append(" extends ").append(Utils.getSimpleClassName(env.getElementUtils().getTypeElement(super_interface.toString())));
}
java_writer.println(" {");
java_writer.append(" {\n");
FieldsGenerator.generateFields(env, java_writer, Utils.getFields(d));
java_writer.println();
java_writer.append('\n');
if ( is_final ) {
// Write private constructor to avoid instantiation
java_writer.append("\tprivate ").append(Utils.getSimpleClassName(d)).append("() {}\n");
}
if ( Utils.getMethods(d).size() > 0 && !context_specific ) {
java_writer.println();
java_writer.append('\n');
java_writer.append("\tstatic native void ").append(Utils.STUB_INITIALIZER_NAME).append("() throws LWJGLException;\n");
}
JavaMethodsGenerator.generateMethodsJava(env, type_map, java_writer, d, generate_error_checks, context_specific);
java_writer.println("}");
java_writer.append("}");
}
private void generateNativeSource(TypeElement d, long startTime) throws IOException {
@ -264,34 +265,33 @@ public class GeneratorVisitor extends ElementKindVisitor6<Void, Void> {
StringWriter native_writer1 = new StringWriter();
PrintWriter native_writer = new PrintWriter(native_writer1);
native_writer.println("/* MACHINE GENERATED FILE, DO NOT EDIT */");
native_writer.println();
native_writer.println("#include <jni.h>");
native_writer.append("/* MACHINE GENERATED FILE, DO NOT EDIT */\n\n");
native_writer.append("#include <jni.h>\n");
type_map.printNativeIncludes(native_writer);
native_writer.println();
native_writer.append('\n');
TypedefsGenerator.generateNativeTypedefs(type_map, native_writer, Utils.getMethods(d));
native_writer.println();
native_writer.append('\n');
if (!context_specific) {
generateMethodsNativePointers(native_writer, Utils.getMethods(d));
native_writer.println();
native_writer.append('\n');
}
NativeMethodStubsGenerator.generateNativeMethodStubs(env, type_map, native_writer, d, generate_error_checks, context_specific);
if (!context_specific) {
native_writer.print("JNIEXPORT void JNICALL " + Utils.getQualifiedNativeMethodName(qualified_interface_name, Utils.STUB_INITIALIZER_NAME));
native_writer.println("(JNIEnv *env, jclass clazz) {");
native_writer.println("\tJavaMethodAndExtFunction functions[] = {");
native_writer.append("JNIEXPORT void JNICALL ").append(Utils.getQualifiedNativeMethodName(qualified_interface_name, Utils.STUB_INITIALIZER_NAME));
native_writer.append("(JNIEnv *env, jclass clazz) {\n");
native_writer.append("\tJavaMethodAndExtFunction functions[] = {\n");
RegisterStubsGenerator.generateMethodsNativeStubBind(native_writer, d, generate_error_checks, context_specific);
native_writer.println("\t};");
native_writer.println("\tint num_functions = NUMFUNCTIONS(functions);");
native_writer.print("\t");
native_writer.print(type_map.getRegisterNativesFunctionName());
native_writer.println("(env, clazz, num_functions, functions);");
native_writer.println("}");
native_writer.append("\t};\n");
native_writer.append("\tint num_functions = NUMFUNCTIONS(functions);\n");
native_writer.append('\t');
native_writer.append(type_map.getRegisterNativesFunctionName());
native_writer.append("(env, clazz, num_functions, functions);\n");
native_writer.append("}");
}
saveGeneratedCSource(env, this.gen_native_path, d, native_writer1.toString(), startTime);
saveGeneratedCSource(env.getMessager(), this.gen_native_path, d, native_writer1.toString(), startTime);
}
private static boolean isFileExistingAndIdentical(ProcessingEnvironment env, Path file, String expected) throws IOException {
private static boolean isFileExistingAndIdentical(Messager messager, Path file, String expected) throws IOException {
if (!Files.exists(file)) return false;
try (Reader existingIs = Files.newBufferedReader(file, Charset.forName("UTF-8"))) {
@ -302,15 +302,15 @@ public class GeneratorVisitor extends ElementKindVisitor6<Void, Void> {
if (c == -1) return i == expected.length();
if (expected.length() <= i || c != expected.charAt(i++)) {
if (expected.length() > (i-1)) {
env.getMessager().printMessage(Kind.NOTE, "mismatch at " + i + ": '" + ((char) c) + '\'');
messager.printMessage(Kind.NOTE, "mismatch at " + i + ": '" + ((char) c) + '\'');
} else {
env.getMessager().printMessage(Kind.NOTE, "mismatch at " + i + ": EOF in expected");
messager.printMessage(Kind.NOTE, "mismatch at " + i + ": EOF in expected");
}
return false;
}
} while (c != -1);
if (i != expected.length()) {
env.getMessager().printMessage(Kind.NOTE, "mismatch at " + i + ": EOF in existing");
messager.printMessage(Kind.NOTE, "mismatch at " + i + ": EOF in existing");
return false;
}
}
@ -318,84 +318,91 @@ public class GeneratorVisitor extends ElementKindVisitor6<Void, Void> {
return true;
}
private void doJavaGen(TypeElement e) {
long startTime = System.currentTimeMillis();
StringWriter java_writer = new StringWriter();
try {
generateJavaSource(e, new PrintWriter(java_writer));
} catch (IOException ex) {
throw new RuntimeException("Failed to generate the Java sources for " + e, ex);
}
saveGeneratedJavaSource(env.getMessager(), this.gen_java_path, e, java_writer.toString(), startTime);
}
@Override
public Void visitTypeAsInterface(TypeElement e, Void p) {
long startTime = System.currentTimeMillis();
final File input = new File("src/templates/" + e.getQualifiedName().toString().replace('.', '/') + ".java");
final Collection<? extends ExecutableElement> methods = Utils.getMethods(e);
if (methods.isEmpty() && Utils.getFields(e).isEmpty()) {
return DEFAULT_VALUE;
}
//env.getMessager().printMessage(Kind.NOTE, "methods count : " + Utils.getMethods(e).size() + " fields count : " + Utils.getFields(e).size(), e);
for (ExecutableElement method : methods) {
validateMethod(method);
methods.parallelStream().forEach(method -> validateMethod(method));
long elapsed = System.currentTimeMillis() - startTime;
if (elapsed > 5) {
env.getMessager().printMessage(Diagnostic.Kind.WARNING, "Validated " + e + " in " + elapsed + " ms.\n\t**** SIGNIFICANT AMOUNT OF TIME");
} else {
env.getMessager().printMessage(Diagnostic.Kind.NOTE, "Validated " + e + " in " + elapsed + " ms.");
}
Thread javaGenThread = new Thread((Runnable) () -> {
StringWriter java_writer = new StringWriter();
try {
generateJavaSource(e, new PrintWriter(java_writer));
} catch (IOException ex) {
throw new RuntimeException("Failed to generate the Java sources for " + e, ex);
}
saveGeneratedJavaSource(env, this.gen_java_path, e, java_writer.toString(), startTime);
});
javaGenThread.start();
if (methods.size() > 0) {
Thread javaGenThread = new Thread((Runnable) () -> {
doJavaGen(e);
});
javaGenThread.start();
Thread cGenThread = new Thread((Runnable) () -> {
long startTime1 = System.currentTimeMillis();
if (methods.size() > 0) {
boolean noNative = true;
for (ExecutableElement method : methods) {
Alternate alt_annotation = method.getAnnotation(Alternate.class);
if ((alt_annotation == null || alt_annotation.nativeAlt()) && method.getAnnotation(Reuse.class) == null) {
noNative = false;
break;
}
}
if (!noNative) {
try {
generateNativeSource(e, startTime1);
} catch (IOException ex) {
throw new RuntimeException(ex);
}
boolean noNative = true;
for (ExecutableElement method : methods) {
Alternate alt_annotation = method.getAnnotation(Alternate.class);
if ((alt_annotation == null || alt_annotation.nativeAlt()) && method.getAnnotation(Reuse.class) == null) {
noNative = false;
break;
}
}
if (!noNative) {
try {
generateNativeSource(e, startTime1);
} catch (IOException ex) {
throw new RuntimeException(ex);
}
}
});
cGenThread.start();
try {
javaGenThread.join();
cGenThread.join();
} catch (Throwable ex) {
throw new RuntimeException(ex);
try {
javaGenThread.join();
} catch (Throwable ex) {
throw new RuntimeException(ex);
}
} else {
doJavaGen(e);
}
return DEFAULT_VALUE;
}
public static void saveGeneratedJavaSource(ProcessingEnvironment env, Path gen_java_path, TypeElement e, String content, long startTime) {
public static void saveGeneratedJavaSource(Messager messager, Path gen_java_path, TypeElement e, String content, long startTime) {
String qualified_interface_name = Utils.getQualifiedClassName(e);
saveGeneratedJavaSource(env, gen_java_path, qualified_interface_name, content, startTime);
saveGeneratedJavaSource(messager, gen_java_path, qualified_interface_name, content, startTime);
}
public static void saveGeneratedJavaSource(ProcessingEnvironment env, Path gen_java_path, String qualified_interface_name, String content, long startTime) {
public static void saveGeneratedJavaSource(Messager messager, Path gen_java_path, String qualified_interface_name, String content, long startTime) {
final Path output = gen_java_path.resolve(qualified_interface_name.replace('.', '/') + ".java");
saveGeneratedSource(env, "java", qualified_interface_name, output, content, startTime);
saveGeneratedSource(messager, "java", qualified_interface_name, output, content, startTime);
}
public static void saveGeneratedCSource(ProcessingEnvironment env, Path gen_native_path, TypeElement e, String content, long startTime) {
public static void saveGeneratedCSource(Messager messager, Path gen_native_path, TypeElement e, String content, long startTime) {
String qualified_interface_name = Utils.getQualifiedClassName(e);
final Path output = gen_native_path.resolve(Utils.getNativeQualifiedName(qualified_interface_name) + ".c");
saveGeneratedSource(env, "c", qualified_interface_name, output, content, startTime);
saveGeneratedSource(messager, "c", qualified_interface_name, output, content, startTime);
}
public static void saveGeneratedSource(ProcessingEnvironment env, String type, String name, Path output, String newStr, long startTime) {
public static void saveGeneratedSource(Messager messager, String type, String name, Path output, String newStr, long startTime) {
try {
if (isFileExistingAndIdentical(env, output, newStr)) {
if (isFileExistingAndIdentical(messager, output, newStr)) {
long elapsed = System.currentTimeMillis() - startTime;
env.getMessager().printMessage(Diagnostic.Kind.NOTE, "Skipped identical '." + type + "' " + name + " at " + output + " in " + elapsed + " ms.");
messager.printMessage(Diagnostic.Kind.NOTE, "Skipped identical '." + type + "' " + name + " at " + output + " in " + elapsed + " ms.");
return;
}
Files.createDirectories(output.getParent());
@ -404,7 +411,6 @@ public class GeneratorVisitor extends ElementKindVisitor6<Void, Void> {
} catch (IOException ex) {
throw new RuntimeException("Failed to create the output file for " + name, ex);
}
//try (Writer java_file_writer = env.getFiler().createSourceFile(Utils.getQualifiedClassName(e), env.getElementUtils().getPackageOf(e)).openWriter()) {
try (Writer java_file_writer = new FileWriter(output.toFile())) {
java_file_writer.write(newStr);
java_file_writer.flush();
@ -413,27 +419,9 @@ public class GeneratorVisitor extends ElementKindVisitor6<Void, Void> {
}
long elapsed = System.currentTimeMillis() - startTime;
if (elapsed > 5) {
env.getMessager().printMessage(Diagnostic.Kind.WARNING, "Generated '." + type + "' " + name + " at " + output + " in " + elapsed + " ms.\n\t**** SIGNIFICANT AMOUNT OF TIME");
messager.printMessage(Diagnostic.Kind.WARNING, "Generated '." + type + "' " + name + " at " + output + " in " + elapsed + " ms.\n\t**** SIGNIFICANT AMOUNT OF TIME");
} else {
env.getMessager().printMessage(Diagnostic.Kind.NOTE, "Generated '." + type + "' " + name + " at " + output + " in " + elapsed + " ms.");
messager.printMessage(Diagnostic.Kind.NOTE, "Generated '." + type + "' " + name + " at " + output + " in " + elapsed + " ms.");
}
}
private static ByteBuffer readFile(final File file) throws IOException {
final FileChannel channel = new FileInputStream(file).getChannel();
final long bytesTotal = channel.size();
final ByteBuffer buffer = ByteBuffer.allocateDirect((int)bytesTotal);
long bytesRead = 0;
do {
bytesRead += channel.read(buffer);
} while ( bytesRead < bytesTotal );
buffer.flip();
channel.close();
return buffer;
}
}

277
src/java/org/lwjgl/util/generator/JavaMethodsGenerator.java
View File

@ -72,7 +72,7 @@ public class JavaMethodsGenerator {
* TODO : fix info multi-type methods print.
*/
private static void generateMethodJava(ProcessingEnvironment env, TypeMap type_map, PrintWriter writer, TypeElement interface_decl, ExecutableElement method, boolean generate_error_checks, boolean context_specific) {
writer.println();
writer.append('\n');
if ( Utils.isMethodIndirect(generate_error_checks, context_specific, method) ) {
if ( method.getAnnotation(GenerateAutos.class) != null ) {
printMethodWithMultiType(env, type_map, writer, interface_decl, method, TypeInfo.getDefaultTypeInfoMap(method), Mode.AUTOS, generate_error_checks, context_specific);
@ -108,25 +108,25 @@ public class JavaMethodsGenerator {
private static void printJavaNativeStub(ProcessingEnvironment env, PrintWriter writer, ExecutableElement method, Mode mode, boolean generate_error_checks, boolean context_specific) {
if ( Utils.isMethodIndirect(generate_error_checks, context_specific, method) ) {
writer.print("\tstatic native ");
writer.append("\tstatic native ");
} else {
Utils.printDocComment(writer, method, env);
writer.print("\tpublic static native ");
writer.append("\tpublic static native ");
}
writer.print(getResultType(method, true));
writer.print(" " + Utils.getSimpleNativeMethodName(method, generate_error_checks, context_specific));
writer.append(getResultType(method, true));
writer.append(' ').append(Utils.getSimpleNativeMethodName(method, generate_error_checks, context_specific));
if ( mode == Mode.BUFFEROBJECT ) {
writer.print(Utils.BUFFER_OBJECT_METHOD_POSTFIX);
writer.append(Utils.BUFFER_OBJECT_METHOD_POSTFIX);
}
writer.print("(");
writer.append('(');
boolean first_parameter = generateParametersJava(writer, method, TypeInfo.getDefaultTypeInfoMap(method), true, true, mode);
if ( context_specific ) {
if ( !first_parameter ) {
writer.print(", ");
writer.append(", ");
}
writer.print("long " + Utils.FUNCTION_POINTER_VAR_NAME);
writer.append("long ").append(Utils.FUNCTION_POINTER_VAR_NAME);
}
writer.println(");");
writer.append(");\n");
}
private static boolean generateParametersJava(PrintWriter writer, ExecutableElement method, Map<VariableElement, TypeInfo> typeinfos_instance, boolean native_stub, final boolean printTypes, Mode mode) {
@ -148,13 +148,13 @@ public class JavaMethodsGenerator {
TypeInfo auto_param_type_info = typeinfos_instance.get(auto_parameter);
if ( auto_param_type_info.getSignedness() == Signedness.BOTH ) {
if ( !first_parameter ) {
writer.print(", ");
writer.append(", ");
}
first_parameter = false;
if ( printTypes ) {
writer.print("boolean ");
writer.append("boolean ");
}
writer.print(TypeInfo.UNSIGNED_PARAMETER_NAME);
writer.append(TypeInfo.UNSIGNED_PARAMETER_NAME);
}
}
} else if ( param.getAnnotation(Result.class) == null
@ -170,33 +170,33 @@ public class JavaMethodsGenerator {
if ( auto_size_annotation == null || !auto_size_annotation.isNative() ) {
if ( cached_result_annotation == null || !cached_result_annotation.isRange() ) {
if ( !first_parameter ) {
writer.print(", ");
writer.append(", ");
}
first_parameter = false;
if ( printTypes ) {
writer.print("long ");
writer.append("long ");
}
writer.print(Utils.RESULT_SIZE_NAME);
writer.append(Utils.RESULT_SIZE_NAME);
}
}
}
if ( cached_result_annotation != null ) {
if ( !first_parameter ) {
writer.print(", ");
writer.append(", ");
}
if ( mode == Mode.CACHEDRESULT ) {
if ( printTypes ) {
writer.print("long ");
writer.append("long ");
}
writer.print(Utils.CACHED_BUFFER_LENGTH_NAME + ", ");
writer.append(Utils.CACHED_BUFFER_LENGTH_NAME).append(", ");
}
first_parameter = false;
if ( printTypes ) {
writer.print(getResultType(method, native_stub));
writer.append(getResultType(method, native_stub));
}
writer.print(" " + Utils.CACHED_BUFFER_NAME);
writer.append(' ').append(Utils.CACHED_BUFFER_NAME);
}
return first_parameter;
}
@ -204,7 +204,7 @@ public class JavaMethodsGenerator {
private static boolean generateParameterJava(PrintWriter writer, VariableElement param, TypeInfo type_info, boolean native_stub, final boolean printTypes, boolean first_parameter, Mode mode) {
Class buffer_type = Utils.getNIOBufferType(param.asType());
if ( !first_parameter ) {
writer.print(", ");
writer.append(", ");
}
BufferObject bo_annotation = param.getAnnotation(BufferObject.class);
if ( bo_annotation != null && mode == Mode.BUFFEROBJECT ) {
@ -212,43 +212,35 @@ public class JavaMethodsGenerator {
throw new RuntimeException("type of " + param + " is not a nio Buffer parameter but is annotated as buffer object");
}
if ( printTypes ) {
writer.print("long ");
writer.append("long ");
}
writer.print(param.getSimpleName() + Utils.BUFFER_OBJECT_PARAMETER_POSTFIX);
writer.append(param.getSimpleName()).append(Utils.BUFFER_OBJECT_PARAMETER_POSTFIX);
} else {
if ( native_stub && param.getAnnotation(PointerWrapper.class) != null ) {
writer.print("long ");
writer.append("long ");
} else {
Class type = type_info.getType();
if ( native_stub && (type == CharSequence.class || type == CharSequence[].class || type == PointerBuffer.class || Buffer.class.isAssignableFrom(type)) ) {
writer.print("long ");
writer.append("long ");
} else if ( printTypes ) {
writer.print(type.getSimpleName() + " ");
writer.append(type.getSimpleName()).append(' ');
}
}
AutoSize auto_size_annotation = param.getAnnotation(AutoSize.class);
if ( auto_size_annotation != null ) {
writer.print(auto_size_annotation.value() + "_");
writer.append(auto_size_annotation.value()).append('_');
}
writer.print(param.getSimpleName());
writer.append(param.getSimpleName());
}
return false;
}
private static void printBufferObjectCheck(PrintWriter writer, BufferKind kind, Mode mode, boolean context_specific) {
String bo_check_method_name = kind.toString();
writer.print("\t\t" + Utils.CHECKS_CLASS_NAME + ".ensure" + bo_check_method_name);
if ( mode == Mode.BUFFEROBJECT ) {
writer.print("enabled");
} else {
writer.print("disabled");
}
writer.append("\t\t" + Utils.CHECKS_CLASS_NAME + ".ensure").append(bo_check_method_name);
writer.append(mode == Mode.BUFFEROBJECT ? "enabled" : "disabled");
if ( context_specific ) {
writer.println("(caps);");
} else {
writer.println("();");
}
writer.append(context_specific ? "(caps);\n" : "();\n");
}
private static void printBufferObjectChecks(PrintWriter writer, ExecutableElement method, Mode mode, boolean context_specific) {
@ -267,14 +259,14 @@ public class JavaMethodsGenerator {
private static void printMethodWithMultiType(ProcessingEnvironment env, TypeMap type_map, PrintWriter writer, TypeElement interface_decl, ExecutableElement method, Map<VariableElement, TypeInfo> typeinfos_instance, Mode mode, boolean generate_error_checks, boolean context_specific) {
Utils.printDocComment(writer, method, env);
if ( method.getAnnotation(Deprecated.class) != null ) {
writer.println("\t@Deprecated");
writer.append("\t@Deprecated\n");
}
if ( interface_decl.getAnnotation(Private.class) == null && method.getAnnotation(Private.class) == null ) {
writer.print("\tpublic static ");
writer.append("\tpublic static ");
} else {
writer.print("\tstatic ");
writer.append("\tstatic ");
}
writer.print(getResultType(method, false));
writer.append(getResultType(method, false));
StripPostfix strip_annotation = method.getAnnotation(StripPostfix.class);
String method_name;
Alternate alt_annotation = method.getAnnotation(Alternate.class);
@ -282,104 +274,101 @@ public class JavaMethodsGenerator {
if ( strip_annotation != null && mode == Mode.NORMAL ) {
method_name = getPostfixStrippedName(type_map, interface_decl, method);
}
writer.print(" " + method_name + "(");
writer.append(' ').append(method_name).append('(');
generateParametersJava(writer, method, typeinfos_instance, false, true, mode);
writer.println(") {");
writer.append(") {\n");
final TypeMirror result_type = Utils.getMethodReturnType(method);
boolean has_result = !result_type.equals(env.getTypeUtils().getNoType(TypeKind.VOID));
final Reuse reuse_annotation = method.getAnnotation(Reuse.class);
if ( reuse_annotation != null ) {
writer.print("\t\t");
writer.append("\t\t");
if ( has_result || method.getAnnotation(GLreturn.class) != null ) {
writer.print("return ");
writer.append("return ");
}
writer.print(reuse_annotation.value() + "." + (reuse_annotation.method().length() > 0 ? reuse_annotation.method() : method_name) + "(");
writer.append(reuse_annotation.value() + "." + (reuse_annotation.method().length() > 0 ? reuse_annotation.method() : method_name) + "(");
generateParametersJava(writer, method, typeinfos_instance, false, false, mode);
writer.println(");\n\t}");
writer.append(");\n\t}\n");
return;
}
if ( context_specific ) {
type_map.printCapabilitiesInit(writer);
writer.print("\t\tlong " + Utils.FUNCTION_POINTER_VAR_NAME + " = " + type_map.getCapabilities() + ".");
writer.println(Utils.getFunctionAddressName(interface_decl, method, true) + ";");
writer.print("\t\tBufferChecks.checkFunctionAddress(");
writer.println(Utils.FUNCTION_POINTER_VAR_NAME + ");");
writer.append("\t\tlong " + Utils.FUNCTION_POINTER_VAR_NAME + " = ").append(type_map.getCapabilities()).append('.');
writer.append(Utils.getFunctionAddressName(interface_decl, method, true)).append(";\n");
writer.append("\t\tBufferChecks.checkFunctionAddress(");
writer.append(Utils.FUNCTION_POINTER_VAR_NAME + ");\n");
}
final Code code_annotation = method.getAnnotation(Code.class);
if ( code_annotation != null && code_annotation.value().length() > 0 ) {
writer.println(code_annotation.value());
writer.append(code_annotation.value()).append('\n');
}
printBufferObjectChecks(writer, method, mode, context_specific);
printParameterChecks(writer, method, typeinfos_instance, mode, generate_error_checks);
printParameterCaching(writer, interface_decl, method, mode, context_specific);
if ( code_annotation != null && code_annotation.javaBeforeNative().length() > 0 ) {
writer.println(code_annotation.javaBeforeNative());
writer.append(code_annotation.javaBeforeNative()).append('\n');
}
writer.print("\t\t");
writer.append("\t\t");
final PointerWrapper pointer_wrapper_annotation = method.getAnnotation(PointerWrapper.class);
if ( has_result ) {
writer.print(getResultType(method, false) + " " + Utils.RESULT_VAR_NAME);
writer.append(getResultType(method, false)).append(" " + Utils.RESULT_VAR_NAME);
if ( code_annotation != null && code_annotation.tryBlock() ) {
writer.print(" = " + getDefaultResultValue(method));
writer.println(";\n\t\ttry {");
writer.print("\t\t\t" + Utils.RESULT_VAR_NAME);
writer.append(" = ").append(getDefaultResultValue(method));
writer.append(";\n\t\ttry {\n");
writer.append("\t\t\t" + Utils.RESULT_VAR_NAME);
}
writer.print(" = ");
writer.append(" = ");
if ( pointer_wrapper_annotation != null ) {
if ( pointer_wrapper_annotation.factory().length() > 0 ) {
writer.print(pointer_wrapper_annotation.factory() + "(");
writer.append(pointer_wrapper_annotation.factory()).append('(');
} else {
writer.print("new " + getResultType(method, false) + "(");
writer.append("new ").append(getResultType(method, false)).append('(');
}
}
} else if ( method.getAnnotation(GLreturn.class) != null ) {
has_result = true;
Utils.printGLReturnPre(writer, method, method.getAnnotation(GLreturn.class), type_map);
}
writer.print(Utils.getSimpleNativeMethodName(method, generate_error_checks, context_specific));
writer.append(Utils.getSimpleNativeMethodName(method, generate_error_checks, context_specific));
if ( mode == Mode.BUFFEROBJECT ) {
writer.print(Utils.BUFFER_OBJECT_METHOD_POSTFIX);
writer.append(Utils.BUFFER_OBJECT_METHOD_POSTFIX);
}
writer.print("(");
writer.append('(');
boolean first_parameter = printMethodCallArguments(writer, method, typeinfos_instance, mode, type_map);
if ( context_specific ) {
if ( !first_parameter ) {
writer.print(", ");
writer.append(", ");
}
writer.print(Utils.FUNCTION_POINTER_VAR_NAME);
writer.append(Utils.FUNCTION_POINTER_VAR_NAME);
}
if ( has_result && pointer_wrapper_annotation != null ) {
writer.print(")");
writer.append(')');
if ( pointer_wrapper_annotation.params().length() > 0 ) {
writer.print(", " + pointer_wrapper_annotation.params());
writer.append(", ").append(pointer_wrapper_annotation.params());
}
}
writer.println(");");
writer.append(");\n");
if ( code_annotation != null && code_annotation.javaAfterNative().length() > 0 ) {
writer.println(code_annotation.javaAfterNative());
writer.append(code_annotation.javaAfterNative()).append('\n');
}
final String tabs = code_annotation != null && code_annotation.tryBlock() ? "\t\t\t" : "\t\t";
if ( generate_error_checks && method.getAnnotation(NoErrorCheck.class) == null ) {
type_map.printErrorCheckMethod(writer, method, tabs);
}
// DISABLED: indirect buffer support
//printNondirectParameterCopies(writer, method, mode);
if ( has_result ) {
if ( method.getAnnotation(GLreturn.class) == null ) {
if ( ByteBuffer.class.equals(Utils.getJavaType(result_type)) ) {
writer.println(tabs + "return LWJGLUtil.CHECKS && " + Utils.RESULT_VAR_NAME + " == null ? null : " + Utils.RESULT_VAR_NAME + ".order(ByteOrder.nativeOrder());"); // safeNewBuffer returns a direct ByteBuffer with BIG_ENDIAN order.
writer.append(tabs).append("return LWJGLUtil.CHECKS && " + Utils.RESULT_VAR_NAME + " == null ? null : " + Utils.RESULT_VAR_NAME + ".order(ByteOrder.nativeOrder());\n"); // safeNewBuffer returns a direct ByteBuffer with BIG_ENDIAN order.
} else {
writer.println(tabs + "return " + Utils.RESULT_VAR_NAME + ";");
writer.append(tabs).append("return " + Utils.RESULT_VAR_NAME + ";\n");
}
} else {
Utils.printGLReturnPost(writer, method, method.getAnnotation(GLreturn.class), type_map);
@ -387,11 +376,11 @@ public class JavaMethodsGenerator {
}
if ( code_annotation != null && code_annotation.tryBlock() ) {
writer.println("\t\t} finally {");
writer.println(code_annotation.javaFinally());
writer.println("\t\t}");
writer.append("\t\t} finally {\n");
writer.append(code_annotation.javaFinally()).append('\n');
writer.append("\t\t}\n");
}
writer.println("\t}");
writer.append("\t}\n");
}
private static String getExtensionPostfix(TypeElement interface_decl) {
@ -505,13 +494,13 @@ public class JavaMethodsGenerator {
private static boolean printMethodCallArgument(PrintWriter writer, ExecutableElement method, VariableElement param, Map<VariableElement, TypeInfo> typeinfos_instance, Mode mode, boolean first_parameter, TypeMap type_map) {
if ( !first_parameter ) {
writer.print(", ");
writer.append(", ");
}
AnnotationMirror auto_annotation = Utils.getParameterAutoAnnotation(param);
Constant constant_annotation = param.getAnnotation(Constant.class);
if ( constant_annotation != null ) {
writer.print(constant_annotation.value());
writer.append(constant_annotation.value());
} else if ( auto_annotation != null && mode == Mode.NORMAL ) {
Class param_type = NativeTypeTranslator.getClassFromType(auto_annotation.getAnnotationType());
if ( AutoType.class.equals(param_type) ) {
@ -521,7 +510,7 @@ public class JavaMethodsGenerator {
if ( auto_type == null ) {
throw new RuntimeException("No auto type for parameter " + param.getSimpleName() + " in method " + method);
}
writer.print(auto_type);
writer.append(auto_type);
} else if ( AutoSize.class.equals(param_type) ) {
final AutoSize auto_size_annotation = param.getAnnotation(AutoSize.class);
if ( !auto_size_annotation.useExpression() ) {
@ -533,65 +522,65 @@ public class JavaMethodsGenerator {
if ( shift_remaining ) {
shifting = getBufferElementSizeExponent(auto_target_type_info.getType());
if ( shifting > 0 ) {
writer.print("(");
writer.append('(');
}
}
if ( auto_size_annotation.canBeNull() ) {
writer.print("(" + auto_parameter_name + " == null ? 0 : " + auto_parameter_name + ".remaining())");
writer.append('(').append(auto_parameter_name).append(" == null ? 0 : ").append(auto_parameter_name).append(".remaining())");
} else {
writer.print(auto_parameter_name + ".remaining()");
writer.append(auto_parameter_name).append(".remaining()");
}
// Shift the remaining if the target parameter is multityped and there's no AutoType to track type
if ( shift_remaining && shifting > 0 ) {
writer.print(" << " + shifting);
writer.print(")");
if ( shifting > 0 ) {
writer.append(" << ").append(String.valueOf(shifting));
writer.append(')');
}
}
writer.print(auto_size_annotation.expression());
writer.append(auto_size_annotation.expression());
} else {
throw new RuntimeException("Unknown auto annotation " + param_type);
}
} else {
if ( mode == Mode.BUFFEROBJECT && param.getAnnotation(BufferObject.class) != null ) {
writer.print(param.getSimpleName() + Utils.BUFFER_OBJECT_PARAMETER_POSTFIX);
writer.append(param.getSimpleName()).append(Utils.BUFFER_OBJECT_PARAMETER_POSTFIX);
} else {
Class type = typeinfos_instance.get(param).getType();
Check check_annotation = param.getAnnotation(Check.class);
boolean hide_buffer = mode == Mode.AUTOS && getAutoTypeParameter(method, param) != null;
if ( hide_buffer ) {
writer.print("0L");
writer.append("0L");
} else {
if ( type == CharSequence.class || type == CharSequence[].class ) {
final String offset = Utils.getStringOffset(method, param);
writer.print("APIUtil.getBuffer");
writer.append("APIUtil.getBuffer");
if ( param.getAnnotation(NullTerminated.class) != null ) {
writer.print("NT");
writer.append("NT");
}
writer.print('(');
writer.print(type_map.getAPIUtilParam(true));
writer.print(param.getSimpleName());
writer.append('(');
writer.append(type_map.getAPIUtilParam(true));
writer.append(param.getSimpleName());
if ( offset != null ) {
writer.print(", " + offset);
writer.append(", ").append(offset);
}
writer.print(")");
writer.append(')');
} else {
final AutoSize auto_size_annotation = param.getAnnotation(AutoSize.class);
if ( auto_size_annotation != null ) {
writer.print(auto_size_annotation.value() + "_");
writer.append(auto_size_annotation.value()).append('_');
}
final Class buffer_type = Utils.getNIOBufferType(param.asType());
if ( buffer_type == null ) {
writer.print(param.getSimpleName());
writer.append(param.getSimpleName());
} else {
writer.print("MemoryUtil.getAddress");
writer.append("MemoryUtil.getAddress");
if ( check_annotation != null && check_annotation.canBeNull() ) {
writer.print("Safe");
writer.append("Safe");
}
writer.print("(");
writer.print(param.getSimpleName());
writer.print(")");
writer.append('(');
writer.append(param.getSimpleName());
writer.append(')');
}
}
}
@ -599,9 +588,9 @@ public class JavaMethodsGenerator {
PointerWrapper pointer_annotation = param.getAnnotation(PointerWrapper.class);
if ( pointer_annotation != null ) {
if ( pointer_annotation.canBeNull() ) {
writer.print(" == null ? 0 : " + param.getSimpleName());
writer.append(" == null ? 0 : ").append(param.getSimpleName());
}
writer.print(".getPointer()");
writer.append(".getPointer()");
}
}
}
@ -629,7 +618,7 @@ public class JavaMethodsGenerator {
AutoSize auto_size_annotation = method.getAnnotation(AutoSize.class);
if ( auto_size_annotation == null || !auto_size_annotation.isNative() ) {
if ( !first_parameter ) {
writer.print(", ");
writer.append(", ");
}
first_parameter = false;
@ -657,21 +646,21 @@ public class JavaMethodsGenerator {
&& cachedReference != null
&& (mode != Mode.BUFFEROBJECT || param.getAnnotation(BufferObject.class) == null)
&& param.getAnnotation(Result.class) == null ) {
writer.print("\t\tif ( LWJGLUtil.CHECKS ) StateTracker.");
writer.append("\t\tif ( LWJGLUtil.CHECKS ) StateTracker.");
if ( context_specific ) {
writer.print("getReferences(caps).");
writer.append("getReferences(caps).");
} else {
writer.print("getTracker().");
writer.append("getTracker().");
}
if ( cachedReference.name().length() > 0 ) {
writer.print(cachedReference.name());
writer.append(cachedReference.name());
} else {
writer.print(Utils.getReferenceName(interface_decl, method, param));
writer.append(Utils.getReferenceName(interface_decl, method, param));
}
if ( cachedReference.index().length() > 0 ) {
writer.print("[" + cachedReference.index() + "]");
writer.append('[').append(cachedReference.index()).append(']');
}
writer.println(" = " + param.getSimpleName() + ";");
writer.append(" = ").append(param.getSimpleName()).append(";\n");
}
}
}
@ -686,12 +675,11 @@ public class JavaMethodsGenerator {
final int shifting = getBufferElementSizeExponent(typeinfos.get(param).getType());
final Check check_annotation = param.getAnnotation(Check.class);
writer.print("\t\tlong " + param.getSimpleName() + "_size = ");
if ( check_annotation == null || !check_annotation.canBeNull() ) {
writer.println(param.getSimpleName() + ".remaining() << " + shifting + ";");
} else {
writer.println(param.getSimpleName() + " == null ? 0 : " + param.getSimpleName() + ".remaining() << " + shifting + ";");
writer.append("\t\tlong ").append(param.getSimpleName()).append("_size = ");
if ( check_annotation != null && check_annotation.canBeNull() ) {
writer.append(param.getSimpleName()).append(" == null ? 0 : ");
}
writer.append(param.getSimpleName()).append(".remaining() << ").append(String.valueOf(shifting)).append(";\n");
}
}
}
@ -716,7 +704,7 @@ public class JavaMethodsGenerator {
printParameterCheck(writer, method, param.getSimpleName().toString(), typeinfo.getType().getSimpleName(), check_value, can_be_null, param.getAnnotation(NullTerminated.class), generate_error_checks);
} else if ( String.class.equals(java_type) ) {
if ( !can_be_null ) {
writer.println("\t\tBufferChecks.checkNotNull(" + param.getSimpleName() + ");");
writer.append("\t\tBufferChecks.checkNotNull(").append(param.getSimpleName()).append(");\n");
}
} else if ( java_type.isArray() ) {
printArrayParameterCheck(writer, param.getSimpleName().toString(), check_value, can_be_null);
@ -731,44 +719,43 @@ public class JavaMethodsGenerator {
private static void printParameterCheck(PrintWriter writer, ExecutableElement method, String name, String type, String check_value, boolean can_be_null, NullTerminated null_terminated, boolean generate_error_checks) {
String tabs;
if ( can_be_null ) {
writer.print("\t\tif (" + name + " != null)");
writer.append("\t\tif (").append(name).append(" != null)");
if ( null_terminated != null ) {
writer.println(" {");
writer.append(" {\n");
} else {
writer.println();
writer.append('\n');
}
tabs = "\t\t\t";
} else {
tabs = "\t\t";
}
writer.print(tabs + "BufferChecks.check");
writer.append(tabs).append("BufferChecks.check");
if ( check_value != null && check_value.length() > 0 ) {
writer.print("Buffer");
writer.append("Buffer");
if ( "Buffer".equals(type) ) {
writer.print("Size"); // Check size only, Buffer.isDirect() was added in 1.6, cannot use yet. TODO: Remove?
writer.append("Size"); // Check size only, Buffer.isDirect() was added in 1.6, cannot use yet. TODO: Remove?
}
writer.print("(" + name + ", " + check_value);
writer.append('(').append(name).append(", ").append(check_value);
} else {
writer.print("Direct(" + name);
writer.append("Direct(").append(name);
}
writer.println(");");
writer.append(");\n");
if ( can_be_null && generate_error_checks ) {
final Check check_annotation = method.getAnnotation(Check.class);
if ( check_annotation != null && check_annotation.value().equals(name) ) {
writer.println("\t\telse");
writer.println("\t\t\t" + name + " = APIUtil.getBufferIntDebug();"); // Use an exclusive buffer here
writer.append("\t\telse\n");
writer.append("\t\t\t").append(name).append(" = APIUtil.getBufferIntDebug();\n"); // Use an exclusive buffer here
}
}
if ( null_terminated != null ) {
writer.print(tabs + "BufferChecks.checkNullTerminated(");
writer.print(name);
writer.append(tabs).append("BufferChecks.checkNullTerminated(");
writer.append(name);
if ( null_terminated.value().length() > 0 ) {
writer.print(", ");
writer.print(null_terminated.value());
writer.append(", ").append(null_terminated.value());
}
writer.println(");");
writer.append(");\n");
if ( can_be_null ) {
writer.println("\t\t}");
writer.append("\t\t}\n");
}
}
}
@ -776,17 +763,17 @@ public class JavaMethodsGenerator {
private static void printArrayParameterCheck(PrintWriter writer, String name, String check_value, boolean can_be_null) {
String tabs;
if ( can_be_null ) {
writer.println("\t\tif (" + name + " != null)");
writer.append("\t\tif (").append(name).append(" != null)\n");
tabs = "\t\t\t";
} else {
tabs = "\t\t";
}
writer.print(tabs + "BufferChecks.checkArray(" + name);
writer.append(tabs).append("BufferChecks.checkArray(").append(name);
if ( check_value != null && check_value.length() > 0 ) {
writer.print(", " + check_value);
writer.append(", ").append(check_value);
}
writer.println(");");
writer.append(");\n");
}
private static String getResultType(ExecutableElement method, boolean native_stub) {

125
src/java/org/lwjgl/util/generator/NativeMethodStubsGenerator.java
View File

@ -84,13 +84,13 @@ public class NativeMethodStubsGenerator {
private static void generateParameter(PrintWriter writer, VariableElement param, Mode mode) {
writer.print(", ");
if ( mode == Mode.BUFFEROBJECT && param.getAnnotation(BufferObject.class) != null ) {
writer.print("jlong " + param.getSimpleName() + Utils.BUFFER_OBJECT_PARAMETER_POSTFIX);
writer.append("jlong ").append(param.getSimpleName()).append(Utils.BUFFER_OBJECT_PARAMETER_POSTFIX);
} else if ( param.getAnnotation(PointerWrapper.class) != null ) {
writer.print("jlong " + param.getSimpleName());
writer.append("jlong ").append(param.getSimpleName());
} else {
JNITypeTranslator translator = new JNITypeTranslator();
param.asType().accept(translator, null);
writer.print(translator.getSignature() + " " + param.getSimpleName());
writer.append(translator.getSignature()).append(' ').append(param.getSimpleName());
}
}
@ -127,15 +127,15 @@ public class NativeMethodStubsGenerator {
if ( context_specific ) {
writer.print(", jlong " + Utils.FUNCTION_POINTER_VAR_NAME);
}
writer.println(") {");
writer.append(") {\n");
generateBufferParameterAddresses(type_map, writer, method, mode);
Alternate alt_annotation = method.getAnnotation(Alternate.class);
if ( context_specific ) {
String typedef_name = Utils.getTypedefName(method);
writer.print("\t" + typedef_name + " " + (alt_annotation == null ? method.getSimpleName() : alt_annotation.value()));
writer.print(" = (" + typedef_name + ")((intptr_t)");
writer.println(Utils.FUNCTION_POINTER_VAR_NAME + ");");
writer.append('\t').append(typedef_name).append(' ').append(alt_annotation == null ? method.getSimpleName() : alt_annotation.value());
writer.append(" = (").append(typedef_name).append(")((intptr_t)");
writer.append(Utils.FUNCTION_POINTER_VAR_NAME + ");\n");
}
final Code code_annotation = method.getAnnotation(Code.class);
@ -146,29 +146,28 @@ public class NativeMethodStubsGenerator {
printResultParam(type_map, writer, method, result_type, true);
if ( code_annotation != null && code_annotation.nativeAfterVars().length() > 0 )
writer.println(code_annotation.nativeAfterVars());
writer.append(code_annotation.nativeAfterVars()).append('\n');
generatePointerArrayInits(type_map, writer, method.getParameters());
if ( code_annotation != null && code_annotation.nativeBeforeCall().length() > 0 )
writer.println(code_annotation.nativeBeforeCall());
writer.append(code_annotation.nativeBeforeCall()).append('\n');
writer.print("\t");
if ( resultPreDeclare )
writer.print(Utils.RESULT_VAR_NAME + " = ");
else if ( hasResult )
printResultParam(type_map, writer, method, result_type, false);
writer.print((alt_annotation == null ? method.getSimpleName() : alt_annotation.value()) + "(");
writer.append(alt_annotation == null ? method.getSimpleName() : alt_annotation.value()).append('(');
generateCallParameters(writer, type_map, method.getParameters());
writer.print(")");
writer.println(";");
writer.append(");\n");
if ( code_annotation != null && code_annotation.nativeAfterCall().length() > 0 )
writer.println(code_annotation.nativeAfterCall());
writer.append(code_annotation.nativeAfterCall()).append('\n');
generateStringDeallocations(writer, method.getParameters());
if ( !result_type.equals(env.getTypeUtils().getNoType(TypeKind.VOID)) ) {
writer.print("\treturn ");
writer.append("\treturn ");
Class java_result_type = Utils.getJavaType(result_type);
if ( Buffer.class.isAssignableFrom(java_result_type) ) {
if ( cached_result_annotation != null )
@ -194,10 +193,9 @@ public class NativeMethodStubsGenerator {
if ( Buffer.class.isAssignableFrom(java_result_type) ||
String.class.equals(java_result_type) )
writer.print(")");
writer.println(";");
writer.append(";\n");
}
writer.println("}");
writer.println();
writer.append("}\n");
}
private static void printResultParam(final TypeMap type_map, final PrintWriter writer, final ExecutableElement method, final TypeMirror result_type, final boolean preDeclare) {
@ -207,11 +205,11 @@ public class NativeMethodStubsGenerator {
result_type.accept(result_translator, null);
if ( preDeclare )
writer.print("\t");
writer.print(result_translator.getSignature() + " " + Utils.RESULT_VAR_NAME);
writer.append(result_translator.getSignature()).append(' ').append(Utils.RESULT_VAR_NAME);
if ( preDeclare )
writer.println(";");
writer.append(";\n");
else
writer.print(result_param == null ? " = " : ";\n\t");
writer.append(result_param == null ? " = " : ";\n\t");
}
private static void generateCallParameters(PrintWriter writer, TypeMap type_map, List<? extends VariableElement> params) {
@ -224,7 +222,7 @@ public class NativeMethodStubsGenerator {
if ( first )
first = false;
else
writer.print(", ");
writer.append(", ");
generateCallParameter(writer, type_map, param);
}
@ -237,31 +235,31 @@ public class NativeMethodStubsGenerator {
final Constant constant_annotation = param.getAnnotation(Constant.class);
if ( constant_annotation != null && constant_annotation.isNative() ) {
writer.print(constant_annotation.value());
writer.append(constant_annotation.value());
return;
}
boolean is_indirect = param.getAnnotation(Indirect.class) != null;
if ( is_indirect || param.getAnnotation(PointerArray.class) != null ) {
writer.print("(");
writer.append('(');
final NativeTypeTranslator translator = new NativeTypeTranslator(type_map, param);
param.asType().accept(translator, null);
writer.print(translator.getSignature());
writer.print("*)");
writer.append(translator.getSignature());
writer.append("*)");
}
if ( param.getAnnotation(PointerWrapper.class) != null )
writer.print("(" + param.getAnnotation(PointerWrapper.class).value() + ")(intptr_t)");
writer.append('(').append(param.getAnnotation(PointerWrapper.class).value()).append(")(intptr_t)");
if ( param.getAnnotation(Result.class) != null || is_indirect )
writer.print("&");
writer.append('&');
if ( param.getAnnotation(Result.class) != null ) {
writer.print(Utils.RESULT_VAR_NAME);
writer.append(Utils.RESULT_VAR_NAME);
} else {
writer.print(param.getSimpleName());
writer.append(param.getSimpleName());
if ( param.getAnnotation(PointerArray.class) != null )
writer.print(getPointerArrayName(Utils.getJavaType(param.asType())));
writer.append(getPointerArrayName(Utils.getJavaType(param.asType())));
else if ( Utils.isAddressableType(param.asType()) )
writer.print(BUFFER_ADDRESS_POSTFIX);
writer.append(BUFFER_ADDRESS_POSTFIX);
}
}
@ -269,9 +267,9 @@ public class NativeMethodStubsGenerator {
for ( VariableElement param : params ) {
final Class java_type = Utils.getJavaType(param.asType());
if ( java_type.equals(String.class) && param.getAnnotation(Result.class) == null )
writer.println("\tfree(" + param.getSimpleName() + BUFFER_ADDRESS_POSTFIX + ");");
writer.append("\tfree(" + param.getSimpleName() + BUFFER_ADDRESS_POSTFIX + ");\n");
else if ( param.getAnnotation(PointerArray.class) != null ) // Free the string array mem
writer.println("\tfree(" + param.getSimpleName() + getPointerArrayName(java_type) + ");");
writer.append("\tfree(" + param.getSimpleName() + getPointerArrayName(java_type) + ");\n");
}
}
@ -298,22 +296,22 @@ public class NativeMethodStubsGenerator {
final String native_type = translator.getSignature();
if ( !java_type.isArray() || CharSequence.class.isAssignableFrom(java_type.getComponentType()) ) {
writer.print("\t" + native_type + param.getSimpleName());
writer.print(BUFFER_ADDRESS_POSTFIX + " = (");
writer.print(native_type);
writer.print(")(intptr_t)");
writer.append('\t').append(native_type).append(param.getSimpleName());
writer.append(BUFFER_ADDRESS_POSTFIX + " = (");
writer.append(native_type);
writer.append(")(intptr_t)");
if ( mode == Mode.BUFFEROBJECT && param.getAnnotation(BufferObject.class) != null ) {
writer.print("offsetToPointer(" + param.getSimpleName() + Utils.BUFFER_OBJECT_PARAMETER_POSTFIX + ")");
writer.append("offsetToPointer(").append(param.getSimpleName()).append(Utils.BUFFER_OBJECT_PARAMETER_POSTFIX + ')');
} else {
if ( Buffer.class.isAssignableFrom(java_type) || java_type.equals(CharSequence.class) || java_type.equals(CharSequence[].class) || PointerBuffer.class.isAssignableFrom(java_type) ) {
writer.print(param.getSimpleName());
writer.append(param.getSimpleName());
} else if ( java_type.equals(String.class) ) {
writer.print("GetStringNativeChars(env, " + param.getSimpleName() + ")");
writer.append("GetStringNativeChars(env, ").append(param.getSimpleName()).append(')');
} else if ( array_annotation == null )
throw new RuntimeException("Illegal type " + java_type);
}
writer.println(";");
writer.append(";\n");
}
if ( array_annotation != null ) {
@ -327,8 +325,8 @@ public class NativeMethodStubsGenerator {
// Declare loop counters and allocate object array
if ( !ptrLoopDeclared ) {
writer.println("\tint " + n + "_i;");
writer.println("\tjobject " + n + "_object;");
writer.append("\tint ").append(n).append("_i;\n");
writer.append("\tjobject ").append(n).append("_object;\n");
ptrLoopDeclared = true;
}
} else {
@ -339,16 +337,16 @@ public class NativeMethodStubsGenerator {
// Declare loop counters and allocate string array
if ( !strLoopDeclared ) {
writer.println("\tint " + n + "_i;");
writer.println("\t" + arrayType + n + "_address;");
writer.append("\tint ").append(n).append("_i;\n");
writer.append("\t").append(arrayType).append(n).append("_address;\n");
strLoopDeclared = true;
}
}
writer.print("\t" + arrayType + "*" + param.getSimpleName() + n + " = ");
writer.append('\t').append(arrayType).append('*').append(param.getSimpleName()).append(n).append(" = ");
if ( check_annotation != null && check_annotation.canBeNull() )
writer.print(array_annotation.value() + " == 0 ? NULL : ");
writer.println("(" + arrayType + "*) malloc(" + array_annotation.value() + " * sizeof(" + arrayType + "));");
writer.append(array_annotation.value()).append(" == 0 ? NULL : ");
writer.append('(').append(arrayType).append("*) malloc(").append(array_annotation.value()).append(" * sizeof(" + arrayType + "));\n");
}
}
@ -381,32 +379,33 @@ public class NativeMethodStubsGenerator {
final String n = getPointerArrayName(java_type);
if ( POINTER_LIST_NAME.equals(n) ) {
// Init vars
writer.println("\t" + n + "_i = 0;");
writer.append('\t').append(n).append("_i = 0;\n");
// Fill pointer array with the buffer pointers
writer.println("\twhile ( " + n + "_i < " + pointerArray_annotation.value() + " ) {");
writer.println("\t\t" + n + "_object = (*env)->GetObjectArrayElement(env, " + param.getSimpleName() + ", " + n + "_i);");
writer.print("\t\t" + param.getSimpleName() + n + "[" + n + "_i++] = (" + translator.getSignature(true) + ")");
writer.append("\twhile ( ").append(n).append("_i < ").append(pointerArray_annotation.value()).append(" ) {\n");
writer.append("\t\t").append(n).append("_object = (*env)->GetObjectArrayElement(env, ").append(param.getSimpleName()).append(", ").append(n).append("_i);\n");
writer.append("\t\t").append(param.getSimpleName()).append(n).append('[').append(n).append("_i++] = (").append(translator.getSignature(true)).append(')');
if ( Buffer.class.isAssignableFrom(component_type) )
writer.println("(*env)->GetDirectBufferAddress(env, " + n + "_object);");
writer.append("(*env)->GetDirectBufferAddress(env, ");
else
writer.println("(intptr_t)getPointerWrapperAddress(env, " + n + "_object);");
writer.println("\t}");
writer.append("(intptr_t)getPointerWrapperAddress(env, ");
writer.append(n).append("_object);\n")
.append("\t}\n");
} else {
final String lengths = pointerArray_annotation.lengths();
// Init vars
writer.println("\t" + n + "_i = 0;");
writer.println("\t" + n + "_address = (" + translator.getSignature(true) + ")" + param.getSimpleName() + BUFFER_ADDRESS_POSTFIX + ";");
writer.append('\t').append(n).append("_i = 0;\n");
writer.append('\t').append(n).append("_address = (").append(translator.getSignature(true)).append(')').append(param.getSimpleName()).append(BUFFER_ADDRESS_POSTFIX + ";\n");
// Fill string array with the string pointers
writer.println("\twhile ( " + n + "_i < " + pointerArray_annotation.value() + " ) {");
writer.append("\twhile ( ").append(n).append("_i < ").append(pointerArray_annotation.value()).append(" ) {\n");
if ( lengths.length() == 0 ) {
writer.println("\t\t" + param.getSimpleName() + n + "[" + n + "_i++] = " + n + "_address;");
writer.println("\t\t" + n + "_address += strlen((const char *)" + n + "_address) + 1;");
writer.append("\t\t").append(param.getSimpleName()).append(n).append('[').append(n).append("_i++] = ").append(n).append("_address;\n");
writer.append("\t\t").append(n).append("_address += strlen((const char *)").append(n).append("_address) + 1;\n");
} else {
writer.println("\t\t" + param.getSimpleName() + n + "[" + n + "_i] = " + n + "_address;");
writer.println("\t\t" + n + "_address += " + lengths + BUFFER_ADDRESS_POSTFIX + "[" + n + "_i++];");
writer.append("\t\t").append(param.getSimpleName()).append(n).append('[').append(n).append("_i] = ").append(n).append("_address;\n");
writer.append("\t\t").append(n).append("_address += ").append(lengths).append(BUFFER_ADDRESS_POSTFIX + "[").append(n).append("_i++];\n");
}
writer.println("\t}");
writer.append("\t}\n");
}
}
}

5
src/java/org/lwjgl/util/generator/NativeTypeTranslator.java
View File

@ -214,7 +214,10 @@ public class NativeTypeTranslator extends SimpleTypeVisitor6<Void, Void> {
* @discuss compare (DeclaredType).getAnnotation(Class) and (Element).getAnnotation(Class), they mean different Annotation's.
*/
public static <T extends Annotation> T getAnnotation(AnnotationMirror annotation, Class<T> type) {
return annotation.getAnnotationType().asElement().getAnnotation(type);
Element e = annotation.getAnnotationType().asElement();
synchronized (e) {
return e.getAnnotation(type);
}
}
private static Class translateAnnotation(AnnotationMirror annotation) {

1
src/java/org/lwjgl/util/generator/TypeMap.java
View File

@ -51,7 +51,6 @@ public interface TypeMap {
void printCapabilitiesInit(PrintWriter writer);
String getCapabilities();
String getAPIUtilParam(boolean comma);
void printErrorCheckMethod(PrintWriter writer, ExecutableElement method, String tabs);
String getRegisterNativesFunctionName();
TypeKind getPrimitiveTypeFromNativeType(Class<? extends Annotation> native_type);
String getTypedefPostfix();

64
src/java/org/lwjgl/util/generator/Utils.java
View File

@ -206,11 +206,11 @@ public class Utils {
String doc_comment = pe.getElementUtils().getDocComment(decl);
if ( doc_comment != null ) {
final String tab = (decl instanceof TypeElement) ? "" : "\t";
writer.println(tab + "/**");
writer.append(tab).append("/**\n");
if ( overloadsComment != null ) {
writer.println("\t * " + overloadsComment);
writer.println("\t * <p>");
writer.append("\t * ").append(overloadsComment).append('\n');
writer.append("\t * <p>").append('\n');
}
final StringTokenizer doc_lines = new StringTokenizer(doc_comment, "\n", true);
@ -219,18 +219,18 @@ public class Utils {
final String t = doc_lines.nextToken();
if ( "\n".equals(t) ) {
if ( lastWasNL ) {
writer.println(tab + " * <p>");
writer.append(tab).append(" * <p>").append('\n');
}
lastWasNL = true;
} else {
writer.println(tab + " * " + t);
writer.append(tab).append(" * ").append(t).append('\n');
lastWasNL = false;
}
}
writer.println(tab + " */");
writer.append(tab).append(" */\n");
} else if ( overloadsComment != null ) {
writer.println("\t/** " + overloadsComment + " */");
writer.append("\t/** ").append(overloadsComment).append(" */\n");
}
}
@ -331,9 +331,9 @@ public class Utils {
}
public static void printExtraCallArguments(PrintWriter writer, ExecutableElement method, String size_parameter_name) {
writer.print(size_parameter_name);
writer.append(size_parameter_name);
if ( method.getAnnotation(CachedResult.class) != null ) {
writer.print(", " + CACHED_BUFFER_NAME);
writer.append(", ").append(CACHED_BUFFER_NAME);
}
}
@ -451,10 +451,9 @@ public class Utils {
if ( "String".equals(return_type) ) {
if ( !return_annotation.forceMaxLength() ) {
writer.println("IntBuffer " + return_annotation.value() + "_length = APIUtil.getLengths(" + type_map.getAPIUtilParam(false) + ");");
writer.print("\t\t");
writer.append("IntBuffer ").append(return_annotation.value()).append("_length = APIUtil.getLengths(").append(type_map.getAPIUtilParam(false)).append(");\n\t\t");
}
writer.print("ByteBuffer " + return_annotation.value() + " = APIUtil.getBufferByte(" + type_map.getAPIUtilParam(true) + return_annotation.maxLength());
writer.append("ByteBuffer ").append(return_annotation.value()).append(" = APIUtil.getBufferByte(").append(type_map.getAPIUtilParam(true)).append(return_annotation.maxLength());
/*
Params that use the return buffer will advance its position while filling it. When we return, the position will be
at the right spot for grabbing the returned string bytes. We only have to make sure that the original buffer was
@ -462,24 +461,27 @@ public class Utils {
*/
final String offset = getStringOffset(method, null);
if ( offset != null ) {
writer.print(" + " + offset);
writer.append(" + ").append(offset);
}
writer.println(");");
writer.append(");\n");
} else {
final String buffer_type = "Boolean".equals(return_type) ? "Byte" : return_type;
writer.print(buffer_type + "Buffer " + return_annotation.value() + " = APIUtil.getBuffer" + buffer_type + "(" + type_map.getAPIUtilParam(false));
writer.append(buffer_type).append("Buffer ").append(return_annotation.value()).append(" = APIUtil.getBuffer").append(buffer_type).append('(').append(type_map.getAPIUtilParam(false));
if ( "Byte".equals(buffer_type) ) {
writer.print((type_map.getAPIUtilParam(false).length() > 0 ? ", " : "") + "1");
if (type_map.getAPIUtilParam(false).length() > 0) {
writer.append(", ");
}
writer.append('1');
}
writer.println(");");
writer.append(");\n");
}
final Code code_annotation = method.getAnnotation(Code.class);
if ( code_annotation != null && code_annotation.tryBlock() ) {
writer.println("\t\ttry {");
writer.print("\t\t\t");
writer.append("\t\ttry {\n");
writer.append("\t\t\t");
} else {
writer.print("\t\t");
writer.append("\t\t");
}
}
@ -487,33 +489,33 @@ public class Utils {
final String return_type = getMethodReturnType(method, return_annotation, true);
if ( "String".equals(return_type) ) {
writer.print("\t\t" + return_annotation.value() + ".limit(");
writer.append("\t\t").append(return_annotation.value()).append(".limit(");
final String offset = getStringOffset(method, null);
if ( offset != null ) {
writer.print(offset + " + ");
writer.append(offset).append(" + ");
}
if ( return_annotation.forceMaxLength() ) {
writer.print(return_annotation.maxLength());
writer.append(return_annotation.maxLength());
} else {
writer.print(return_annotation.value() + "_length.get(0)");
writer.append(return_annotation.value()).append("_length.get(0)");
}
writer.println(");");
writer.println("\t\treturn APIUtil.getString(" + type_map.getAPIUtilParam(true) + return_annotation.value() + ");");
writer.append(");\n");
writer.append("\t\treturn APIUtil.getString(").append(type_map.getAPIUtilParam(true)).append(return_annotation.value()).append(");\n");
} else {
writer.print("\t\treturn " + return_annotation.value() + ".get(0)");
writer.append("\t\treturn ").append(return_annotation.value()).append(".get(0)");
if ( "Boolean".equals(return_type) ) {
writer.print(" == 1");
writer.append(" == 1");
}
writer.println(";");
writer.append(";\n");
}
}
public static Collection<VariableElement> getFields(TypeElement d) {
return ElementFilter.fieldsIn(new LinkedHashSet<Element>(d.getEnclosedElements()));
return ElementFilter.fieldsIn(d.getEnclosedElements());
}
public static Collection<ExecutableElement> getMethods(TypeElement d) {
return ElementFilter.methodsIn(new LinkedHashSet<Element>(d.getEnclosedElements()));
return ElementFilter.methodsIn(d.getEnclosedElements());
}
}

5
src/java/org/lwjgl/util/generator/openal/ALTypeMap.java
View File

@ -190,11 +190,6 @@ public class ALTypeMap implements TypeMap {
return "";
}
@Override
public void printErrorCheckMethod(final PrintWriter writer, final ExecutableElement method, final String tabs) {
writer.println(tabs + "Util.checkALError();");
}
@Override
public String getRegisterNativesFunctionName() {
return "extal_InitializeClass";

4
src/java/org/lwjgl/util/generator/opencl/CLGeneratorProcessor.java
View File

@ -134,7 +134,7 @@ public class CLGeneratorProcessor extends AbstractProcessor {
}
writer.println("}");
saveGeneratedJavaSource(processingEnv, genJavaPath, "org.lwjgl.opencl." + CLCAPS_CLASS_NAME, writer1.toString(), startTime);
saveGeneratedJavaSource(processingEnv.getMessager(), genJavaPath, "org.lwjgl.opencl." + CLCAPS_CLASS_NAME, writer1.toString(), startTime);
}
private void generateCLPDCapabilitiesSource(Path genJavaPath, Set<TypeElement> templates, final Class<? extends Annotation> capsType, final String capsName, final Class<? extends PointerWrapper> objectType, final String objectName) throws IOException {
@ -161,6 +161,6 @@ public class CLGeneratorProcessor extends AbstractProcessor {
CLPDCapabilitiesGenerator.generateToString(writer, templates, capsType);
writer.println("}");
saveGeneratedJavaSource(processingEnv, genJavaPath, "org.lwjgl.opencl." + capsName, writer1.toString(), startTime);
saveGeneratedJavaSource(processingEnv.getMessager(), genJavaPath, "org.lwjgl.opencl." + capsName, writer1.toString(), startTime);
}
}

25
src/java/org/lwjgl/util/generator/opencl/CLTypeMap.java
View File

@ -96,29 +96,6 @@ public class CLTypeMap implements TypeMap {
return "";
}
@Override
public void printErrorCheckMethod(final PrintWriter writer, final ExecutableElement method, final String tabs) {
final Check check = method.getAnnotation(Check.class);
if ( check != null ) // Get the error code from an IntBuffer output parameter
writer.println(tabs + "Util.checkCLError(" + check.value() + ".get(" + check.value() + ".position()));");
else {
final Class return_type = Utils.getJavaType(method.getReturnType());
if ( return_type == int.class )
writer.println(tabs + "Util.checkCLError(__result);");
else {
boolean hasErrCodeParam = false;
for ( final VariableElement param : method.getParameters() ) {
if ( "errcode_ret".equals(param.getSimpleName().toString()) && Utils.getJavaType(param.asType()) == IntBuffer.class ) {
hasErrCodeParam = true;
break;
}
}
if ( hasErrCodeParam )
throw new RuntimeException("A method is missing the @Check annotation: " + method.toString());
}
}
}
@Override
public String getRegisterNativesFunctionName() {
return "extcl_InitializeClass";
@ -285,4 +262,4 @@ public class CLTypeMap implements TypeMap {
public String getAutoTypeFromAnnotation(AnnotationMirror annotation) {
return null;
}
}
}

192
src/java/org/lwjgl/util/generator/opengl/GLCapabilitiesGenerator.java
View File

@ -62,19 +62,18 @@ public class GLCapabilitiesGenerator {
private static final String CORE_PREFIX = "Open";
public static void generateClassPrologue(PrintWriter writer, boolean context_specific, boolean generate_error_checks) {
writer.println("public class " + Utils.CONTEXT_CAPS_CLASS_NAME + " {");
writer.println("\tstatic final boolean DEBUG = " + Boolean.toString(generate_error_checks) + ";");
writer.println("\tfinal APIUtil util = new APIUtil();");
writer.println("\tfinal StateTracker tracker = new StateTracker();");
writer.println();
writer.append("public class " + Utils.CONTEXT_CAPS_CLASS_NAME + " {\n");
writer.append("\tstatic final boolean DEBUG = ").append(Boolean.toString(generate_error_checks)).append(";\n");
writer.append("\tfinal APIUtil util = new APIUtil();\n");
writer.append("\tfinal StateTracker tracker = new StateTracker();\n\n");
if ( !context_specific ) {
writer.println("\tprivate static boolean " + STUBS_LOADED_NAME + " = false;");
writer.append("\tprivate static boolean " + STUBS_LOADED_NAME + " = false;\n");
}
}
public static void generateInitializerPrologue(PrintWriter writer) {
writer.println("\t" + Utils.CONTEXT_CAPS_CLASS_NAME + "(boolean forwardCompatible) throws LWJGLException {");
writer.println("\t\tSet<String> " + CACHED_EXTS_VAR_NAME + " = " + ALL_INIT_METHOD_NAME + "(forwardCompatible);");
writer.append("\t" + Utils.CONTEXT_CAPS_CLASS_NAME + "(boolean forwardCompatible) throws LWJGLException {\n");
writer.append("\t\tSet<String> " + CACHED_EXTS_VAR_NAME + " = " + ALL_INIT_METHOD_NAME + "(forwardCompatible);\n");
}
private static String translateFieldName(String interface_name) {
@ -90,34 +89,34 @@ public class GLCapabilitiesGenerator {
throw new RuntimeException(d + " extends more than one other interface");
if ( super_interfaces.size() == 1 ) {
TypeMirror super_interface = super_interfaces.iterator().next();
writer.print("\t\tif (" + CACHED_EXTS_VAR_NAME + ".contains(\"");
writer.println(translateFieldName(d.getSimpleName().toString()) + "\"))");
writer.print("\t\t\t");
writer.append("\t\tif (").append(CACHED_EXTS_VAR_NAME).append(".contains(\"");
writer.append(translateFieldName(d.getSimpleName().toString())).append("\"))\n");
writer.append("\t\t\t");
generateAddExtension(writer, env.getElementUtils().getTypeElement(super_interface.toString()));
}
}
public static void generateInitializer(PrintWriter writer, TypeElement d, ProcessingEnvironment env) {
String translated_field_name = translateFieldName(d.getSimpleName().toString());
writer.print("\t\tthis." + translated_field_name + " = ");
writer.print(CACHED_EXTS_VAR_NAME + ".contains(\"");
writer.print(translated_field_name + "\")");
writer.append("\t\tthis.").append(translated_field_name).append(" = ");
writer.append(CACHED_EXTS_VAR_NAME + ".contains(\"");
writer.append(translated_field_name).append("\")");
List<? extends TypeMirror> super_interfaces = d.getInterfaces();
if ( super_interfaces.size() > 1 )
throw new RuntimeException(d + " extends more than one other interface");
if ( super_interfaces.size() == 1 ) {
TypeMirror super_interface = super_interfaces.iterator().next();
writer.println();
writer.print("\t\t\t&& " + CACHED_EXTS_VAR_NAME + ".contains(\"");
writer.print(translateFieldName(env.getElementUtils().getTypeElement(super_interface.toString()).getSimpleName().toString()) + "\")");
writer.append('\n');
writer.append("\t\t\t&& ").append(CACHED_EXTS_VAR_NAME).append(".contains(\"");
writer.append(translateFieldName(env.getElementUtils().getTypeElement(super_interface.toString()).getSimpleName().toString())).append("\")");
}
Alias alias_annotation = d.getAnnotation(Alias.class);
if ( alias_annotation != null ) {
writer.println();
writer.print("\t\t\t|| " + CACHED_EXTS_VAR_NAME + ".contains(\"");
writer.print(translateFieldName(alias_annotation.value()) + "\")");
writer.append('\n');
writer.append("\t\t\t|| ").append(CACHED_EXTS_VAR_NAME).append(".contains(\"");
writer.append(translateFieldName(alias_annotation.value())).append("\")");
}
writer.println(";");
writer.append(";\n");
}
private static String getAddressesInitializerName(String class_name) {
@ -125,48 +124,47 @@ public class GLCapabilitiesGenerator {
}
public static void generateInitStubsPrologue(PrintWriter writer, boolean context_specific) {
writer.println("\tprivate Set<String> " + ALL_INIT_METHOD_NAME + "(boolean forwardCompatible) throws LWJGLException {");
writer.append("\tprivate Set<String> ").append(ALL_INIT_METHOD_NAME).append("(boolean forwardCompatible) throws LWJGLException {\n");
// Load the basic pointers we need to detect OpenGL version and supported extensions.
writer.println("\t\tglGetError = GLContext.getFunctionAddress(\"glGetError\");");
writer.println("\t\tglGetString = GLContext.getFunctionAddress(\"glGetString\");");
writer.append("\t\tglGetError = GLContext.getFunctionAddress(\"glGetError\");\n");
writer.append("\t\tglGetString = GLContext.getFunctionAddress(\"glGetString\");\n");
// Initialize GL11.glGetIntegerv and GL30.glGetStringi here, in case we have created an OpenGL 3.0 context.
// (they will be used in GLContext.getSupportedExtensions)
writer.println("\t\tglGetIntegerv = GLContext.getFunctionAddress(\"glGetIntegerv\");");
writer.println("\t\tglGetStringi = GLContext.getFunctionAddress(\"glGetStringi\");");
writer.append("\t\tglGetIntegerv = GLContext.getFunctionAddress(\"glGetIntegerv\");\n");
writer.append("\t\tglGetStringi = GLContext.getFunctionAddress(\"glGetStringi\");\n");
// Get the supported extensions set.
writer.println("\t\tGLContext.setCapabilities(this);");
writer.println("\t\tSet<String> " + CACHED_EXTS_VAR_NAME + " = new HashSet<String>(256);");
writer.println("\t\tint " + PROFILE_MASK_VAR_NAME + " = GLContext.getSupportedExtensions(" + CACHED_EXTS_VAR_NAME + ");");
writer.append("\t\tGLContext.setCapabilities(this);\n");
writer.append("\t\tSet<String> " + CACHED_EXTS_VAR_NAME + " = new HashSet<String>(256);\n");
writer.append("\t\tint " + PROFILE_MASK_VAR_NAME + " = GLContext.getSupportedExtensions(" + CACHED_EXTS_VAR_NAME + ");\n");
// Force forward compatible mode when OpenGL version is 3.1 or higher and ARB_compatibility is not available.
writer.println("\t\tif ( supported_extensions.contains(\"OpenGL31\") && !(supported_extensions.contains(\"GL_ARB_compatibility\") || (profileMask & GL32.GL_CONTEXT_COMPATIBILITY_PROFILE_BIT) != 0) )");
writer.println("\t\t\tforwardCompatible = true;");
writer.append("\t\tif ( supported_extensions.contains(\"OpenGL31\") && !(supported_extensions.contains(\"GL_ARB_compatibility\") || (profileMask & GL32.GL_CONTEXT_COMPATIBILITY_PROFILE_BIT) != 0) )\n");
writer.append("\t\t\tforwardCompatible = true;\n");
if ( !context_specific ) {
writer.println("\t\tif (" + STUBS_LOADED_NAME + ")");
writer.println("\t\t\treturn GLContext.getSupportedExtensions();");
writer.println("\t\torg.lwjgl.opengl.GL11." + Utils.STUB_INITIALIZER_NAME + "();");
writer.append("\t\tif (" + STUBS_LOADED_NAME + ")\n");
writer.append("\t\t\treturn GLContext.getSupportedExtensions();\n");
writer.append("\t\torg.lwjgl.opengl.GL11." + Utils.STUB_INITIALIZER_NAME + "();\n");
} else {
writer.println("\t\tif (!" + getAddressesInitializerName("GL11") + "(forwardCompatible))");
writer.println("\t\t\tthrow new LWJGLException(\"GL11 not supported\");");
writer.append("\t\tif (!").append(getAddressesInitializerName("GL11")).append("(forwardCompatible))\n");
writer.append("\t\t\tthrow new LWJGLException(\"GL11 not supported\");\n");
}
}
public static void generateInitStubsEpilogue(PrintWriter writer, boolean context_specific) {
if ( !context_specific ) {
writer.println("\t\t" + STUBS_LOADED_NAME + " = true;");
writer.append("\t\t" + STUBS_LOADED_NAME + " = true;\n");
}
writer.println("\t\treturn " + CACHED_EXTS_VAR_NAME + ";");
writer.println("\t}");
writer.append("\t\treturn " + CACHED_EXTS_VAR_NAME + ";\n");
writer.append("\t}\n");
}
public static void generateUnloadStubs(ProcessingEnvironment env, PrintWriter writer, TypeElement d) {
if ( Utils.getMethods(d).size() > 0 ) {
writer.print("\t\tGLContext.resetNativeStubs(" + Utils.getSimpleClassName(d));
writer.println(".class);");
writer.append("\t\tGLContext.resetNativeStubs(").append(Utils.getSimpleClassName(d)).append(".class);\n");
}
}
@ -176,44 +174,41 @@ public class GLCapabilitiesGenerator {
final Alias alias_annotation = d.getAnnotation(Alias.class);
if ( d.getAnnotation(ForceInit.class) != null )
writer.println("\t\t" + CACHED_EXTS_VAR_NAME + ".add(\"" + translateFieldName(d.getSimpleName().toString()) + "\");");
writer.print("\t\tif (");
writer.append("\t\t" + CACHED_EXTS_VAR_NAME + ".add(\"").append(translateFieldName(d.getSimpleName().toString())).append("\");\n");
writer.append("\t\tif (");
if ( alias_annotation != null )
writer.print("(");
writer.print(CACHED_EXTS_VAR_NAME + ".contains(\"");
writer.print(translateFieldName(d.getSimpleName().toString()) + "\")");
writer.append('(');
writer.append(CACHED_EXTS_VAR_NAME + ".contains(\"");
writer.append(translateFieldName(d.getSimpleName().toString())).append("\")");
if ( alias_annotation != null ) {
writer.print(" || " + CACHED_EXTS_VAR_NAME + ".contains(\"");
writer.print(translateFieldName(alias_annotation.value()) + "\"))");
writer.append(" || " + CACHED_EXTS_VAR_NAME + ".contains(\"");
writer.append(translateFieldName(alias_annotation.value())).append("\"))");
}
writer.print(" && !" + getAddressesInitializerName(d.getSimpleName().toString()) + "(");
writer.append(" && !").append(getAddressesInitializerName(d.getSimpleName().toString())).append('(');
if ( d.getAnnotation(DeprecatedGL.class) != null )
writer.print("forwardCompatible");
writer.append("forwardCompatible");
if ( d.getAnnotation(Dependent.class) != null ) {
if ( d.getAnnotation(DeprecatedGL.class) != null )
writer.print(",");
writer.print("supported_extensions");
writer.append(",");
writer.append("supported_extensions");
}
if ( alias_annotation != null ) {
writer.println(")) {");
writer.print("\t\t\tremove(" + CACHED_EXTS_VAR_NAME + ", \"");
writer.println(translateFieldName(alias_annotation.value()) + "\");");
writer.append(")) {\n");
writer.append("\t\t\tremove(" + CACHED_EXTS_VAR_NAME + ", \"").append(translateFieldName(alias_annotation.value())).append("\");\n");
} else
writer.println("))");
writer.print("\t\t\tremove(" + CACHED_EXTS_VAR_NAME + ", \"");
writer.println(translateFieldName(d.getSimpleName().toString()) + "\");");
writer.append("))\n");
writer.append("\t\t\tremove(" + CACHED_EXTS_VAR_NAME + ", \"").append(translateFieldName(d.getSimpleName().toString())).append("\");\n");
if ( alias_annotation != null )
writer.println("\t\t}");
writer.append("\t\t}\n");
} else {
writer.print("\t\tGLContext." + Utils.STUB_INITIALIZER_NAME + "(" + Utils.getSimpleClassName(d));
writer.println(".class, " + CACHED_EXTS_VAR_NAME + ", \"" + translateFieldName(d.getSimpleName().toString()) + "\");");
writer.append("\t\tGLContext." + Utils.STUB_INITIALIZER_NAME + "(").append(Utils.getSimpleClassName(d));
writer.append(".class, " + CACHED_EXTS_VAR_NAME + ", \"").append(translateFieldName(d.getSimpleName().toString())).append("\");\n");
}
}
}
private static void generateAddExtension(PrintWriter writer, TypeElement d) {
writer.print(CACHED_EXTS_VAR_NAME + ".add(\"");
writer.println(translateFieldName(d.getSimpleName().toString()) + "\");");
writer.append(CACHED_EXTS_VAR_NAME + ".add(\"").append(translateFieldName(d.getSimpleName().toString())).append("\");\n");
}
public static void generateAddressesInitializers(ProcessingEnvironment env, PrintWriter writer, TypeElement d) {
@ -221,24 +216,24 @@ public class GLCapabilitiesGenerator {
if ( !methods.hasNext() )
return;
writer.print("\tprivate boolean " + getAddressesInitializerName(d.getSimpleName().toString()) + "(");
writer.append("\tprivate boolean ").append(getAddressesInitializerName(d.getSimpleName().toString())).append('(');
boolean optional;
boolean deprecated = d.getAnnotation(DeprecatedGL.class) != null;
Dependent dependent = d.getAnnotation(Dependent.class);
if ( deprecated )
writer.print("boolean forwardCompatible");
writer.append("boolean forwardCompatible");
if ( dependent != null ) {
if ( deprecated )
writer.print(",");
writer.print("Set<String> supported_extensions");
writer.append(',');
writer.append("Set<String> supported_extensions");
}
Alias alias_annotation = d.getAnnotation(Alias.class);
boolean aliased = alias_annotation != null && alias_annotation.postfix().length() > 0;
writer.println(") {");
writer.println("\t\treturn ");
writer.append(") {\n");
writer.append("\t\treturn \n");
boolean first = true;
while ( methods.hasNext() ) {
@ -247,7 +242,7 @@ public class GLCapabilitiesGenerator {
continue;
if ( !first )
writer.println(" &");
writer.append(" &\n");
else
first = false;
@ -255,58 +250,57 @@ public class GLCapabilitiesGenerator {
deprecated = method.getAnnotation(DeprecatedGL.class) != null;
dependent = method.getAnnotation(Dependent.class);
writer.print("\t\t\t(");
writer.append("\t\t\t(");
if ( optional )
writer.print('(');
writer.append('(');
if ( deprecated )
writer.print("forwardCompatible || ");
writer.append("forwardCompatible || ");
if ( dependent != null ) {
if ( dependent.value().indexOf(',') == -1 )
writer.print("!supported_extensions.contains(\"" + dependent.value() + "\") || ");
writer.append("!supported_extensions.contains(\"").append(dependent.value()).append("\") || ");
else {
writer.print("!(false");
writer.append("!(false");
for ( String extension : dependent.value().split(",") )
writer.print(" || supported_extensions.contains(\"" + extension + "\")");
writer.print(") || ");
writer.append(" || supported_extensions.contains(\"").append(extension).append("\")");
writer.append(") || ");
}
}
if ( deprecated || dependent != null )
writer.print('(');
writer.print(Utils.getFunctionAddressName(d, method) + " = ");
writer.append('(');
writer.append(Utils.getFunctionAddressName(d, method)).append(" = ");
PlatformDependent platform_dependent = method.getAnnotation(PlatformDependent.class);
if ( platform_dependent != null ) {
EnumSet<Platform> platform_set = EnumSet.copyOf(Arrays.asList(platform_dependent.value()));
writer.print("GLContext.getPlatformSpecificFunctionAddress(\"");
writer.print(Platform.ALL.getPrefix() + "\", ");
writer.print("new String[]{");
writer.append("GLContext.getPlatformSpecificFunctionAddress(\"");
writer.append(Platform.ALL.getPrefix()).append("\", ");
writer.append("new String[]{");
Iterator<Platform> platforms = platform_set.iterator();
while ( platforms.hasNext() ) {
writer.print("\"" + platforms.next().getOSPrefix() + "\"");
writer.append("\"").append(platforms.next().getOSPrefix()).append("\"");
if ( platforms.hasNext() )
writer.print(", ");
writer.append(", ");
}
writer.print("}, new String[]{");
writer.append("}, new String[]{");
platforms = platform_set.iterator();
while ( platforms.hasNext() ) {
writer.print("\"" + platforms.next().getPrefix() + "\"");
writer.append("\"").append(platforms.next().getPrefix()).append("\"");
if ( platforms.hasNext() )
writer.print(", ");
writer.append(", ");
}
writer.print("}, ");
writer.append("}, ");
} else if ( aliased ) {
writer.print("GLContext.getFunctionAddress(new String[] {\"" + method.getSimpleName() + "\",\"" + method.getSimpleName() + alias_annotation.postfix() + "\"})) != 0");
writer.append("GLContext.getFunctionAddress(new String[] {\"").append(method.getSimpleName()).append("\",\"").append(method.getSimpleName()).append(alias_annotation.postfix()).append("\"})) != 0");
} else
writer.print("GLContext.getFunctionAddress(");
writer.append("GLContext.getFunctionAddress(");
if ( !aliased )
writer.print("\"" + method.getSimpleName() + "\")) != 0");
writer.append("\"").append(method.getSimpleName()).append("\")) != 0");
if ( deprecated || dependent != null )
writer.print(')');
writer.append(')');
if ( optional )
writer.print(" || true)");
writer.append(" || true)");
}
writer.println(";");
writer.println("\t}");
writer.println();
writer.append(";\n");
writer.append("\t}\n");
}
public static void generateSymbolAddresses(ProcessingEnvironment env, PrintWriter writer, TypeElement d) {
@ -316,14 +310,14 @@ public class GLCapabilitiesGenerator {
continue;
if ( first ) {
writer.println("\t// " + d.getSimpleName());
writer.append("\t// ").append(d.getSimpleName()).append('\n');
first = false;
}
writer.println("\tlong " + Utils.getFunctionAddressName(d, method) + ";");
writer.append("\tlong ").append(Utils.getFunctionAddressName(d, method)).append(";\n");
}
}
public static void generateField(PrintWriter writer, TypeElement d) {
writer.println("\tpublic final boolean " + translateFieldName(d.getSimpleName().toString()) + ";");
writer.append("\tpublic final boolean ").append(translateFieldName(d.getSimpleName().toString())).append(";\n");
}
}

5
src/java/org/lwjgl/util/generator/opengl/GLESTypeMap.java
View File

@ -107,11 +107,6 @@ public class GLESTypeMap implements TypeMap {
return "";
}
@Override
public void printErrorCheckMethod(final PrintWriter writer, final ExecutableElement method, final String tabs) {
writer.println(tabs + "Util.checkGLError();");
}
@Override
public String getRegisterNativesFunctionName() {
return "extgl_InitializeClass";

4
src/java/org/lwjgl/util/generator/opengl/GLGeneratorProcessor.java
View File

@ -123,7 +123,7 @@ public class GLGeneratorProcessor extends AbstractProcessor {
}
writer.println("\tprivate static void remove(Set supported_extensions, String extension) {");
writer.println("\t\tLWJGLUtil.log(extension + \" was reported as available but an entry point is missing\");");
writer.println("\t\tLWJGLUtil.logger().log(() -> extension + \" was reported as available but an entry point is missing\");");
writer.println("\t\tsupported_extensions.remove(extension);");
writer.println("\t}\n");
@ -169,6 +169,6 @@ public class GLGeneratorProcessor extends AbstractProcessor {
writer.println("\t}");
writer.println("}");
saveGeneratedJavaSource(env, genJavaPath, "org.lwjgl.opengl." + Utils.CONTEXT_CAPS_CLASS_NAME, writer1.toString(), startTime);
saveGeneratedJavaSource(env.getMessager(), genJavaPath, "org.lwjgl.opengl." + Utils.CONTEXT_CAPS_CLASS_NAME, writer1.toString(), startTime);
}
}

2
src/java/org/lwjgl/util/generator/opengl/GLReferencesGeneratorProcessor.java
View File

@ -196,7 +196,7 @@ public class GLReferencesGeneratorProcessor extends AbstractProcessor {
writer.println("\t}");
writer.println("}");
saveGeneratedJavaSource(env, genJavaPath, "org.lwjgl.opengl." + REFERENCES_CLASS_NAME, writer1.toString(), startTime);
saveGeneratedJavaSource(env.getMessager(), genJavaPath, "org.lwjgl.opengl." + REFERENCES_CLASS_NAME, writer1.toString(), startTime);
}
}

5
src/java/org/lwjgl/util/generator/opengl/GLTypeMap.java
View File

@ -113,11 +113,6 @@ public class GLTypeMap implements TypeMap {
return comma ? "caps, " : "caps";
}
@Override
public void printErrorCheckMethod(final PrintWriter writer, final ExecutableElement method, final String tabs) {
writer.println(tabs + "Util.checkGLError();");
}
@Override
public String getRegisterNativesFunctionName() {
return "extgl_InitializeClass";