861 lines
34 KiB
Java
861 lines
34 KiB
Java
/*
|
|
* Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* This code is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2 only, as
|
|
* published by the Free Software Foundation. Oracle designates this
|
|
* particular file as subject to the "Classpath" exception as provided
|
|
* by Oracle in the LICENSE file that accompanied this code.
|
|
*
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*/
|
|
|
|
package com.sun.tools.sjavac;
|
|
|
|
import java.io.*;
|
|
import java.util.Collections;
|
|
import java.util.Date;
|
|
import java.util.Set;
|
|
import java.util.HashSet;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.HashMap;
|
|
import java.text.SimpleDateFormat;
|
|
import java.net.URI;
|
|
import java.util.*;
|
|
|
|
/**
|
|
* 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.
|
|
* If you write code that depends on this, you do so at your own
|
|
* risk. This code and its internal interfaces are subject to change
|
|
* or deletion without notice.</b></p>
|
|
*/
|
|
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,
|
|
// then saved as the new javac_state.
|
|
private BuildState now;
|
|
|
|
// Something has changed in the javac_state. It needs to be saved!
|
|
private boolean needsSaving;
|
|
// If this is a new javac_state file, then do not print unnecessary messages.
|
|
private boolean newJavacState;
|
|
|
|
// These are packages where something has changed and the package
|
|
// needs to be recompiled. Actions that trigger recompilation:
|
|
// * source belonging to the package has changed
|
|
// * artifact belonging to the package is lost, or its timestamp has been changed.
|
|
// * an unknown artifact has appeared, we simply delete it, but we also trigger a recompilation.
|
|
// * a package that is tainted, taints all packages that depend on it.
|
|
private Set<String> taintedPackages;
|
|
// After a compile, the pubapis are compared with the pubapis stored in the javac state file.
|
|
// Any packages where the pubapi differ are added to this set.
|
|
// Later we use this set and the dependency information to taint dependent packages.
|
|
private Set<String> packagesWithChangedPublicApis;
|
|
// When a module-info.java file is changed, taint the module,
|
|
// then taint all modules that depend on that that module.
|
|
// A module dependency can occur directly through a require, or
|
|
// indirectly through a module that does a public export for the first tainted module.
|
|
// When all modules are tainted, then taint all packages belonging to these modules.
|
|
// Then rebuild. It is perhaps possible (and valuable?) to do a more finegrained examination of the
|
|
// change in module-info.java, but that will have to wait.
|
|
private Set<String> taintedModules;
|
|
// The set of all packages that has been recompiled.
|
|
// 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;
|
|
|
|
// The current status of the file system.
|
|
private Set<File> binArtifacts;
|
|
private Set<File> gensrcArtifacts;
|
|
private Set<File> headerArtifacts;
|
|
|
|
// The status of the sources.
|
|
Set<Source> removedSources = null;
|
|
Set<Source> addedSources = null;
|
|
Set<Source> modifiedSources = null;
|
|
|
|
// Visible sources for linking. These are the only
|
|
// ones that -sourcepath is allowed to see.
|
|
Set<URI> visibleSrcs;
|
|
|
|
// Visible classes for linking. These are the only
|
|
// ones that -classpath is allowed to see.
|
|
// It maps from a classpath root to the set of visible classes for that root.
|
|
// If the set is empty, then all classes are visible for that root.
|
|
// It can also map from a jar file to the set of visible classes for that jar file.
|
|
Map<URI,Set<String>> visibleClasses;
|
|
|
|
// Setup two transforms that always exist.
|
|
private CopyFile copyFiles = new CopyFile();
|
|
private CompileJavaPackages compileJavaPackages = new CompileJavaPackages();
|
|
|
|
// Where to send stdout and stderr.
|
|
private PrintStream out, err;
|
|
|
|
JavacState(String[] args, File bd, File gd, File hd, boolean permitUnidentifiedArtifacts, boolean removeJavacState,
|
|
PrintStream o, PrintStream e) {
|
|
out = o;
|
|
err = e;
|
|
numCores = Main.findNumberOption(args, "-j");
|
|
theArgs = "";
|
|
for (String a : removeArgsNotAffectingState(args)) {
|
|
theArgs = theArgs+a+" ";
|
|
}
|
|
binDir = bd;
|
|
gensrcDir = gd;
|
|
headerDir = hd;
|
|
javacStateFilename = binDir.getPath()+File.separator+"javac_state";
|
|
javacState = new File(javacStateFilename);
|
|
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 (!permitUnidentifiedArtifacts) {
|
|
deleteContents(binDir);
|
|
deleteContents(gensrcDir);
|
|
deleteContents(headerDir);
|
|
}
|
|
needsSaving = true;
|
|
}
|
|
prev = new BuildState();
|
|
now = new BuildState();
|
|
taintedPackages = new HashSet<String>();
|
|
recompiledPackages = new HashSet<String>();
|
|
packagesWithChangedPublicApis = new HashSet<String>();
|
|
}
|
|
|
|
public BuildState prev() { return prev; }
|
|
public BuildState now() { return now; }
|
|
|
|
/**
|
|
* Remove args not affecting the state.
|
|
*/
|
|
static String[] removeArgsNotAffectingState(String[] args) {
|
|
String[] out = new String[args.length];
|
|
int j = 0;
|
|
for (int i = 0; i<args.length; ++i) {
|
|
if (args[i].equals("-j")) {
|
|
// Just skip it and skip following value
|
|
i++;
|
|
} else if (args[i].startsWith("--server:")) {
|
|
// Just skip it.
|
|
} else if (args[i].startsWith("--log=")) {
|
|
// Just skip it.
|
|
} else if (args[i].equals("--compare-found-sources")) {
|
|
// Just skip it and skip verify file name
|
|
i++;
|
|
} else {
|
|
// Copy argument.
|
|
out[j] = args[i];
|
|
j++;
|
|
}
|
|
}
|
|
String[] ret = new String[j];
|
|
System.arraycopy(out, 0, ret, 0, j);
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* Specify which sources are visible to the compiler through -sourcepath.
|
|
*/
|
|
public void setVisibleSources(Map<String,Source> vs) {
|
|
visibleSrcs = new HashSet<URI>();
|
|
for (String s : vs.keySet()) {
|
|
Source src = vs.get(s);
|
|
visibleSrcs.add(src.file().toURI());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Specify which classes are visible to the compiler through -classpath.
|
|
*/
|
|
public void setVisibleClasses(Map<String,Source> vs) {
|
|
visibleSrcs = new HashSet<URI>();
|
|
for (String s : vs.keySet()) {
|
|
Source src = vs.get(s);
|
|
visibleSrcs.add(src.file().toURI());
|
|
}
|
|
}
|
|
/**
|
|
* Returns true if this is an incremental build.
|
|
*/
|
|
public boolean isIncremental() {
|
|
return !prev.sources().isEmpty();
|
|
}
|
|
|
|
/**
|
|
* Find all artifacts that exists on disk.
|
|
*/
|
|
public void findAllArtifacts() {
|
|
binArtifacts = findAllFiles(binDir);
|
|
gensrcArtifacts = findAllFiles(gensrcDir);
|
|
headerArtifacts = findAllFiles(headerDir);
|
|
}
|
|
|
|
/**
|
|
* Lookup the artifacts generated for this package in the previous build.
|
|
*/
|
|
private Map<String,File> fetchPrevArtifacts(String pkg) {
|
|
Package p = prev.packages().get(pkg);
|
|
if (p != null) {
|
|
return p.artifacts();
|
|
}
|
|
return new HashMap<String,File>();
|
|
}
|
|
|
|
/**
|
|
* Delete all prev artifacts in the currently tainted packages.
|
|
*/
|
|
public void deleteClassArtifactsInTaintedPackages() {
|
|
for (String pkg : taintedPackages) {
|
|
Map<String,File> arts = fetchPrevArtifacts(pkg);
|
|
for (File f : arts.values()) {
|
|
if (f.exists() && f.getName().endsWith(".class")) {
|
|
f.delete();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Mark the javac_state file to be in need of saving and as a side effect,
|
|
* it gets a new timestamp.
|
|
*/
|
|
private void needsSaving() {
|
|
needsSaving = true;
|
|
}
|
|
|
|
/**
|
|
* Save the javac_state file.
|
|
*/
|
|
public void save() throws IOException {
|
|
if (!needsSaving) return;
|
|
try (FileWriter out = new FileWriter(javacStateFilename)) {
|
|
StringBuilder b = new StringBuilder();
|
|
long millisNow = System.currentTimeMillis();
|
|
Date d = new Date(millisNow);
|
|
SimpleDateFormat df =
|
|
new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
|
|
b.append("# javac_state ver 0.3 generated "+millisNow+" "+df.format(d)+"\n");
|
|
b.append("# This format might change at any time. Please do not depend on it.\n");
|
|
b.append("# M module\n");
|
|
b.append("# P package\n");
|
|
b.append("# S C source_tobe_compiled timestamp\n");
|
|
b.append("# S L link_only_source timestamp\n");
|
|
b.append("# G C generated_source timestamp\n");
|
|
b.append("# A artifact timestamp\n");
|
|
b.append("# D dependency\n");
|
|
b.append("# I pubapi\n");
|
|
b.append("# R arguments\n");
|
|
b.append("R ").append(theArgs).append("\n");
|
|
|
|
// Copy over the javac_state for the packages that did not need recompilation.
|
|
now.copyPackagesExcept(prev, recompiledPackages, new HashSet<String>());
|
|
// Save the packages, ie package names, dependencies, pubapis and artifacts!
|
|
// I.e. the lot.
|
|
Module.saveModules(now.modules(), b);
|
|
|
|
String s = b.toString();
|
|
out.write(s, 0, s.length());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Load a javac_state file.
|
|
*/
|
|
public static JavacState load(String[] args, File binDir, File gensrcDir, File headerDir,
|
|
boolean permitUnidentifiedArtifacts, PrintStream out, PrintStream err) {
|
|
JavacState db = new JavacState(args, binDir, gensrcDir, headerDir, permitUnidentifiedArtifacts, false, out, err);
|
|
Module lastModule = null;
|
|
Package lastPackage = null;
|
|
Source lastSource = null;
|
|
boolean noFileFound = false;
|
|
boolean foundCorrectVerNr = false;
|
|
boolean newCommandLine = false;
|
|
boolean syntaxError = false;
|
|
|
|
try (BufferedReader in = new BufferedReader(new FileReader(db.javacStateFilename))) {
|
|
for (;;) {
|
|
String l = in.readLine();
|
|
if (l==null) break;
|
|
if (l.length()>=3 && l.charAt(1) == ' ') {
|
|
char c = l.charAt(0);
|
|
if (c == 'M') {
|
|
lastModule = db.prev.loadModule(l);
|
|
} else
|
|
if (c == 'P') {
|
|
if (lastModule == null) { syntaxError = true; break; }
|
|
lastPackage = db.prev.loadPackage(lastModule, l);
|
|
} else
|
|
if (c == 'D') {
|
|
if (lastModule == null || lastPackage == null) { syntaxError = true; break; }
|
|
lastPackage.loadDependency(l);
|
|
} else
|
|
if (c == 'I') {
|
|
if (lastModule == null || lastPackage == null) { syntaxError = true; break; }
|
|
lastPackage.loadPubapi(l);
|
|
} else
|
|
if (c == 'A') {
|
|
if (lastModule == null || lastPackage == null) { syntaxError = true; break; }
|
|
lastPackage.loadArtifact(l);
|
|
} else
|
|
if (c == 'S') {
|
|
if (lastModule == null || lastPackage == null) { syntaxError = true; break; }
|
|
lastSource = db.prev.loadSource(lastPackage, l, false);
|
|
} else
|
|
if (c == 'G') {
|
|
if (lastModule == null || lastPackage == null) { syntaxError = true; break; }
|
|
lastSource = db.prev.loadSource(lastPackage, l, true);
|
|
} else
|
|
if (c == 'R') {
|
|
String ncmdl = "R "+db.theArgs;
|
|
if (!l.equals(ncmdl)) {
|
|
newCommandLine = true;
|
|
}
|
|
} else
|
|
if (c == '#') {
|
|
if (l.startsWith("# javac_state ver ")) {
|
|
int sp = l.indexOf(" ", 18);
|
|
if (sp != -1) {
|
|
String ver = l.substring(18,sp);
|
|
if (!ver.equals("0.3")) {
|
|
break;
|
|
}
|
|
foundCorrectVerNr = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} catch (FileNotFoundException e) {
|
|
// Silently create a new javac_state file.
|
|
noFileFound = true;
|
|
} catch (IOException e) {
|
|
Log.info("Dropping old javac_state because of errors when reading it.");
|
|
db = new JavacState(args, binDir, gensrcDir, headerDir, permitUnidentifiedArtifacts, true, out, err);
|
|
foundCorrectVerNr = true;
|
|
newCommandLine = false;
|
|
syntaxError = false;
|
|
}
|
|
if (foundCorrectVerNr == false && !noFileFound) {
|
|
Log.info("Dropping old javac_state since it is of an old version.");
|
|
db = new JavacState(args, binDir, gensrcDir, headerDir, permitUnidentifiedArtifacts, true, out, err);
|
|
} else
|
|
if (newCommandLine == true && !noFileFound) {
|
|
Log.info("Dropping old javac_state since a new command line is used!");
|
|
db = new JavacState(args, binDir, gensrcDir, headerDir, permitUnidentifiedArtifacts, true, out, err);
|
|
} else
|
|
if (syntaxError == true) {
|
|
Log.info("Dropping old javac_state since it contains syntax errors.");
|
|
db = new JavacState(args, binDir, gensrcDir, headerDir, permitUnidentifiedArtifacts, true, out, err);
|
|
}
|
|
db.prev.calculateDependents();
|
|
return db;
|
|
}
|
|
|
|
/**
|
|
* Mark a java package as tainted, ie it needs recompilation.
|
|
*/
|
|
public void taintPackage(String name, String because) {
|
|
if (!taintedPackages.contains(name)) {
|
|
if (because != null) Log.debug("Tainting "+Util.justPackageName(name)+" because "+because);
|
|
// It has not been tainted before.
|
|
taintedPackages.add(name);
|
|
needsSaving();
|
|
Package nowp = now.packages().get(name);
|
|
if (nowp != null) {
|
|
for (String d : nowp.dependents()) {
|
|
taintPackage(d, because);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This packages need recompilation.
|
|
*/
|
|
public Set<String> taintedPackages() {
|
|
return taintedPackages;
|
|
}
|
|
|
|
/**
|
|
* Clean out the tainted package set, used after the first round of compiles,
|
|
* prior to propagating dependencies.
|
|
*/
|
|
public void clearTaintedPackages() {
|
|
taintedPackages = new HashSet<String>();
|
|
}
|
|
|
|
/**
|
|
* Go through all sources and check which have been removed, added or modified
|
|
* and taint the corresponding packages.
|
|
*/
|
|
public void checkSourceStatus(boolean check_gensrc) {
|
|
removedSources = calculateRemovedSources();
|
|
for (Source s : removedSources) {
|
|
if (!s.isGenerated() || check_gensrc) {
|
|
taintPackage(s.pkg().name(), "source "+s.name()+" was removed");
|
|
}
|
|
}
|
|
|
|
addedSources = calculateAddedSources();
|
|
for (Source s : addedSources) {
|
|
String msg = null;
|
|
if (isIncremental()) {
|
|
// When building from scratch, there is no point
|
|
// printing "was added" for every file since all files are added.
|
|
// However for an incremental build it makes sense.
|
|
msg = "source "+s.name()+" was added";
|
|
}
|
|
if (!s.isGenerated() || check_gensrc) {
|
|
taintPackage(s.pkg().name(), msg);
|
|
}
|
|
}
|
|
|
|
modifiedSources = calculateModifiedSources();
|
|
for (Source s : modifiedSources) {
|
|
if (!s.isGenerated() || check_gensrc) {
|
|
taintPackage(s.pkg().name(), "source "+s.name()+" was modified");
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Acquire the compile_java_packages suffix rule for .java files.
|
|
*/
|
|
public Map<String,Transformer> getJavaSuffixRule() {
|
|
Map<String,Transformer> sr = new HashMap<String,Transformer>();
|
|
sr.put(".java", compileJavaPackages);
|
|
return sr;
|
|
}
|
|
|
|
/**
|
|
* Acquire the copying transform.
|
|
*/
|
|
public Transformer getCopier() {
|
|
return copyFiles;
|
|
}
|
|
|
|
/**
|
|
* If artifacts have gone missing, force a recompile of the packages
|
|
* they belong to.
|
|
*/
|
|
public void taintPackagesThatMissArtifacts() {
|
|
for (Package pkg : prev.packages().values()) {
|
|
for (File f : pkg.artifacts().values()) {
|
|
if (!f.exists()) {
|
|
// Hmm, the artifact on disk does not exist! Someone has removed it....
|
|
// Lets rebuild the package.
|
|
taintPackage(pkg.name(), ""+f+" is missing.");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Propagate recompilation through the dependency chains.
|
|
* Avoid re-tainting packages that have already been compiled.
|
|
*/
|
|
public void taintPackagesDependingOnChangedPackages(Set<String> pkgs, Set<String> recentlyCompiled) {
|
|
for (Package pkg : prev.packages().values()) {
|
|
for (String dep : pkg.dependencies()) {
|
|
if (pkgs.contains(dep) && !recentlyCompiled.contains(pkg.name())) {
|
|
taintPackage(pkg.name(), " its depending on "+dep);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Scan all output dirs for artifacts and remove those files (artifacts?)
|
|
* that are not recognized as such, in the javac_state file.
|
|
*/
|
|
public void removeUnidentifiedArtifacts() {
|
|
Set<File> allKnownArtifacts = new HashSet<File>();
|
|
for (Package pkg : prev.packages().values()) {
|
|
for (File f : pkg.artifacts().values()) {
|
|
allKnownArtifacts.add(f);
|
|
}
|
|
}
|
|
// Do not forget about javac_state....
|
|
allKnownArtifacts.add(javacState);
|
|
|
|
for (File f : binArtifacts) {
|
|
if (!allKnownArtifacts.contains(f)) {
|
|
Log.debug("Removing "+f.getPath()+" since it is unknown to the javac_state.");
|
|
f.delete();
|
|
}
|
|
}
|
|
for (File f : headerArtifacts) {
|
|
if (!allKnownArtifacts.contains(f)) {
|
|
Log.debug("Removing "+f.getPath()+" since it is unknown to the javac_state.");
|
|
f.delete();
|
|
}
|
|
}
|
|
for (File f : gensrcArtifacts) {
|
|
if (!allKnownArtifacts.contains(f)) {
|
|
Log.debug("Removing "+f.getPath()+" since it is unknown to the javac_state.");
|
|
f.delete();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Remove artifacts that are no longer produced when compiling!
|
|
*/
|
|
public void removeSuperfluousArtifacts(Set<String> recentlyCompiled) {
|
|
// Nothing to do, if nothing was recompiled.
|
|
if (recentlyCompiled.size() == 0) return;
|
|
|
|
for (String pkg : now.packages().keySet()) {
|
|
// If this package has not been recompiled, skip the check.
|
|
if (!recentlyCompiled.contains(pkg)) continue;
|
|
Collection<File> arts = now.artifacts().values();
|
|
for (File f : fetchPrevArtifacts(pkg).values()) {
|
|
if (!arts.contains(f)) {
|
|
Log.debug("Removing "+f.getPath()+" since it is now superfluous!");
|
|
if (f.exists()) f.delete();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Return those files belonging to prev, but not now.
|
|
*/
|
|
private Set<Source> calculateRemovedSources() {
|
|
Set<Source> removed = new HashSet<Source>();
|
|
for (String src : prev.sources().keySet()) {
|
|
if (now.sources().get(src) == null) {
|
|
removed.add(prev.sources().get(src));
|
|
}
|
|
}
|
|
return removed;
|
|
}
|
|
|
|
/**
|
|
* Return those files belonging to now, but not prev.
|
|
*/
|
|
private Set<Source> calculateAddedSources() {
|
|
Set<Source> added = new HashSet<Source>();
|
|
for (String src : now.sources().keySet()) {
|
|
if (prev.sources().get(src) == null) {
|
|
added.add(now.sources().get(src));
|
|
}
|
|
}
|
|
return added;
|
|
}
|
|
|
|
/**
|
|
* Return those files where the timestamp is newer.
|
|
* If a source file timestamp suddenly is older than what is known
|
|
* about it in javac_state, then consider it modified, but print
|
|
* a warning!
|
|
*/
|
|
private Set<Source> calculateModifiedSources() {
|
|
Set<Source> modified = new HashSet<Source>();
|
|
for (String src : now.sources().keySet()) {
|
|
Source n = now.sources().get(src);
|
|
Source t = prev.sources().get(src);
|
|
if (prev.sources().get(src) != null) {
|
|
if (t != null) {
|
|
if (n.lastModified() > t.lastModified()) {
|
|
modified.add(n);
|
|
} else if (n.lastModified() < t.lastModified()) {
|
|
modified.add(n);
|
|
Log.warn("The source file "+n.name()+" timestamp has moved backwards in time.");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return modified;
|
|
}
|
|
|
|
/**
|
|
* Recursively delete a directory and all its contents.
|
|
*/
|
|
private static void deleteContents(File dir) {
|
|
if (dir != null && dir.exists()) {
|
|
for (File f : dir.listFiles()) {
|
|
if (f.isDirectory()) {
|
|
deleteContents(f);
|
|
}
|
|
f.delete();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Run the copy translator only.
|
|
*/
|
|
public void performCopying(File binDir, Map<String,Transformer> suffixRules) {
|
|
Map<String,Transformer> sr = new HashMap<String,Transformer>();
|
|
for (Map.Entry<String,Transformer> e : suffixRules.entrySet()) {
|
|
if (e.getValue() == copyFiles) {
|
|
sr.put(e.getKey(), e.getValue());
|
|
}
|
|
}
|
|
perform(binDir, sr);
|
|
}
|
|
|
|
/**
|
|
* Run all the translators that translate into java source code.
|
|
* I.e. all translators that are not copy nor compile_java_source.
|
|
*/
|
|
public void performTranslation(File gensrcDir, Map<String,Transformer> suffixRules) {
|
|
Map<String,Transformer> sr = new HashMap<String,Transformer>();
|
|
for (Map.Entry<String,Transformer> e : suffixRules.entrySet()) {
|
|
if (e.getValue() != copyFiles &&
|
|
e.getValue() != compileJavaPackages) {
|
|
sr.put(e.getKey(), e.getValue());
|
|
}
|
|
}
|
|
perform(gensrcDir, sr);
|
|
}
|
|
|
|
/**
|
|
* Compile all the java sources. Return true, if it needs to be called again!
|
|
*/
|
|
public boolean performJavaCompilations(File binDir,
|
|
String serverSettings,
|
|
String[] args,
|
|
Set<String> recentlyCompiled,
|
|
boolean[] rcValue) {
|
|
Map<String,Transformer> suffixRules = new HashMap<String,Transformer>();
|
|
suffixRules.put(".java", compileJavaPackages);
|
|
compileJavaPackages.setExtra(serverSettings);
|
|
compileJavaPackages.setExtra(args);
|
|
|
|
rcValue[0] = perform(binDir, suffixRules);
|
|
recentlyCompiled.addAll(taintedPackages());
|
|
clearTaintedPackages();
|
|
boolean again = !packagesWithChangedPublicApis.isEmpty();
|
|
taintPackagesDependingOnChangedPackages(packagesWithChangedPublicApis, recentlyCompiled);
|
|
packagesWithChangedPublicApis = new HashSet<String>();
|
|
return again && rcValue[0];
|
|
}
|
|
|
|
/**
|
|
* Store the source into the set of sources belonging to the given transform.
|
|
*/
|
|
private void addFileToTransform(Map<Transformer,Map<String,Set<URI>>> gs, Transformer t, Source s) {
|
|
Map<String,Set<URI>> fs = gs.get(t);
|
|
if (fs == null) {
|
|
fs = new HashMap<String,Set<URI>>();
|
|
gs.put(t, fs);
|
|
}
|
|
Set<URI> ss = fs.get(s.pkg().name());
|
|
if (ss == null) {
|
|
ss = new HashSet<URI>();
|
|
fs.put(s.pkg().name(), ss);
|
|
}
|
|
ss.add(s.file().toURI());
|
|
}
|
|
|
|
/**
|
|
* 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(File outputDir, 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<Transformer,Map<String,Set<URI>>>();
|
|
for (Source src : now.sources().values()) {
|
|
Transformer t = suffixRules.get(src.suffix());
|
|
if (t != null) {
|
|
if (taintedPackages.contains(src.pkg().name()) && !src.isLinkedOnly()) {
|
|
addFileToTransform(groupedSources, t, src);
|
|
}
|
|
}
|
|
}
|
|
// Go through the transforms and transform them.
|
|
for (Map.Entry<Transformer,Map<String,Set<URI>>> e : groupedSources.entrySet()) {
|
|
Transformer t = e.getKey();
|
|
Map<String,Set<URI>> srcs = e.getValue();
|
|
// These maps need to be synchronized since multiple threads will be writing results into them.
|
|
Map<String,Set<URI>> packageArtifacts = Collections.synchronizedMap(new HashMap<String,Set<URI>>());
|
|
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(srcs,
|
|
visibleSrcs,
|
|
visibleClasses,
|
|
prev.dependents(),
|
|
outputDir.toURI(),
|
|
packageArtifacts,
|
|
packageDependencies,
|
|
packagePublicApis,
|
|
0,
|
|
isIncremental(),
|
|
numCores,
|
|
out,
|
|
err);
|
|
if (!r) rc = false;
|
|
|
|
for (String p : srcs.keySet()) {
|
|
recompiledPackages.add(p);
|
|
}
|
|
// The transform is done! Extract all the artifacts and store the info into the Package objects.
|
|
for (Map.Entry<String,Set<URI>> a : packageArtifacts.entrySet()) {
|
|
Module mnow = now.findModuleFromPackageName(a.getKey());
|
|
mnow.addArtifacts(a.getKey(), a.getValue());
|
|
}
|
|
// Extract all the dependencies and store the info into the Package objects.
|
|
for (Map.Entry<String,Set<String>> a : packageDependencies.entrySet()) {
|
|
Set<String> deps = a.getValue();
|
|
Module mnow = now.findModuleFromPackageName(a.getKey());
|
|
mnow.setDependencies(a.getKey(), deps);
|
|
}
|
|
// Extract all the pubapis and store the info into the Package objects.
|
|
for (Map.Entry<String,String> a : packagePublicApis.entrySet()) {
|
|
Module mprev = prev.findModuleFromPackageName(a.getKey());
|
|
List<String> pubapi = Package.pubapiToList(a.getValue());
|
|
Module mnow = now.findModuleFromPackageName(a.getKey());
|
|
mnow.setPubapi(a.getKey(), pubapi);
|
|
if (mprev.hasPubapiChanged(a.getKey(), pubapi)) {
|
|
// Aha! The pubapi of this package has changed!
|
|
// It can also be a new compile from scratch.
|
|
if (mprev.lookupPackage(a.getKey()).existsInJavacState()) {
|
|
// This is an incremental compile! The pubapi
|
|
// did change. Trigger recompilation of dependents.
|
|
packagesWithChangedPublicApis.add(a.getKey());
|
|
Log.info("The pubapi of "+Util.justPackageName(a.getKey())+" has changed!");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* Utility method to recursively find all files below a directory.
|
|
*/
|
|
private static Set<File> findAllFiles(File dir) {
|
|
Set<File> foundFiles = new HashSet<File>();
|
|
if (dir == null) {
|
|
return foundFiles;
|
|
}
|
|
recurse(dir, foundFiles);
|
|
return foundFiles;
|
|
}
|
|
|
|
private static void recurse(File dir, Set<File> foundFiles) {
|
|
for (File f : dir.listFiles()) {
|
|
if (f.isFile()) {
|
|
foundFiles.add(f);
|
|
} else if (f.isDirectory()) {
|
|
recurse(f, foundFiles);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 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)
|
|
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 == ';';
|
|
|
|
if (makefileSourceList == null) return;
|
|
|
|
Set<String> calculatedSources = new HashSet<String>();
|
|
Set<String> listedSources = new HashSet<String>();
|
|
|
|
// Create a set of filenames with full paths.
|
|
for (Source s : now.sources().values()) {
|
|
// Don't include link only sources when comparing sources to compile
|
|
if (!s.isLinkedOnly()) {
|
|
calculatedSources.add(s.file().getPath());
|
|
}
|
|
}
|
|
// Read in the file and create another set of filenames with full paths.
|
|
try {
|
|
BufferedReader in = new BufferedReader(new FileReader(makefileSourceList));
|
|
for (;;) {
|
|
String l = in.readLine();
|
|
if (l==null) break;
|
|
l = l.trim();
|
|
if (mightNeedRewriting) {
|
|
if (l.indexOf(":") == 1 && l.indexOf("\\") == 2) {
|
|
// Everything a-ok, the format is already C:\foo\bar
|
|
} else if (l.indexOf(":") == 1 && l.indexOf("/") == 2) {
|
|
// The format is C:/foo/bar, rewrite into the above format.
|
|
l = l.replaceAll("/","\\\\");
|
|
} else if (l.charAt(0) == '/' && l.indexOf("/",1) != -1) {
|
|
// The format might be: /cygdrive/c/foo/bar, rewrite into the above format.
|
|
// Do not hardcode the name cygdrive here.
|
|
int slash = l.indexOf("/",1);
|
|
l = l.replaceAll("/","\\\\");
|
|
l = ""+l.charAt(slash+1)+":"+l.substring(slash+2);
|
|
}
|
|
if (Character.isLowerCase(l.charAt(0))) {
|
|
l = Character.toUpperCase(l.charAt(0))+l.substring(1);
|
|
}
|
|
}
|
|
listedSources.add(l);
|
|
}
|
|
} catch (FileNotFoundException e) {
|
|
throw new ProblemException("Could not open "+makefileSourceList.getPath()+" since it does not exist!");
|
|
} catch (IOException e) {
|
|
throw new ProblemException("Could not read "+makefileSourceList.getPath());
|
|
}
|
|
|
|
for (String s : listedSources) {
|
|
if (!calculatedSources.contains(s)) {
|
|
throw new ProblemException("The makefile listed source "+s+" was not calculated by the smart javac wrapper!");
|
|
}
|
|
}
|
|
|
|
for (String s : calculatedSources) {
|
|
if (!listedSources.contains(s)) {
|
|
throw new ProblemException("The smart javac wrapper calculated source "+s+" was not listed by the makefiles!");
|
|
}
|
|
}
|
|
}
|
|
}
|