net.sf.jasperreports.engine.design.JRJdtCompiler Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of jasperreports Show documentation
Show all versions of jasperreports Show documentation
Free Java Reporting Library
/*
* JasperReports - Free Java Reporting Library.
* Copyright (C) 2001 - 2022 TIBCO Software 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, unitName, 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].getName()))
{
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].getName());
}
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 HashSet<>();
}
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;
}
}
}