first commit
This commit is contained in:
394
hrmsEjb/net/sf/jasperreports/engine/design/JRJdtCompiler.java
Normal file
394
hrmsEjb/net/sf/jasperreports/engine/design/JRJdtCompiler.java
Normal file
@@ -0,0 +1,394 @@
|
||||
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);
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user