Search in sources :

Example 1 with JavaCompilerSettings

use of org.kie.memorycompiler.JavaCompilerSettings in project drools by kiegroup.

the class EclipseJavaCompiler method compile.

public CompilationResult compile(final String[] pSourceFiles, final ResourceReader pReader, final ResourceStore pStore, final ClassLoader pClassLoader, final JavaCompilerSettings pSettings) {
    final Collection problems = new ArrayList();
    final ICompilationUnit[] compilationUnits = new ICompilationUnit[pSourceFiles.length];
    for (int i = 0; i < compilationUnits.length; i++) {
        final KiePath sourceFile = KiePath.of(pSourceFiles[i]);
        if (pReader.isAvailable(sourceFile)) {
            compilationUnits[i] = new CompilationUnit(pReader, sourceFile.asString());
        } else {
            // log.error("source not found " + sourceFile);
            final CompilationProblem problem = new CompilationProblem() {

                public int getEndColumn() {
                    return 0;
                }

                public int getEndLine() {
                    return 0;
                }

                public String getFileName() {
                    return sourceFile.asString();
                }

                public String getMessage() {
                    return "Source " + sourceFile.asString() + " could not be found";
                }

                public int getStartColumn() {
                    return 0;
                }

                public int getStartLine() {
                    return 0;
                }

                public boolean isError() {
                    return true;
                }

                public String toString() {
                    return getMessage();
                }
            };
            problems.add(problem);
        }
    }
    if (problems.size() > 0) {
        final CompilationProblem[] result = new CompilationProblem[problems.size()];
        problems.toArray(result);
        return new CompilationResult(result);
    }
    final IErrorHandlingPolicy policy = DefaultErrorHandlingPolicies.proceedWithAllProblems();
    final IProblemFactory problemFactory = new DefaultProblemFactory(Locale.getDefault());
    final INameEnvironment nameEnvironment = new INameEnvironment() {

        public NameEnvironmentAnswer findType(final char[][] pCompoundTypeName) {
            final StringBuilder result = new StringBuilder();
            for (int i = 0; i < pCompoundTypeName.length; i++) {
                if (i != 0) {
                    result.append('.');
                }
                result.append(pCompoundTypeName[i]);
            }
            return findType(result.toString());
        }

        public NameEnvironmentAnswer findType(final char[] pTypeName, final char[][] pPackageName) {
            final StringBuilder result = new StringBuilder();
            for (char[] chars : pPackageName) {
                result.append(chars);
                result.append('.');
            }
            result.append(pTypeName);
            return findType(result.toString());
        }

        private NameEnvironmentAnswer findType(final String pClazzName) {
            final String resourceName = ClassUtils.convertClassToResourcePath(pClazzName);
            final byte[] clazzBytes = pStore.read(resourceName);
            if (clazzBytes != null) {
                try {
                    return createNameEnvironmentAnswer(pClazzName, clazzBytes);
                } catch (final ClassFormatException e) {
                    throw new RuntimeException("ClassFormatException in loading class '" + pClazzName + "' with JCI.");
                }
            }
            try (InputStream is = pClassLoader.getResourceAsStream(resourceName)) {
                if (is == null) {
                    return null;
                }
                if (ClassUtils.isCaseSenstiveOS()) {
                    // check it really is a class, this issue is due to windows case sensitivity issues for the class org.kie.Process and path org/droosl/process
                    try {
                        pClassLoader.loadClass(pClazzName);
                    } catch (ClassNotFoundException | NoClassDefFoundError e) {
                        return null;
                    }
                }
                final byte[] buffer = new byte[8192];
                try (ByteArrayOutputStream baos = new ByteArrayOutputStream(buffer.length)) {
                    int count;
                    while ((count = is.read(buffer, 0, buffer.length)) > 0) {
                        baos.write(buffer, 0, count);
                    }
                    baos.flush();
                    return createNameEnvironmentAnswer(pClazzName, baos.toByteArray());
                }
            } catch (final IOException e) {
                throw new RuntimeException("could not read class", e);
            } catch (final ClassFormatException e) {
                throw new RuntimeException("wrong class format", e);
            }
        }

        private NameEnvironmentAnswer createNameEnvironmentAnswer(final String pClazzName, final byte[] clazzBytes) throws ClassFormatException {
            final char[] fileName = pClazzName.toCharArray();
            final ClassFileReader classFileReader = new ClassFileReader(clazzBytes, fileName, true);
            return new NameEnvironmentAnswer(classFileReader, null);
        }

        private boolean isSourceAvailable(final String pClazzName, final ResourceReader pReader) {
            // FIXME: this should not be tied to the extension
            final String javaSource = pClazzName.replace('.', '/') + ".java";
            final String classSource = pClazzName.replace('.', '/') + ".class";
            return pReader.isAvailable(sourceFolder + javaSource) || pReader.isAvailable(sourceFolder + classSource);
        }

        private boolean isPackage(final String pClazzName) {
            try (InputStream is = pClassLoader.getResourceAsStream(ClassUtils.convertClassToResourcePath(pClazzName))) {
                if (is != null) {
                    if (ClassUtils.isWindows() || ClassUtils.isOSX()) {
                        try {
                            Class cls = pClassLoader.loadClass(pClazzName);
                            if (cls != null) {
                                return false;
                            }
                        } catch (ClassNotFoundException | NoClassDefFoundError e) {
                            return true;
                        }
                    }
                }
                return is == null && !isSourceAvailable(pClazzName, pReader);
            } catch (IOException e) {
                throw new RuntimeException("Cannot open or close resource stream!", e);
            }
        }

        public boolean isPackage(char[][] parentPackageName, char[] pPackageName) {
            final StringBuilder result = new StringBuilder();
            if (parentPackageName != null) {
                for (int i = 0; i < parentPackageName.length; i++) {
                    if (i != 0) {
                        result.append('.');
                    }
                    result.append(parentPackageName[i]);
                }
            }
            if (parentPackageName != null && parentPackageName.length > 0) {
                result.append('.');
            }
            result.append(pPackageName);
            return isPackage(result.toString());
        }

        public void cleanup() {
        }
    };
    final ICompilerRequestor compilerRequestor = pResult -> {
        if (pResult.hasProblems()) {
            final IProblem[] iproblems = pResult.getProblems();
            for (final IProblem iproblem : iproblems) {
                final CompilationProblem problem = new EclipseCompilationProblem(iproblem);
                problems.add(problem);
            }
        }
        if (!pResult.hasErrors()) {
            final ClassFile[] clazzFiles = pResult.getClassFiles();
            for (final ClassFile clazzFile : clazzFiles) {
                final char[][] compoundName = clazzFile.getCompoundName();
                final StringBuilder clazzName = new StringBuilder();
                for (int j = 0; j < compoundName.length; j++) {
                    if (j != 0) {
                        clazzName.append('.');
                    }
                    clazzName.append(compoundName[j]);
                }
                pStore.write(clazzName.toString().replace('.', '/') + ".class", clazzFile.getBytes());
            }
        }
    };
    final Map settingsMap = new EclipseJavaCompilerSettings(pSettings).toNativeSettings();
    CompilerOptions compilerOptions = new CompilerOptions(settingsMap);
    compilerOptions.parseLiteralExpressionsAsConstants = false;
    final Compiler compiler = new Compiler(nameEnvironment, policy, compilerOptions, compilerRequestor, problemFactory);
    if (ClassBuilderFactory.DUMP_GENERATED_CLASSES) {
        dumpUnits(compilationUnits, pReader);
    }
    compiler.compile(compilationUnits);
    final CompilationProblem[] result = new CompilationProblem[problems.size()];
    problems.toArray(result);
    return new CompilationResult(result);
}
Also used : IErrorHandlingPolicy(org.eclipse.jdt.internal.compiler.IErrorHandlingPolicy) ResourceReader(org.kie.memorycompiler.resources.ResourceReader) INameEnvironment(org.eclipse.jdt.internal.compiler.env.INameEnvironment) KiePath(org.kie.memorycompiler.resources.KiePath) ByteArrayOutputStream(java.io.ByteArrayOutputStream) URLDecoder(java.net.URLDecoder) ResourceStore(org.kie.memorycompiler.resources.ResourceStore) ClassFormatException(org.eclipse.jdt.internal.compiler.classfmt.ClassFormatException) CompilationProblem(org.kie.memorycompiler.CompilationProblem) CompilationResult(org.kie.memorycompiler.CompilationResult) AbstractJavaCompiler(org.kie.memorycompiler.AbstractJavaCompiler) ArrayList(java.util.ArrayList) ClassBuilderFactory(org.drools.core.factmodel.ClassBuilderFactory) NameEnvironmentAnswer(org.eclipse.jdt.internal.compiler.env.NameEnvironmentAnswer) IoUtils(org.drools.core.util.IoUtils) Locale(java.util.Locale) StringTokenizer(java.util.StringTokenizer) Map(java.util.Map) ResourceReader(org.kie.memorycompiler.resources.ResourceReader) ClassFileReader(org.eclipse.jdt.internal.compiler.classfmt.ClassFileReader) IProblemFactory(org.eclipse.jdt.internal.compiler.IProblemFactory) ClassUtils(org.drools.core.util.ClassUtils) IErrorHandlingPolicy(org.eclipse.jdt.internal.compiler.IErrorHandlingPolicy) Collection(java.util.Collection) ClassFile(org.eclipse.jdt.internal.compiler.ClassFile) IOException(java.io.IOException) ICompilerRequestor(org.eclipse.jdt.internal.compiler.ICompilerRequestor) Compiler(org.eclipse.jdt.internal.compiler.Compiler) DefaultProblemFactory(org.eclipse.jdt.internal.compiler.problem.DefaultProblemFactory) DefaultErrorHandlingPolicies(org.eclipse.jdt.internal.compiler.DefaultErrorHandlingPolicies) IProblem(org.eclipse.jdt.core.compiler.IProblem) CompilerOptions(org.eclipse.jdt.internal.compiler.impl.CompilerOptions) JavaCompilerSettings(org.kie.memorycompiler.JavaCompilerSettings) UnsupportedEncodingException(java.io.UnsupportedEncodingException) ICompilationUnit(org.eclipse.jdt.internal.compiler.env.ICompilationUnit) InputStream(java.io.InputStream) NameEnvironmentAnswer(org.eclipse.jdt.internal.compiler.env.NameEnvironmentAnswer) ClassFileReader(org.eclipse.jdt.internal.compiler.classfmt.ClassFileReader) ArrayList(java.util.ArrayList) CompilationProblem(org.kie.memorycompiler.CompilationProblem) ClassFormatException(org.eclipse.jdt.internal.compiler.classfmt.ClassFormatException) INameEnvironment(org.eclipse.jdt.internal.compiler.env.INameEnvironment) DefaultProblemFactory(org.eclipse.jdt.internal.compiler.problem.DefaultProblemFactory) IProblemFactory(org.eclipse.jdt.internal.compiler.IProblemFactory) ICompilationUnit(org.eclipse.jdt.internal.compiler.env.ICompilationUnit) ICompilationUnit(org.eclipse.jdt.internal.compiler.env.ICompilationUnit) AbstractJavaCompiler(org.kie.memorycompiler.AbstractJavaCompiler) Compiler(org.eclipse.jdt.internal.compiler.Compiler) ClassFile(org.eclipse.jdt.internal.compiler.ClassFile) ICompilerRequestor(org.eclipse.jdt.internal.compiler.ICompilerRequestor) InputStream(java.io.InputStream) ByteArrayOutputStream(java.io.ByteArrayOutputStream) IOException(java.io.IOException) IProblem(org.eclipse.jdt.core.compiler.IProblem) CompilerOptions(org.eclipse.jdt.internal.compiler.impl.CompilerOptions) Collection(java.util.Collection) KiePath(org.kie.memorycompiler.resources.KiePath) CompilationResult(org.kie.memorycompiler.CompilationResult) Map(java.util.Map)

Aggregations

ByteArrayOutputStream (java.io.ByteArrayOutputStream)1 IOException (java.io.IOException)1 InputStream (java.io.InputStream)1 UnsupportedEncodingException (java.io.UnsupportedEncodingException)1 URLDecoder (java.net.URLDecoder)1 ArrayList (java.util.ArrayList)1 Collection (java.util.Collection)1 Locale (java.util.Locale)1 Map (java.util.Map)1 StringTokenizer (java.util.StringTokenizer)1 ClassBuilderFactory (org.drools.core.factmodel.ClassBuilderFactory)1 ClassUtils (org.drools.core.util.ClassUtils)1 IoUtils (org.drools.core.util.IoUtils)1 IProblem (org.eclipse.jdt.core.compiler.IProblem)1 ClassFile (org.eclipse.jdt.internal.compiler.ClassFile)1 Compiler (org.eclipse.jdt.internal.compiler.Compiler)1 DefaultErrorHandlingPolicies (org.eclipse.jdt.internal.compiler.DefaultErrorHandlingPolicies)1 ICompilerRequestor (org.eclipse.jdt.internal.compiler.ICompilerRequestor)1 IErrorHandlingPolicy (org.eclipse.jdt.internal.compiler.IErrorHandlingPolicy)1 IProblemFactory (org.eclipse.jdt.internal.compiler.IProblemFactory)1