net.sf.jasperreports.jdt.JRJdtCompiler Maven / Gradle / Ivy
The newest version!
/*
* JasperReports - Free Java Reporting Library.
* Copyright (C) 2001 - 2023 Cloud Software Group, Inc. All rights reserved.
* http://www.jaspersoft.com
*
* Unless you have purchased a commercial license agreement from Jaspersoft,
* the following license terms apply:
*
* This program is part of JasperReports.
*
* JasperReports is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* JasperReports is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with JasperReports. If not, see getJdtSettings()
{
final Map settings = new HashMap<>();
settings.put(CompilerOptions.OPTION_LineNumberAttribute, CompilerOptions.GENERATE);
settings.put(CompilerOptions.OPTION_SourceFileAttribute, CompilerOptions.GENERATE);
settings.put(CompilerOptions.OPTION_ReportDeprecation, CompilerOptions.IGNORE);
// if (ctxt.getOptions().getJavaEncoding() != null)
// {
// settings.put(CompilerOptions.OPTION_Encoding, ctxt.getOptions().getJavaEncoding());
// }
// if (ctxt.getOptions().getClassDebugInfo())
// {
// settings.put(CompilerOptions.OPTION_LocalVariableAttribute, CompilerOptions.GENERATE);
// }
List properties = JRPropertiesUtil.getInstance(jasperReportsContext).getProperties(JDT_PROPERTIES_PREFIX);
for (Iterator it = properties.iterator(); it.hasNext();)
{
JRPropertiesUtil.PropertySuffix property = it.next();
String propVal = property.getValue();
if (propVal != null && propVal.length() > 0)
{
settings.put(property.getKey(), propVal);
}
}
Properties systemProps = System.getProperties();
for (String propName : systemProps.stringPropertyNames())
{
if (propName.startsWith(JDT_PROPERTIES_PREFIX))
{
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 (log.isWarnEnabled())
// log.warn("Failure using Thread.currentThread().getContextClassLoader() in JRJdtCompiler class. Using JRJdtCompiler.class.getClassLoader() instead.");
}
}
if (clsLoader == null)
{
clsLoader = JRClassLoader.class.getClassLoader();
}
return clsLoader;
}
protected InputStream getResource (String resourceName)
{
if (classLoader == null)
{
return JRJdtCompiler.class.getResourceAsStream("/" + resourceName);
}
return classLoader.getResourceAsStream(resourceName);
}
protected Class loadClass (String className) throws ClassNotFoundException
{
if (classLoader == null)
{
return Class.forName(className);
}
return classLoader.loadClass(className);
}
@Override
protected void checkLanguage(String language) throws JRException
{
if (!JRReport.LANGUAGE_JAVA.equals(language))
{
throw
new JRException(
EXCEPTION_MESSAGE_KEY_EXPECTED_JAVA_LANGUAGE,
new Object[]{language, JRReport.LANGUAGE_JAVA});
}
}
protected JRCompilationUnit recreateCompileUnit(JRCompilationUnit compilationUnit, Set missingMethods)
{
String unitName = compilationUnit.getName();
JRSourceCompileTask sourceTask = compilationUnit.getCompileTask();
JRCompilationSourceCode sourceCode = JRClassGenerator.modifySource(sourceTask, missingMethods, compilationUnit.getSourceCode());
File sourceFile = compilationUnit.getSourceFile();
File saveSourceDir = sourceFile == null ? null : sourceFile.getParentFile();
sourceFile = getSourceFile(saveSourceDir, compilationUnit.getCompileName(), sourceCode);
JRCompilationUnit newUnit = new JRCompilationUnit(unitName);
newUnit.setDirectEvaluations(compilationUnit.getDirectEvaluations());
newUnit.setSource(sourceCode, sourceFile, sourceTask);
return newUnit;
}
@Override
protected JRCompilationSourceCode generateSourceCode(JRSourceCompileTask sourceTask) throws JRException
{
return JRClassGenerator.generateClass(sourceTask);
}
@Override
protected String getSourceFileName(String unitName)
{
return unitName + ".java";
}
@Override
protected String getCompilerClass()
{
return JRJavacCompiler.class.getName();
}
/**
*
*/
public static class CompilerRequestor implements ICompilerRequestor
{
public static final String EXCEPTION_MESSAGE_KEY_METHOD_INVOKING_ERROR = "compilers.jdt.method.invoking.error";
public static final String EXCEPTION_MESSAGE_KEY_METHOD_RESOLVING_ERROR = "compilers.jdt.method.resolving.error";
private final JasperReportsContext jasperReportsContext;
protected final JRJdtCompiler compiler;
protected final JRCompilationUnit[] units;
protected final CompilationUnitResult[] unitResults;
public CompilerRequestor(final JasperReportsContext jasperReportsContext, final JRJdtCompiler compiler, final JRCompilationUnit[] units)
{
this.jasperReportsContext = jasperReportsContext;
this.compiler = compiler;
this.units = units;
this.unitResults = new CompilationUnitResult[units.length];
reset();
}
@Override
public void acceptResult(CompilationResult result)
{
String className = ((CompilationUnit) result.getCompilationUnit()).className;
int classIdx;
for (classIdx = 0; classIdx < units.length; ++classIdx)
{
if (className.equals(units[classIdx].getCompileName()))
{
break;
}
}
if (result.hasErrors())
{
//IProblem[] problems = result.getErrors();
IProblem[] problems = getJavaCompilationErrors(result);
unitResults[classIdx].problems = problems;
String sourceCode = units[classIdx].getSourceCode();
for (int i = 0; i < problems.length; i++)
{
IProblem problem = problems[i];
if (IProblem.UndefinedMethod == problem.getID())
{
if (
problem.getSourceStart() >= 0
&& problem.getSourceEnd() >= 0
)
{
String methodName =
sourceCode.substring(
problem.getSourceStart(),
problem.getSourceEnd() + 1
);
Method method = FunctionsUtil.getInstance(jasperReportsContext).getMethod4Function(methodName);
if (method != null)
{
unitResults[classIdx].addMissingMethod(method);
//continue;
}
}
}
}
}
else
{
ClassFile[] resultClassFiles = result.getClassFiles();
for (int i = 0; i < resultClassFiles.length; i++)
{
units[classIdx].setCompileData(resultClassFiles[i].getBytes());
}
}
}
/**
*
*/
public void processProblems()
{
//nothing to do here
}
/**
*
*/
public String getFormattedProblems()
{
StringBuilder problemBuilder = new StringBuilder();
for (int u = 0; u < units.length; u++)
{
String sourceCode = units[u].getSourceCode();
IProblem[] problems = unitResults[u].problems;
if (problems != null && problems.length > 0)
{
for (int i = 0; i < problems.length; i++)
{
IProblem problem = problems[i];
problemBuilder.append(i + 1);
problemBuilder.append(". ");
problemBuilder.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();
}
problemBuilder.append("\n");
problemBuilder.append(
sourceCode.substring(
problemStartIndex,
problemEndIndex
)
);
problemBuilder.append("\n");
for(int j = problemStartIndex; j < problem.getSourceStart(); j++)
{
problemBuilder.append(" ");
}
if (problem.getSourceStart() == problem.getSourceEnd())
{
problemBuilder.append("^");
}
else
{
problemBuilder.append("<");
for(int j = problem.getSourceStart() + 1; j < problem.getSourceEnd(); j++)
{
problemBuilder.append("-");
}
problemBuilder.append(">");
}
problemBuilder.append("\n");
}
}
problemBuilder.append(problems.length);
problemBuilder.append(" errors\n");
}
}
return problemBuilder.length() > 0 ? problemBuilder.toString() : null;
}
/**
*
*/
public boolean hasMissingMethods()
{
for (CompilationUnitResult unitResult : unitResults)
{
if (unitResult.hasMissingMethods())
{
return true;
}
}
return false;
}
/**
*
*/
public CompilationUnit[] processCompilationUnits()
{
final CompilationUnit[] compilationUnits = new CompilationUnit[units.length];
for (int i = 0; i < compilationUnits.length; i++)
{
if (unitResults[i].hasMissingMethods())
{
units[i] = compiler.recreateCompileUnit(units[i], unitResults[i].getMissingMethods());
unitResults[i].resolveMissingMethods();
}
compilationUnits[i] = new CompilationUnit(units[i].getSourceCode(), units[i].getCompileName());
}
reset();
return compilationUnits;
}
/**
*
*/
protected void reset()
{
for (int i = 0; i < unitResults.length; i++)
{
if (unitResults[i] == null)
{
unitResults[i] = new CompilationUnitResult();
}
unitResults[i].reset();
}
}
/**
*
*/
protected IProblem[] getJavaCompilationErrors(CompilationResult result)
{
try {
Method getErrorsMethod = result.getClass().getMethod("getErrors", (Class[])null);
return (IProblem[]) getErrorsMethod.invoke(result, (Object[])null);
} catch (SecurityException | NoSuchMethodException | IllegalArgumentException
| IllegalAccessException | InvocationTargetException e) {
throw
new JRRuntimeException(
EXCEPTION_MESSAGE_KEY_METHOD_INVOKING_ERROR,
(Object[])null,
e);
}
}
}
/**
*
*/
public static class CompilationUnit implements ICompilationUnit
{
protected String srcCode;
protected String className;
public CompilationUnit(String srcCode, String className)
{
this.srcCode = srcCode;
this.className = className;
}
@Override
public char[] getFileName()
{
return className.toCharArray();
}
@Override
public char[] getContents()
{
return srcCode.toCharArray();
}
@Override
public char[] getMainTypeName()
{
return className.toCharArray();
}
@Override
public char[][] getPackageName()
{
return new char[0][0];
}
@Override
public boolean ignoreOptionalProblems()
{
return false;
}
}
/**
*
*/
public static class CompilationUnitResult
{
private Set resolvedMethods;
private Set missingMethods;
private IProblem[] problems;
public boolean hasMissingMethods()
{
return missingMethods != null && missingMethods.size() > 0;
}
public Set getMissingMethods()
{
return missingMethods;
}
public void addMissingMethod(Method missingMethod)
{
if (resolvedMethods == null || !resolvedMethods.contains(missingMethod))
{
if (missingMethods == null)
{
missingMethods = new LinkedHashSet<>();
}
missingMethods.add(missingMethod);
}
}
public IProblem[] getProblems()
{
return problems;
}
public void setProblems(IProblem[] problems)
{
this.problems = problems;
}
public void resolveMissingMethods()
{
if (missingMethods != null && missingMethods.size() > 0)
{
if (resolvedMethods == null)
{
resolvedMethods = new HashSet<>();
}
resolvedMethods.addAll(missingMethods);
}
}
public void reset()
{
missingMethods = null;
problems = null;
}
}
}