    001    /*
    002     * Licensed to the Apache Software Foundation (ASF) under one or more
    003     * contributor license agreements.  See the NOTICE file distributed with
    004     * this work for additional information regarding copyright ownership.
    005     * The ASF licenses this file to You under the Apache License, Version 2.0
    006     * (the "License"); you may not use this file except in compliance with
    007     * the License.  You may obtain a copy of the License at
    008     *
    009     *      http://www.apache.org/licenses/LICENSE-2.0
    010     *
    011     * Unless required by applicable law or agreed to in writing, software
    012     * distributed under the License is distributed on an "AS IS" BASIS,
    013     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    014     * See the License for the specific language governing permissions and
    015     * limitations under the License.
    016     */
    017    package org.apache.commons.jci.compilers;
    018
    019    import java.io.ByteArrayOutputStream;
    020    import java.io.IOException;
    021    import java.io.InputStream;
    022    import java.util.ArrayList;
    023    import java.util.Collection;
    024    import java.util.Locale;
    025    import java.util.Map;
    026    import java.util.StringTokenizer;
    027
    028    import org.apache.commons.jci.problems.CompilationProblem;
    029    import org.apache.commons.jci.readers.ResourceReader;
    030    import org.apache.commons.jci.stores.ResourceStore;
    031    import org.apache.commons.jci.utils.ConversionUtils;
    032    import org.apache.commons.logging.Log;
    033    import org.apache.commons.logging.LogFactory;
    034    import org.eclipse.jdt.core.compiler.IProblem;
    035    import org.eclipse.jdt.internal.compiler.ClassFile;
    036    import org.eclipse.jdt.internal.compiler.CompilationResult;
    037    import org.eclipse.jdt.internal.compiler.Compiler;
    038    import org.eclipse.jdt.internal.compiler.DefaultErrorHandlingPolicies;
    039    import org.eclipse.jdt.internal.compiler.ICompilerRequestor;
    040    import org.eclipse.jdt.internal.compiler.IErrorHandlingPolicy;
    041    import org.eclipse.jdt.internal.compiler.IProblemFactory;
    042    import org.eclipse.jdt.internal.compiler.classfmt.ClassFileReader;
    043    import org.eclipse.jdt.internal.compiler.classfmt.ClassFormatException;
    044    import org.eclipse.jdt.internal.compiler.env.ICompilationUnit;
    045    import org.eclipse.jdt.internal.compiler.env.INameEnvironment;
    046    import org.eclipse.jdt.internal.compiler.env.NameEnvironmentAnswer;
    047    import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
    048    import org.eclipse.jdt.internal.compiler.problem.DefaultProblemFactory;
    049
    050    /**
    051     * Eclipse compiler implemenation
    052     *
    053     * @author tcurdt
    054     */
    055    public final class EclipseJavaCompiler extends AbstractJavaCompiler {
    056
    057        private final Log log = LogFactory.getLog(EclipseJavaCompiler.class);
    058        private final EclipseJavaCompilerSettings defaultSettings;
    059
    060        public EclipseJavaCompiler() {
    061            this(new EclipseJavaCompilerSettings());
    062        }
    063
    064        public EclipseJavaCompiler( final Map<String, String> pSettings ) {
    065            defaultSettings = new EclipseJavaCompilerSettings(pSettings);
    066        }
    067
    068        public EclipseJavaCompiler( final EclipseJavaCompilerSettings pSettings ) {
    069            defaultSettings = pSettings;
    070        }
    071
    072        final class CompilationUnit implements ICompilationUnit {
    073
    074            final private String clazzName;
    075            final private String fileName;
    076            final private char[] typeName;
    077            final private char[][] packageName;
    078            final private ResourceReader reader;
    079
    080            CompilationUnit( final ResourceReader pReader, final String pSourceFile ) {
    081                reader = pReader;
    082                clazzName = ConversionUtils.convertResourceToClassName(pSourceFile);
    083                fileName = pSourceFile;
    084                int dot = clazzName.lastIndexOf('.');
    085                if (dot > 0) {
    086                    typeName = clazzName.substring(dot + 1).toCharArray();
    087                } else {
    088                    typeName = clazzName.toCharArray();
    089                }
    090
    091                log.debug("className=" + clazzName);
    092                log.debug("fileName=" + fileName);
    093                log.debug("typeName=" + new String(typeName));
    094
    095                final StringTokenizer izer = new StringTokenizer(clazzName, ".");
    096                packageName = new char[izer.countTokens() - 1][];
    097                for (int i = 0; i < packageName.length; i++) {
    098                    packageName[i] = izer.nextToken().toCharArray();
    099                    log.debug("package[" + i + "]=" + new String(packageName[i]));
    100                }
    101            }
    102
    103            public char[] getFileName() {
    104                return fileName.toCharArray();
    105            }
    106
    107            public char[] getContents() {
    108                final byte[] content = reader.getBytes(fileName);
    109
    110                if (content == null) {
    111                    return null;
    112                    //throw new RuntimeException("resource " + fileName + " could not be found");
    113                }
    114
    115                return new String(content).toCharArray();
    116            }
    117
    118            public char[] getMainTypeName() {
    119                return typeName;
    120            }
    121
    122            public char[][] getPackageName() {
    123                return packageName;
    124            }
    125
    126            public boolean ignoreOptionalProblems() {
    127                return false;
    128            }
    129        }
    130
    131
    132        public org.apache.commons.jci.compilers.CompilationResult compile(
    133                final String[] pSourceFiles,
    134                final ResourceReader pReader,
    135                final ResourceStore pStore,
    136                final ClassLoader pClassLoader,
    137                final JavaCompilerSettings pSettings
    138                ) {
    139
    140            final Map<String, String> settingsMap = new EclipseJavaCompilerSettings(pSettings).toNativeSettings();
    141
    142            final Collection<CompilationProblem> problems = new ArrayList<CompilationProblem>();
    143
    144            final ICompilationUnit[] compilationUnits = new ICompilationUnit[pSourceFiles.length];
    145            for (int i = 0; i < compilationUnits.length; i++) {
    146                final String sourceFile = pSourceFiles[i];
    147
    148                if (pReader.isAvailable(sourceFile)) {
    149                    compilationUnits[i] = new CompilationUnit(pReader, sourceFile);
    150                    log.debug("compiling " + sourceFile);
    151                } else {
    152                    // log.error("source not found " + sourceFile);
    153
    154                    final CompilationProblem problem = new CompilationProblem() {
    155
    156                        public int getEndColumn() {
    157                            return 0;
    158                        }
    159
    160                        public int getEndLine() {
    161                            return 0;
    162                        }
    163
    164                        public String getFileName() {
    165                            return sourceFile;
    166                        }
    167
    168                        public String getMessage() {
    169                            return "Source " + sourceFile + " could not be found";
    170                        }
    171
    172                        public int getStartColumn() {
    173                            return 0;
    174                        }
    175
    176                        public int getStartLine() {
    177                            return 0;
    178                        }
    179
    180                        public boolean isError() {
    181                            return true;
    182                        }
    183
    184                        @Override
    185                        public String toString() {
    186                            return getMessage();
    187                        }
    188                    };
    189
    190                    if (problemHandler != null) {
    191                        problemHandler.handle(problem);
    192                    }
    193
    194                    problems.add(problem);
    195                }
    196            }
    197
    198            if (problems.size() > 0) {
    199                final CompilationProblem[] result = new CompilationProblem[problems.size()];
    200                problems.toArray(result);
    201                return new org.apache.commons.jci.compilers.CompilationResult(result);
    202            }
    203
    204            final IErrorHandlingPolicy policy = DefaultErrorHandlingPolicies.proceedWithAllProblems();
    205            final IProblemFactory problemFactory = new DefaultProblemFactory(Locale.getDefault());
    206            final INameEnvironment nameEnvironment = new INameEnvironment() {
    207
    208                public NameEnvironmentAnswer findType( final char[][] pCompoundTypeName ) {
    209                    final StringBuilder result = new StringBuilder();
    210                    for (int i = 0; i < pCompoundTypeName.length; i++) {
    211                        if (i != 0) {
    212                            result.append('.');
    213                        }
    214                        result.append(pCompoundTypeName[i]);
    215                    }
    216
    217                    //log.debug("finding compoundTypeName=" + result.toString());
    218
    219                    return findType(result.toString());
    220                }
    221
    222                public NameEnvironmentAnswer findType( final char[] pTypeName, final char[][] pPackageName ) {
    223                    final StringBuilder result = new StringBuilder();
    224                    for (int i = 0; i < pPackageName.length; i++) {
    225                        result.append(pPackageName[i]);
    226                        result.append('.');
    227                    }
    228
    229    //                log.debug("finding typeName=" + new String(typeName) + " packageName=" + result.toString());
    230
    231                    result.append(pTypeName);
    232                    return findType(result.toString());
    233                }
    234
    235                private NameEnvironmentAnswer findType( final String pClazzName ) {
    236
    237                    if (isPackage(pClazzName)) {
    238                        return null;
    239                    }
    240
    241                    log.debug("finding " + pClazzName);
    242
    243                    final String resourceName = ConversionUtils.convertClassToResourcePath(pClazzName);
    244
    245                    final byte[] clazzBytes = pStore.read(resourceName);
    246                    if (clazzBytes != null) {
    247                        log.debug("loading from store " + pClazzName);
    248
    249                        final char[] fileName = pClazzName.toCharArray();
    250                        try {
    251                            final ClassFileReader classFileReader = new ClassFileReader(clazzBytes, fileName, true);
    252                            return new NameEnvironmentAnswer(classFileReader, null);
    253                        } catch (final ClassFormatException e) {
    254                            log.error("wrong class format", e);
    255                            return null;
    256                        }
    257                    }
    258
    259                    log.debug("not in store " + pClazzName);
    260
    261                    final InputStream is = pClassLoader.getResourceAsStream(resourceName);
    262                    if (is == null) {
    263                        log.debug("class " + pClazzName + " not found");
    264                        return null;
    265                    }
    266
    267                    final byte[] buffer = new byte[8192];
    268                    final ByteArrayOutputStream baos = new ByteArrayOutputStream(buffer.length);
    269                    int count;
    270                    try {
    271                        while ((count = is.read(buffer, 0, buffer.length)) > 0) {
    272                            baos.write(buffer, 0, count);
    273                        }
    274                        baos.flush();
    275                        final char[] fileName = pClazzName.toCharArray();
    276                        final ClassFileReader classFileReader = new ClassFileReader(baos.toByteArray(), fileName, true);
    277                        return new NameEnvironmentAnswer(classFileReader, null);
    278                    } catch (final IOException e) {
    279                        log.error("could not read class", e);
    280                        return null;
    281                    } catch (final ClassFormatException e) {
    282                        log.error("wrong class format", e);
    283                        return null;
    284                    } finally {
    285                        try {
    286                            baos.close();
    287                        } catch (final IOException oe) {
    288                            log.error("could not close output stream", oe);
    289                        }
    290                        try {
    291                            is.close();
    292                        } catch (final IOException ie) {
    293                            log.error("could not close input stream", ie);
    294                        }
    295                    }
    296                }
    297
    298                private boolean isPackage( final String pClazzName ) {
    299
    300                    // reject this early as it is cheap
    301                    if (pClazzName.contains("-")) { // "-" is not valid in package names
    302                        return false;
    303                    }
    304
    305                    final InputStream is = pClassLoader.getResourceAsStream(ConversionUtils.convertClassToResourcePath(pClazzName));
    306                    if (is != null) {
    307                        log.debug("found the class for " + pClazzName + "- no package");
    308                        try {
    309                            is.close();
    310                        } catch (final IOException ie) {
    311                            log.error("could not close input stream", ie);
    312                        }
    313                        return false;
    314                    }
    315
    316                    // FIXME: this should not be tied to the extension
    317                    final String source = pClazzName.replace('.', '/') + ".java";
    318                    if (pReader.isAvailable(source)) {
    319                        log.debug("found the source " + source + " for " + pClazzName + " - no package ");
    320                        return false;
    321                    }
    322
    323                    /*
    324                     * See https://issues.apache.org/jira/browse/JCI-59
    325                     * At present, the code assumes that anything else is a package name
    326                     * This is wrong, as for example jci.AdditionalTopLevel is not a package name.
    327                     * It's not clear how to fix this in general.
    328                     * It would seem to need access to the input classpath and/or the generated classes.
    329                     */
    330                    return true;
    331                }
    332
    333                public boolean isPackage( char[][] parentPackageName, char[] pPackageName ) {
    334                    final StringBuilder result = new StringBuilder();
    335                    if (parentPackageName != null) {
    336                        for (int i = 0; i < parentPackageName.length; i++) {
    337                            if (i != 0) {
    338                                result.append('.');
    339                            }
    340                            result.append(parentPackageName[i]);
    341                        }
    342                    }
    343
    344    //                log.debug("isPackage parentPackageName=" + result.toString() + " packageName=" + new String(packageName));
    345
    346                    if (parentPackageName != null && parentPackageName.length > 0) {
    347                        result.append('.');
    348                    }
    349                    result.append(pPackageName);
    350                    return isPackage(result.toString());
    351                }
    352
    353                public void cleanup() {
    354                    log.debug("cleanup");
    355                }
    356            };
    357
    358            final ICompilerRequestor compilerRequestor = new ICompilerRequestor() {
    359                public void acceptResult( final CompilationResult pResult ) {
    360                    if (pResult.hasProblems()) {
    361                        for (IProblem iproblem : pResult.getProblems()) {
    362                            final CompilationProblem problem = new EclipseCompilationProblem(iproblem);
    363                            if (problemHandler != null) {
    364                                problemHandler.handle(problem);
    365                            }
    366                            problems.add(problem);
    367                        }
    368                    }
    369                    if (!pResult.hasErrors()) {
    370                        final ClassFile[] clazzFiles = pResult.getClassFiles();
    371                        for (ClassFile clazzFile : clazzFiles) {
    372                            final char[][] compoundName = clazzFile.getCompoundName();
    373                            final StringBuilder clazzName = new StringBuilder();
    374                            for (int j = 0; j < compoundName.length; j++) {
    375                                if (j != 0) {
    376                                    clazzName.append('.');
    377                                }
    378                                clazzName.append(compoundName[j]);
    379                            }
    380                            pStore.write(clazzName.toString().replace('.', '/') + ".class", clazzFile.getBytes());
    381                        }
    382                    }
    383                }
    384            };
    385
    386            final Compiler compiler = new Compiler(nameEnvironment, policy, new CompilerOptions(settingsMap), compilerRequestor, problemFactory);
    387
    388            compiler.compile(compilationUnits);
    389
    390            final CompilationProblem[] result = new CompilationProblem[problems.size()];
    391            problems.toArray(result);
    392            return new org.apache.commons.jci.compilers.CompilationResult(result);
    393        }
    394
    395        public JavaCompilerSettings createDefaultSettings() {
    396            return new EclipseJavaCompilerSettings(defaultSettings);
    397        }
    398    }