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;
}
}
