395 lines
16 KiB
Java
395 lines
16 KiB
Java
package net.sf.jasperreports.engine.design;
|
|
|
|
import java.io.ByteArrayOutputStream;
|
|
import java.io.File;
|
|
import java.io.IOException;
|
|
import java.io.InputStream;
|
|
import java.io.Serializable;
|
|
import java.lang.reflect.Constructor;
|
|
import java.lang.reflect.InvocationTargetException;
|
|
import java.lang.reflect.Method;
|
|
import java.util.Enumeration;
|
|
import java.util.HashMap;
|
|
import java.util.Iterator;
|
|
import java.util.List;
|
|
import java.util.Locale;
|
|
import java.util.Map;
|
|
import java.util.Properties;
|
|
import net.sf.jasperreports.engine.JRException;
|
|
import net.sf.jasperreports.engine.JRRuntimeException;
|
|
import net.sf.jasperreports.engine.util.JRClassLoader;
|
|
import net.sf.jasperreports.engine.util.JRProperties;
|
|
import org.apache.commons.logging.Log;
|
|
import org.apache.commons.logging.LogFactory;
|
|
import org.eclipse.jdt.core.compiler.IProblem;
|
|
import org.eclipse.jdt.internal.compiler.ClassFile;
|
|
import org.eclipse.jdt.internal.compiler.CompilationResult;
|
|
import org.eclipse.jdt.internal.compiler.Compiler;
|
|
import org.eclipse.jdt.internal.compiler.DefaultErrorHandlingPolicies;
|
|
import org.eclipse.jdt.internal.compiler.ICompilerRequestor;
|
|
import org.eclipse.jdt.internal.compiler.IErrorHandlingPolicy;
|
|
import org.eclipse.jdt.internal.compiler.IProblemFactory;
|
|
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileReader;
|
|
import org.eclipse.jdt.internal.compiler.classfmt.ClassFormatException;
|
|
import org.eclipse.jdt.internal.compiler.env.IBinaryType;
|
|
import org.eclipse.jdt.internal.compiler.env.ICompilationUnit;
|
|
import org.eclipse.jdt.internal.compiler.env.INameEnvironment;
|
|
import org.eclipse.jdt.internal.compiler.env.NameEnvironmentAnswer;
|
|
import org.eclipse.jdt.internal.compiler.problem.DefaultProblemFactory;
|
|
|
|
public class JRJdtCompiler extends JRAbstractJavaCompiler {
|
|
private static final String JDT_PROPERTIES_PREFIX = "org.eclipse.jdt.core.";
|
|
|
|
static final Log log = LogFactory.getLog(JRJdtCompiler.class);
|
|
|
|
private final ClassLoader classLoader;
|
|
|
|
Constructor constrNameEnvAnsBin;
|
|
|
|
Constructor constrNameEnvAnsCompUnit;
|
|
|
|
boolean is2ArgsConstr;
|
|
|
|
Constructor constrNameEnvAnsBin2Args;
|
|
|
|
Constructor constrNameEnvAnsCompUnit2Args;
|
|
|
|
public JRJdtCompiler() {
|
|
super(false);
|
|
boolean bool;
|
|
this.classLoader = getClassLoader();
|
|
try {
|
|
Class classAccessRestriction = loadClass("org.eclipse.jdt.internal.compiler.env.AccessRestriction");
|
|
this.constrNameEnvAnsBin2Args = NameEnvironmentAnswer.class.getConstructor(new Class[] { IBinaryType.class, classAccessRestriction });
|
|
this.constrNameEnvAnsCompUnit2Args = NameEnvironmentAnswer.class.getConstructor(new Class[] { ICompilationUnit.class, classAccessRestriction });
|
|
this.is2ArgsConstr = true;
|
|
bool = true;
|
|
} catch (NoSuchMethodException e) {
|
|
bool = false;
|
|
} catch (ClassNotFoundException ex) {
|
|
bool = false;
|
|
}
|
|
if (!bool)
|
|
try {
|
|
this.constrNameEnvAnsBin = NameEnvironmentAnswer.class.getConstructor(new Class[] { IBinaryType.class });
|
|
this.constrNameEnvAnsCompUnit = NameEnvironmentAnswer.class.getConstructor(new Class[] { ICompilationUnit.class });
|
|
this.is2ArgsConstr = false;
|
|
} catch (NoSuchMethodException ex) {
|
|
throw new JRRuntimeException("Not able to load JDT classes", ex);
|
|
}
|
|
}
|
|
|
|
class CompilationUnit implements ICompilationUnit {
|
|
protected String srcCode;
|
|
|
|
protected String className;
|
|
|
|
private final JRJdtCompiler this$0;
|
|
|
|
public CompilationUnit(String srcCode, String className) {
|
|
this.srcCode = srcCode;
|
|
this.className = className;
|
|
}
|
|
|
|
public char[] getFileName() {
|
|
return this.className.toCharArray();
|
|
}
|
|
|
|
public char[] getContents() {
|
|
return this.srcCode.toCharArray();
|
|
}
|
|
|
|
public char[] getMainTypeName() {
|
|
return this.className.toCharArray();
|
|
}
|
|
|
|
public char[][] getPackageName() {
|
|
return new char[0][0];
|
|
}
|
|
}
|
|
|
|
protected String compileUnits(JRCompilationUnit[] units, String classpath, File tempDirFile) {
|
|
StringBuffer problemBuffer = new StringBuffer();
|
|
INameEnvironment env = getNameEnvironment(units);
|
|
IErrorHandlingPolicy policy = DefaultErrorHandlingPolicies.proceedWithAllProblems();
|
|
Map settings = getJdtSettings();
|
|
DefaultProblemFactory defaultProblemFactory = new DefaultProblemFactory(Locale.getDefault());
|
|
ICompilerRequestor requestor = getCompilerRequestor(units, problemBuffer);
|
|
ICompilationUnit[] compilationUnits = new ICompilationUnit[units.length];
|
|
for (int i = 0; i < compilationUnits.length; i++)
|
|
compilationUnits[i] = new CompilationUnit(units[i].getSourceCode(), units[i].getName());
|
|
Compiler compiler = new Compiler(env, policy, settings, requestor, (IProblemFactory)defaultProblemFactory);
|
|
compiler.compile(compilationUnits);
|
|
if (problemBuffer.length() > 0)
|
|
return problemBuffer.toString();
|
|
return null;
|
|
}
|
|
|
|
protected INameEnvironment getNameEnvironment(final JRCompilationUnit[] units) {
|
|
INameEnvironment env = new INameEnvironment() {
|
|
private final JRCompilationUnit[] val$units;
|
|
|
|
private final JRJdtCompiler this$0;
|
|
|
|
public NameEnvironmentAnswer findType(char[][] compoundTypeName) {
|
|
StringBuffer result = new StringBuffer();
|
|
String sep = "";
|
|
for (int i = 0; i < compoundTypeName.length; i++) {
|
|
result.append(sep);
|
|
result.append(compoundTypeName[i]);
|
|
sep = ".";
|
|
}
|
|
return findType(result.toString());
|
|
}
|
|
|
|
public NameEnvironmentAnswer findType(char[] typeName, char[][] packageName) {
|
|
StringBuffer result = new StringBuffer();
|
|
String sep = "";
|
|
for (int i = 0; i < packageName.length; i++) {
|
|
result.append(sep);
|
|
result.append(packageName[i]);
|
|
sep = ".";
|
|
}
|
|
result.append(sep);
|
|
result.append(typeName);
|
|
return findType(result.toString());
|
|
}
|
|
|
|
private int getClassIndex(String className) {
|
|
int classIdx;
|
|
for (classIdx = 0; classIdx < units.length; classIdx++) {
|
|
if (className.equals(units[classIdx].getName()))
|
|
break;
|
|
}
|
|
if (classIdx >= units.length)
|
|
classIdx = -1;
|
|
return classIdx;
|
|
}
|
|
|
|
private NameEnvironmentAnswer findType(String className) {
|
|
try {
|
|
int classIdx = getClassIndex(className);
|
|
if (classIdx >= 0) {
|
|
ICompilationUnit compilationUnit = new JRJdtCompiler.CompilationUnit(units[classIdx].getSourceCode(), className);
|
|
if (JRJdtCompiler.this.is2ArgsConstr)
|
|
return JRJdtCompiler.this.constrNameEnvAnsCompUnit2Args.newInstance(new Object[] { compilationUnit, null });
|
|
return JRJdtCompiler.this.constrNameEnvAnsCompUnit.newInstance(new Object[] { compilationUnit });
|
|
}
|
|
String resourceName = className.replace('.', '/') + ".class";
|
|
InputStream is = JRJdtCompiler.this.getResource(resourceName);
|
|
if (is != null) {
|
|
byte[] buf = new byte[8192];
|
|
ByteArrayOutputStream baos = new ByteArrayOutputStream(buf.length);
|
|
int count;
|
|
while ((count = is.read(buf, 0, buf.length)) > 0)
|
|
baos.write(buf, 0, count);
|
|
baos.flush();
|
|
byte[] classBytes = baos.toByteArray();
|
|
char[] fileName = className.toCharArray();
|
|
ClassFileReader classFileReader = new ClassFileReader(classBytes, fileName, true);
|
|
if (JRJdtCompiler.this.is2ArgsConstr)
|
|
return JRJdtCompiler.this.constrNameEnvAnsBin2Args.newInstance(new Object[] { classFileReader, null });
|
|
return JRJdtCompiler.this.constrNameEnvAnsBin.newInstance(new Object[] { classFileReader });
|
|
}
|
|
} catch (IOException exc) {
|
|
JRJdtCompiler.log.error("Compilation error", exc);
|
|
} catch (ClassFormatException exc) {
|
|
JRJdtCompiler.log.error("Compilation error", (Throwable)exc);
|
|
} catch (InvocationTargetException e) {
|
|
throw new JRRuntimeException("Not able to create NameEnvironmentAnswer", e);
|
|
} catch (IllegalArgumentException e) {
|
|
throw new JRRuntimeException("Not able to create NameEnvironmentAnswer", e);
|
|
} catch (InstantiationException e) {
|
|
throw new JRRuntimeException("Not able to create NameEnvironmentAnswer", e);
|
|
} catch (IllegalAccessException e) {
|
|
throw new JRRuntimeException("Not able to create NameEnvironmentAnswer", e);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private boolean isPackage(String result) {
|
|
int classIdx = getClassIndex(result);
|
|
if (classIdx >= 0)
|
|
return false;
|
|
String resourceName = result.replace('.', '/') + ".class";
|
|
boolean isPackage = true;
|
|
InputStream is = JRJdtCompiler.this.getResource(resourceName);
|
|
if (is != null)
|
|
try {
|
|
isPackage = (is.read() > 0);
|
|
} catch (IOException e) {
|
|
try {
|
|
is.close();
|
|
} catch (IOException iOException) {}
|
|
} finally {
|
|
try {
|
|
is.close();
|
|
} catch (IOException e) {}
|
|
}
|
|
return isPackage;
|
|
}
|
|
|
|
public boolean isPackage(char[][] parentPackageName, char[] packageName) {
|
|
StringBuffer result = new StringBuffer();
|
|
String sep = "";
|
|
if (parentPackageName != null)
|
|
for (int i = 0; i < parentPackageName.length; i++) {
|
|
result.append(sep);
|
|
result.append(parentPackageName[i]);
|
|
sep = ".";
|
|
}
|
|
if (Character.isUpperCase(packageName[0]))
|
|
if (!isPackage(result.toString()))
|
|
return false;
|
|
result.append(sep);
|
|
result.append(packageName);
|
|
return isPackage(result.toString());
|
|
}
|
|
|
|
public void cleanup() {}
|
|
};
|
|
return env;
|
|
}
|
|
|
|
protected ICompilerRequestor getCompilerRequestor(final JRCompilationUnit[] units, final StringBuffer problemBuffer) {
|
|
ICompilerRequestor requestor = new ICompilerRequestor() {
|
|
private final JRCompilationUnit[] val$units;
|
|
|
|
private final StringBuffer val$problemBuffer;
|
|
|
|
private final JRJdtCompiler this$0;
|
|
|
|
public void acceptResult(CompilationResult result) {
|
|
String className = ((JRJdtCompiler.CompilationUnit)result.getCompilationUnit()).className;
|
|
int classIdx;
|
|
for (classIdx = 0; classIdx < units.length; classIdx++) {
|
|
if (className.equals(units[classIdx].getName()))
|
|
break;
|
|
}
|
|
if (result.hasErrors()) {
|
|
String sourceCode = units[classIdx].getSourceCode();
|
|
IProblem[] problems = JRJdtCompiler.this.getJavaCompilationErrors(result);
|
|
for (int i = 0; i < problems.length; i++) {
|
|
IProblem problem = problems[i];
|
|
problemBuffer.append(i + 1);
|
|
problemBuffer.append(". ");
|
|
problemBuffer.append(problem.getMessage());
|
|
if (problem.getSourceStart() >= 0 && problem.getSourceEnd() >= 0) {
|
|
int problemStartIndex = sourceCode.lastIndexOf("\n", problem.getSourceStart()) + 1;
|
|
int problemEndIndex = sourceCode.indexOf("\n", problem.getSourceEnd());
|
|
if (problemEndIndex < 0)
|
|
problemEndIndex = sourceCode.length();
|
|
problemBuffer.append("\n");
|
|
problemBuffer.append(sourceCode.substring(problemStartIndex, problemEndIndex));
|
|
problemBuffer.append("\n");
|
|
int j;
|
|
for (j = problemStartIndex; j < problem.getSourceStart(); j++)
|
|
problemBuffer.append(" ");
|
|
if (problem.getSourceStart() == problem.getSourceEnd()) {
|
|
problemBuffer.append("^");
|
|
} else {
|
|
problemBuffer.append("<");
|
|
for (j = problem.getSourceStart() + 1; j < problem.getSourceEnd(); j++)
|
|
problemBuffer.append("-");
|
|
problemBuffer.append(">");
|
|
}
|
|
}
|
|
problemBuffer.append("\n");
|
|
}
|
|
problemBuffer.append(problems.length);
|
|
problemBuffer.append(" errors\n");
|
|
}
|
|
if (problemBuffer.length() == 0) {
|
|
ClassFile[] resultClassFiles = result.getClassFiles();
|
|
for (int i = 0; i < resultClassFiles.length; i++)
|
|
units[classIdx].setCompileData((Serializable)resultClassFiles[i].getBytes());
|
|
}
|
|
}
|
|
};
|
|
return requestor;
|
|
}
|
|
|
|
protected Map getJdtSettings() {
|
|
Map settings = new HashMap();
|
|
settings.put("org.eclipse.jdt.core.compiler.debug.lineNumber", "generate");
|
|
settings.put("org.eclipse.jdt.core.compiler.debug.sourceFile", "generate");
|
|
settings.put("org.eclipse.jdt.core.compiler.problem.deprecation", "ignore");
|
|
List properties = JRProperties.getProperties("org.eclipse.jdt.core.");
|
|
for (Iterator it = properties.iterator(); it.hasNext(); ) {
|
|
JRProperties.PropertySuffix property = it.next();
|
|
String propVal = property.getValue();
|
|
if (propVal != null && propVal.length() > 0)
|
|
settings.put(property.getKey(), propVal);
|
|
}
|
|
Properties systemProps = System.getProperties();
|
|
for (Enumeration enumeration = systemProps.propertyNames(); enumeration.hasMoreElements(); ) {
|
|
String propName = (String)enumeration.nextElement();
|
|
if (propName.startsWith("org.eclipse.jdt.core.")) {
|
|
String propVal = systemProps.getProperty(propName);
|
|
if (propVal != null && propVal.length() > 0)
|
|
settings.put(propName, propVal);
|
|
}
|
|
}
|
|
return settings;
|
|
}
|
|
|
|
private ClassLoader getClassLoader() {
|
|
ClassLoader clsLoader = Thread.currentThread().getContextClassLoader();
|
|
if (clsLoader != null)
|
|
try {
|
|
Class.forName(JRJdtCompiler.class.getName(), true, clsLoader);
|
|
} catch (ClassNotFoundException e) {
|
|
clsLoader = null;
|
|
}
|
|
if (clsLoader == null)
|
|
clsLoader = JRClassLoader.class.getClassLoader();
|
|
return clsLoader;
|
|
}
|
|
|
|
protected InputStream getResource(String resourceName) {
|
|
if (this.classLoader == null)
|
|
return JRJdtCompiler.class.getResourceAsStream("/" + resourceName);
|
|
return this.classLoader.getResourceAsStream(resourceName);
|
|
}
|
|
|
|
protected Class loadClass(String className) throws ClassNotFoundException {
|
|
if (this.classLoader == null)
|
|
return Class.forName(className);
|
|
return this.classLoader.loadClass(className);
|
|
}
|
|
|
|
protected void checkLanguage(String language) throws JRException {
|
|
if (!"java".equals(language))
|
|
throw new JRException("Language \"" + language + "\" not supported by this report compiler.\n" + "Expecting \"java\" instead.");
|
|
}
|
|
|
|
protected JRCompilationSourceCode generateSourceCode(JRSourceCompileTask sourceTask) throws JRException {
|
|
return JRClassGenerator.generateClass(sourceTask);
|
|
}
|
|
|
|
protected String getSourceFileName(String unitName) {
|
|
return unitName + ".java";
|
|
}
|
|
|
|
protected String getCompilerClass() {
|
|
return JRJavacCompiler.class.getName();
|
|
}
|
|
|
|
protected IProblem[] getJavaCompilationErrors(CompilationResult result) {
|
|
try {
|
|
Method getErrorsMethod = result.getClass().getMethod("getErrors", null);
|
|
return (IProblem[])getErrorsMethod.invoke(result, null);
|
|
} catch (SecurityException e) {
|
|
throw new JRRuntimeException("Error resolving JDT methods", e);
|
|
} catch (NoSuchMethodException e) {
|
|
throw new JRRuntimeException("Error resolving JDT methods", e);
|
|
} catch (IllegalArgumentException e) {
|
|
throw new JRRuntimeException("Error invoking JDT methods", e);
|
|
} catch (IllegalAccessException e) {
|
|
throw new JRRuntimeException("Error invoking JDT methods", e);
|
|
} catch (InvocationTargetException e) {
|
|
throw new JRRuntimeException("Error invoking JDT methods", e);
|
|
}
|
|
}
|
|
}
|