jdk-sandbox: comparison langtools/src/jdk.compiler/share/classes/com/sun/tools/sjavac/JavacState.java

equal deleted inserted replaced

-:d06a6d3c66c0
+:a4a156a33c94
 */
 package com.sun.tools.sjavac;
 import java.io.*;
-import java.nio.file.Path;
 import java.util.Collections;
 import java.util.Date;
 import java.util.Set;
 import java.util.HashSet;
 import java.util.List;
 import java.text.SimpleDateFormat;
 import java.net.URI;
 import java.util.*;
 import com.sun.tools.sjavac.options.Options;
-import com.sun.tools.sjavac.options.SourceLocation;
+import com.sun.tools.sjavac.server.Sjavac;
-import com.sun.tools.sjavac.server.JavacService;
 /**
 * The javac state class maintains the previous (prev) and the current (now)
 * build states and everything else that goes into the javac_state file.
 *
-* <p><b>This is NOT part of any supported API.
+*  <p><b>This is NOT part of any supported API.
-* If you write code that depends on this, you do so at your own
+*  If you write code that depends on this, you do so at your own risk.
-* risk.  This code and its internal interfaces are subject to change
+*  This code and its internal interfaces are subject to change or
-* or deletion without notice.</b></p>
+*  deletion without notice.</b>
 */
-public class JavacState
+public class JavacState {
-{
 // The arguments to the compile. If not identical, then it cannot
 // be an incremental build!
 String theArgs;
 // The number of cores limits how many threads are used for heavy concurrent work.
 int numCores;
 // The bin_dir/javac_state
-private String javacStateFilename;
 private File javacState;
 // The previous build state is loaded from javac_state
 private BuildState prev;
 // The current build state is constructed during the build,
 // Copy over the javac_state for the packages that did not need recompilation,
 // verbatim from the previous (prev) to the new (now) build state.
 private Set<String> recompiledPackages;
 // The output directories filled with tasty artifacts.
-private File binDir, gensrcDir, headerDir;
+private File binDir, gensrcDir, headerDir, stateDir;
 // The current status of the file system.
 private Set<File> binArtifacts;
 private Set<File> gensrcArtifacts;
 private Set<File> headerArtifacts;
 private CompileJavaPackages compileJavaPackages = new CompileJavaPackages();
 // Where to send stdout and stderr.
 private PrintStream out, err;
-JavacState(Options options, boolean removeJavacState, PrintStream o, PrintStream e) {
+// Command line options.
+private Options options;
+JavacState(Options op, boolean removeJavacState, PrintStream o, PrintStream e) {
+options = op;
 out = o;
 err = e;
 numCores = options.getNumCores();
 theArgs = options.getStateArgsString();
 binDir = Util.pathToFile(options.getDestDir());
 gensrcDir = Util.pathToFile(options.getGenSrcDir());
 headerDir = Util.pathToFile(options.getHeaderDir());
-javacStateFilename = binDir.getPath()+File.separator+"javac_state";
+stateDir = Util.pathToFile(options.getStateDir());
-javacState = new File(javacStateFilename);
+javacState = new File(stateDir, "javac_state");
 if (removeJavacState && javacState.exists()) {
 javacState.delete();
 }
 newJavacState = false;
 if (!javacState.exists()) {
 newJavacState = true;
 // If there is no javac_state then delete the contents of all the artifact dirs!
 // We do not want to risk building a broken incremental build.
 // BUT since the makefiles still copy things straight into the bin_dir et al,
 // we avoid deleting files here, if the option --permit-unidentified-classes was supplied.
-if (!options.isUnidentifiedArtifactPermitted()) {
+if (!options.areUnidentifiedArtifactsPermitted()) {
 deleteContents(binDir);
 deleteContents(gensrcDir);
 deleteContents(headerDir);
 }
 needsSaving = true;
 /**
 * Save the javac_state file.
 */
 public void save() throws IOException {
 if (!needsSaving) return;
-try (FileWriter out = new FileWriter(javacStateFilename)) {
+try (FileWriter out = new FileWriter(javacState)) {
 StringBuilder b = new StringBuilder();
 long millisNow = System.currentTimeMillis();
 Date d = new Date(millisNow);
 SimpleDateFormat df =
 new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
 boolean noFileFound = false;
 boolean foundCorrectVerNr = false;
 boolean newCommandLine = false;
 boolean syntaxError = false;
-try (BufferedReader in = new BufferedReader(new FileReader(db.javacStateFilename))) {
+try (BufferedReader in = new BufferedReader(new FileReader(db.javacState))) {
 for (;;) {
 String l = in.readLine();
 if (l==null) break;
 if (l.length()>=3 && l.charAt(1) == ' ') {
 char c = l.charAt(0);
 }
 // Do not forget about javac_state....
 allKnownArtifacts.add(javacState);
 for (File f : binArtifacts) {
-if (!allKnownArtifacts.contains(f)) {
+if (!allKnownArtifacts.contains(f) &&
+!options.isUnidentifiedArtifactPermitted(f.getAbsolutePath())) {
 Log.debug("Removing "+f.getPath()+" since it is unknown to the javac_state.");
 f.delete();
 }
 }
 for (File f : headerArtifacts) {
 }
 /**
 * Recursively delete a directory and all its contents.
 */
-private static void deleteContents(File dir) {
+private void deleteContents(File dir) {
 if (dir != null && dir.exists()) {
 for (File f : dir.listFiles()) {
 if (f.isDirectory()) {
 deleteContents(f);
 }
-f.delete();
+if (!options.isUnidentifiedArtifactPermitted(f.getAbsolutePath())) {
+Log.debug("Removing "+f.getAbsolutePath());
+f.delete();
+}
 }
 }
 }
 /**
 }
 /**
 * Compile all the java sources. Return true, if it needs to be called again!
 */
-public boolean performJavaCompilations(JavacService javacService,
+public boolean performJavaCompilations(Sjavac sjavac,
 Options args,
 Set<String> recentlyCompiled,
 boolean[] rcValue) {
 Map<String,Transformer> suffixRules = new HashMap<>();
 suffixRules.put(".java", compileJavaPackages);
 compileJavaPackages.setExtra(args);
-rcValue[0] = perform(javacService, binDir, suffixRules);
+rcValue[0] = perform(sjavac, binDir, suffixRules);
 recentlyCompiled.addAll(taintedPackages());
 clearTaintedPackages();
 boolean again = !packagesWithChangedPublicApis.isEmpty();
 taintPackagesDependingOnChangedPackages(packagesWithChangedPublicApis, recentlyCompiled);
 packagesWithChangedPublicApis = new HashSet<>();
 /**
 * For all packages, find all sources belonging to the package, group the sources
 * based on their transformers and apply the transformers on each source code group.
 */
-private boolean perform(JavacService javacService,
+private boolean perform(Sjavac sjavac,
 File outputDir,
-Map<String,Transformer> suffixRules)
+Map<String,Transformer> suffixRules) {
-{
 boolean rc = true;
 // Group sources based on transforms. A source file can only belong to a single transform.
 Map<Transformer,Map<String,Set<URI>>> groupedSources = new HashMap<>();
 for (Source src : now.sources().values()) {
 Transformer t = suffixRules.get(src.suffix());
 Map<String,Set<String>> packageDependencies =
 Collections.synchronizedMap(new HashMap<String,Set<String>>());
 Map<String,String> packagePublicApis =
 Collections.synchronizedMap(new HashMap<String, String>());
-boolean  r = t.transform(javacService,
+boolean  r = t.transform(sjavac,
 srcs,
 visibleSrcs,
 visibleClasses,
 prev.dependents(),
 outputDir.toURI(),
 /**
 * Compare the calculate source list, with an explicit list, usually supplied from the makefile.
 * Used to detect bugs where the makefile and sjavac have different opinions on which files
 * should be compiled.
 */
-public void compareWithMakefileList(File makefileSourceList)
+public void compareWithMakefileList(File makefileSourceList) throws ProblemException {
-throws ProblemException
-{
 // If we are building on win32 using for example cygwin the paths in the makefile source list
 // might be /cygdrive/c/.... which does not match c:\....
 // We need to adjust our calculated sources to be identical, if necessary.
 boolean mightNeedRewriting = File.pathSeparatorChar == ';';

changeset 26107	a4a156a33c94
parent 26098	32588700060b
parent 25874	83c19f00452c
child 27225	8369cde9152a