Fix javac --incremental by using jmake for dependency analysis

third_party/jmake/src/org/pantsbuild/jmake/PCDManager.java

+/* Copyright (c) 2002-2008 Sun Microsystems, Inc. All rights reserved
+ *
+ * This program is distributed under the terms of
+ * the GNU General Public License Version 2. See the LICENSE file
+ * at the top of the source tree.
+ */
+package org.pantsbuild.jmake;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+import java.util.StringTokenizer;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
+import java.util.zip.Adler32;
+
+/**
+ * This class implements management of the Project Class Directory, automatic tracking
+ * of changes and recompilation of .java sources for a project.
+ *
+ * @author Misha Dmitriev
+ *  23 January 2003
+ */
+public class PCDManager {
+
+    private PCDContainer pcdc;
+    private Map<String,PCDEntry> pcd;   // Maps project class names to PCDEntries
+    private String projectJavaAndJarFilesArray[];
+    private String addedJavaAndJarFilesArray[],  removedJavaAndJarFilesArray[],  updatedJavaAndJarFilesArray[];
+    private List<String> newJavaFiles;
+    private Set<String> updatedJavaFiles;
+    private Set<String> recompiledJavaFiles;
+    private Set<String> updatedClasses;       // This set is emptied on every new internal jmake iteration...
+    private Set<String> allUpdatedClasses;    // whereas in this one the names of all updated classes found during this jmake invocation are stored.
+    private Set<String> updatedAndCheckedClasses;
+    private Set<String> deletedClasses;
+    private Set<String> updatedJarFiles;
+    private Set<String> stableJarFiles;
+    private Set<String> newJarFiles;
+    private Set<String> deletedJarFiles;
+    /* Dependencies from the dependencyFile, if any */
+    private Map<String, List<String>> extraDependencies;
+
+    private String destDir;
+    private boolean destDirSpecified;
+    private List<String> javacAddArgs;
+    private Class<?> compilerClass;
+    private Method compileMethod;
+    private String jcExecApp;
+    private Object externalApp;
+    private Method externalCompileSourceFilesMethod;
+    private Adler32 checkSum;
+    private CompatibilityChecker cv;
+    private ClassFileReader cfr;
+    private boolean newProject = false;
+    private String dependencyFile = null;
+    private static boolean backSlashFileSeparator = File.separatorChar != '/';
+
+    /**** Interface to the class ****/
+    /**
+     * Either projectJavaAndJarFilesArray != null and added.. == removed.. == updatedJavaAndJarFilesArray == null,
+     * or projectJavaAndJarFilesArray == null and one or more of others != null.
+     * When PCDManager is called from Main, this is guaranteed, since separate entrypoint functions initialize
+     * either one or another of the above argument groups, but never both.
+     */
+    public PCDManager(PCDContainer pcdc,
+                      String projectJavaAndJarFilesArray[],
+                      String addedJavaAndJarFilesArray[],
+                      String removedJavaAndJarFilesArray[],
+                      String updatedJavaAndJarFilesArray[],
+                      String in_destDir,
+                      List<String> javacAddArgs,
+                      boolean failOnDependentJar,
+                      boolean noWarnOnDependentJar,
+                      String dependencyFile) {
+        this.pcdc = pcdc;
+        if (pcdc.pcd == null) {
+            pcd = new LinkedHashMap<String,PCDEntry>();
+            pcdc.pcd = pcd;
+            newProject = true;
+        } else {
+            pcd = pcdc.pcd;
+        }
+
+        this.projectJavaAndJarFilesArray = projectJavaAndJarFilesArray;
+        this.addedJavaAndJarFilesArray = addedJavaAndJarFilesArray;
+        this.removedJavaAndJarFilesArray = removedJavaAndJarFilesArray;
+        this.updatedJavaAndJarFilesArray = updatedJavaAndJarFilesArray;
+        this.dependencyFile = dependencyFile;
+        newJavaFiles = new ArrayList<String>();
+        updatedJavaFiles = new LinkedHashSet<String>();
+        recompiledJavaFiles = new LinkedHashSet<String>();
+        updatedAndCheckedClasses = new LinkedHashSet<String>();
+        deletedClasses = new LinkedHashSet<String>();
+        allUpdatedClasses = new LinkedHashSet<String>();
+
+        updatedJarFiles = new LinkedHashSet<String>();
+        stableJarFiles = new LinkedHashSet<String>();
+        newJarFiles = new LinkedHashSet<String>();
+        deletedJarFiles = new LinkedHashSet<String>();
+
+        initializeDestDir(in_destDir);
+        this.javacAddArgs = javacAddArgs;
+
+        checkSum = new Adler32();
+
+        cv = new CompatibilityChecker(this, failOnDependentJar, noWarnOnDependentJar);
+        cfr = new ClassFileReader();
+    }
+
+    public Collection<PCDEntry> entries() {
+        return pcd.values();
+    }
+
+    public ClassFileReader getClassFileReader() {
+        return cfr;
+    }
+
+    public ClassInfo getClassInfoForName(int verCode, String className) {
+        PCDEntry pcde = pcd.get(className);
+        if (pcde != null) {
+            return getClassInfoForPCDEntry(verCode, pcde);
+        } else {
+            return null;
+        }
+    }
+
+    public boolean isProjectClass(int verCode, String className) {
+        if (verCode == ClassInfo.VER_OLD) {
+            return pcd.containsKey(className);
+        } else {
+            PCDEntry pcde = pcd.get(className);
+            return (pcde != null && pcde.checkResult != PCDEntry.CV_DELETED);
+        }
+    }
+
+    /**
+     * Get an instance of ClassInfo (load a class file if necessary) for the given version (old or new) of
+     * the class determined by pcde. For an old class version, always returns a non-null result; but for a new
+     * version, null is returned if class file is not found. In most of the current uses of this method null result
+     * is not checked, because it's either called for an old version or it is already known that the .class file
+     * should be present; nevertheless, beware!
+     */
+    public ClassInfo getClassInfoForPCDEntry(int verCode, PCDEntry pcde) {
+        if (verCode == ClassInfo.VER_OLD) {
+            return pcde.oldClassInfo;
+        }
+
+        ClassInfo res = pcde.newClassInfo;
+        if (res == null) {
+            byte classFileBytes[];
+            String classFileFullPath = null;
+            if (pcde.javaFileFullPath.endsWith(".java")) {
+                File classFile = Utils.checkFileForName(pcde.classFileFullPath);
+                if (classFile == null) {
+                    return null;  // Class file not found.
+                }
+                classFileBytes = Utils.readFileIntoBuffer(classFile);
+                classFileFullPath = pcde.classFileFullPath;
+            } else {
+                try {
+                    JarFile jarFile = new JarFile(pcde.javaFileFullPath);
+                    JarEntry jarEntry =
+                            jarFile.getJarEntry(pcde.className + ".class");
+                    if (jarEntry == null) {
+                        return null;
+                    }
+                    classFileBytes =
+                            Utils.readZipEntryIntoBuffer(jarFile, jarEntry);
+                } catch (IOException ex) {
+                    throw new PrivateException(ex);
+                }
+            }
+            res =
+                    new ClassInfo(classFileBytes, verCode, this, classFileFullPath);
+            pcde.newClassInfo = res;
+        }
+        return res;
+    }
+
+    /**
+     * Returns null if class is compileable (has a .java source) and not recompiled yet, "" if
+     * class has already been recompiled or has been deleted from project, and the class's .jar
+     * name if class comes from a jar, hence is uncompileable.
+     */
+    public String classAlreadyRecompiledOrUncompileable(String className) {
+        PCDEntry pcde = pcd.get(className);
+        if (pcde == null) {
+            //!!!
+            for (String keyName : pcd.keySet()) {
+                PCDEntry entry = pcd.get(keyName);
+                if (entry.className.equals(className)) {
+                    System.out.println("ERROR: inconsistent entry: key = " +
+                            keyName + ", name in entry = " + entry.className);
+                }
+            }
+            //!!!
+            throw internalException(className + " not in project when it should be");
+        }
+        if (pcde.checkResult == PCDEntry.CV_DELETED) {
+            return "";
+        }
+        if (pcde.javaFileFullPath.endsWith(".jar")) {
+            return pcde.javaFileFullPath;
+        } else {
+            return (recompiledJavaFiles.contains(pcde.javaFileFullPath) ? "" : null);
+        }
+    }
+
+    /**
+     * Compiler initialization depends on compiler type specified.
+     * If jcExecApp != null, i.e. an external executable compiler application is used, and nothing has to be done.
+     * If externalApp != null, that is, jmake is called by an external application such as Ant, which
+     * manages compilation in its own way, and also nothing has to be done.
+     * Otherwise, load the compiler class and method (either specified through jcPath, jcMainClass and jcMethod,
+     * or the default one.
+     */
+    public void initializeCompiler(String jcExecApp,
+            String jcPath, String jcMainClass, String jcMethod,
+            Object externalApp, Method externalCompileSourceFilesMethod) {
+        ClassPath.initializeAllClassPaths();
+
+        if (externalApp != null) {
+            this.externalApp = externalApp;
+            this.externalCompileSourceFilesMethod =
+                    externalCompileSourceFilesMethod;
+            return;
+        }
+        if (jcExecApp != null) {
+            this.jcExecApp = jcExecApp;
+            return;
+        }
+
+        if (jcPath == null) {
+            String javaHome = System.getProperty("java.home");
+            // In my tests it ends with '/jre'. Or it could be ending with '/bin' as well? Let's assume it can be both and delete
+            // this latter directory.
+            if (javaHome.endsWith(File.separator + "jre") || javaHome.endsWith(File.separator + "bin")) {
+                javaHome = javaHome.substring(0, javaHome.length() - 4);
+            }
+            jcPath = javaHome + "/lib/tools.jar";
+        }
+        ClassLoader compilerLoader;
+        try {
+            compilerLoader = ClassPath.getClassLoaderForPath(jcPath);
+        } catch (Exception ex) {
+            throw compilerInteractionException("error opening compiler path", ex, 0);
+        }
+
+        if (jcMainClass == null) {
+            jcMainClass = "com.sun.tools.javac.Main";
+        }
+        if (jcMethod == null) {
+            jcMethod = "compile";
+        }
+
+        try {
+            compilerClass = compilerLoader.loadClass(jcMainClass);
+        } catch (ClassNotFoundException e) {
+            throw compilerInteractionException("error loading compiler main class " + jcMainClass, e, 0);
+        }
+
+        Class<?>[] args = new Class<?>[]{String[].class};
+        try {
+            compileMethod = compilerClass.getMethod(jcMethod, args);
+        } catch (Exception e) {
+            throw compilerInteractionException("error getting method com.sun.tools.javac.Main.compile(String args[])", e, 0);
+        }
+    }
+
+    /** Main entrypoint for this class */
+    public void run() {
+        Utils.startTiming(Utils.TIMING_SYNCHRO);
+        synchronizeProjectFilesAndPCD();
+        Utils.stopAndPrintTiming("Synchro", Utils.TIMING_SYNCHRO);
+        Utils.printTiming("of which synchro check file", Utils.TIMING_SYNCHRO_CHECK_JAVA_FILES);
+
+        Utils.startTiming(Utils.TIMING_FIND_UPDATED_JAVA_FILES);
+        findUpdatedJavaAndJarFiles();
+        Utils.stopAndPrintTiming("findUpdatedJavaAndJarFiles", Utils.TIMING_FIND_UPDATED_JAVA_FILES);
+        Utils.printTiming("of which classFileObsoleteOrDeleted", Utils.TIMING_CLASS_FILE_OBSOLETE_OR_DELETED);
+
+        // Let's free some memory
+        projectJavaAndJarFilesArray = null;
+
+        updatedClasses = new LinkedHashSet<String>();
+        dealWithClassesInUpdatedJarFiles();
+
+        int iterNo = 0;
+        int res = 0;
+        while (iterNo == 0 || updatedJavaFiles.size() != 0 || newJavaFiles.size() != 0) {
+            // It may happen that we didn't find any updated or new .java files. However, we still need to enter
+            // this loop because there may be some class files that need compatibility checking. This can happen
+            // either if somebody had recompiled their sources bypassing jmake, or if their checking during the
+            // previous invocation of jmake failed, because their dependent code recompilation failed.
+            if (updatedJavaFiles.size() > 0 || newJavaFiles.size() > 0) {
+                Utils.startTiming(Utils.TIMING_COMPILE);
+                int intermediateRes = recompileUpdatedJavaFiles();
+                Utils.stopAndPrintTiming("Compile", Utils.TIMING_COMPILE);
+                if (intermediateRes != 0) {
+                    res = intermediateRes;
+                }
+            }
+
+            Utils.startTiming(Utils.TIMING_PDBUPDATE);
+            // New classes can be added to pdb only if compilation was successful, i.e. the new project version is consistent.
+            if (iterNo++ == 0 && res == 0) {
+                findClassFilesForNewJavaAndJarFiles();
+                findClassFilesForUpdatedJavaFiles();
+                dealWithNestedClassesForUpdatedJavaFiles();
+            }
+            Utils.stopAndPrintTiming("Entering new classes in PDB", Utils.TIMING_PDBUPDATE);
+
+            updatedJavaFiles.clear();
+            newJavaFiles.clear();
+
+            Utils.startTiming(Utils.TIMING_FIND_UPDATED_CLASSES);
+            findUpdatedClasses();
+            Utils.stopAndPrintTiming("Find updated classes", Utils.TIMING_FIND_UPDATED_CLASSES);
+
+            Utils.startTiming(Utils.TIMING_CHECK_UPDATED_CLASSES);
+            checkDeletedClasses();
+            checkUpdatedClasses();
+            Utils.stopAndPrintTiming("Check updated classes", Utils.TIMING_CHECK_UPDATED_CLASSES);
+
+            updatedClasses = new LinkedHashSet<String>();
+            if (ClassPath.getVirtualPath() != null) {
+                if (res != 0)
+                    break;
+            }
+        }
+
+        Utils.startTiming(Utils.TIMING_PDBWRITE);
+        updateClassFilesInfoInPCD(res);
+        pcdc.save();
+        Utils.stopAndPrintTiming("PDB write", Utils.TIMING_PDBWRITE);
+
+        if (res != 0) {
+            throw compilerInteractionException("compilation error(s)", null, res);
+        }
+    }
+
+    /**
+     * Find the newly-created class files for existing java files.
+     */
+    private void findClassFilesForUpdatedJavaFiles() {
+        if (dependencyFile == null)
+            return;
+
+        Set<String> allClasses = new HashSet<String>();
+
+        Map<String, List<String>> dependencies = parseDependencyFile();
+        for (String file : updatedJavaFiles) {
+            List<String> myDeps = dependencies.get(file);
+            if (myDeps != null) {
+                PCDEntry parent = getNamedPCDE(file, dependencies);
+                for (String dependency : myDeps) {
+                    allClasses.add(dependency);
+                    if (pcd.containsKey(dependency))
+                        continue;
+                    findClassFileOnFilesystem(file, parent, dependency, false);
+                }
+            }
+        }
+        for (Map.Entry<String, PCDEntry> entry : pcd.entrySet()) {
+            String cls = entry.getKey();
+            if (!allClasses.contains(cls)) {
+                PCDEntry pcde = entry.getValue();
+                if (updatedJavaFiles.contains(pcde.javaFileFullPath)) {
+                    deletedClasses.add(cls);
+                }
+            }
+        }
+    }
+
+    public String[] getAllUpdatedClassesAsStringArray() {
+        String[] res = new String[allUpdatedClasses.size()];
+        int i = 0;
+        for (String updatedClass : allUpdatedClasses) {
+            res[i++] = updatedClass.replace('/', '.');
+        }
+        return res;
+    }
+
+    /**
+     * Synchronize projectJavaAndJarFilesArray and PCD, i.e. leave only those entries in the PCD which have their
+     * .java (.jar) files in projectJavaAndJarFilesArray. New .java files in projectJavaAndJarFilesArray (i.e. those
+     * for which there are no entries in the PCD yet) are added to newJavaFiles; new .jar files are added to newJarFiles.
+     * Alternatively, just use the supplied arrays of added and deleted .java and .jar files.
+     *
+     * For entries whose .java files are not in the PCD anymore, try to delete .class files. We need to do that before
+     * compilation to avoid the situation when a .java file is removed but compilation succeeds because the .class file
+     * is still there.
+     *
+     * Unfortunately, we also need to delete all class files for non-nested classes whose names differ from their .java
+     * file name, because we can't tell when they've been removed from their .java files -- but it's only safe to do this
+     * for files that originate from java files that we're compiling this round.
+     *
+     * Upon return from this method, all of the .java and .jar files in the PCD are known to exist.
+     */
+    private void synchronizeProjectFilesAndPCD() {
+        if (projectJavaAndJarFilesArray != null) {
+            Set<String> pcdJavaFilesSet = new LinkedHashSet<String>(pcd.size() * 3 / 2);
+            for(PCDEntry entry : entries()) {
+                pcdJavaFilesSet.add(entry.javaFileFullPath);
+            }
+
+            Set<String> canonicalPJF =
+                    new LinkedHashSet<String>(projectJavaAndJarFilesArray.length * 3 / 2);
+
+            // Add .java files that are not in PCD to newJavaFiles; add .jar files that are not in PCD to newJarFiles.
+            for (int i = 0; i < projectJavaAndJarFilesArray.length; i++) {
+                String projFileName = projectJavaAndJarFilesArray[i];
+                Utils.startTiming(Utils.TIMING_SYNCHRO_CHECK_TMP);
+                File projFile = Utils.checkFileForName(projFileName);
+                Utils.stopAndAddTiming(Utils.TIMING_SYNCHRO_CHECK_TMP, Utils.TIMING_SYNCHRO_CHECK_JAVA_FILES);
+                if (projFile == null) {
+                    throw new PrivateException(new FileNotFoundException("specified source file " + projFileName + " not found."));
+                }
+                // The main reason for using getAbsolutePath() instead of more reliable getCanonicalPath() is the fact that
+                // sometimes users may name the actual files containing Java code in some custom way, and give javac/jmake
+                // symbolic links to these files (that have correct .java names) instead. getCanonicalPath(), however, returns the
+                // real (i.e. user custom) file name, which will confuse our test below and then javac.
+                String absoluteProjFileName = projFile.getAbsolutePath();
+                // On Windows, make sure the drive letter is always in lower case
+                if (backSlashFileSeparator) {
+                    absoluteProjFileName =
+                            Utils.convertDriveLetterToLowerCase(absoluteProjFileName);
+                }
+                canonicalPJF.add(absoluteProjFileName);
+                if (!pcdJavaFilesSet.contains(absoluteProjFileName)) {
+                    if (absoluteProjFileName.endsWith(".java")) {
+                        newJavaFiles.add(absoluteProjFileName);
+                    } else if (absoluteProjFileName.endsWith(".jar")) {
+                        newJarFiles.add(absoluteProjFileName);
+                    } else {
+                        throw new PrivateException(new PublicExceptions.InvalidSourceFileExtensionException("specified source file " + projFileName + " has an invalid extension (not .java or .jar)."));
+                    }
+                }
+            }
+
+            // Find the entries containing .java or .jar files that are not in project anymore
+            for (Entry<String, PCDEntry> entry : pcd.entrySet()) {
+                String key = entry.getKey();
+                PCDEntry e = entry.getValue();
+                e.oldClassInfo.restorePCDM(this);
+                if (canonicalPJF.contains(e.javaFileFullPath)) {
+                    if (e.isPackagePrivateClass()) {
+                        initializeClassFileFullPath(e);
+                        new File(e.classFileFullPath).delete();
+                    }
+                } else {
+                    if (ClassPath.getVirtualPath() == null) {
+                        deletedClasses.add(key);
+                    } else {
+                        // Okay, not found locally, but virtual path was defined, so try it now....
+                        if ( (e.oldClassFileFingerprint == projectJavaAndJarFilesArray.length &&
+                                newJavaFiles.size() == 0) ||
+                                Utils.checkFileForName(e.javaFileFullPath) != null)
+                        {
+                            e.checkResult = PCDEntry.CV_NEWER_FOUND_NEARER;
+                            e.oldClassFileFingerprint = projectJavaAndJarFilesArray.length;
+                        }
+                        else
+                        {
+                            String classFound = null;
+                            String sourceFound = null;
+                            // Find source and class file via virtual path
+                            String path = ClassPath.getVirtualPath();
+                            // TODO(Eric Ayers): IntelliJ static analysis shows several useless
+                            // expressions that make this loop a no-op.
+                            for (StringTokenizer st = new StringTokenizer(path, File.pathSeparator);
+                                !(classFound != null && sourceFound != null) && st.hasMoreTokens();)
+                            {
+                                String fullPath = st.nextToken()+File.separator+e.className;
+                                if (sourceFound != null && new File(fullPath+".java").exists())
+                                {
+                                    sourceFound = fullPath + ".java";
+                                }
+                                if (classFound != null && new File(fullPath+".class").exists())
+                                {
+                                    classFound = fullPath + ".class";
+                                }
+                            }
+                            // TODO(Eric Ayers): IntelliJ static analysis shows that this expression
+                            // is always true.
+                            if (classFound == null)
+                            {
+                                deletedClasses.add(key);
+                                if (e.javaFileFullPath.endsWith(".jar"))
+                                {
+                                    deletedJarFiles.add(e.javaFileFullPath);
+                                }
+                                else
+                                {
+                                    initializeClassFileFullPath(e);
+                                    (new File(e.classFileFullPath)).delete();
+                                }
+                            }
+                            else if (sourceFound != null)
+                            {
+                                newJavaFiles.add(sourceFound);
+                                e.checkResult = PCDEntry.CV_NEWER_FOUND_NEARER;
+                                e.oldClassFileFingerprint = projectJavaAndJarFilesArray.length;
+                            }
+                            else
+                            {
+                                classFound = classFound.replace('/', File.separatorChar);
+                                throw new PrivateException(new FileNotFoundException("deleted class " + classFound + " still exists."));
+                            }
+                        }
+                    }
+                    if (e.javaFileFullPath.endsWith(".jar")) {
+                        deletedJarFiles.add(e.javaFileFullPath);
+                    } else {  // Try to delete a class file for the removed project class.
+                        initializeClassFileFullPath(e);
+                        (new File(e.classFileFullPath)).delete();
+                    }
+                }
+            }
+        } else { // projectJavaAndJarFilesArray == null - use supplied arrays of added and removed .java and .jar files
+            if (addedJavaAndJarFilesArray != null) {
+                for (String fileName : addedJavaAndJarFilesArray) {
+                    fileName = fileName.intern();
+                    if (fileName.endsWith(".java")) {
+                        newJavaFiles.add(fileName);
+                    } else if (fileName.endsWith(".jar")) {
+                        newJarFiles.add(fileName);
+                    } else {
+                        throw new PrivateException(new PublicExceptions.InvalidSourceFileExtensionException(
+                            "specified source file " + fileName + " has an invalid extension (not .java or .jar)."));
+                    }
+                }
+            }
+
+            Set<String> removedJavaAndJarFilesSet = null;
+            if (removedJavaAndJarFilesArray != null) {
+                removedJavaAndJarFilesSet = new LinkedHashSet<String>();
+                for (String fileName : removedJavaAndJarFilesArray) {
+                    fileName = fileName.intern();
+                    removedJavaAndJarFilesSet.add(fileName);
+                    if (fileName.endsWith(".jar")) {
+                        deletedJarFiles.add(fileName);
+                    }
+                }
+            }
+
+            for (Entry<String, PCDEntry> entry : pcd.entrySet()) {
+                String key = entry.getKey();
+                PCDEntry e = entry.getValue();
+                e.oldClassInfo.restorePCDM(this);
+                if (removedJavaAndJarFilesSet != null &&
+                        removedJavaAndJarFilesSet.contains(e.javaFileFullPath)) {
+                    deletedClasses.add(key);
+                    if (!e.javaFileFullPath.endsWith(".jar")) {  // Try to delete a class file for the removed project class.
+                        initializeClassFileFullPath(e);
+                        (new File(e.classFileFullPath)).delete();
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * In the end of run, update the information in the project database for the class files which have
+     * been updated and checked, or deleted. If compilationResult == 0, i.e. all recompilations were
+     * successful, information for new versions of all of the classes is made permanent, and entries
+     * for deleted classes are removed permanently. Otherwise, information is updated only for those
+     * classes whose old and new versions were found source compatible.
+     */
+    private void updateClassFilesInfoInPCD(int compilationResult) {
+        // If the project appears to be inconsistent after changes, make a preliminary pass that will deal with enclosing
+        // classes for deleted nested classes. The problem with them can be as follows: we delete a nested class C$X,
+        // which is still referenced from somewhere. However, C has not changed at all or at least incompatibly, and
+        // thus we update its PCDEntry, which now does not reference C$X. Other parts of jmake require that a nested
+        // class is always referenced from its directly enclusing class, thus to keep the PCD consistent we have to remove
+        // C$X from the PCD. On the next invocation of jmake, C$X is not in the PDB at all, and thus any classes that
+        // may still reference it and have not been updated are not checked => project becomes inconsistent. We could do
+        // better by immediately marking enclosing classes incompatible once we detect that a deleted nested class is
+        // really referenced from somewhere, but the solution below seems to be more robust.
+        if (compilationResult != 0) {
+            for (String className : updatedAndCheckedClasses) {
+                PCDEntry entry = pcd.get(className);
+                if (entry.checkResult == PCDEntry.CV_DELETED &&
+                        !"".equals(entry.oldClassInfo.directlyEnclosingClass)) {
+                    PCDEntry enclEntry =
+                            pcd.get(entry.oldClassInfo.directlyEnclosingClass);
+                    enclEntry.checkResult = PCDEntry.CV_INCOMPATIBLE;
+                }
+            }
+        }
+
+        for (String className : updatedAndCheckedClasses) {
+            PCDEntry entry = pcd.get(className);
+            if (entry.checkResult == PCDEntry.CV_UNCHECKED) {
+                continue;
+            }
+            if (ClassPath.getVirtualPath() != null) {
+                if (entry.checkResult == PCDEntry.CV_NEWER_FOUND_NEARER) {
+                    continue;
+                }
+            }
+            if (entry.checkResult == PCDEntry.CV_DELETED) {
+                if (compilationResult == 0) {
+                    pcd.remove(className);  // Only if consistency checking is ok, a deleted class can be safely removed from the PCD
+                }
+            } else if (entry.checkResult == PCDEntry.CV_COMPATIBLE ||
+                    entry.checkResult == PCDEntry.CV_NEW ||
+                    (entry.checkResult == PCDEntry.CV_INCOMPATIBLE && compilationResult == 0)) {
+                if (entry.newClassInfo == null) {  // "Safety net" for the (hopefully unlikely) case we overlooked something before...
+                    Utils.printWarningMessage("Warning: internal information inconsistency detected during pdb updating");
+                    Utils.printWarningMessage(Utils.REPORT_PROBLEM);
+                    Utils.printWarningMessage("Class name: " + className);
+                    if (entry.checkResult == PCDEntry.CV_NEW) {
+                        pcd.remove(className);
+                    } else {
+                        continue;
+                    }
+                }
+                entry.oldClassFileLastModified = entry.newClassFileLastModified;
+                entry.oldClassFileFingerprint = entry.newClassFileFingerprint;
+                entry.oldClassInfo = entry.newClassInfo;
+            }
+        }
+    }
+
+    /**
+     * Find all .java files on the filesystem,  for which the .class file does not exist
+     * or is newer than the .java file. Also find all .jar files for which the timestamp
+     * has changed. Alternatively, just use the supplied array of updated .java/.jar files.
+     */
+    private void findUpdatedJavaAndJarFiles() {
+        boolean projectSpecifiedAsAllSources =
+                projectJavaAndJarFilesArray != null;
+        for (PCDEntry entry : entries()) {
+            if (deletedClasses.contains(entry.className)) {
+                continue;
+            }
+            if (entry.javaFileFullPath.endsWith(".java")) {
+                initializeClassFileFullPath(entry);
+                if (projectSpecifiedAsAllSources) {
+                    if (ClassPath.getVirtualPath() != null) {
+                        String paths[] = ClassPath.getVirtualPath().split(File.pathSeparator);
+                        String tmpClassName = entry.className;
+                        tmpClassName = tmpClassName.replaceAll("\\Q$\\E.*$", "");
+                        for (int i=0; i<paths.length; i++) {
+                            String tmpFilename = paths[i] + File.separator + tmpClassName + ".java";
+                            File tmpFile = new File(tmpFilename);
+                            if (tmpFile.exists()) {
+                                entry.javaFileFullPath = tmpFile.getAbsolutePath();
+                                break;
+                            }
+                        }
+                    }
+                    Utils.startTiming(Utils.TIMING_CLASS_FILE_OBSOLETE_TMP);
+                    if (classFileObsoleteOrDeleted(entry)) {
+                        updatedJavaFiles.add(entry.javaFileFullPath);
+                    }
+                    Utils.stopAndAddTiming(Utils.TIMING_CLASS_FILE_OBSOLETE_TMP, Utils.TIMING_CLASS_FILE_OBSOLETE_OR_DELETED);
+                }
+                entry.checked = true;
+            } else {  // Class coming from a .jar file. Mark this entry as checked only if its JAR hasn't changed
+                if (projectJavaAndJarFilesArray != null) {
+                    entry.checked = !checkJarFileForUpdate(entry);
+                }
+            }
+        }
+
+        // Lists of updated/added/deleted source files specified instead of a full list of project sources
+        if (!projectSpecifiedAsAllSources && updatedJavaAndJarFilesArray != null) {
+            for (int i = 0; i < updatedJavaAndJarFilesArray.length; i++) {
+                if (updatedJavaAndJarFilesArray[i].endsWith(".java")) {
+                    updatedJavaFiles.add(updatedJavaAndJarFilesArray[i]);
+                } else {
+                    updatedJarFiles.add(updatedJavaAndJarFilesArray[i]);
+                }
+            }
+        }
+    }
+
+    private boolean classFileObsoleteOrDeleted(PCDEntry entry) {
+        if (ClassPath.getVirtualPath() != null) {
+            File file1 = new File(entry.javaFileFullPath);
+            if (!file1.exists())
+                throw new PrivateException(new FileNotFoundException("specified source file " +
+                        entry.javaFileFullPath + " not found."));
+            if (file1.lastModified() < entry.oldClassFileLastModified)
+            {
+                return false;
+            }
+        }
+        File classFile = Utils.checkFileForName(entry.classFileFullPath);
+        if (classFile == null || !classFile.exists()) {
+            return true; // Class file has been deleted
+        }
+        File javaFile = new File(entry.javaFileFullPath); // Guaranteed to exist at this point
+        if (classFile.lastModified() <= javaFile.lastModified()) {
+            return true;
+        }
+        return false;
+    }
+
+    private boolean checkJarFileForUpdate(PCDEntry entry) {
+        String jarFileName = entry.javaFileFullPath;
+        if (stableJarFiles.contains(jarFileName)) {
+            return false;
+        } else if (updatedJarFiles.contains(jarFileName) ||
+                newJarFiles.contains(jarFileName) ||
+                deletedJarFiles.contains(jarFileName)) {
+            return true;
+        } else {
+            File jarFile = new File(jarFileName); // Guaranteed to exist at this point.
+            if (entry.oldClassFileLastModified != jarFile.lastModified()) {
+                updatedJarFiles.add(jarFileName);
+                return true;
+            } else {
+                stableJarFiles.add(jarFileName);
+                return false;
+            }
+        }
+    }
+
+    public int recompileUpdatedJavaFiles() {
+        if (externalApp != null) {
+            return recompileUpdatedJavaFilesUsingExternalMethod();
+        } else {
+            return recompileUpdatedJavaFilesOurselves();
+        }
+    }
+
+    private int recompileUpdatedJavaFilesOurselves() {
+        int filesNo = updatedJavaFiles.size() + newJavaFiles.size();
+        int addArgsNo = javacAddArgs.size();
+        int argsNo = addArgsNo + filesNo + 2;
+        String compilerBootClassPath, compilerExtDirs;
+        if ((compilerBootClassPath = ClassPath.getCompilerBootClassPath()) != null) {
+            argsNo += 2;
+        }
+        if ((compilerExtDirs = ClassPath.getCompilerExtDirs()) != null) {
+            argsNo += 2;
+        }
+        if (jcExecApp != null) {
+            argsNo++;
+        }
+        String args[] = new String[argsNo];
+        int pos = 0;
+        if (jcExecApp != null) {
+            args[pos++] = jcExecApp;
+        }
+        for (int i = 0; i < addArgsNo; i++) {
+            args[pos++] = javacAddArgs.get(i);
+        }
+        args[pos++] = "-classpath";
+        args[pos++] = ClassPath.getCompilerUserClassPath();
+        if (compilerBootClassPath != null) {
+            args[pos++] = "-bootclasspath";
+            args[pos++] = compilerBootClassPath;
+        }
+        if (compilerExtDirs != null) {
+            args[pos++] = "-extdirs";
+            args[pos++] = compilerExtDirs;
+        }
+        if (!newProject) {
+            Utils.printInfoMessage("Recompiling source files:");
+        }
+        for (String javaFileFullPath : updatedJavaFiles) {
+            if (!newProject) {
+                Utils.printInfoMessage(javaFileFullPath);
+            }
+            recompiledJavaFiles.add(args[pos++] = javaFileFullPath);
+        }
+        for (int j = 0; j < newJavaFiles.size(); j++) {
+            String javaFileFullPath = newJavaFiles.get(j);
+            if (!newProject) {
+                Utils.printInfoMessage(javaFileFullPath);
+            }
+            recompiledJavaFiles.add(args[pos++] = javaFileFullPath);
+        }
+
+        if (jcExecApp == null) {  // Executing javac or some other compiler within the same JVM
+            Object reflectArgs[] = new Object[1];
+            reflectArgs[0] = args;
+            try {
+                Object dummy = compilerClass.newInstance();
+                Integer res = (Integer) compileMethod.invoke(dummy, reflectArgs);
+                return res.intValue();
+            } catch (Exception e) {
+                throw compilerInteractionException("exception thrown when trying to invoke the compiler method", e, 0);
+            }
+        } else {  // Executing an external Java compiler, such as jikes
+            int exitCode = 0;
+            try {
+                Process p = Runtime.getRuntime().exec(args);
+                InputStream pErr = p.getErrorStream();
+                InputStream pOut = p.getInputStream();
+                boolean terminated = false;
+
+                while (!terminated) {
+                    try {
+                        exitCode = p.exitValue();
+                        terminated = true;
+                    } catch (IllegalThreadStateException itse) { // Process not yet terminated, wait for some time
+                        Utils.ignore(itse);
+                        Utils.delay(100);
+                    }
+                    try {
+                        Utils.readAndPrintBytesFromStream(pErr, System.err);
+                        Utils.readAndPrintBytesFromStream(pOut, System.out);
+                    } catch (IOException ioe1) {
+                        throw compilerInteractionException("I/O error when reading the compiler application output", ioe1, exitCode);
+                    }
+                }
+                return exitCode;
+            } catch (IOException ioe2) {
+                throw compilerInteractionException("I/O error when trying to invoke the compiler application", ioe2, exitCode);
+            }
+        }
+    }
+
+    /** Execution under complete control of external app - use externally supplied method to recompile classes */
+    private int recompileUpdatedJavaFilesUsingExternalMethod() {
+        int filesNo = updatedJavaFiles.size() + newJavaFiles.size();
+        String[] fileNames = new String[filesNo];
+        int i = 0;
+        for (String updatedFile : updatedJavaFiles) {
+            recompiledJavaFiles.add(fileNames[i] = updatedFile);
+        }
+        for (int j = 0; j < newJavaFiles.size(); j++) {
+            recompiledJavaFiles.add(fileNames[i++] = newJavaFiles.get(j));
+        }
+
+        try {
+            Integer res =
+                    (Integer) externalCompileSourceFilesMethod.invoke(externalApp, new Object[]{fileNames});
+            return res.intValue();
+        } catch (IllegalAccessException e1) {
+            throw compilerInteractionException("compiler method is not accessible", e1, 0);
+        } catch (IllegalArgumentException e2) {
+            throw compilerInteractionException("illegal arguments passed to compiler method", e2, 0);
+        } catch (InvocationTargetException e3) {
+            throw compilerInteractionException("exception when executing the compiler method", e3, 0);
+        }
+    }
+
+    /**
+     * For each .java file from newJavaFiles, find all of the .class files, the names of which we can
+     * logically deduce (a top-level class with the same name, and all of the nested classes),
+     * and put the info on them into the PCD. Also include any class files from the dependencyFile,
+     * if any. For each .jar file from newJarFiles, find all of the .class files in that archive and
+     * put info on them into the PCD.
+     */
+    private void findClassFilesForNewJavaAndJarFiles() {
+        for (String javaFileFullPath : newJavaFiles) {
+            PCDEntry pcde =
+                    findClassFileOnFilesystem(javaFileFullPath, null, null, false);
+
+            if (pcde == null) {
+                // .class file not found - possible compilation error
+                if (missingClassIsOk(javaFileFullPath)) {
+                    continue;
+                } else {
+                    throw new PrivateException(new PublicExceptions.ClassNameMismatchException(
+                            "Could not find class file for " + javaFileFullPath));
+                }
+            }
+            Set<String> entries = new HashSet<String>();
+            if (pcde.checkResult == PCDEntry.CV_NEW) {  // It's really a new .java file, not a moved one
+                entries.addAll(findAndUpdateAllNestedClassesForClass(pcde, false));
+            } else {
+                entries.addAll(findAndUpdateAllNestedClassesForClass(pcde, true));
+            }
+            entries.add(pcde.className);
+            if (dependencyFile != null) {
+                Map<String, List<String>> dependencies = parseDependencyFile();
+                List<String> myDeps = dependencies.get(javaFileFullPath);
+                if (myDeps != null) {
+                    for (String dependency : myDeps) {
+                        if (entries.contains(dependency))
+                            continue;
+                        findClassFileOnFilesystem(javaFileFullPath, pcde,
+                                dependency, false);
+                    }
+                }
+            }
+        }
+
+        for (String newJarFile : newJarFiles) {
+            processAllClassesFromJarFile(newJarFile);
+        }
+    }
+
+    /**
+     * Parse an extra dependency file.  The format of the file is a series of lines,
+     * each consisting of:
+     * SourceFileName.java -> ClassName
+     * (these file names are relative to destDir)
+     */
+    private Map<String, List<String>> parseDependencyFile() {
+        if (!destDirSpecified)
+            throw new RuntimeException("Dependency files require destDir");
+        if (extraDependencies != null)
+            return extraDependencies;
+        BufferedReader in = null;
+        try {
+            extraDependencies = new HashMap<String, List<String>>();
+            in = new BufferedReader(new FileReader(dependencyFile));
+            int lineNumber = 0;
+            while (true) {
+                lineNumber ++;
+                String line = in.readLine();
+                if (line == null)
+                    break;
+                String[] parts = line.split("->");
+                if (parts.length != 2) {
+                    throw new RuntimeException("Failed to parse line " + lineNumber + " of " + dependencyFile
+                                               + ". Expected {foo.java} -> {classname}.");
+                }
+                String src = parts[0].trim();
+                src = new File(destDir, src).getCanonicalPath();
+                String cls = parts[1].trim();
+                List<String> classes = extraDependencies.get(src);
+                if (classes == null) {
+                    classes = new ArrayList<String>();
+                    extraDependencies.put(src, classes);
+                }
+                cls = cls.substring(0, cls.length() - 6); // strip trailing ".class"
+                classes.add(cls);
+            }
+        } catch (IOException e) {
+            throw new PrivateException(e);
+        } finally {
+            if (in != null)
+                try {
+                    in.close();
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+        }
+        return extraDependencies;
+    }
+
+    /**
+     * In most cases we want to fail the build if a class cannot be found.
+     *
+     * However there is one common valid case where a .java file might not contain
+     * a class: package-info.java files.
+     *
+     * See this doc for more info: http://docs.oracle.com/javase/specs/jls/se7/html/jls-7.html
+     */
+    private boolean missingClassIsOk(String javaFileFullPath) {
+        return javaFileFullPath != null && "package-info.java".equals(new File(javaFileFullPath).getName());
+    }
+
+    /**
+     * Find the .class file for the given javaFileFullPath and create a new PCDEntry for it.
+     * If enclosingClassPCDE is null, the named top-level class for the given .java file is looked up.
+     * Otherwise, the specified class specified by nestedClassFullName is looked up.
+     */
+    private PCDEntry findClassFileOnFilesystem(String javaFileFullPath, PCDEntry enclosingClassPCDE, String nestedClassFullName, boolean isNested) {
+        String classFileFullPath = null;
+        String fullClassName;
+        File classFile = null;
+
+        if (enclosingClassPCDE == null) { // Looking for a top-level class. May need to locate an appropriate directory.
+            // Remove the ".java" suffix. A Windows disk-name prefix, such as 'c:', will be cut off later automatically
+            fullClassName =
+                    javaFileFullPath.substring(0, javaFileFullPath.length() - 5);
+            if (destDirSpecified) {
+                // Search for the .class file. We first assume the longest possible name. In case of failure,
+                // we cut the assumed top-most package from it and repeat the search.
+                while (classFile == null) {
+                    classFileFullPath = destDir + fullClassName + ".class";
+                    classFile = Utils.checkFileForName(classFileFullPath);
+                    if (classFile == null) {
+                        int cutIndex = fullClassName.indexOf(File.separatorChar);
+                        if (cutIndex == -1) {
+                            // Most probably, there was an error during compilation of this file.
+                            // This does not prevent us from continuing.
+                            Utils.printWarningMessage("Warning: unable to find .class file corresponding to source " + javaFileFullPath + ": expected " + classFileFullPath);
+
+                            return null;
+                        }
+                        fullClassName = fullClassName.substring(cutIndex + 1);
+                    }
+                }
+            } else {
+                classFileFullPath = fullClassName + ".class";
+                classFile = Utils.checkFileForName(classFileFullPath);
+                if (classFile == null) {
+                    Utils.printWarningMessage("Warning: unable to find .class file corresponding to source " + javaFileFullPath);
+                    return null;
+                }
+            }
+        } else {  // Looking for a nested class, which always sits in the same directory as its enclosing class
+            classFileFullPath =
+                    Utils.getClassFileFullPathForNestedClass(enclosingClassPCDE.classFileFullPath, nestedClassFullName);
+            classFile = Utils.checkFileForName(classFileFullPath);
+            if (classFile == null) {
+                Utils.printWarningMessage("Warning: unable to find .class file corresponding to nested class " + nestedClassFullName);
+                return null;
+            }
+            fullClassName = nestedClassFullName;
+        }
+
+        if (backSlashFileSeparator) {
+            fullClassName = fullClassName.replace(File.separatorChar, '/');
+        }
+
+        byte classFileBytes[] = Utils.readFileIntoBuffer(classFile);
+        ClassInfo classInfo =
+                new ClassInfo(classFileBytes, ClassInfo.VER_NEW, this, classFileFullPath);
+        if (isNested) {
+            if (!classInfo.directlyEnclosingClass.equals(enclosingClassPCDE.newClassInfo.name)) {
+                // Check if the above strings are like A and A$1. If so, there is actually no problem - the correct
+                // answer is A$1. The reason why just A was determined as a directly enclosing class when parsing
+                // class classInfo is due to the ambiguous interpretation of names like A$1$B. Such a name may mean
+                // (1) a non-member local nested class B of A, or (2) a member class B of an anonymous nested class A$1.
+                // When parsing any non-toplevel class, the first interpretation is always used.
+                // NOTE FOR JDK 1.5 - starting from this version, there is no ambiguity anymore.
+                // (1) will be called A$1B, and (2) will still be A$1$B
+                String a = classInfo.directlyEnclosingClass;
+                String ad1 = enclosingClassPCDE.newClassInfo.name;
+                if (!((classInfo.javacTargetRelease == Utils.JAVAC_TARGET_RELEASE_OLDEST) &&
+                        (ad1.startsWith(a + "$") && Character.isDigit(ad1.charAt(a.length() + 1))))) {
+                    throw new PrivateException(new PublicExceptions.ClassFileParseException(
+                            "Enclosing class names for class " + classInfo.name + " don't match:\n" +
+                            classInfo.directlyEnclosingClass + " and " + enclosingClassPCDE.newClassInfo.name));
+                }
+            }
+        }
+
+        // If dest dir was specified, check if the deduced name is equal to the one in this class (in this case
+        // they should necessarily match). Otherwise, without parsing the .java file, we can't reliably say what the
+        // full class name (actually, its package part) should be - so we just note the name.
+        if (destDirSpecified) {
+            if (!fullClassName.equals(classInfo.name)) {
+                throw new PrivateException(new PublicExceptions.ClassNameMismatchException(
+                        "Error: deduced class name is different from the real one for source " +
+                        javaFileFullPath + "\n" + fullClassName + " and " + classInfo.name));
+            }
+        } else {
+            fullClassName = classInfo.name;
+        }
+
+        if (enclosingClassPCDE != null) {
+            javaFileFullPath = enclosingClassPCDE.javaFileFullPath;
+        }
+        long classFileLastMod = classFile.lastModified();
+        long classFileFP = computeFP(classFileBytes);
+
+        if (pcd.containsKey(fullClassName)) {
+            PCDEntry pcde = pcd.get(fullClassName);
+            // If this entry has already been checked, it's a second entry for the same class, which is illegal.
+            if (pcde.checkResult == PCDEntry.CV_NEWER_FOUND_NEARER) {
+                // Newer copy of same file found in closer layer
+                // Reset to CV_UNCHECKED and skip redundnacy check
+                // as we know this would be redundant
+                pcde.checkResult = PCDEntry.CV_UNCHECKED;
+            } else {
+                if (pcde.checked) {
+                    throw new PrivateException(new PublicExceptions.DoubleEntryException(
+                            "Two entries for class " + classInfo.name + " detected: " + pcde.javaFileFullPath + " and " + javaFileFullPath));
+                }
+            }
+            // Otherwise, it means that the .java file for this class has been moved. jmake initially interprets
+            // a new source file name as a new class, and it's only at this point that we can actually see that it was
+            // only a move. We update javaFileFullPath for nested classes after we return from here.
+            pcde.javaFileFullPath = javaFileFullPath;
+            pcde.classFileFullPath = classFileFullPath;
+            pcde.newClassInfo = classInfo;
+            if (deletedClasses.contains(fullClassName)) {
+                deletedClasses.remove(fullClassName);
+            }
+            return pcde;
+        }
+
+        PCDEntry pcde = new PCDEntry(fullClassName,
+                javaFileFullPath,
+                classFileFullPath, classFileLastMod, classFileFP,
+                classInfo);
+        pcde.checkResult = PCDEntry.CV_NEW;          // So that later it's promoted into oldClassInfo correctly
+        updatedAndCheckedClasses.add(fullClassName); // So that the above happens
+        pcd.put(fullClassName, pcde);
+        return pcde;
+    }
+
+    /**
+     * For the given class, find all direct nested classes (which may include reading their .class files from the
+     * class path) and set their access flags (contained in this, enclosing class, object) appropriately. If
+     * this class is a one coming from a .java source, repeat the procedure for each nested class in turn.
+     * Otherwise, i.e. if a class comes from a .jar, don't bother, since we will come across each of these
+     * classes anyway - when scanning their .jar. If 'move' parameter is true, it means that this method is called for
+     * a class that is not new, but has been moved (and possibly updated).
+     */
+    private Set<String> findAndUpdateAllNestedClassesForClass(PCDEntry pcde, boolean move) {
+        ClassInfo classInfo = pcde.newClassInfo;
+        if (classInfo.nestedClasses == null) {
+            return Collections.emptySet();
+        }
+        Set<String> entries = new LinkedHashSet<String>();
+        String nestedClasses[] = classInfo.nestedClasses;
+        String javaFileFullPath = pcde.javaFileFullPath;
+        String enclosingClassFileFullPath = pcde.classFileFullPath;
+        boolean isJavaSourceFile = javaFileFullPath.endsWith(".java");
+
+        for (int i = 0; i < nestedClasses.length; i++) {
+            PCDEntry nestedPCDE = pcd.get(nestedClasses[i]);
+            if (nestedPCDE == null) {
+                if (isJavaSourceFile) {
+                    nestedPCDE =
+                            findClassFileOnFilesystem(null, pcde, nestedClasses[i], true);
+                }
+                // For classes that come from a .jar, pcde should already be there. Otherwise this class just doesn't exist.
+                if (nestedPCDE == null) {
+                    // Probably a compilation error, such that enclosing class is compiled but nested is not.
+                    throw new PrivateException(new PublicExceptions.ClassNameMismatchException(
+                            "Could not find class file for " + pcde.toString()));
+                }
+            }
+            if (move) {
+                if (deletedClasses.contains(nestedClasses[i])) {
+                    deletedClasses.remove(nestedClasses[i]);
+                }
+                nestedPCDE.javaFileFullPath = javaFileFullPath;
+                if (javaFileFullPath.endsWith(".java")) {
+                    nestedPCDE.classFileFullPath =
+                            Utils.getClassFileFullPathForNestedClass(enclosingClassFileFullPath, nestedClasses[i]);
+                } else {
+                    nestedPCDE.classFileFullPath = javaFileFullPath;
+                }
+            }
+            if (nestedPCDE.newClassInfo == null) {
+                getClassInfoForPCDEntry(ClassInfo.VER_NEW, nestedPCDE);
+            }
+            nestedPCDE.newClassInfo.accessFlags =
+                    pcde.newClassInfo.nestedClassAccessFlags[i];
+            nestedPCDE.newClassInfo.isNonMemberNestedClass =
+                    pcde.newClassInfo.nestedClassNonMember[i];
+
+            entries.add(nestedPCDE.className);
+            entries.addAll(findAndUpdateAllNestedClassesForClass(nestedPCDE, move));
+        }
+        return entries;
+    }
+
+    /**
+     * Take care of new nested classes that could have been generated from already existing .java sources,
+     * and of nested classes that do not exist anymore because they were deleted from these sources.
+     */
+    private void dealWithNestedClassesForUpdatedJavaFiles() {
+        if (updatedJavaFiles.size() == 0) {
+            return;
+        }
+
+        // First put PCDEntries for all updated classes that have nested classes into a temporary list.
+        // That's because we can then find new nested classes, which we will need to add to the PCD, which
+        // may probably conflict with us still iterating over it.
+        List<PCDEntry> updatedEntries = new ArrayList<PCDEntry>();
+        for (PCDEntry pcde : entries()) {
+            if (pcde.checkResult == PCDEntry.CV_NEW) {
+                continue;  // This class has just been added to the PCD
+            }
+            if (updatedJavaFiles.contains(pcde.javaFileFullPath)) {
+                ClassInfo oldClassInfo = pcde.oldClassInfo;
+                ClassInfo newClassInfo =
+                        getClassInfoForPCDEntry(ClassInfo.VER_NEW, pcde);
+                if (newClassInfo == null) {
+                    deletedClasses.add(pcde.className);
+                    continue; // Class file deleted then not re-created due to a compilation error somewhere.
+                }
+                if (oldClassInfo.nestedClasses != null || newClassInfo.nestedClasses != null) {
+                    updatedEntries.add(pcde);
+                }
+            }
+        }
+
+        if (dependencyFile != null) {
+            Map<String, List<String>> dependencies = parseDependencyFile();
+            for (String file : updatedJavaFiles) {
+                List<String> myDeps = dependencies.get(file);
+                if (myDeps == null)
+                    continue;
+                PCDEntry pcde = getNamedPCDE(file, dependencies);
+                for (String dependency : myDeps) {
+                    PCDEntry dep = pcd.get(dependency);
+                    if (dep != null)
+                        // This is an existing dep.
+                        continue;
+                    dep = findClassFileOnFilesystem(file, pcde, dependency,  false);
+                    getClassInfoForPCDEntry(ClassInfo.VER_NEW, dep);
+                    if (dep.newClassInfo.nestedClasses != null)
+                        updatedEntries.add(dep);
+                }
+            }
+        }
+        dealWithNestedClassesForUpdatedPCDEntries(updatedEntries, false);
+    }
+
+    private PCDEntry getNamedPCDE(String file, Map<String, List<String>> dependencies) {
+        List<String> depsForFile = dependencies.get(file);
+        PCDEntry pcde = null;
+        // Find a non-nested class for this java file for which we already have
+        // a pcde
+        for (String dependency : depsForFile) {
+            if (dependency.indexOf('$') != -1)
+                continue;
+            pcde = pcd.get(dependency);
+            if (pcde != null)
+                break;
+        }
+        if (pcde == null) {
+            throw new PrivateException(new PublicExceptions.InternalException(file
+                    + " was supposed to be an updated file, but there are no PCDEntries for any of its deps"));
+        }
+        return pcde;
+    }
+
+    private void dealWithNestedClassesForUpdatedPCDEntries(List<PCDEntry> entries, boolean move) {
+        for (int i = 0; i < entries.size(); i++) {
+            PCDEntry pcde = entries.get(i);
+            ClassInfo oldClassInfo = pcde.oldClassInfo;
+            ClassInfo newClassInfo = pcde.newClassInfo;
+            if (newClassInfo.nestedClasses != null) {
+                Set<String> nested = findAndUpdateAllNestedClassesForClass(pcde, move);
+                if (oldClassInfo.nestedClasses != null) {  // Check if any old nested classes don't exist anymore
+                    for (int j = 0; j < oldClassInfo.nestedClasses.length; j++) {
+                        boolean found = false;
+                        String oldNestedClass = oldClassInfo.nestedClasses[j];
+                        for (int k = 0; k < newClassInfo.nestedClasses.length; k++) {
+                            if (oldNestedClass.equals(newClassInfo.nestedClasses[k])) {
+                                found = true;
+                                break;
+                            }
+                        }
+                        if (!found) {
+                            deletedClasses.add(oldNestedClass);
+                        }
+                    }
+                }
+            } else {  // newNestedClasses == null and oldNestedClasses != null, so all nested classes have been removed in the new version
+                for (int j = 0; j < oldClassInfo.nestedClasses.length; j++) {
+                    deletedClasses.add(oldClassInfo.nestedClasses[j]);
+                }
+            }
+        }
+    }
+
+    private void findUpdatedClasses() {
+        // This (iterating over all of the classes once again after performing that in classFileObsoleteOrDeleted()) may
+        // seem time-consuming, but in reality it isn't, since the most time-consuming operation of obtaining internal
+        // file handles for class files has already been performed in classFileObsoleteOrDeleted(). Once we have done that,
+        // this re-iteration takes very small amount of time. However, if we switch from "class file older than .java
+        // file" to ".java file timestamp changed" condition for recompilation, this will have to be changed as well.
+         for (PCDEntry entry : entries()) {
+            String className = entry.className;
+            if (updatedAndCheckedClasses.contains(className) ||
+                    deletedClasses.contains(className)) {
+                continue;
+            }
+            if (!entry.javaFileFullPath.endsWith(".java")) {
+                continue; // classes from (updated) .jars have been dealt with separately
+            }
+            //DAB TODO understand this bit better.  It is needed to support -vpath, I'm just not sure why....
+            if (entry.checkResult != PCDEntry.CV_NEWER_FOUND_NEARER &&
+                    !updatedAndCheckedClasses.contains(className) &&
+                    !deletedClasses.contains(className) &&
+                    entry.javaFileFullPath.endsWith(".java") &&
+                    classFileUpdated(entry))
+            {
+            //DAB TODO this is the old way....
+            //DAB    if (classFileUpdated(entry)) {
+                updatedClasses.add(className);
+                allUpdatedClasses.add(className);
+            }
+        }
+    }
+
+    private boolean classFileUpdated(PCDEntry entry) {
+        File classFile = Utils.checkFileForName(entry.classFileFullPath);
+        if (classFile == null) {
+            return false;
+        }
+        // The only case when the above can happen is if class file was first deleted, and then there
+        // was an error recompiling its source
+
+        long classFileLastMod = classFile.lastModified();
+
+        if (classFileLastMod > entry.oldClassFileLastModified) {
+            entry.newClassFileLastModified = classFileLastMod;
+            // Check if the class was actually modified, to avoid the costly procedure of detailed version compare
+            long classFileFP = computeFP(classFile);
+            if (classFileFP != entry.oldClassFileFingerprint) {
+                entry.newClassFileFingerprint = classFileFP;
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Compare old (preserved in pdb) and new (file system) versions of updated classes, and find all
+     * potentially affected dependent classes.
+     */
+    private void checkUpdatedClasses() {
+        for (String className : updatedClasses) {
+            PCDEntry pcde = pcd.get(className);
+            getClassInfoForPCDEntry(ClassInfo.VER_NEW, pcde);
+            if (!"".equals(pcde.oldClassInfo.directlyEnclosingClass)) {
+                // The following problem can occur with nested classes. A C.java source has been changed, so that C.class is
+                // not changed or changed in a compatible way, whereas the access modifiers of C$X.class are changed in an
+                // incompatible way, so that something is broken in the project. When jmake is called for the first time,
+                // it reports the problem, then saves the info on the new version of C in the pdb. Of course, the record for
+                // C$X in the pdb is not updated, since the change to it is incompatible and recompilation of dependent sources
+                // has failed. Suppose we don't change anything and invoke jmake again. C$X is found different from its old
+                // version and is checked here again. The outcome should be the same. But since C has not changed, C.class is
+                // not read from disk and the access flags of C$X, which are stored in C.class, are not set appropriately. So
+                // in such circumstances we have wrong access flags for C$X here. To fix the problem we need to load C explicitly.
+                ClassInfo enclosingClassInfo =
+                        getClassInfoForName(ClassInfo.VER_NEW, pcde.oldClassInfo.directlyEnclosingClass);
+                //if (enclosingClassInfo == null || enclosingClassInfo.nestedClasses == null) {
+                //  System.out.println("!!! Suspicious updated class name = " + className);
+                //  System.out.println("!!! enclosingClassInfo for it = " + enclosingClassInfo);
+                //  if (enclosingClassInfo != null) {
+                //    System.out.println("!!! enclosingClassInfo.name = " + enclosingClassInfo.name);
+                //    if (enclosingClassInfo.nestedClasses == null) System.out.println("!!! enclosingClassInfo.nestedClasses = null");
+                //  }
+                //}
+                if (enclosingClassInfo.nestedClasses != null) {  // Can be that this nested class was the only one for enclosing class, and it's deleted now
+                    for (int i = 0; i < enclosingClassInfo.nestedClasses.length; i++) {
+                        if (className.equals(enclosingClassInfo.nestedClasses[i])) {
+                            pcde.newClassInfo.accessFlags =
+                                    enclosingClassInfo.nestedClassAccessFlags[i];
+                            pcde.newClassInfo.isNonMemberNestedClass =
+                                    enclosingClassInfo.nestedClassNonMember[i];
+                            break;
+                        }
+                    }
+                }
+            }
+            if (!(pcde.oldClassInfo.isNonMemberNestedClass && pcde.newClassInfo.isNonMemberNestedClass)) {
+                Utils.printInfoMessage("Checking " + pcde.className);
+                pcde.checkResult = cv.compareClassVersions(pcde) ? PCDEntry.CV_COMPATIBLE
+                        : PCDEntry.CV_INCOMPATIBLE;
+                String affectedClasses[] = cv.getAffectedClasses();
+                if (affectedClasses != null) {
+                    for (int i = 0; i < affectedClasses.length; i++) {
+                        PCDEntry affEntry = pcd.get(affectedClasses[i]);
+                        updatedJavaFiles.add(affEntry.javaFileFullPath);
+                    }
+                }
+            } else {
+                // A non-member nested class can not be referenced by the source code of any class defined outside the
+                // immediately enclosing source code block for this class. Therefore, any incompatibility in the new
+                // version of this class can affect only classes that are defined in the same source file - and they
+                // are necessarily recompiled together with this class. So there is no point in initiating version
+                // compare for this class. However, the new class version should always tembe promoted into the store, since
+                // this class itself may depend on other changing classes.
+                pcde.checkResult = PCDEntry.CV_COMPATIBLE;
+            }
+
+            updatedAndCheckedClasses.add(className);
+        }
+    }
+
+    /** Find all dependent classes for deleted classes. */
+    private void checkDeletedClasses() {
+        for (String className : deletedClasses) {
+            PCDEntry pcde = pcd.get(className);
+
+            if (pcde == null) {  // "Safety net" for the (hopefully unlikely) case. I observed it just once and couldn't identify the reason
+                Utils.printWarningMessage("Warning: internal information inconsistency when checking deleted classes");
+                Utils.printWarningMessage(Utils.REPORT_PROBLEM);
+                Utils.printWarningMessage("Class name: " + className);
+                continue;
+            }
+
+            ClassInfo oldCI = pcde.oldClassInfo;
+            if (!oldCI.isNonMemberNestedClass) { // See the comment above
+                Utils.printInfoMessage("Checking deleted class " + oldCI.name);
+                cv.checkDeletedClass(pcde);
+                String[] affectedClasses = cv.getAffectedClasses();
+                if (affectedClasses != null) {
+                    for (int i = 0; i < affectedClasses.length; i++) {
+                        PCDEntry affEntry = pcd.get(affectedClasses[i]);
+                        if (deletedClasses.contains(affEntry.className)) {
+                            continue;
+                        }
+                        updatedJavaFiles.add(affEntry.javaFileFullPath);
+                    }
+                }
+            }
+            pcde.checkResult = PCDEntry.CV_DELETED;
+            updatedAndCheckedClasses.add(className);
+        }
+        deletedClasses.clear();
+    }
+
+    /**
+     * Determine what classes in the given .jar (which may be an existing updated one, or a new one) are new,
+     * updated, or moved, and treat them accordingly.
+     */
+    private void processAllClassesFromJarFile(String jarFileName) {
+        JarFile jarFile;
+        long jarFileLastMod = 0;
+        try {
+            File file = new File(jarFileName);
+            jarFileLastMod = file.lastModified();
+            jarFile = new JarFile(jarFileName);
+        } catch (IOException ex) {
+            throw new PrivateException(ex);
+        }
+
+        List<PCDEntry> newEntries = new ArrayList<PCDEntry>();
+        List<PCDEntry> updatedEntries = new ArrayList<PCDEntry>();
+        List<PCDEntry> movedEntries = new ArrayList<PCDEntry>();
+
+        for (Enumeration<JarEntry> entries = jarFile.entries(); entries.hasMoreElements();) {
+            JarEntry jarEntry = entries.nextElement();
+            String fullClassName = jarEntry.getName();
+            if (!fullClassName.endsWith(".class")) {
+                continue;
+            }
+            fullClassName =
+                    fullClassName.substring(0, fullClassName.length() - 6).intern();
+            byte classFileBytes[];
+            classFileBytes = Utils.readZipEntryIntoBuffer(jarFile, jarEntry);
+            long classFileFP = computeFP(classFileBytes);
+
+            PCDEntry pcde = pcd.get(fullClassName);
+            if (pcde != null) {
+                if (pcde.checked) {
+                    throw new PrivateException(new PublicExceptions.DoubleEntryException(
+                            "Two entries for class " + fullClassName + " detected: " + pcde.javaFileFullPath + " and " + jarFileName));
+                }
+                pcde.checked = true;
+                pcde.newClassFileLastModified = jarFileLastMod;
+                // If we are scanning an existing updated .jar file, and there is no change to the class itself,
+                // and it previously was located in the same .jar, do nothing.
+                if (pcde.oldClassFileFingerprint == classFileFP &&
+                        pcde.javaFileFullPath.equals(jarFileName)) {
+                    pcde.oldClassFileLastModified = jarFileLastMod;   // So that next time jmake is inoked, checking
+                    continue;                                         // of this.jar is not triggered.
+                }
+                if (pcde.oldClassFileFingerprint != classFileFP) {  // This class has been updated
+                    updatedClasses.add(fullClassName);
+                    allUpdatedClasses.add(fullClassName);
+                    pcde.newClassFileLastModified = jarFileLastMod;
+                    pcde.newClassFileFingerprint = classFileFP;
+                    pcde.newClassInfo =
+                            new ClassInfo(classFileBytes, ClassInfo.VER_NEW, this, fullClassName);
+                    if (pcde.oldClassInfo.nestedClasses != null || pcde.newClassInfo.nestedClasses != null) {
+                        updatedEntries.add(pcde);
+                    }
+                } else {
+                    pcde.oldClassFileLastModified = jarFileLastMod;
+                }
+                if (!pcde.javaFileFullPath.equals(jarFileName)) {
+                    // Found an existing class in a different .jar file.
+                    // May happen if the class file has been moved from one .jar to another (or into a .jar, losing its
+                    // .java source). It's only at this point that we can actually see that it was really a move.
+                    if (deletedClasses.contains(fullClassName)) {
+                        deletedClasses.remove(fullClassName);
+                    }
+                    if (pcde.oldClassInfo.nestedClasses != null) {
+                        movedEntries.add(pcde);
+                        pcde.newClassInfo =
+                                new ClassInfo(classFileBytes, ClassInfo.VER_NEW, this, fullClassName);
+                    }
+                }
+                pcde.javaFileFullPath = jarFileName;
+            } else {  // New class file
+                ClassInfo classInfo =
+                        new ClassInfo(classFileBytes, ClassInfo.VER_NEW, this, fullClassName);
+                pcde = new PCDEntry(fullClassName,
+                        jarFileName,
+                        jarFileName, jarFileLastMod, classFileFP,
+                        classInfo);
+                pcde.checkResult = PCDEntry.CV_NEW;          // So that later it's promoted into oldClassInfo correctly
+                updatedAndCheckedClasses.add(fullClassName); // So that the above happens
+                pcd.put(fullClassName, pcde);
+                if (pcde.newClassInfo.nestedClasses != null) {
+                    newEntries.add(pcde);
+                }
+            }
+        }
+
+        dealWithNestedClassesForUpdatedPCDEntries(updatedEntries, false);
+        dealWithNestedClassesForUpdatedPCDEntries(movedEntries, true);
+        for (int i = 0; i < newEntries.size(); i++) {
+            findAndUpdateAllNestedClassesForClass(newEntries.get(i), false);
+        }
+    }
+
+    /** Determine new, deleted and updated classes coming from updated .jar files. */
+    private void dealWithClassesInUpdatedJarFiles() {
+        if (updatedJarFiles.size() == 0) {
+            return;
+        }
+
+        for (String updatedJarFile : updatedJarFiles) {
+            processAllClassesFromJarFile(updatedJarFile);
+        }
+
+        // Now scan the PCD to check which classes that come from updated .jar files have not been marked as checked
+        for (PCDEntry pcde : entries()) {
+            if (updatedJarFiles.contains(pcde.javaFileFullPath)) {
+                if (!pcde.checked) {
+                    deletedClasses.add(pcde.className);
+                }
+            }
+        }
+    }
+
+    /** Check if the destination directory exists, and get the canonical path for it. */
+    private void initializeDestDir(String inDestDir) {
+        if (!(inDestDir == null || inDestDir.equals(""))) {
+            File dir = Utils.checkOrCreateDirForName(inDestDir);
+            if (dir == null) {
+                throw new PrivateException(new IOException("specified directory " + inDestDir + " cannot be created."));
+            }
+            inDestDir = getCanonicalPath(dir);
+            if (!inDestDir.endsWith(File.separator)) {
+                inDestDir += File.separatorChar;
+            }
+            destDir = inDestDir;
+            destDirSpecified = true;
+        } else {
+            destDirSpecified = false;
+        }
+    }
+
+    /**
+     * For the given PCDEntry, set the entry.classFileFullPath according to the value of the .java file full
+     * path and the value of the "-d" option at this particular jmake invocation
+     */
+    private void initializeClassFileFullPath(PCDEntry entry) {
+        String classFileFullPath;
+        if (destDirSpecified) {
+            classFileFullPath = destDir + entry.className + ".class";
+        } else {
+            String javaFileDir = entry.javaFileFullPath;
+            int cutIndex = javaFileDir.lastIndexOf(File.separatorChar);
+            if (cutIndex != -1) {
+                javaFileDir = javaFileDir.substring(0, cutIndex + 1);
+            }
+            String classFileName = entry.className;
+            cutIndex = classFileName.lastIndexOf('/');
+            if (cutIndex != -1) {
+                classFileName = classFileName.substring(cutIndex + 1);
+            }
+            classFileFullPath = javaFileDir + classFileName + ".class";
+        }
+        if (backSlashFileSeparator) {
+            classFileFullPath =
+                    classFileFullPath.replace('/', File.separatorChar);
+        }
+        entry.classFileFullPath = classFileFullPath;
+    }
+
+    private static String getCanonicalPath(File file) {
+        try {
+            return file.getCanonicalPath().intern();
+        } catch (IOException e) {
+            throw new PrivateException(e);
+        }
+    }
+
+    private long computeFP(File file) {
+        byte buf[] = Utils.readFileIntoBuffer(file);
+        return computeFP(buf);
+    }
+
+    private long computeFP(byte[] buf) {
+        checkSum.reset();
+        checkSum.update(buf);
+        return checkSum.getValue();
+    }
+
+    private PrivateException compilerInteractionException(String message, Exception origException, int errCode) {
+        return new PrivateException(new PublicExceptions.CompilerInteractionException(message, origException, errCode));
+    }
+
+    private PrivateException internalException(String message) {
+        return new PrivateException(new PublicExceptions.InternalException(message));
+    }
+}