aboutsummaryrefslogtreecommitdiffstats
path: root/src/java/com/sun/gluegen/opengl/BuildComposablePipeline.java
diff options
context:
space:
mode:
authorMichael Bien <[email protected]>2010-03-31 19:05:36 +0200
committerMichael Bien <[email protected]>2010-03-31 19:05:36 +0200
commitaf9ff963c4120731ec65ed1a9628e82d1f5b66e1 (patch)
treebd1418732573f4dafe1a7b3cecd067fed4e238cb /src/java/com/sun/gluegen/opengl/BuildComposablePipeline.java
parent384c1d6d39e345d092965ec926de249fc6ff2bb4 (diff)
refactoring and code cleanup in gluegen.opengl and gluegen.procaddress package.
Diffstat (limited to 'src/java/com/sun/gluegen/opengl/BuildComposablePipeline.java')
-rw-r--r--src/java/com/sun/gluegen/opengl/BuildComposablePipeline.java1942
1 files changed, 952 insertions, 990 deletions
diff --git a/src/java/com/sun/gluegen/opengl/BuildComposablePipeline.java b/src/java/com/sun/gluegen/opengl/BuildComposablePipeline.java
index cbc0d894c..9750c13df 100644
--- a/src/java/com/sun/gluegen/opengl/BuildComposablePipeline.java
+++ b/src/java/com/sun/gluegen/opengl/BuildComposablePipeline.java
@@ -36,7 +36,6 @@
* Sun gratefully acknowledges that this software was originally authored
* and developed by Kenneth Bradley Russell and Christopher John Kline.
*/
-
package com.sun.gluegen.opengl;
import com.sun.gluegen.*;
@@ -44,1079 +43,1042 @@ import com.sun.gluegen.*;
import java.lang.reflect.*;
import java.io.*;
import java.util.*;
-import java.util.regex.*;
-
-public class BuildComposablePipeline
-{
- public static final int GEN_DEBUG = 1 << 0 ; // default
- public static final int GEN_TRACE = 1 << 1 ; // default
- public static final int GEN_CUSTOM = 1 << 2 ;
- public static final int GEN_PROLOG_XOR_DOWNSTREAM = 1 << 3 ;
-
- int mode;
- private String outputDir;
- private String outputPackage;
- private String outputName;
- private Class classToComposeAround;
- private Class classPrologOpt;
- private Class classDownstream;
- private String basePackage;
- private String baseName; // does not include package!
- private String downstreamPackage;
- private String downstreamName; // does not include package!
-
- // Only desktop OpenGL has immediate mode glBegin / glEnd
- private boolean hasImmediateMode;
-
- // Desktop OpenGL and GLES1 have GL_STACK_OVERFLOW and GL_STACK_UNDERFLOW errors
- private boolean hasStackOverflow;
-
- public static Class getClass(String name) {
- Class clazz=null;
- try {
- clazz = Class.forName(name);
- } catch (Exception e) {
- throw new RuntimeException(
- "Could not find class \"" + name + "\"", e);
- }
- return clazz;
- }
-
- public static Method getMethod(Class clazz, Method m) {
- Method res = null;
- try {
- res = clazz.getMethod(m.getName(), m.getParameterTypes());
- } catch (Exception e) { }
- return res;
- }
-
- public static void main(String[] args)
- {
- String classToComposeAroundName = args[0];
- Class classPrologOpt, classDownstream;
- Class classToComposeAround = getClass(classToComposeAroundName);
-
- String outputDir = args[1];
- String outputPackage, outputName;
+
+public class BuildComposablePipeline {
+
+ public static final int GEN_DEBUG = 1 << 0; // default
+ public static final int GEN_TRACE = 1 << 1; // default
+ public static final int GEN_CUSTOM = 1 << 2;
+ public static final int GEN_PROLOG_XOR_DOWNSTREAM = 1 << 3;
int mode;
+ private String outputDir;
+ private String outputPackage;
+ private String outputName;
+ private Class<?> classToComposeAround;
+ private Class<?> classPrologOpt;
+ private Class<?> classDownstream;
+ // Only desktop OpenGL has immediate mode glBegin / glEnd
+ private boolean hasImmediateMode;
+ // Desktop OpenGL and GLES1 have GL_STACK_OVERFLOW and GL_STACK_UNDERFLOW errors
+ private boolean hasStackOverflow;
+
+ public static Class<?> getClass(String name) {
+ Class<?> clazz = null;
+ try {
+ clazz = Class.forName(name);
+ } catch (Exception e) {
+ throw new RuntimeException(
+ "Could not find class \"" + name + "\"", e);
+ }
+ return clazz;
+ }
- if(args.length>2) {
- String outputClazzName = args[2];
- outputPackage = getPackageName(outputClazzName);
- outputName = getBaseClassName(outputClazzName);
- classPrologOpt = getClass(args[3]);
- classDownstream = getClass(args[4]);
- mode = GEN_CUSTOM;
- if(args.length>5) {
- if(args[5].equals("prolog_xor_downstream")) {
- mode |= GEN_PROLOG_XOR_DOWNSTREAM;
+ public static Method getMethod(Class<?> clazz, Method m) {
+ Method res = null;
+ try {
+ res = clazz.getMethod(m.getName(), m.getParameterTypes());
+ } catch (Exception e) {
+ }
+ return res;
+ }
+
+ public static void main(String[] args) {
+ String classToComposeAroundName = args[0];
+ Class<?> classPrologOpt, classDownstream;
+ Class<?> classToComposeAround = getClass(classToComposeAroundName);
+
+ String outputDir = args[1];
+ String outputPackage, outputName;
+ int mode;
+
+ if (args.length > 2) {
+ String outputClazzName = args[2];
+ outputPackage = getPackageName(outputClazzName);
+ outputName = getBaseClassName(outputClazzName);
+ classPrologOpt = getClass(args[3]);
+ classDownstream = getClass(args[4]);
+ mode = GEN_CUSTOM;
+ if (args.length > 5) {
+ if (args[5].equals("prolog_xor_downstream")) {
+ mode |= GEN_PROLOG_XOR_DOWNSTREAM;
+ }
}
+ } else {
+ outputPackage = getPackageName(classToComposeAroundName);
+ outputName = null; // TBD ..
+ classPrologOpt = null;
+ classDownstream = classToComposeAround;
+ mode = GEN_DEBUG | GEN_TRACE;
}
- } else {
- outputPackage = getPackageName(classToComposeAroundName);
- outputName = null; // TBD ..
- classPrologOpt = null;
- classDownstream = classToComposeAround;
- mode = GEN_DEBUG | GEN_TRACE;
- }
- BuildComposablePipeline composer =
- new BuildComposablePipeline(mode, outputDir, outputPackage, outputName, classToComposeAround, classPrologOpt, classDownstream);
+ BuildComposablePipeline composer =
+ new BuildComposablePipeline(mode, outputDir, outputPackage, outputName, classToComposeAround, classPrologOpt, classDownstream);
- try
- {
- composer.emit();
- }
- catch (IOException e)
- {
- throw new RuntimeException(
- "Error generating composable pipeline source files", e);
- }
- }
-
- protected BuildComposablePipeline(int mode, String outputDir, String outputPackage, String outputName,
- Class classToComposeAround, Class classPrologOpt, Class classDownstream)
- {
- this.mode=mode;
- this.outputDir=outputDir;
- this.outputPackage=outputPackage;
- this.outputName=outputName;
- this.classToComposeAround=classToComposeAround;
- this.classPrologOpt=classPrologOpt;
- this.classDownstream=classDownstream;
-
- if (! classToComposeAround.isInterface())
- {
- throw new IllegalArgumentException(
- classToComposeAround.getName() + " is not an interface class");
- }
-
- try {
- hasImmediateMode =
- (classToComposeAround.getMethod("glBegin", new Class[] { Integer.TYPE }) != null);
- } catch (Exception e) {
+ try {
+ composer.emit();
+ } catch (IOException e) {
+ throw new RuntimeException(
+ "Error generating composable pipeline source files", e);
+ }
}
- try {
- hasStackOverflow =
- (classToComposeAround.getField("GL_STACK_OVERFLOW") != null);
- } catch (Exception e) {
- }
- }
-
- /**
- * Emit the java source code for the classes that comprise the composable
- * pipeline.
- */
- public void emit() throws IOException
- {
- List/*<Method>*/ publicMethodsRaw = new ArrayList();
- publicMethodsRaw.addAll(Arrays.asList(classToComposeAround.getMethods()));
- Set/*<Method>*/ publicMethodsPlain = new HashSet();
- for (Iterator iter=publicMethodsRaw.iterator(); iter.hasNext(); ) {
- Method method = (Method) iter.next();
- // Don't hook methods which aren't real GL methods,
- // such as the synthetic "isGL2ES2" "getGL2ES2"
- String name = method.getName();
- boolean runHooks = name.startsWith("gl");
- if (!name.startsWith("getGL") && !name.startsWith("isGL") && !name.equals("toString")) {
- publicMethodsPlain.add(new PlainMethod(method, runHooks));
+ protected BuildComposablePipeline(int mode, String outputDir, String outputPackage, String outputName,
+ Class<?> classToComposeAround, Class<?> classPrologOpt, Class<?> classDownstream) {
+ this.mode = mode;
+ this.outputDir = outputDir;
+ this.outputPackage = outputPackage;
+ this.outputName = outputName;
+ this.classToComposeAround = classToComposeAround;
+ this.classPrologOpt = classPrologOpt;
+ this.classDownstream = classDownstream;
+
+ if (!classToComposeAround.isInterface()) {
+ throw new IllegalArgumentException(
+ classToComposeAround.getName() + " is not an interface class");
+ }
+
+ try {
+ hasImmediateMode =
+ (classToComposeAround.getMethod("glBegin", new Class<?>[]{Integer.TYPE}) != null);
+ } catch (Exception e) {
}
- }
- if(0!=(mode&GEN_DEBUG)) {
- (new DebugPipeline(outputDir, outputPackage, classToComposeAround, classDownstream)).emit(publicMethodsPlain.iterator());
+ try {
+ hasStackOverflow =
+ (classToComposeAround.getField("GL_STACK_OVERFLOW") != null);
+ } catch (Exception e) {
+ }
}
- if(0!=(mode&GEN_TRACE)) {
- (new TracePipeline(outputDir, outputPackage, classToComposeAround, classDownstream)).emit(publicMethodsPlain.iterator());
+
+ /**
+ * Emit the java source code for the classes that comprise the composable
+ * pipeline.
+ */
+ public void emit() throws IOException {
+
+ List<Method> publicMethodsRaw = Arrays.asList(classToComposeAround.getMethods());
+
+ Set<PlainMethod> publicMethodsPlain = new HashSet<PlainMethod>();
+ for (Iterator<Method> iter = publicMethodsRaw.iterator(); iter.hasNext();) {
+ Method method = iter.next();
+ // Don't hook methods which aren't real GL methods,
+ // such as the synthetic "isGL2ES2" "getGL2ES2"
+ String name = method.getName();
+ boolean runHooks = name.startsWith("gl");
+ if (!name.startsWith("getGL") && !name.startsWith("isGL") && !name.equals("toString")) {
+ publicMethodsPlain.add(new PlainMethod(method, runHooks));
+ }
+ }
+
+ if (0 != (mode & GEN_DEBUG)) {
+ (new DebugPipeline(outputDir, outputPackage, classToComposeAround, classDownstream)).emit(publicMethodsPlain.iterator());
+ }
+ if (0 != (mode & GEN_TRACE)) {
+ (new TracePipeline(outputDir, outputPackage, classToComposeAround, classDownstream)).emit(publicMethodsPlain.iterator());
+ }
+ if (0 != (mode & GEN_CUSTOM)) {
+ (new CustomPipeline(mode, outputDir, outputPackage, outputName, classToComposeAround, classPrologOpt, classDownstream)).emit(publicMethodsPlain.iterator());
+ }
}
- if(0!=(mode&GEN_CUSTOM)) {
- (new CustomPipeline(mode, outputDir, outputPackage, outputName, classToComposeAround, classPrologOpt, classDownstream)).emit(publicMethodsPlain.iterator());
+
+ public static String getPackageName(String clazzName) {
+ int lastDot = clazzName.lastIndexOf('.');
+ if (lastDot == -1) {
+ // no package, class is at root level
+ return null;
+ }
+ return clazzName.substring(0, lastDot);
}
- }
-
- public static String getPackageName(String clazzName) {
- int lastDot = clazzName.lastIndexOf('.');
- if (lastDot == -1)
- {
- // no package, class is at root level
- return null;
- }
- return clazzName.substring(0, lastDot);
- }
-
- public static String getBaseClassName(String clazzName) {
- int lastDot = clazzName.lastIndexOf('.');
- if (lastDot == -1)
- {
- // no package, class is at root level
- return clazzName;
- }
- return clazzName.substring(lastDot+1);
- }
-
- //-------------------------------------------------------
-
- protected class PlainMethod
- {
- Method m;
- boolean runHooks;
-
- public PlainMethod(Method m, boolean runHooks) {
- this.m=m;
- this.runHooks = runHooks;
+
+ public static String getBaseClassName(String clazzName) {
+ int lastDot = clazzName.lastIndexOf('.');
+ if (lastDot == -1) {
+ // no package, class is at root level
+ return clazzName;
+ }
+ return clazzName.substring(lastDot + 1);
}
- public Method getWrappedMethod() { return m; }
+ //-------------------------------------------------------
+ protected class PlainMethod {
- public boolean runHooks() { return runHooks; }
+ Method m;
+ boolean runHooks;
- public boolean equals(Object obj) {
- if(obj instanceof PlainMethod) {
- PlainMethod b = (PlainMethod)obj;
- boolean res =
- m.getName().equals(b.m.getName()) &&
- m.getModifiers() == b.m.getModifiers() &&
- m.getReturnType().equals(b.m.getReturnType()) &&
- Arrays.equals( m.getParameterTypes() , b.m.getParameterTypes() ) ;
- return res;
+ PlainMethod(Method m, boolean runHooks) {
+ this.m = m;
+ this.runHooks = runHooks;
}
- return false;
- }
- public int hashCode() {
- int hash = m.getName().hashCode() ^ m.getModifiers() ^ m.getReturnType().hashCode();
- Class[] args = m.getParameterTypes();
- for(int i=0; i<args.length; i++) {
- hash ^= args[i].hashCode();
+ public Method getWrappedMethod() {
+ return m;
}
- return hash;
- }
- public String toString() {
- Class[] args = m.getParameterTypes();
- StringBuffer argsString = new StringBuffer();
- argsString.append("(");
- for (int i = 0; i < args.length; i++) {
- if (i > 0)
- argsString.append(", ");
- argsString.append(args[i].getName());
- }
- argsString.append(")");
- return m.toString() +
- "\n\tname: " + m.getName() +
- "\n\tmods: " + m.getModifiers() +
- "\n\tretu: " + m.getReturnType() +
- "\n\targs[" + args.length + "]: "+argsString.toString();
+ public boolean runHooks() {
+ return runHooks;
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (obj instanceof PlainMethod) {
+ PlainMethod b = (PlainMethod) obj;
+ boolean res =
+ m.getName().equals(b.m.getName())
+ && m.getModifiers() == b.m.getModifiers()
+ && m.getReturnType().equals(b.m.getReturnType())
+ && Arrays.equals(m.getParameterTypes(), b.m.getParameterTypes());
+ return res;
+ }
+ return false;
+ }
+
+ @Override
+ public int hashCode() {
+ int hash = m.getName().hashCode() ^ m.getModifiers() ^ m.getReturnType().hashCode();
+ Class<?>[] args = m.getParameterTypes();
+ for (int i = 0; i < args.length; i++) {
+ hash ^= args[i].hashCode();
+ }
+ return hash;
+ }
+
+ @Override
+ public String toString() {
+ Class<?>[] args = m.getParameterTypes();
+ StringBuilder argsString = new StringBuilder();
+ argsString.append("(");
+ for (int i = 0; i < args.length; i++) {
+ if (i > 0) {
+ argsString.append(", ");
+ }
+ argsString.append(args[i].getName());
+ }
+ argsString.append(")");
+ return m.toString()
+ + "\n\tname: " + m.getName()
+ + "\n\tmods: " + m.getModifiers()
+ + "\n\tretu: " + m.getReturnType()
+ + "\n\targs[" + args.length + "]: " + argsString.toString();
+ }
}
- }
-
- /**
- * Emits a Java source file that represents one element of the composable
- * pipeline.
- */
- protected abstract class PipelineEmitter
- {
- private File file;
- protected String basePackage;
- protected String baseName; // does not include package!
- protected String downstreamPackage;
- protected String downstreamName; // does not include package!
- protected String prologPackageOpt=null;
- protected String prologNameOpt=null; // does not include package!
-
- protected String outputDir;
- protected String outputPackage;
- protected Class baseInterfaceClass;
- protected Class prologClassOpt=null;
- protected Class downstreamClass;
/**
- * @param outputDir the directory into which the pipeline classes will be
- * generated.
- * @param baseInterfaceClassName the full class name (including package,
- * e.g. "java.lang.String") of the interface that the pipeline wraps
- * @exception IllegalArgumentException if classToComposeAround is not an
- * interface.
+ * Emits a Java source file that represents one element of the composable
+ * pipeline.
*/
- public PipelineEmitter(String outputDir, String outputPackage, Class baseInterfaceClass, Class prologClassOpt, Class downstreamClass)
- {
- this.outputDir=outputDir;
- this.outputPackage=outputPackage;
- this.baseInterfaceClass=baseInterfaceClass;
- this.prologClassOpt=prologClassOpt;
- this.downstreamClass=downstreamClass;
-
- basePackage = getPackageName(baseInterfaceClass.getName());
- baseName = getBaseClassName(baseInterfaceClass.getName());
- downstreamPackage = getPackageName(downstreamClass.getName());
- downstreamName = getBaseClassName(downstreamClass.getName());
- if(null!=prologClassOpt) {
- prologPackageOpt = getPackageName(prologClassOpt.getName());
- prologNameOpt = getBaseClassName(prologClassOpt.getName());
- }
- }
+ protected abstract class PipelineEmitter {
+
+ private File file;
+ protected String basePackage;
+ protected String baseName; // does not include package!
+ protected String downstreamPackage;
+ protected String downstreamName; // does not include package!
+ protected String prologPackageOpt = null;
+ protected String prologNameOpt = null; // does not include package!
+ protected String outputDir;
+ protected String outputPackage;
+ protected Class<?> baseInterfaceClass;
+ protected Class<?> prologClassOpt = null;
+ protected Class<?> downstreamClass;
+
+ /**
+ * @param outputDir the directory into which the pipeline classes will be
+ * generated.
+ * @param baseInterfaceClassName the full class name (including package,
+ * e.g. "java.lang.String") of the interface that the pipeline wraps
+ * @exception IllegalArgumentException if classToComposeAround is not an
+ * interface.
+ */
+ PipelineEmitter(String outputDir, String outputPackage, Class<?> baseInterfaceClass, Class<?> prologClassOpt, Class<?> downstreamClass) {
+ this.outputDir = outputDir;
+ this.outputPackage = outputPackage;
+ this.baseInterfaceClass = baseInterfaceClass;
+ this.prologClassOpt = prologClassOpt;
+ this.downstreamClass = downstreamClass;
+
+ basePackage = getPackageName(baseInterfaceClass.getName());
+ baseName = getBaseClassName(baseInterfaceClass.getName());
+ downstreamPackage = getPackageName(downstreamClass.getName());
+ downstreamName = getBaseClassName(downstreamClass.getName());
+ if (null != prologClassOpt) {
+ prologPackageOpt = getPackageName(prologClassOpt.getName());
+ prologNameOpt = getBaseClassName(prologClassOpt.getName());
+ }
+ }
+
+ public void emit(Iterator<PlainMethod> methodsToWrap) throws IOException {
+ String outputClassName = getOutputName();
+ this.file = new File(outputDir + File.separatorChar + outputClassName + ".java");
+ String parentDir = file.getParent();
+ if (parentDir != null) {
+ File pDirFile = new File(parentDir);
+ pDirFile.mkdirs();
+ }
- public void emit(Iterator/*<Method>*/ methodsToWrap) throws IOException
- {
- String outputClassName = getOutputName();
- this.file = new File(outputDir + File.separatorChar + outputClassName + ".java");
- String parentDir = file.getParent();
- if (parentDir != null)
- {
- File pDirFile = new File(parentDir);
- pDirFile.mkdirs();
- }
-
- PrintWriter output = new PrintWriter(new BufferedWriter(new FileWriter(file)));
-
- List baseInterfaces = Arrays.asList(baseInterfaceClass.getInterfaces());
- HashSet clazzList = new HashSet();
- clazzList.add(baseInterfaceClass);
- clazzList.addAll(baseInterfaces);
- int ifNamesNumber = clazzList.size();
-
- // keep original order ..
- clazzList.clear();
- String[] ifNames = new String[ifNamesNumber];
- {
- int i=0;
-
- for (Iterator iter=baseInterfaces.iterator(); iter.hasNext(); ) {
- Class ifClass = (Class)iter.next();
- if(!clazzList.contains(ifClass)) {
- ifNames[i++] = new String(ifClass.getName());
- clazzList.add(ifClass);
+ PrintWriter output = new PrintWriter(new BufferedWriter(new FileWriter(file)));
+
+ List<Class<?>> baseInterfaces = Arrays.asList(baseInterfaceClass.getInterfaces());
+ HashSet<Class<?>> clazzList = new HashSet<Class<?>>();
+ clazzList.add(baseInterfaceClass);
+ clazzList.addAll(baseInterfaces);
+ int ifNamesNumber = clazzList.size();
+
+ // keep original order ..
+ clazzList.clear();
+ String[] ifNames = new String[ifNamesNumber];
+ {
+ int i = 0;
+
+ for (Iterator<Class<?>> iter = baseInterfaces.iterator(); iter.hasNext();) {
+ Class<?> ifClass = iter.next();
+ if (!clazzList.contains(ifClass)) {
+ ifNames[i++] = ifClass.getName();
+ clazzList.add(ifClass);
+ }
}
- }
-
- if(null!=baseInterfaceClass && !clazzList.contains(baseInterfaceClass)) {
- ifNames[i++] = new String(baseInterfaceClass.getName());
- clazzList.add(baseInterfaceClass);
- }
- }
-
- clazzList.add(downstreamClass);
- if(null!=prologClassOpt) {
- clazzList.add(prologClassOpt);
- }
-
- String[] importNames = new String[clazzList.size()+2];
- {
- int i=0;
- importNames[i++] = new String("java.io.*");
- importNames[i++] = new String("javax.media.opengl.*");
- for (Iterator iter=clazzList.iterator(); iter.hasNext(); ) {
- importNames[i++] = new String(((Class)iter.next()).getName());
- }
- }
-
- CodeGenUtils.emitJavaHeaders(output,
- outputPackage,
- outputClassName,
- "com.jogamp.gluegen.runtime", // FIXME: should make configurable
- true,
- importNames,
- new String[] { "public" },
- ifNames,
- null,
- new CodeGenUtils.EmissionCallback() {
- public void emit(PrintWriter w) { emitClassDocComment(w); }
- }
- );
-
- preMethodEmissionHook(output);
-
- constructorHook(output);
-
- emitGLIsMethods(output);
- emitGLGetMethods(output);
-
- while (methodsToWrap.hasNext())
- {
- PlainMethod pm = (PlainMethod)methodsToWrap.next();
- Method m = pm.getWrappedMethod();
- emitMethodDocComment(output, m);
- emitSignature(output, m);
- emitBody(output, m, pm.runHooks());
- }
-
- postMethodEmissionHook(output);
-
- output.println();
- output.print(" private " + downstreamName + " " + getDownstreamObjectName() + ";");
-
- // end the class
- output.println();
- output.print("} // end class ");
- output.println(outputClassName);
-
- output.flush();
- output.close();
-
- System.out.println("wrote to file: "+file); // JAU
- }
- /** Get the name of the object through which API calls should be routed. */
- protected String getDownstreamObjectName()
- {
- return "downstream" + downstreamName;
- }
-
- /** Get the name of the object which shall be called as a prolog. */
- protected String getPrologObjectNameOpt()
- {
- if(null!=prologNameOpt) {
- return "prolog" + prologNameOpt;
- }
- return null;
- }
-
- protected void emitMethodDocComment(PrintWriter output, Method m)
- {
- }
-
- protected void emitSignature(PrintWriter output, Method m)
- {
- output.print(" public ");
- output.print(' ');
- output.print(JavaType.createForClass(m.getReturnType()).getName());
- output.print(' ');
- output.print(m.getName());
- output.print('(');
- output.print(getArgListAsString(m, true, true));
- output.println(")");
- }
-
- protected void emitBody(PrintWriter output, Method m, boolean runHooks)
- {
- output.println(" {");
- output.print(" ");
- Class retType = m.getReturnType();
-
- boolean callPreDownstreamHook = runHooks && hasPreDownstreamCallHook(m);
- boolean callPostDownstreamHook = runHooks && hasPostDownstreamCallHook(m);
- boolean callDownstream = (null!=getMethod(downstreamClass, m)) &&
- !( 0!=(GEN_PROLOG_XOR_DOWNSTREAM&getMode()) && callPreDownstreamHook ) ;
- boolean hasResult = (retType != Void.TYPE);
-
- if(!callDownstream) {
- if(!emptyDownstreamAllowed()) {
- throw new RuntimeException("Method "+m+" has no downstream ("+downstreamName+")");
- }
- }
-
- if(!callPreDownstreamHook && !callPostDownstreamHook && !callDownstream) {
- if(!emptyMethodAllowed()) {
- throw new RuntimeException("Method "+m+" is empty, no downstream ("+downstreamName+") nor prolog ("+prologNameOpt+").");
- } else {
- output.print(" if(DEBUG) { System.out.println(\"WARNING: No prolog, no downstream, empty: \"+");
- printFunctionCallString(output, m);
- output.println("); } ");
+ if (null != baseInterfaceClass && !clazzList.contains(baseInterfaceClass)) {
+ ifNames[i++] = baseInterfaceClass.getName();
+ clazzList.add(baseInterfaceClass);
+ }
+ }
+
+ clazzList.add(downstreamClass);
+ if (null != prologClassOpt) {
+ clazzList.add(prologClassOpt);
+ }
+
+ String[] importNames = new String[clazzList.size() + 2];
+ {
+ int i = 0;
+ importNames[i++] = "java.io.*";
+ importNames[i++] = "javax.media.opengl.*";
+ for (Iterator<Class<?>> iter = clazzList.iterator(); iter.hasNext();) {
+ importNames[i++] = iter.next().getName();
+ }
+ }
+
+ CodeGenUtils.emitJavaHeaders(output,
+ outputPackage,
+ outputClassName,
+ "com.jogamp.gluegen.runtime", // FIXME: should make configurable
+ true,
+ importNames,
+ new String[]{"public"},
+ ifNames,
+ null,
+ new CodeGenUtils.EmissionCallback() {
+ public void emit(PrintWriter w) {
+ emitClassDocComment(w);
+ }
+ });
+
+ preMethodEmissionHook(output);
+
+ constructorHook(output);
+
+ emitGLIsMethods(output);
+ emitGLGetMethods(output);
+
+ while (methodsToWrap.hasNext()) {
+ PlainMethod pm = methodsToWrap.next();
+ Method m = pm.getWrappedMethod();
+ emitMethodDocComment(output, m);
+ emitSignature(output, m);
+ emitBody(output, m, pm.runHooks());
+ }
+
+ postMethodEmissionHook(output);
+
+ output.println();
+ output.print(" private " + downstreamName + " " + getDownstreamObjectName() + ";");
+
+ // end the class
+ output.println();
+ output.print("} // end class ");
+ output.println(outputClassName);
+
+ output.flush();
+ output.close();
+
+ System.out.println("wrote to file: " + file); // JAU
}
- }
- if (callPreDownstreamHook) {
- if(hasResult && !callDownstream) {
- if(callPostDownstreamHook) {
- output.print(" "+JavaType.createForClass(retType).getName());
- output.print(" _res = ");
- } else {
- output.print(" return ");
+ /** Get the name of the object through which API calls should be routed. */
+ protected String getDownstreamObjectName() {
+ return "downstream" + downstreamName;
+ }
+
+ /** Get the name of the object which shall be called as a prolog. */
+ protected String getPrologObjectNameOpt() {
+ if (null != prologNameOpt) {
+ return "prolog" + prologNameOpt;
}
- }
- preDownstreamCallHook(output, m);
- }
-
- if(callDownstream) {
- if (hasResult) {
- if(callPostDownstreamHook) {
- output.print(" "+JavaType.createForClass(retType).getName());
- output.print(" _res = ");
- } else {
- output.print(" return ");
+ return null;
+ }
+
+ protected void emitMethodDocComment(PrintWriter output, Method m) {
+ }
+
+ protected void emitSignature(PrintWriter output, Method m) {
+ output.print(" public ");
+ output.print(' ');
+ output.print(JavaType.createForClass(m.getReturnType()).getName());
+ output.print(' ');
+ output.print(m.getName());
+ output.print('(');
+ output.print(getArgListAsString(m, true, true));
+ output.println(")");
+ }
+
+ protected void emitBody(PrintWriter output, Method m, boolean runHooks) {
+ output.println(" {");
+ output.print(" ");
+ Class<?> retType = m.getReturnType();
+
+ boolean callPreDownstreamHook = runHooks && hasPreDownstreamCallHook(m);
+ boolean callPostDownstreamHook = runHooks && hasPostDownstreamCallHook(m);
+ boolean callDownstream = (null != getMethod(downstreamClass, m))
+ && !(0 != (GEN_PROLOG_XOR_DOWNSTREAM & getMode()) && callPreDownstreamHook);
+ boolean hasResult = (retType != Void.TYPE);
+
+ if (!callDownstream) {
+ if (!emptyDownstreamAllowed()) {
+ throw new RuntimeException("Method " + m + " has no downstream (" + downstreamName + ")");
+ }
}
- }
- output.print(getDownstreamObjectName());
- output.print('.');
- output.print(m.getName());
- output.print('(');
- output.print(getArgListAsString(m, false, true));
- output.println(");");
- }
-
- if (callPostDownstreamHook) {
- postDownstreamCallHook(output, m);
- }
-
- if (hasResult && callDownstream && callPostDownstreamHook) {
- output.println(" return _res;");
- }
- output.println(" }");
- }
+ if (!callPreDownstreamHook && !callPostDownstreamHook && !callDownstream) {
+ if (!emptyMethodAllowed()) {
+ throw new RuntimeException("Method " + m + " is empty, no downstream (" + downstreamName + ") nor prolog (" + prologNameOpt + ").");
+ } else {
+ output.print(" if(DEBUG) { System.out.println(\"WARNING: No prolog, no downstream, empty: \"+");
+ printFunctionCallString(output, m);
+ output.println("); } ");
+ }
+ }
- protected String getArgListAsString(Method m, boolean includeArgTypes, boolean includeArgNames)
- {
- StringBuffer buf = new StringBuffer(256);
- if (!includeArgNames && !includeArgTypes)
- {
- throw new IllegalArgumentException(
- "Cannot generate arglist without both arg types and arg names");
- }
-
- Class[] argTypes = m.getParameterTypes();
- for (int i = 0; i < argTypes.length; ++i)
- {
- if (includeArgTypes)
- {
- buf.append(JavaType.createForClass(argTypes[i]).getName());
- buf.append(' ');
- }
-
- if (includeArgNames)
- {
- buf.append("arg");
- buf.append(i);
- }
- if (i < argTypes.length-1) { buf.append(','); }
- }
-
- return buf.toString();
- }
-
- /** The name of the class around which this pipeline is being
- * composed. E.g., if this pipeline was constructed with
- * "java.util.Set" as the baseInterfaceClassName, then this method will
- * return "Set".
- */
- protected String getBaseInterfaceName()
- {
- return baseName;
- }
-
- /** Get the output name for this pipeline class. */
- protected abstract String getOutputName();
+ if (callPreDownstreamHook) {
+ if (hasResult && !callDownstream) {
+ if (callPostDownstreamHook) {
+ output.print(" " + JavaType.createForClass(retType).getName());
+ output.print(" _res = ");
+ } else {
+ output.print(" return ");
+ }
+ }
+ preDownstreamCallHook(output, m);
+ }
- /**
- * Called after the class headers have been generated, but before any
- * method wrappers have been generated.
- */
- protected void preMethodEmissionHook(PrintWriter output) {
- output.println(" public static final boolean DEBUG = com.jogamp.opengl.impl.Debug.debug(\""+getOutputName()+"\");");
- }
+ if (callDownstream) {
+ if (hasResult) {
+ if (callPostDownstreamHook) {
+ output.print(" " + JavaType.createForClass(retType).getName());
+ output.print(" _res = ");
+ } else {
+ output.print(" return ");
+ }
+ }
+ output.print(getDownstreamObjectName());
+ output.print('.');
+ output.print(m.getName());
+ output.print('(');
+ output.print(getArgListAsString(m, false, true));
+ output.println(");");
+ }
- /**
- * Emits the constructor for the pipeline; called after the preMethodEmissionHook.
- */
- protected abstract void constructorHook(PrintWriter output);
+ if (callPostDownstreamHook) {
+ postDownstreamCallHook(output, m);
+ }
- /**
- * Called after the method wrappers have been generated, but before the
- * closing parenthesis of the class is emitted.
- */
- protected void postMethodEmissionHook(PrintWriter output) {
- output.println( " public String toString() {");
- output.println( " StringBuffer sb = new StringBuffer();");
- output.println( " sb.append(\""+getOutputName()+" [ implementing "+baseInterfaceClass.getName()+",\\n\\t\");");
- if(null!=prologClassOpt) {
- output.println( " sb.append(\" prolog: \"+"+getPrologObjectNameOpt()+".toString()+\",\\n\\t\");");
- }
- output.println( " sb.append(\" downstream: \"+"+getDownstreamObjectName()+".toString()+\"\\n\\t]\");");
- output.println( " return sb.toString();");
- output.println( " }");
- }
+ if (hasResult && callDownstream && callPostDownstreamHook) {
+ output.println(" return _res;");
+ }
+ output.println(" }");
- /**
- * Called before the pipeline routes the call to the downstream object.
- */
- protected abstract void preDownstreamCallHook(PrintWriter output, Method m);
- protected abstract boolean hasPreDownstreamCallHook(Method m);
+ }
- /**
- * Called after the pipeline has routed the call to the downstream object,
- * but before the calling function exits or returns a value.
- */
- protected abstract void postDownstreamCallHook(PrintWriter output, Method m);
+ protected String getArgListAsString(Method m, boolean includeArgTypes, boolean includeArgNames) {
+ StringBuilder buf = new StringBuilder(256);
+ if (!includeArgNames && !includeArgTypes) {
+ throw new IllegalArgumentException(
+ "Cannot generate arglist without both arg types and arg names");
+ }
- protected abstract boolean hasPostDownstreamCallHook(Method m);
+ Class<?>[] argTypes = m.getParameterTypes();
+ for (int i = 0; i < argTypes.length; ++i) {
+ if (includeArgTypes) {
+ buf.append(JavaType.createForClass(argTypes[i]).getName());
+ buf.append(' ');
+ }
- protected abstract int getMode();
- protected abstract boolean emptyMethodAllowed();
- protected abstract boolean emptyDownstreamAllowed();
+ if (includeArgNames) {
+ buf.append("arg");
+ buf.append(i);
+ }
+ if (i < argTypes.length - 1) {
+ buf.append(',');
+ }
+ }
- /** Emit a Javadoc comment for this pipeline class. */
- protected abstract void emitClassDocComment(PrintWriter output);
+ return buf.toString();
+ }
- /**
- * Emits one of the isGL* methods.
- */
- protected void emitGLIsMethod(PrintWriter output, String type) {
- output.println(" public boolean is" + type + "() {");
- Class clazz = BuildComposablePipeline.getClass("javax.media.opengl." + type);
- if (clazz.isAssignableFrom(baseInterfaceClass)) {
- output.println(" return true;");
- } else {
- output.println(" return false;");
- }
- output.println(" }");
- }
+ /** The name of the class around which this pipeline is being
+ * composed. E.g., if this pipeline was constructed with
+ * "java.util.Set" as the baseInterfaceClassName, then this method will
+ * return "Set".
+ */
+ protected String getBaseInterfaceName() {
+ return baseName;
+ }
- /**
- * Emits all of the isGL* methods.
- */
- protected void emitGLIsMethods(PrintWriter output) {
- emitGLIsMethod(output, "GL");
- emitGLIsMethod(output, "GL3bc");
- emitGLIsMethod(output, "GL3");
- emitGLIsMethod(output, "GL2");
- emitGLIsMethod(output, "GLES1");
- emitGLIsMethod(output, "GLES2");
- emitGLIsMethod(output, "GL2ES1");
- emitGLIsMethod(output, "GL2ES2");
- emitGLIsMethod(output, "GL2GL3");
- output.println(" public boolean isGLES() {");
- output.println(" return isGLES2() || isGLES1();");
- output.println(" }");
- }
- /**
- * Emits one of the getGL* methods.
- */
- protected void emitGLGetMethod(PrintWriter output, String type) {
- output.println(" public javax.media.opengl." + type + " get" + type + "() {");
- Class clazz = BuildComposablePipeline.getClass("javax.media.opengl." + type);
- if (clazz.isAssignableFrom(baseInterfaceClass)) {
- output.println(" return this;");
- } else {
- output.println(" throw new GLException(\"Not a " + type + " implementation\");");
- }
- output.println(" }");
- }
+ /** Get the output name for this pipeline class. */
+ protected abstract String getOutputName();
- /**
- * Emits all of the getGL* methods.
- */
- protected void emitGLGetMethods(PrintWriter output) {
- emitGLGetMethod(output, "GL");
- emitGLGetMethod(output, "GL3bc");
- emitGLGetMethod(output, "GL3");
- emitGLGetMethod(output, "GL2");
- emitGLGetMethod(output, "GLES1");
- emitGLGetMethod(output, "GLES2");
- emitGLGetMethod(output, "GL2ES1");
- emitGLGetMethod(output, "GL2ES2");
- emitGLGetMethod(output, "GL2GL3");
- output.println(" public GLProfile getGLProfile() {");
- output.println(" return "+getDownstreamObjectName()+".getGLProfile();");
- output.println(" }");
- }
- } // end class PipelineEmitter
+ /**
+ * Called after the class headers have been generated, but before any
+ * method wrappers have been generated.
+ */
+ protected void preMethodEmissionHook(PrintWriter output) {
+ output.println(" public static final boolean DEBUG = com.jogamp.opengl.impl.Debug.debug(\"" + getOutputName() + "\");");
+ }
- //-------------------------------------------------------
+ /**
+ * Emits the constructor for the pipeline; called after the preMethodEmissionHook.
+ */
+ protected abstract void constructorHook(PrintWriter output);
+
+ /**
+ * Called after the method wrappers have been generated, but before the
+ * closing parenthesis of the class is emitted.
+ */
+ protected void postMethodEmissionHook(PrintWriter output) {
+ output.println(" public String toString() {");
+ output.println(" StringBuffer sb = new StringBuffer();");
+ output.println(" sb.append(\"" + getOutputName() + " [ implementing " + baseInterfaceClass.getName() + ",\\n\\t\");");
+ if (null != prologClassOpt) {
+ output.println(" sb.append(\" prolog: \"+" + getPrologObjectNameOpt() + ".toString()+\",\\n\\t\");");
+ }
+ output.println(" sb.append(\" downstream: \"+" + getDownstreamObjectName() + ".toString()+\"\\n\\t]\");");
+ output.println(" return sb.toString();");
+ output.println(" }");
+ }
- protected class CustomPipeline extends PipelineEmitter
- {
- String className;
- int mode;
+ /**
+ * Called before the pipeline routes the call to the downstream object.
+ */
+ protected abstract void preDownstreamCallHook(PrintWriter output, Method m);
- public CustomPipeline(int mode, String outputDir, String outputPackage, String outputName, Class baseInterfaceClass, Class prologClassOpt, Class downstreamClass)
- {
- super(outputDir, outputPackage, baseInterfaceClass, prologClassOpt, downstreamClass);
- className = outputName;
- this.mode = mode;
- }
+ protected abstract boolean hasPreDownstreamCallHook(Method m);
- protected String getOutputName()
- {
- return className;
- }
+ /**
+ * Called after the pipeline has routed the call to the downstream object,
+ * but before the calling function exits or returns a value.
+ */
+ protected abstract void postDownstreamCallHook(PrintWriter output, Method m);
- protected int getMode() { return mode; }
+ protected abstract boolean hasPostDownstreamCallHook(Method m);
- protected boolean emptyMethodAllowed() {
- return true;
- }
- protected boolean emptyDownstreamAllowed() {
- return true;
- }
+ protected abstract int getMode();
- protected void preMethodEmissionHook(PrintWriter output)
- {
- super.preMethodEmissionHook(output);
- }
+ protected abstract boolean emptyMethodAllowed();
- protected void constructorHook(PrintWriter output) {
- output.print( " public " + getOutputName() + "(" );
- output.print( downstreamName + " " + getDownstreamObjectName() );
- if(null!=prologNameOpt) {
- output.println( ", " + prologNameOpt + " " + getPrologObjectNameOpt() + ")");
- } else {
- output.println(")");
- }
- output.println(" {");
- output.println(" if (" + getDownstreamObjectName() + " == null) {");
- output.println(" throw new IllegalArgumentException(\"null " + getDownstreamObjectName() + "\");");
- output.println(" }");
- output.print( " this." + getDownstreamObjectName());
- output.println(" = " + getDownstreamObjectName() + ";");
- if(null!=prologNameOpt) {
- output.print( " this." + getPrologObjectNameOpt());
- output.println(" = " + getPrologObjectNameOpt() + ";");
- }
- output.println(" }");
- output.println();
- }
+ protected abstract boolean emptyDownstreamAllowed();
- protected void postMethodEmissionHook(PrintWriter output)
- {
- super.postMethodEmissionHook(output);
- if(null!=prologNameOpt) {
- output.print(" private " + prologNameOpt + " " + getPrologObjectNameOpt() + ";");
- }
- }
+ /** Emit a Javadoc comment for this pipeline class. */
+ protected abstract void emitClassDocComment(PrintWriter output);
- protected void emitClassDocComment(PrintWriter output)
- {
- output.println("/**");
- output.println(" * Composable pipeline {@link "+outputPackage+"."+outputName+"}, implementing the interface");
- output.println(" * {@link "+baseInterfaceClass.getName()+"}");
- output.println(" * <p>");
- output.println(" * Each method follows the call graph <ul>");
- if(null!=prologClassOpt) {
- output.println(" * <li> call <em>prolog</em> {@link "+prologClassOpt.getName()+"} if available");
- }
- output.println(" * <li> call <em>downstream</em> {@link "+downstreamClass.getName()+"} if available");
- if(null!=prologClassOpt && 0!=(GEN_PROLOG_XOR_DOWNSTREAM&getMode())) {
- output.println(" * <strong>and</strong> if no call to {@link "+prologClassOpt.getName()+"} is made");
- }
- output.println(" * </ul><p>");
- output.println(" * ");
- output.println(" * <ul>");
- output.println(" * <li> <em>Interface</em> {@link "+baseInterfaceClass.getName()+"}");
- if(null!=prologClassOpt) {
- output.println(" * <li> <em>Prolog</em> {@link "+prologClassOpt.getName()+"}");
- }
- output.println(" * <li> <em>Downstream</em> {@link "+downstreamClass.getName()+"}");
- output.println(" * </ul><p>");
- output.println(" * Sample code which installs this pipeline: </P>");
- output.println(" * ");
- output.println("<PRE>");
- if(null!=prologNameOpt) {
- output.println(" GL gl = drawable.setGL( new "+className+"( drawable.getGL().getGL2ES2(), new "+prologNameOpt+"( drawable.getGL().getGL2ES2() ) ) );");
- } else {
- output.println(" GL gl = drawable.setGL( new "+className+"( drawable.getGL().getGL2ES2() ) );");
- }
- output.println("</PRE>");
- output.println("*/");
- }
-
- protected boolean hasPreDownstreamCallHook(Method m) {
- return null!=getMethod(prologClassOpt, m);
- }
+ /**
+ * Emits one of the isGL* methods.
+ */
+ protected void emitGLIsMethod(PrintWriter output, String type) {
+ output.println(" public boolean is" + type + "() {");
+ Class<?> clazz = BuildComposablePipeline.getClass("javax.media.opengl." + type);
+ if (clazz.isAssignableFrom(baseInterfaceClass)) {
+ output.println(" return true;");
+ } else {
+ output.println(" return false;");
+ }
+ output.println(" }");
+ }
- protected void preDownstreamCallHook(PrintWriter output, Method m)
- {
- if(null!=prologNameOpt) {
- output.print(getPrologObjectNameOpt());
- output.print('.');
- output.print(m.getName());
- output.print('(');
- output.print(getArgListAsString(m, false, true));
- output.println(");");
- }
- }
+ /**
+ * Emits all of the isGL* methods.
+ */
+ protected void emitGLIsMethods(PrintWriter output) {
+ emitGLIsMethod(output, "GL");
+ emitGLIsMethod(output, "GL3bc");
+ emitGLIsMethod(output, "GL3");
+ emitGLIsMethod(output, "GL2");
+ emitGLIsMethod(output, "GLES1");
+ emitGLIsMethod(output, "GLES2");
+ emitGLIsMethod(output, "GL2ES1");
+ emitGLIsMethod(output, "GL2ES2");
+ emitGLIsMethod(output, "GL2GL3");
+ output.println(" public boolean isGLES() {");
+ output.println(" return isGLES2() || isGLES1();");
+ output.println(" }");
+ }
- protected boolean hasPostDownstreamCallHook(Method m) {
- return false;
- }
+ /**
+ * Emits one of the getGL* methods.
+ */
+ protected void emitGLGetMethod(PrintWriter output, String type) {
+ output.println(" public javax.media.opengl." + type + " get" + type + "() {");
+ Class<?> clazz = BuildComposablePipeline.getClass("javax.media.opengl." + type);
+ if (clazz.isAssignableFrom(baseInterfaceClass)) {
+ output.println(" return this;");
+ } else {
+ output.println(" throw new GLException(\"Not a " + type + " implementation\");");
+ }
+ output.println(" }");
+ }
- protected void postDownstreamCallHook(PrintWriter output, Method m)
- {
- }
+ /**
+ * Emits all of the getGL* methods.
+ */
+ protected void emitGLGetMethods(PrintWriter output) {
+ emitGLGetMethod(output, "GL");
+ emitGLGetMethod(output, "GL3bc");
+ emitGLGetMethod(output, "GL3");
+ emitGLGetMethod(output, "GL2");
+ emitGLGetMethod(output, "GLES1");
+ emitGLGetMethod(output, "GLES2");
+ emitGLGetMethod(output, "GL2ES1");
+ emitGLGetMethod(output, "GL2ES2");
+ emitGLGetMethod(output, "GL2GL3");
+ output.println(" public GLProfile getGLProfile() {");
+ output.println(" return " + getDownstreamObjectName() + ".getGLProfile();");
+ output.println(" }");
+ }
+ } // end class PipelineEmitter
- } // end class CustomPipeline
+ //-------------------------------------------------------
+ protected class CustomPipeline extends PipelineEmitter {
- protected class DebugPipeline extends PipelineEmitter
- {
- String className;
- public DebugPipeline(String outputDir, String outputPackage, Class baseInterfaceClass, Class downstreamClass)
- {
- super(outputDir, outputPackage, baseInterfaceClass, null, downstreamClass);
- className = "Debug" + getBaseInterfaceName();
- }
+ String className;
+ int mode;
- protected String getOutputName()
- {
- return className;
- }
+ CustomPipeline(int mode, String outputDir, String outputPackage, String outputName, Class<?> baseInterfaceClass, Class<?> prologClassOpt, Class<?> downstreamClass) {
+ super(outputDir, outputPackage, baseInterfaceClass, prologClassOpt, downstreamClass);
+ className = outputName;
+ this.mode = mode;
+ }
- protected int getMode() { return 0; }
+ protected String getOutputName() {
+ return className;
+ }
- protected boolean emptyMethodAllowed() {
- return false;
- }
- protected boolean emptyDownstreamAllowed() {
- return false;
- }
+ protected int getMode() {
+ return mode;
+ }
- protected void preMethodEmissionHook(PrintWriter output)
- {
- super.preMethodEmissionHook(output);
- }
+ protected boolean emptyMethodAllowed() {
+ return true;
+ }
- protected void constructorHook(PrintWriter output) {
- output.print( " public " + getOutputName() + "(" );
- output.println( downstreamName + " " + getDownstreamObjectName() + ")");
- output.println(" {");
- output.println(" if (" + getDownstreamObjectName() + " == null) {");
- output.println(" throw new IllegalArgumentException(\"null " + getDownstreamObjectName() + "\");");
- output.println(" }");
- output.print( " this." + getDownstreamObjectName());
- output.println(" = " + getDownstreamObjectName() + ";");
- if(null!=prologNameOpt) {
- output.print( " this." + getPrologObjectNameOpt());
- output.println(" = " + getPrologObjectNameOpt() + ";");
- }
- output.println(" // Fetch GLContext object for better error checking (if possible)");
- output.println(" _context = " + getDownstreamObjectName() + ".getContext();");
- output.println(" }");
- output.println();
- }
+ protected boolean emptyDownstreamAllowed() {
+ return true;
+ }
- protected void postMethodEmissionHook(PrintWriter output)
- {
- super.postMethodEmissionHook(output);
- output.println(" private void checkGLGetError(String caller)");
- output.println(" {");
- if (hasImmediateMode) {
- output.println(" if (insideBeginEndPair) {");
- output.println(" return;");
- output.println(" }");
- output.println();
- }
- output.println(" // Debug code to make sure the pipeline is working; leave commented out unless testing this class");
- output.println(" //System.err.println(\"Checking for GL errors " +
- "after call to \" + caller);");
- output.println();
- output.println(" int err = " +
- getDownstreamObjectName() +
- ".glGetError();");
- output.println(" if (err == GL_NO_ERROR) { return; }");
- output.println();
- output.println(" StringBuffer buf = new StringBuffer(Thread.currentThread()+");
- output.println(" \" glGetError() returned the following error codes " +
- "after a call to \" + caller + \": \");");
- output.println();
- output.println(" // Loop repeatedly to allow for distributed GL implementations,");
- output.println(" // as detailed in the glGetError() specification");
- output.println(" int recursionDepth = 10;");
- output.println(" do {");
- output.println(" switch (err) {");
- output.println(" case GL_INVALID_ENUM: buf.append(\"GL_INVALID_ENUM \"); break;");
- output.println(" case GL_INVALID_VALUE: buf.append(\"GL_INVALID_VALUE \"); break;");
- output.println(" case GL_INVALID_OPERATION: buf.append(\"GL_INVALID_OPERATION \"); break;");
- if (hasStackOverflow) {
- output.println(" case GL_STACK_OVERFLOW: buf.append(\"GL_STACK_OVERFLOW \"); break;");
- output.println(" case GL_STACK_UNDERFLOW: buf.append(\"GL_STACK_UNDERFLOW \"); break;");
- }
- output.println(" case GL_OUT_OF_MEMORY: buf.append(\"GL_OUT_OF_MEMORY \"); break;");
- output.println(" case GL_NO_ERROR: throw new InternalError(\"Should not be treating GL_NO_ERROR as error\");");
- output.println(" default: buf.append(\"Unknown glGetError() return value: \");");
- output.println(" }");
- output.println(" buf.append(\"( \" + err + \" 0x\"+Integer.toHexString(err).toUpperCase() + \"), \");");
- output.println(" } while ((--recursionDepth >= 0) && (err = " +
- getDownstreamObjectName() +
- ".glGetError()) != GL_NO_ERROR);");
- output.println(" throw new GLException(buf.toString());");
- output.println(" }");
- if (hasImmediateMode) {
- output.println(" /** True if the pipeline is inside a glBegin/glEnd pair.*/");
- output.println(" private boolean insideBeginEndPair = false;");
- output.println();
- }
- output.println(" private void checkContext() {");
- output.println(" GLContext currentContext = GLContext.getCurrent();");
- output.println(" if (currentContext == null) {");
- output.println(" throw new GLException(\"No OpenGL context is current on this thread\");");
- output.println(" }");
- output.println(" if ((_context != null) && (_context != currentContext)) {");
- output.println(" throw new GLException(\"This GL object is being incorrectly used with a different GLContext than that which created it\");");
- output.println(" }");
- output.println(" }");
- output.println(" private GLContext _context;");
- }
+ @Override
+ protected void preMethodEmissionHook(PrintWriter output) {
+ super.preMethodEmissionHook(output);
+ }
- protected void emitClassDocComment(PrintWriter output)
- {
- output.println("/** <P> Composable pipeline which wraps an underlying {@link GL} implementation,");
- output.println(" providing error checking after each OpenGL method call. If an error occurs,");
- output.println(" causes a {@link GLException} to be thrown at exactly the point of failure.");
- output.println(" Sample code which installs this pipeline: </P>");
- output.println();
- output.println("<PRE>");
- output.println(" GL gl = drawable.setGL(new DebugGL(drawable.getGL()));");
- output.println("</PRE>");
- output.println("*/");
- }
-
- protected boolean hasPreDownstreamCallHook(Method m) {
- return true;
- }
+ protected void constructorHook(PrintWriter output) {
+ output.print(" public " + getOutputName() + "(");
+ output.print(downstreamName + " " + getDownstreamObjectName());
+ if (null != prologNameOpt) {
+ output.println(", " + prologNameOpt + " " + getPrologObjectNameOpt() + ")");
+ } else {
+ output.println(")");
+ }
+ output.println(" {");
+ output.println(" if (" + getDownstreamObjectName() + " == null) {");
+ output.println(" throw new IllegalArgumentException(\"null " + getDownstreamObjectName() + "\");");
+ output.println(" }");
+ output.print(" this." + getDownstreamObjectName());
+ output.println(" = " + getDownstreamObjectName() + ";");
+ if (null != prologNameOpt) {
+ output.print(" this." + getPrologObjectNameOpt());
+ output.println(" = " + getPrologObjectNameOpt() + ";");
+ }
+ output.println(" }");
+ output.println();
+ }
- protected void preDownstreamCallHook(PrintWriter output, Method m)
- {
- output.println(" checkContext();");
- }
+ @Override
+ protected void postMethodEmissionHook(PrintWriter output) {
+ super.postMethodEmissionHook(output);
+ if (null != prologNameOpt) {
+ output.print(" private " + prologNameOpt + " " + getPrologObjectNameOpt() + ";");
+ }
+ }
- protected boolean hasPostDownstreamCallHook(Method m) {
- return true;
- }
+ protected void emitClassDocComment(PrintWriter output) {
+ output.println("/**");
+ output.println(" * Composable pipeline {@link " + outputPackage + "." + outputName + "}, implementing the interface");
+ output.println(" * {@link " + baseInterfaceClass.getName() + "}");
+ output.println(" * <p>");
+ output.println(" * Each method follows the call graph <ul>");
+ if (null != prologClassOpt) {
+ output.println(" * <li> call <em>prolog</em> {@link " + prologClassOpt.getName() + "} if available");
+ }
+ output.println(" * <li> call <em>downstream</em> {@link " + downstreamClass.getName() + "} if available");
+ if (null != prologClassOpt && 0 != (GEN_PROLOG_XOR_DOWNSTREAM & getMode())) {
+ output.println(" * <strong>and</strong> if no call to {@link " + prologClassOpt.getName() + "} is made");
+ }
+ output.println(" * </ul><p>");
+ output.println(" * ");
+ output.println(" * <ul>");
+ output.println(" * <li> <em>Interface</em> {@link " + baseInterfaceClass.getName() + "}");
+ if (null != prologClassOpt) {
+ output.println(" * <li> <em>Prolog</em> {@link " + prologClassOpt.getName() + "}");
+ }
+ output.println(" * <li> <em>Downstream</em> {@link " + downstreamClass.getName() + "}");
+ output.println(" * </ul><p>");
+ output.println(" * Sample code which installs this pipeline: </P>");
+ output.println(" * ");
+ output.println("<PRE>");
+ if (null != prologNameOpt) {
+ output.println(" GL gl = drawable.setGL( new " + className + "( drawable.getGL().getGL2ES2(), new " + prologNameOpt + "( drawable.getGL().getGL2ES2() ) ) );");
+ } else {
+ output.println(" GL gl = drawable.setGL( new " + className + "( drawable.getGL().getGL2ES2() ) );");
+ }
+ output.println("</PRE>");
+ output.println("*/");
+ }
- protected void postDownstreamCallHook(PrintWriter output, Method m)
- {
- if (m.getName().equals("glBegin"))
- {
- output.println(" insideBeginEndPair = true;");
- output.println(" // NOTE: can't check glGetError(); it's not allowed inside glBegin/glEnd pair");
- }
- else
- {
- if (m.getName().equals("glEnd"))
- {
- output.println(" insideBeginEndPair = false;");
- }
-
- output.println(" String txt = new String(\""+ m.getName() + "(\" +");
- Class[] params = m.getParameterTypes() ;
- for(int i=0; params!=null && i<params.length; i++) {
- if(params[i].equals(int.class)) {
- output.println(" \"<"+params[i].getName()+"> 0x\"+Integer.toHexString(arg"+i+").toUpperCase() +");
- } else {
- output.println(" \"<"+params[i].getName()+">\" +");
- }
- if(i<params.length-1) {
- output.println(" \", \" +");
- }
- }
- output.println(" \")\");");
- // calls to glGetError() are only allowed outside of glBegin/glEnd pairs
- output.println(" checkGLGetError( txt );");
- }
- }
+ protected boolean hasPreDownstreamCallHook(Method m) {
+ return null != getMethod(prologClassOpt, m);
+ }
- } // end class DebugPipeline
+ protected void preDownstreamCallHook(PrintWriter output, Method m) {
+ if (null != prologNameOpt) {
+ output.print(getPrologObjectNameOpt());
+ output.print('.');
+ output.print(m.getName());
+ output.print('(');
+ output.print(getArgListAsString(m, false, true));
+ output.println(");");
+ }
+ }
- //-------------------------------------------------------
+ protected boolean hasPostDownstreamCallHook(Method m) {
+ return false;
+ }
- protected class TracePipeline extends PipelineEmitter
- {
- String className;
- public TracePipeline(String outputDir, String outputPackage, Class baseInterfaceClass, Class downstreamClass)
- {
- super(outputDir, outputPackage, baseInterfaceClass, null, downstreamClass);
- className = "Trace" + getBaseInterfaceName();
- }
+ protected void postDownstreamCallHook(PrintWriter output, Method m) {
+ }
+ } // end class CustomPipeline
- protected String getOutputName()
- {
- return className;
- }
+ protected class DebugPipeline extends PipelineEmitter {
- protected int getMode() { return 0; }
+ String className;
- protected boolean emptyMethodAllowed() {
- return false;
- }
- protected boolean emptyDownstreamAllowed() {
- return false;
- }
+ DebugPipeline(String outputDir, String outputPackage, Class<?> baseInterfaceClass, Class<?> downstreamClass) {
+ super(outputDir, outputPackage, baseInterfaceClass, null, downstreamClass);
+ className = "Debug" + getBaseInterfaceName();
+ }
- protected void preMethodEmissionHook(PrintWriter output)
- {
- super.preMethodEmissionHook(output);
- }
+ protected String getOutputName() {
+ return className;
+ }
- protected void constructorHook(PrintWriter output) {
- output.print( " public " + getOutputName() + "(" );
- output.println( downstreamName + " " + getDownstreamObjectName() + ", PrintStream " + getOutputStreamName() + ")");
- output.println(" {");
- output.println(" if (" + getDownstreamObjectName() + " == null) {");
- output.println(" throw new IllegalArgumentException(\"null " + getDownstreamObjectName() + "\");");
- output.println(" }");
- output.print( " this." + getDownstreamObjectName());
- output.println(" = " + getDownstreamObjectName() + ";");
- output.print( " this." + getOutputStreamName());
- output.println(" = " + getOutputStreamName() + ";");
- output.println(" }");
- output.println();
- }
+ protected int getMode() {
+ return 0;
+ }
- protected void postMethodEmissionHook(PrintWriter output)
- {
- super.postMethodEmissionHook(output);
- output.println("private PrintStream " + getOutputStreamName() + ";");
- output.println("private int indent = 0;");
- output.println("protected String dumpArray(Object obj)");
- output.println("{");
- output.println(" if (obj == null) return \"[null]\";");
- output.println(" StringBuffer sb = new StringBuffer(\"[\");");
- output.println(" int len = java.lang.reflect.Array.getLength(obj);");
- output.println(" int count = Math.min(len,16);");
- output.println(" for ( int i =0; i < count; i++ ) {");
- output.println(" sb.append(java.lang.reflect.Array.get(obj,i));");
- output.println(" if (i < count-1)");
- output.println(" sb.append(',');");
- output.println(" }");
- output.println(" if ( len > 16 )");
- output.println(" sb.append(\"...\").append(len);");
- output.println(" sb.append(']');");
- output.println(" return sb.toString();");
- output.println("}");
- output.println("protected void print(String str)");
- output.println("{");
- output.println(" "+getOutputStreamName()+".print(str);");
- output.println("}");
- output.println("protected void println(String str)");
- output.println("{");
- output.println(" "+getOutputStreamName()+".println(str);");
- output.println("}");
- output.println("protected void printIndent()");
- output.println("{");
- output.println(" for( int i =0; i < indent; i++) {"+getOutputStreamName()+".print(' ');}");
- output.println("}");
- }
- protected void emitClassDocComment(PrintWriter output)
- {
- output.println("/** <P> Composable pipeline which wraps an underlying {@link GL} implementation,");
- output.println(" providing tracing information to a user-specified {@link java.io.PrintStream}");
- output.println(" before and after each OpenGL method call. Sample code which installs this pipeline: </P>");
- output.println();
- output.println("<PRE>");
- output.println(" GL gl = drawable.setGL(new TraceGL(drawable.getGL(), System.err));");
- output.println("</PRE>");
- output.println("*/");
- }
-
- protected boolean hasPreDownstreamCallHook(Method m) {
- return true;
- }
+ protected boolean emptyMethodAllowed() {
+ return false;
+ }
- protected void preDownstreamCallHook(PrintWriter output, Method m)
- {
- if ( m.getName().equals("glEnd") || m.getName().equals("glEndList"))
- {
- output.println("indent-=2;");
- output.println(" printIndent();");
- }
- else
- {
- output.println("printIndent();");
- }
-
- output.print(" print(");
- printFunctionCallString(output, m);
- output.println(");");
- }
+ protected boolean emptyDownstreamAllowed() {
+ return false;
+ }
- protected boolean hasPostDownstreamCallHook(Method m) {
- return true;
- }
+ @Override
+ protected void preMethodEmissionHook(PrintWriter output) {
+ super.preMethodEmissionHook(output);
+ }
- protected void postDownstreamCallHook(PrintWriter output, Method m)
- {
- Class ret = m.getReturnType();
- if ( ret != Void.TYPE )
- {
- output.println(" println(\" = \"+_res);");
- }
- else
- {
- output.println(" println(\"\");");
- }
- }
+ protected void constructorHook(PrintWriter output) {
+ output.print(" public " + getOutputName() + "(");
+ output.println(downstreamName + " " + getDownstreamObjectName() + ")");
+ output.println(" {");
+ output.println(" if (" + getDownstreamObjectName() + " == null) {");
+ output.println(" throw new IllegalArgumentException(\"null " + getDownstreamObjectName() + "\");");
+ output.println(" }");
+ output.print(" this." + getDownstreamObjectName());
+ output.println(" = " + getDownstreamObjectName() + ";");
+ if (null != prologNameOpt) {
+ output.print(" this." + getPrologObjectNameOpt());
+ output.println(" = " + getPrologObjectNameOpt() + ";");
+ }
+ output.println(" // Fetch GLContext object for better error checking (if possible)");
+ output.println(" _context = " + getDownstreamObjectName() + ".getContext();");
+ output.println(" }");
+ output.println();
+ }
- private String getOutputStreamName() {
- return "stream";
- }
+ @Override
+ protected void postMethodEmissionHook(PrintWriter output) {
+ super.postMethodEmissionHook(output);
+ output.println(" private void checkGLGetError(String caller)");
+ output.println(" {");
+ if (hasImmediateMode) {
+ output.println(" if (insideBeginEndPair) {");
+ output.println(" return;");
+ output.println(" }");
+ output.println();
+ }
+ output.println(" // Debug code to make sure the pipeline is working; leave commented out unless testing this class");
+ output.println(" //System.err.println(\"Checking for GL errors "
+ + "after call to \" + caller);");
+ output.println();
+ output.println(" int err = "
+ + getDownstreamObjectName()
+ + ".glGetError();");
+ output.println(" if (err == GL_NO_ERROR) { return; }");
+ output.println();
+ output.println(" StringBuffer buf = new StringBuffer(Thread.currentThread()+");
+ output.println(" \" glGetError() returned the following error codes after a call to \" + caller + \": \");");
+ output.println();
+ output.println(" // Loop repeatedly to allow for distributed GL implementations,");
+ output.println(" // as detailed in the glGetError() specification");
+ output.println(" int recursionDepth = 10;");
+ output.println(" do {");
+ output.println(" switch (err) {");
+ output.println(" case GL_INVALID_ENUM: buf.append(\"GL_INVALID_ENUM \"); break;");
+ output.println(" case GL_INVALID_VALUE: buf.append(\"GL_INVALID_VALUE \"); break;");
+ output.println(" case GL_INVALID_OPERATION: buf.append(\"GL_INVALID_OPERATION \"); break;");
+ if (hasStackOverflow) {
+ output.println(" case GL_STACK_OVERFLOW: buf.append(\"GL_STACK_OVERFLOW \"); break;");
+ output.println(" case GL_STACK_UNDERFLOW: buf.append(\"GL_STACK_UNDERFLOW \"); break;");
+ }
+ output.println(" case GL_OUT_OF_MEMORY: buf.append(\"GL_OUT_OF_MEMORY \"); break;");
+ output.println(" case GL_NO_ERROR: throw new InternalError(\"Should not be treating GL_NO_ERROR as error\");");
+ output.println(" default: buf.append(\"Unknown glGetError() return value: \");");
+ output.println(" }");
+ output.println(" buf.append(\"( \" + err + \" 0x\"+Integer.toHexString(err).toUpperCase() + \"), \");");
+ output.println(" } while ((--recursionDepth >= 0) && (err = "
+ + getDownstreamObjectName()
+ + ".glGetError()) != GL_NO_ERROR);");
+ output.println(" throw new GLException(buf.toString());");
+ output.println(" }");
+ if (hasImmediateMode) {
+ output.println(" /** True if the pipeline is inside a glBegin/glEnd pair.*/");
+ output.println(" private boolean insideBeginEndPair = false;");
+ output.println();
+ }
+ output.println(" private void checkContext() {");
+ output.println(" GLContext currentContext = GLContext.getCurrent();");
+ output.println(" if (currentContext == null) {");
+ output.println(" throw new GLException(\"No OpenGL context is current on this thread\");");
+ output.println(" }");
+ output.println(" if ((_context != null) && (_context != currentContext)) {");
+ output.println(" throw new GLException(\"This GL object is being incorrectly used with a different GLContext than that which created it\");");
+ output.println(" }");
+ output.println(" }");
+ output.println(" private GLContext _context;");
+ }
- } // end class TracePipeline
-
- public static final void printFunctionCallString(PrintWriter output, Method m) {
- Class[] params = m.getParameterTypes();
- output.print(" \"" + m.getName() + "(\"");
- for ( int i =0; i < params.length; i++ )
- {
- if ( params[i].isArray() ) {
- output.print("+\"<"+params[i].getName()+">\"");
- } else if(params[i].equals(int.class)) {
- output.print("+\"<"+params[i].getName()+"> 0x\"+Integer.toHexString(arg"+i+").toUpperCase()");
- } else {
- output.print("+\"<"+params[i].getName()+"> \"+arg"+i);
+ protected void emitClassDocComment(PrintWriter output) {
+ output.println("/** <P> Composable pipeline which wraps an underlying {@link GL} implementation,");
+ output.println(" providing error checking after each OpenGL method call. If an error occurs,");
+ output.println(" causes a {@link GLException} to be thrown at exactly the point of failure.");
+ output.println(" Sample code which installs this pipeline: </P>");
+ output.println();
+ output.println("<PRE>");
+ output.println(" GL gl = drawable.setGL(new DebugGL(drawable.getGL()));");
+ output.println("</PRE>");
+ output.println("*/");
+ }
+
+ protected boolean hasPreDownstreamCallHook(Method m) {
+ return true;
+ }
+
+ protected void preDownstreamCallHook(PrintWriter output, Method m) {
+ output.println(" checkContext();");
+ }
+
+ protected boolean hasPostDownstreamCallHook(Method m) {
+ return true;
+ }
+
+ protected void postDownstreamCallHook(PrintWriter output, Method m) {
+ if (m.getName().equals("glBegin")) {
+ output.println(" insideBeginEndPair = true;");
+ output.println(" // NOTE: can't check glGetError(); it's not allowed inside glBegin/glEnd pair");
+ } else {
+ if (m.getName().equals("glEnd")) {
+ output.println(" insideBeginEndPair = false;");
+ }
+
+ output.println(" String txt = new String(\"" + m.getName() + "(\" +");
+ Class<?>[] params = m.getParameterTypes();
+ for (int i = 0; params != null && i < params.length; i++) {
+ if (params[i].equals(int.class)) {
+ output.println(" \"<" + params[i].getName() + "> 0x\"+Integer.toHexString(arg" + i + ").toUpperCase() +");
+ } else {
+ output.println(" \"<" + params[i].getName() + ">\" +");
+ }
+ if (i < params.length - 1) {
+ output.println(" \", \" +");
+ }
+ }
+ output.println(" \")\");");
+ // calls to glGetError() are only allowed outside of glBegin/glEnd pairs
+ output.println(" checkGLGetError( txt );");
+ }
+ }
+ } // end class DebugPipeline
+
+ //-------------------------------------------------------
+ protected class TracePipeline extends PipelineEmitter {
+
+ String className;
+
+ TracePipeline(String outputDir, String outputPackage, Class<?> baseInterfaceClass, Class<?> downstreamClass) {
+ super(outputDir, outputPackage, baseInterfaceClass, null, downstreamClass);
+ className = "Trace" + getBaseInterfaceName();
+ }
+
+ protected String getOutputName() {
+ return className;
+ }
+
+ protected int getMode() {
+ return 0;
}
- if ( i < params.length-1) {
- output.print("+\", \"");
+
+ protected boolean emptyMethodAllowed() {
+ return false;
}
- }
- output.print("+\")\"");
- }
+
+ protected boolean emptyDownstreamAllowed() {
+ return false;
+ }
+
+ @Override
+ protected void preMethodEmissionHook(PrintWriter output) {
+ super.preMethodEmissionHook(output);
+ }
+
+ protected void constructorHook(PrintWriter output) {
+ output.print(" public " + getOutputName() + "(");
+ output.println(downstreamName + " " + getDownstreamObjectName() + ", PrintStream " + getOutputStreamName() + ")");
+ output.println(" {");
+ output.println(" if (" + getDownstreamObjectName() + " == null) {");
+ output.println(" throw new IllegalArgumentException(\"null " + getDownstreamObjectName() + "\");");
+ output.println(" }");
+ output.print(" this." + getDownstreamObjectName());
+ output.println(" = " + getDownstreamObjectName() + ";");
+ output.print(" this." + getOutputStreamName());
+ output.println(" = " + getOutputStreamName() + ";");
+ output.println(" }");
+ output.println();
+ }
+
+ @Override
+ protected void postMethodEmissionHook(PrintWriter output) {
+ super.postMethodEmissionHook(output);
+ output.println("private PrintStream " + getOutputStreamName() + ";");
+ output.println("private int indent = 0;");
+ output.println("protected String dumpArray(Object obj)");
+ output.println("{");
+ output.println(" if (obj == null) return \"[null]\";");
+ output.println(" StringBuffer sb = new StringBuffer(\"[\");");
+ output.println(" int len = java.lang.reflect.Array.getLength(obj);");
+ output.println(" int count = Math.min(len,16);");
+ output.println(" for ( int i =0; i < count; i++ ) {");
+ output.println(" sb.append(java.lang.reflect.Array.get(obj,i));");
+ output.println(" if (i < count-1)");
+ output.println(" sb.append(',');");
+ output.println(" }");
+ output.println(" if ( len > 16 )");
+ output.println(" sb.append(\"...\").append(len);");
+ output.println(" sb.append(']');");
+ output.println(" return sb.toString();");
+ output.println("}");
+ output.println("protected void print(String str)");
+ output.println("{");
+ output.println(" " + getOutputStreamName() + ".print(str);");
+ output.println("}");
+ output.println("protected void println(String str)");
+ output.println("{");
+ output.println(" " + getOutputStreamName() + ".println(str);");
+ output.println("}");
+ output.println("protected void printIndent()");
+ output.println("{");
+ output.println(" for( int i =0; i < indent; i++) {" + getOutputStreamName() + ".print(' ');}");
+ output.println("}");
+ }
+
+ protected void emitClassDocComment(PrintWriter output) {
+ output.println("/** <P> Composable pipeline which wraps an underlying {@link GL} implementation,");
+ output.println(" providing tracing information to a user-specified {@link java.io.PrintStream}");
+ output.println(" before and after each OpenGL method call. Sample code which installs this pipeline: </P>");
+ output.println();
+ output.println("<PRE>");
+ output.println(" GL gl = drawable.setGL(new TraceGL(drawable.getGL(), System.err));");
+ output.println("</PRE>");
+ output.println("*/");
+ }
+
+ protected boolean hasPreDownstreamCallHook(Method m) {
+ return true;
+ }
+
+ protected void preDownstreamCallHook(PrintWriter output, Method m) {
+ if (m.getName().equals("glEnd") || m.getName().equals("glEndList")) {
+ output.println("indent-=2;");
+ output.println(" printIndent();");
+ } else {
+ output.println("printIndent();");
+ }
+
+ output.print(" print(");
+ printFunctionCallString(output, m);
+ output.println(");");
+ }
+
+ protected boolean hasPostDownstreamCallHook(Method m) {
+ return true;
+ }
+
+ protected void postDownstreamCallHook(PrintWriter output, Method m) {
+ Class<?> ret = m.getReturnType();
+ if (ret != Void.TYPE) {
+ output.println(" println(\" = \"+_res);");
+ } else {
+ output.println(" println(\"\");");
+ }
+ }
+
+ private String getOutputStreamName() {
+ return "stream";
+ }
+ } // end class TracePipeline
+
+ public static final void printFunctionCallString(PrintWriter output, Method m) {
+ Class<?>[] params = m.getParameterTypes();
+ output.print(" \"" + m.getName() + "(\"");
+ for (int i = 0; i < params.length; i++) {
+ if (params[i].isArray()) {
+ output.print("+\"<" + params[i].getName() + ">\"");
+ } else if (params[i].equals(int.class)) {
+ output.print("+\"<" + params[i].getName() + "> 0x\"+Integer.toHexString(arg" + i + ").toUpperCase()");
+ } else {
+ output.print("+\"<" + params[i].getName() + "> \"+arg" + i);
+ }
+ if (i < params.length - 1) {
+ output.print("+\", \"");
+ }
+ }
+ output.print("+\")\"");
+ }
}