Java CompilerUtil类代码示例

import com.intellij.compiler.impl.CompilerUtil; //导入依赖的package包/类
private static String[] createParserSetupCommand(final Sdk jdk) {

    final VirtualFile homeDirectory = jdk.getHomeDirectory();
    if (homeDirectory == null) {
      throw new IllegalArgumentException(CompilerBundle.jdkHomeNotFoundMessage(jdk));
    }

    final List<String> commandLine = new ArrayList<String>();
    commandLine.add(((JavaSdkType)jdk.getSdkType()).getVMExecutablePath(jdk));

    CompilerUtil.addLocaleOptions(commandLine, false);

    //noinspection HardCodedStringLiteral
    commandLine.add("-classpath");
    commandLine.add(((JavaSdkType)jdk.getSdkType()).getToolsPath(jdk) + File.pathSeparator + JavaSdkUtil.getIdeaRtJarPath());

    commandLine.add(JavacResourcesReader.class.getName());

    return ArrayUtil.toStringArray(commandLine);
  }
 

import com.intellij.compiler.impl.CompilerUtil; //导入依赖的package包/类
private void createStartupCommand(final ModuleChunk chunk,
                                  @NonNls final ArrayList<String> commandLine,
                                  final String outputPath,
                                  final boolean useTempFile) throws IOException {
  final EclipseCompilerOptions options = EclipseCompilerConfiguration.getOptions(myProject, EclipseCompilerConfiguration.class);

  final Sdk projectJdk = JavaAwareProjectJdkTableImpl.getInstanceEx().getInternalJdk();
  final String vmExePath = ((JavaSdkType)projectJdk.getSdkType()).getVMExecutablePath(projectJdk);
  commandLine.add(vmExePath);
  commandLine.add("-Xmx" + options.MAXIMUM_HEAP_SIZE + "m");

  CompilerUtil.addLocaleOptions(commandLine, false);

  commandLine.add("-classpath");
  commandLine.add(PATH_TO_COMPILER_JAR);
  commandLine.add(getCompilerClass());

  addCommandLineOptions(commandLine, chunk, outputPath, options, useTempFile, true);
}
 

import com.intellij.compiler.impl.CompilerUtil; //导入依赖的package包/类
private static List<VirtualFile> writeStubs(VirtualFile outputRootDirectory, Map<String, CharSequence> output, VirtualFile src) {
  final ArrayList<VirtualFile> stubs = ContainerUtil.newArrayList();
  for (String relativePath : output.keySet()) {
    final File stubFile = new File(outputRootDirectory.getPath(), relativePath);
    FileUtil.createIfDoesntExist(stubFile);
    try {
      FileUtil.writeToFile(stubFile, output.get(relativePath).toString().getBytes(src.getCharset()));
    }
    catch (IOException e) {
      LOG.error(e);
    }
    CompilerUtil.refreshIOFile(stubFile);
    ContainerUtil.addIfNotNull(LocalFileSystem.getInstance().refreshAndFindFileByIoFile(stubFile), stubs);
  }
  return stubs;
}
 

import com.intellij.compiler.impl.CompilerUtil; //导入依赖的package包/类
public static void run(@NotNull AndroidAutogeneratorMode mode,
                       @NotNull AndroidFacet facet,
                       @NotNull CompileContext context,
                       boolean force) {
  if (!toRun(mode, facet, force)) {
    return;
  }
  final Set<String> obsoleteFiles = new HashSet<String>(facet.getAutogeneratedFiles(mode));

  switch (mode) {
    case AAPT:
      runAapt(facet, context, force);
      break;
    case AIDL:
      runAidl(facet, context);
      break;
    case RENDERSCRIPT:
      runRenderscript(facet, context);
      break;
    case BUILDCONFIG:
      runBuildConfigGenerator(facet, context);
      break;
    default:
      LOG.error("Unknown mode" + mode);
  }
  obsoleteFiles.removeAll(facet.getAutogeneratedFiles(mode));

  for (String path : obsoleteFiles) {
    final File file = new File(path);

    if (file.isFile()) {
      FileUtil.delete(file);
      CompilerUtil.refreshIOFile(file);
    }
  }
}
 

import com.intellij.compiler.impl.CompilerUtil; //导入依赖的package包/类
public GenerationItem[] generate(CompileContext context, GenerationItem[] items, VirtualFile outputRootDirectory) {
    if (JFlex.isCompilationEnabled()) {
        if (items != null && items.length > 0) {
            Application application = ApplicationManager.getApplication();
            GenerationItem[] generationItems = application.runReadAction(new GenerateAction(context, items, outputRootDirectory, ProjectRootManager.getInstance(context.getProject()).getProjectSdk()));
            for (GenerationItem item : generationItems) {
                CompilerUtil.refreshIOFile(((JFlexGenerationItem) item).getGeneratedFile());
            }
            return generationItems;
        }
    }
    return EMPTY_GENERATION_ITEM_ARRAY;
}
 

import com.intellij.compiler.impl.CompilerUtil; //导入依赖的package包/类
public static void addCommandLineOptions(@NotNull ModuleChunk chunk,
                                         @NonNls List<String> commandLine,
                                         @NotNull String outputPath,
                                         @NotNull Sdk jdk,
                                         boolean isAnnotationProcessingMode) throws IOException {

  LanguageLevel languageLevel = chunk.getLanguageLevel();
  CompilerUtil.addSourceCommandLineSwitch(jdk, languageLevel, commandLine);

  commandLine.add("-verbose");

  final String bootCp = chunk.getCompilationBootClasspath();

  final String classPath = chunk.getCompilationClasspath();
  commandLine.add("-bootclasspath");
  addClassPathValue(commandLine, bootCp);

  commandLine.add("-classpath");
  addClassPathValue(commandLine, classPath);

  if (isAnnotationProcessingMode) {
    commandLine.add("-s");
    commandLine.add(outputPath.replace('/', File.separatorChar));
    final String moduleOutputPath = CompilerPaths.getModuleOutputPath(chunk.getModules()[0], false);
    if (moduleOutputPath != null) {
      commandLine.add("-d");
      commandLine.add(moduleOutputPath.replace('/', File.separatorChar));
    }
  }
  else {
    commandLine.add("-d");
    commandLine.add(outputPath.replace('/', File.separatorChar));
  }
}
 

import com.intellij.compiler.impl.CompilerUtil; //导入依赖的package包/类
@Override
public void processItems(@NotNull final ArtifactBuildTarget target,
                         @NotNull final List<GenericCompilerProcessingItem<ArtifactCompilerCompileItem,VirtualFilePersistentState,ArtifactPackagingItemOutputState>> changedItems,
                         @NotNull List<GenericCompilerCacheState<String, VirtualFilePersistentState, ArtifactPackagingItemOutputState>> obsoleteItems,
                         @NotNull OutputConsumer<ArtifactCompilerCompileItem> consumer) {

  final THashSet<String> deletedJars = deleteFiles(obsoleteItems, changedItems);

  final Set<String> writtenPaths = createPathsHashSet();
  final Ref<Boolean> built = Ref.create(false);
  final Set<ArtifactCompilerCompileItem> processedItems = new HashSet<ArtifactCompilerCompileItem>();
  CompilerUtil.runInContext(myContext, "Copying files", new ThrowableRunnable<RuntimeException>() {
    public void run() throws RuntimeException {
      built.set(doBuild(target.getArtifact(), changedItems, processedItems, writtenPaths, deletedJars));
    }
  });
  if (!built.get()) {
    return;
  }

  myContext.getProgressIndicator().setText(CompilerBundle.message("packaging.compiler.message.updating.caches"));
  myContext.getProgressIndicator().setText2("");
  for (String path : writtenPaths) {
    consumer.addFileToRefresh(new File(path));
  }
  for (ArtifactCompilerCompileItem item : processedItems) {
    consumer.addProcessedItem(item);
  }
  ArtifactsCompiler.addWrittenPaths(myContext, writtenPaths);
  ArtifactsCompiler.addChangedArtifact(myContext, target.getArtifact());
}
 

import com.intellij.compiler.impl.CompilerUtil; //导入依赖的package包/类
public void deleteGeneratedFiles() {
  if (FileUtil.delete(myStub)) {
    CompilerUtil.refreshIOFile(myStub);
  }
  if (FileUtil.delete(mySkel)) {
    CompilerUtil.refreshIOFile(mySkel);
  }
  if (FileUtil.delete(myTie)) {
    CompilerUtil.refreshIOFile(myTie);
  }
}
 

import com.intellij.compiler.impl.CompilerUtil; //导入依赖的package包/类
@SuppressWarnings({"HardCodedStringLiteral"})
private static void setupSourceVersion(final ModuleChunk chunk, final ArrayList<String> commandLine) {
  final Sdk jdk = chunk.getJdk();
  final String versionString = jdk.getVersionString();

  final LanguageLevel applicableLanguageLevel = CompilerUtil.getApplicableLanguageLevel(versionString, chunk.getLanguageLevel());
  if (applicableLanguageLevel.equals(LanguageLevel.JDK_1_5)) {
    commandLine.add("-source");
    commandLine.add("1.4"); // -source 1.5 not supported yet by jikes, so use the highest possible version
  }
  else if (applicableLanguageLevel.equals(LanguageLevel.JDK_1_4)) {
    commandLine.add("-source");
    commandLine.add("1.4");
  }
}
 

import com.intellij.compiler.impl.CompilerUtil; //导入依赖的package包/类
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
}
 

import com.intellij.compiler.impl.CompilerUtil; //导入依赖的package包/类
public void compile(final CompileContext context, Chunk<Module> moduleChunk, final VirtualFile[] files, OutputSink sink) {
  final List<File> filesToRefresh = new ArrayList<File>();
  final Map<String, Collection<OutputItem>> outputs = new HashMap<String, Collection<OutputItem>>();
  ApplicationManager.getApplication().runReadAction(new Runnable() {
    public void run() {
      for (final VirtualFile file : files) {
        final Module module = context.getModuleByFile(file);
        try {
          final VirtualFile outputDir = context.getModuleOutputDirectory(module);
          if (outputDir != null) {
            final String outputDirPath = outputDir.getPath();
            final File compiledFile = doCompile(outputDir, file);
            filesToRefresh.add(compiledFile);
            Collection<OutputItem> collection = outputs.get(outputDirPath);
            if (collection == null) {
              collection = new ArrayList<OutputItem>();
              outputs.put(outputDirPath, collection);
            }
            collection.add(new OutputItemImpl(FileUtil.toSystemIndependentName(compiledFile.getPath()), file));
          }
        }
        catch (IOException e) {
          context.addMessage(CompilerMessageCategory.ERROR, e.getMessage(), null, 0, 0);
        }
      }
    }
  });
  CompilerUtil.refreshIOFiles(filesToRefresh);
  for (Map.Entry<String, Collection<OutputItem>> entry : outputs.entrySet()) {
    sink.add(entry.getKey(), entry.getValue(), VirtualFile.EMPTY_ARRAY);
  }
}
 

import com.intellij.compiler.impl.CompilerUtil; //导入依赖的package包/类
protected static void addStubsToCompileScope(List<String> outputPaths, CompileContext compileContext, Module module) {
  List<VirtualFile> stubFiles = new ArrayList<VirtualFile>();
  for (String outputPath : outputPaths) {
    final File stub = new File(outputPath);
    CompilerUtil.refreshIOFile(stub);
    final VirtualFile file = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(stub);
    ContainerUtil.addIfNotNull(file, stubFiles);
  }
  ((CompileContextEx)compileContext).addScope(new FileSetCompileScope(stubFiles, new Module[]{module}));
}
 

import com.intellij.compiler.impl.CompilerUtil; //导入依赖的package包/类
public void compile(final CompileContext compileContext, Chunk<Module> moduleChunk, final VirtualFile[] virtualFiles, OutputSink sink) {
  Map<Module, List<VirtualFile>> mapModulesToVirtualFiles;
  if (moduleChunk.getNodes().size() == 1) {
    mapModulesToVirtualFiles = Collections.singletonMap(moduleChunk.getNodes().iterator().next(), Arrays.asList(virtualFiles));
  }
  else {
    mapModulesToVirtualFiles = CompilerUtil.buildModuleToFilesMap(compileContext, virtualFiles);
  }
  for (final Module module : moduleChunk.getNodes()) {
    final List<VirtualFile> moduleFiles = mapModulesToVirtualFiles.get(module);
    if (moduleFiles == null) {
      continue;
    }

    final ModuleFileIndex index = ModuleRootManager.getInstance(module).getFileIndex();
    final List<VirtualFile> toCompile = new ArrayList<VirtualFile>();
    final List<VirtualFile> toCompileTests = new ArrayList<VirtualFile>();
    final CompilerConfiguration configuration = CompilerConfiguration.getInstance(myProject);
    final PsiManager psiManager = PsiManager.getInstance(myProject);

    if (GroovyUtils.isAcceptableModuleType(ModuleType.get(module))) {
      for (final VirtualFile file : moduleFiles) {
        if (shouldCompile(file, configuration, psiManager)) {
          (index.isInTestSourceContent(file) ? toCompileTests : toCompile).add(file);
        }
      }
    }

    if (!toCompile.isEmpty()) {
      compileFiles(compileContext, module, toCompile, sink, false);
    }
    if (!toCompileTests.isEmpty()) {
      compileFiles(compileContext, module, toCompileTests, sink, true);
    }

  }

}
 

import com.intellij.compiler.impl.CompilerUtil; //导入依赖的package包/类
@Override
public void processItems(@Nonnull final ArtifactBuildTarget target,
                         @Nonnull final List<GenericCompilerProcessingItem<ArtifactCompilerCompileItem,VirtualFilePersistentState,ArtifactPackagingItemOutputState>> changedItems,
                         @Nonnull List<GenericCompilerCacheState<String, VirtualFilePersistentState, ArtifactPackagingItemOutputState>> obsoleteItems,
                         @Nonnull OutputConsumer<ArtifactCompilerCompileItem> consumer) {

  final THashSet<String> deletedJars = deleteFiles(obsoleteItems, changedItems);

  final Set<String> writtenPaths = createPathsHashSet();
  final Ref<Boolean> built = Ref.create(false);
  final Set<ArtifactCompilerCompileItem> processedItems = new HashSet<ArtifactCompilerCompileItem>();
  CompilerUtil.runInContext(myContext, "Copying files", new ThrowableRunnable<RuntimeException>() {
    @Override
    public void run() throws RuntimeException {
      built.set(doBuild(target.getArtifact(), changedItems, processedItems, writtenPaths, deletedJars));
    }
  });
  if (!built.get()) {
    return;
  }

  myContext.getProgressIndicator().setText(CompilerBundle.message("packaging.compiler.message.updating.caches"));
  myContext.getProgressIndicator().setText2("");
  for (String path : writtenPaths) {
    consumer.addFileToRefresh(new File(path));
  }
  for (ArtifactCompilerCompileItem item : processedItems) {
    consumer.addProcessedItem(item);
  }
  ArtifactsCompiler.addWrittenPaths(myContext, writtenPaths);
  ArtifactsCompiler.addChangedArtifact(myContext, target.getArtifact());
}
 

import com.intellij.compiler.impl.CompilerUtil; //导入依赖的package包/类
private Map<Module, List<VirtualFile>> buildModuleToFilesMap(final List<VirtualFile> filesToCompile)
{
	if(myChunk.getNodes().size() == 1)
	{
		return Collections.singletonMap(myChunk.getNodes().iterator().next(), Collections.unmodifiableList(filesToCompile));
	}
	return CompilerUtil.buildModuleToFilesMap(myCompileContext, filesToCompile);
}