private void compileFinished(int exitValue, final ModuleChunk chunk, final String outputDir) { if (exitValue != 0 && !myCompileContext.getProgressIndicator().isCanceled() && myCompileContext.getMessageCount(CompilerMessageCategory.ERROR) == 0) { myCompileContext.addMessage( CompilerMessageCategory.ERROR, CompilerBundle.message("error.compiler.internal.error", exitValue), null, -1, -1); } myCompiler.compileFinished(); final List<File> toRefresh = new ArrayList<File>(); final Map<String, Collection<TranslatingCompiler.OutputItem>> results = new HashMap<String, Collection<TranslatingCompiler.OutputItem>>(); try { final FileTypeManager typeManager = FileTypeManager.getInstance(); final String outputDirPath = outputDir.replace(File.separatorChar, '/'); try { for (final Module module : chunk.getModules()) { for (final VirtualFile root : chunk.getSourceRoots(module)) { final String packagePrefix = myProjectFileIndex.getPackageNameByDirectory(root); if (LOG.isDebugEnabled()) { LOG.debug( "Building output items for " + root.getPresentableUrl() + "; output dir = " + outputDirPath + "; packagePrefix = \"" + packagePrefix + "\""); } buildOutputItemsList( outputDirPath, module, root, typeManager, root, packagePrefix, toRefresh, results); } } } catch (CacheCorruptedException e) { myCompileContext.requestRebuildNextTime( CompilerBundle.message("error.compiler.caches.corrupted")); if (LOG.isDebugEnabled()) { LOG.debug(e); } } } finally { CompilerUtil.refreshIOFiles(toRefresh); for (Iterator<Map.Entry<String, Collection<TranslatingCompiler.OutputItem>>> it = results.entrySet().iterator(); it.hasNext(); ) { Map.Entry<String, Collection<TranslatingCompiler.OutputItem>> entry = it.next(); mySink.add(entry.getKey(), entry.getValue(), VirtualFile.EMPTY_ARRAY); it.remove(); // to free memory } } myFileNameToSourceMap.clear(); // clear the map before the next use }
private void doCompile(@NotNull final ModuleChunk chunk, @NotNull String outputDir) throws IOException { myCompileContext.getProgressIndicator().checkCanceled(); if (ApplicationManager.getApplication() .runReadAction( new Computable<Boolean>() { public Boolean compute() { return chunk.getFilesToCompile().isEmpty() ? Boolean.TRUE : Boolean.FALSE; } }) .booleanValue()) { return; // should not invoke javac with empty sources list } int exitValue = 0; try { final Process process = myCompiler.launchProcess(chunk, outputDir, myCompileContext); final long compilationStart = System.currentTimeMillis(); final ClassParsingThread classParsingThread = new ClassParsingThread(isJdk6(JavaSdkUtil.getSdkForCompilation(chunk)), outputDir); final Future<?> classParsingThreadFuture = ApplicationManager.getApplication().executeOnPooledThread(classParsingThread); OutputParser errorParser = myCompiler.createErrorParser(outputDir, process); CompilerParsingThread errorParsingThread = errorParser == null ? null : new SynchedCompilerParsing( process, myCompileContext, errorParser, classParsingThread, true, errorParser.isTrimLines()); Future<?> errorParsingThreadFuture = null; if (errorParsingThread != null) { errorParsingThreadFuture = ApplicationManager.getApplication().executeOnPooledThread(errorParsingThread); } OutputParser outputParser = myCompiler.createOutputParser(outputDir); CompilerParsingThread outputParsingThread = outputParser == null ? null : new SynchedCompilerParsing( process, myCompileContext, outputParser, classParsingThread, false, outputParser.isTrimLines()); Future<?> outputParsingThreadFuture = null; if (outputParsingThread != null) { outputParsingThreadFuture = ApplicationManager.getApplication().executeOnPooledThread(outputParsingThread); } try { exitValue = process.waitFor(); } catch (InterruptedException e) { process.destroy(); exitValue = process.exitValue(); } catch (Error e) { process.destroy(); exitValue = process.exitValue(); throw e; } finally { if (CompileDriver.ourDebugMode) { System.out.println("Compiler exit code is " + exitValue); } if (errorParsingThread != null) { errorParsingThread.setProcessTerminated(true); } if (outputParsingThread != null) { outputParsingThread.setProcessTerminated(true); } joinThread(errorParsingThreadFuture); joinThread(outputParsingThreadFuture); classParsingThread.stopParsing(); joinThread(classParsingThreadFuture); registerParsingException(outputParsingThread); registerParsingException(errorParsingThread); assert outputParsingThread == null || !outputParsingThread.processing; assert errorParsingThread == null || !errorParsingThread.processing; assert classParsingThread == null || !classParsingThread.processing; } } finally { compileFinished(exitValue, chunk, outputDir); myModuleName = null; } }