--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/share/tools/MakeDeps/BuildConfig.java	Sat Dec 01 00:00:00 2007 +0000
@@ -0,0 +1,706 @@
+/*
+ * Copyright 2005-2006 Sun Microsystems, Inc.  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.
+ *
+ * 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ *
+ */
+
+import java.util.*;
+import java.io.File;
+
+class BuildConfig {
+    Hashtable vars;
+    Vector basicNames, basicPaths;
+    String[] context;
+
+    static CompilerInterface ci;
+    static CompilerInterface getCI() {
+        if (ci == null) {
+            String comp = (String)getField(null, "CompilerVersion");
+            try {
+                ci = (CompilerInterface)Class.forName("CompilerInterface" + comp).newInstance();
+            } catch (Exception cnfe) {
+                System.err.println("Cannot find support for compiler " + comp);
+                throw new RuntimeException(cnfe.toString());
+            }
+        }
+        return ci;
+    }
+
+    protected void initNames(String flavour, String build, String outDll) {
+        if (vars == null) vars = new Hashtable();
+
+        String flavourBuild =  flavour + "_" + build;
+        put("Name", getCI().makeCfgName(flavourBuild));
+        put("Flavour", flavour);
+        put("Build", build);
+
+        // ones mentioned above were needed to expand format
+        String buildBase = expandFormat(getFieldString(null, "BuildBase"));
+        String jdkDir =  getFieldString(null, "JdkTargetRoot");
+        String sourceBase = getFieldString(null, "SourceBase");
+        String outDir = buildBase;
+
+        put("Id", flavourBuild);
+        put("OutputDir", outDir);
+        put("SourceBase", sourceBase);
+        put("BuildBase", buildBase);
+        put("OutputDll", jdkDir + Util.sep + outDll);
+
+        context = new String [] {flavourBuild, flavour, build, null};
+    }
+
+    protected void init(Vector includes, Vector defines) {
+        initDefaultDefines(defines);
+        initDefaultCompilerFlags(includes);
+        initDefaultLinkerFlags();
+        handleDB((String)getFieldInContext("IncludeDB"));
+    }
+
+
+    protected void initDefaultCompilerFlags(Vector includes) {
+        Vector compilerFlags = new Vector();
+
+        compilerFlags.addAll(getCI().getBaseCompilerFlags(getV("Define"),
+                                                          includes,
+                                                          get("OutputDir")));
+
+        put("CompilerFlags", compilerFlags);
+    }
+
+    protected void initDefaultLinkerFlags() {
+        Vector linkerFlags = new Vector();
+
+        linkerFlags.addAll(getCI().getBaseLinkerFlags( get("OutputDir"), get("OutputDll")));
+
+        put("LinkerFlags", linkerFlags);
+    }
+
+    DirectoryTree getSourceTree(String sourceBase, String startAt) {
+        DirectoryTree tree = new DirectoryTree();
+
+        tree.addSubdirToIgnore("Codemgr_wsdata");
+        tree.addSubdirToIgnore("deleted_files");
+        tree.addSubdirToIgnore("SCCS");
+        tree.setVerbose(true);
+        if (startAt != null) {
+            tree.readDirectory(sourceBase + File.separator + startAt);
+        } else {
+            tree.readDirectory(sourceBase);
+        }
+
+        return tree;
+    }
+
+
+    Vector getPreferredPaths(Database currentDB) {
+        Vector preferredPaths = new Vector();
+        // In the case of multiple files with the same name in
+        // different subdirectories, prefer the versions specified in
+        // the platform file as the "os_family" and "arch" macros.
+        for (Iterator iter = currentDB.getMacros(); iter.hasNext(); ) {
+            Macro macro = (Macro) iter.next();
+            if (macro.name.equals("os_family") ||
+                macro.name.equals("arch")) {
+                preferredPaths.add(macro.contents);
+            }
+        }
+        // Also prefer "opto" over "adlc" for adlcVMDeps.hpp
+        preferredPaths.add("opto");
+
+        return preferredPaths;
+    }
+
+
+    void handleDB(String dbFile) {
+        WinGammaPlatform platform = (WinGammaPlatform)getField(null, "PlatformObject");
+        Database db = new Database(platform, platform.defaultGrandIncludeThreshold());
+
+        try {
+            File incls = new File(get("OutputDir")+Util.sep+"incls");
+            FileName oldInclTempl = platform.getInclFileTemplate();
+            FileName oldGITempl = platform.getGIFileTemplate();
+            FileName oldGDTempl = platform.getGDFileTemplate();
+
+            platform.setInclFileTemplate(new FileName(platform, incls.getPath()+Util.sep,
+                                                      "_", "", ".incl", "", ""));
+            platform.setGIFileTemplate(new FileName(platform, incls.getPath()+Util.sep,
+                                                    "",  "_precompiled", ".incl", "", ""));
+
+            incls.mkdirs();
+
+            db.get(getFieldString(null, "Platform"), dbFile);
+            db.compute();
+
+            db.put();
+
+            //platform.setInclFileTemplate(oldInclTempl);
+            //platform.setGIFileTemplate(oldInclTempl);
+        } catch (Exception e) {
+            e.printStackTrace();
+            throw new RuntimeException("cannot do db: "+e);
+        }
+
+        putSpecificField("AllFilesHash", computeAllFiles(platform, db));
+    }
+
+
+    void addAll(Iterator i, Hashtable hash,
+                WinGammaPlatform platform, DirectoryTree tree,
+                Vector preferredPaths, Vector filesNotFound, Vector filesDuplicate) {
+        for (; i.hasNext(); ) {
+            String fileName = (String) i.next();
+            if (lookupHashFieldInContext("IgnoreFile", fileName) == null) {
+                String prefixedName = platform.envVarPrefixedFileName(fileName,
+                                                                      0, /* ignored */
+                                                                      tree,
+                                                                      preferredPaths,
+                                                                      filesNotFound,
+                                                                      filesDuplicate);
+                if (prefixedName != null) {
+                    addTo(hash, Util.normalize(prefixedName), fileName);
+                }
+            }
+        }
+    }
+
+    void addTo(Hashtable ht, String key, String value) {
+        ht.put(expandFormat(key), expandFormat(value));
+    }
+
+    Hashtable computeAllFiles(WinGammaPlatform platform, Database db) {
+        Hashtable rv = new Hashtable();
+        DirectoryTree tree = getSourceTree(get("SourceBase"), getFieldString(null, "StartAt"));
+        Vector preferredPaths = getPreferredPaths(db);
+
+        // Hold errors until end
+        Vector filesNotFound = new Vector();
+        Vector filesDuplicate = new Vector();
+
+
+        // find all files
+        Vector dbFiles = new Vector();
+        for (Iterator i=db.getAllFiles().iterator(); i.hasNext(); ) {
+            FileList fl = (FileList) i.next();
+            dbFiles.add(fl.getName());
+        }
+        addAll(dbFiles.iterator(), rv,
+               platform, tree,
+               preferredPaths, filesNotFound, filesDuplicate);
+
+        Vector addFiles = new Vector();
+        collectRelevantVectors(addFiles, "AdditionalFile");
+        addAll(addFiles.iterator(), rv,
+               platform, tree,
+               preferredPaths, filesNotFound, filesDuplicate);
+
+        collectRelevantHashes(rv, "AdditionalGeneratedFile");
+
+        if ((filesNotFound.size() != 0) ||
+            (filesDuplicate.size() != 0)) {
+            System.err.println("Error: some files were not found or " +
+                               "appeared in multiple subdirectories of " +
+                               "directory " + get("SourceBase") + " and could not " +
+                               "be resolved with the os_family and arch " +
+                               "macros in the platform file.");
+            if (filesNotFound.size() != 0) {
+                System.err.println("Files not found:");
+                for (Iterator iter = filesNotFound.iterator();
+                     iter.hasNext(); ) {
+                    System.err.println("  " + (String) iter.next());
+                }
+            }
+            if (filesDuplicate.size() != 0) {
+                System.err.println("Duplicate files:");
+                for (Iterator iter = filesDuplicate.iterator();
+                     iter.hasNext(); ) {
+                    System.err.println("  " + (String) iter.next());
+                }
+            }
+            throw new RuntimeException();
+        }
+
+        return rv;
+    }
+
+    void initDefaultDefines(Vector defines) {
+        Vector sysDefines = new Vector();
+        sysDefines.add("WIN32");
+        sysDefines.add("_WINDOWS");
+        sysDefines.add("HOTSPOT_BUILD_USER="+System.getProperty("user.name"));
+        sysDefines.add("HOTSPOT_BUILD_TARGET=\\\""+get("Build")+"\\\"");
+        sysDefines.add("_JNI_IMPLEMENTATION_");
+
+        sysDefines.addAll(defines);
+
+        put("Define", sysDefines);
+    }
+
+    String get(String key) {
+        return (String)vars.get(key);
+    }
+
+    Vector getV(String key) {
+        return (Vector)vars.get(key);
+    }
+
+    Object getO(String key) {
+        return vars.get(key);
+    }
+
+    Hashtable getH(String key) {
+        return (Hashtable)vars.get(key);
+    }
+
+    Object getFieldInContext(String field) {
+        for (int i=0; i<context.length; i++) {
+            Object rv = getField(context[i], field);
+            if (rv != null) {
+                return rv;
+            }
+        }
+        return null;
+    }
+
+    Object lookupHashFieldInContext(String field, String key) {
+        for (int i=0; i<context.length; i++) {
+            Hashtable ht = (Hashtable)getField(context[i], field);
+            if (ht != null) {
+                Object rv = ht.get(key);
+                if (rv != null) {
+                    return rv;
+                }
+            }
+        }
+        return null;
+    }
+
+    void put(String key, String value) {
+        vars.put(key, value);
+    }
+
+    void put(String key, Vector vvalue) {
+        vars.put(key, vvalue);
+    }
+
+    void add(String key, Vector vvalue) {
+        getV(key).addAll(vvalue);
+    }
+
+    String flavour() {
+        return get("Flavour");
+    }
+
+    String build() {
+        return get("Build");
+    }
+
+    Object getSpecificField(String field) {
+        return getField(get("Id"), field);
+    }
+
+    void putSpecificField(String field, Object value) {
+        putField(get("Id"), field, value);
+    }
+
+    void collectRelevantVectors(Vector rv, String field) {
+        for (int i = 0; i < context.length; i++) {
+            Vector v = getFieldVector(context[i], field);
+            if (v != null) {
+                for (Iterator j=v.iterator(); j.hasNext(); ) {
+                    String val = (String)j.next();
+                    rv.add(expandFormat(val));
+                }
+            }
+        }
+    }
+
+    void collectRelevantHashes(Hashtable rv, String field) {
+        for (int i = 0; i < context.length; i++) {
+            Hashtable v = (Hashtable)getField(context[i], field);
+            if (v != null) {
+                for (Enumeration e=v.keys(); e.hasMoreElements(); ) {
+                    String key = (String)e.nextElement();
+                    String val =  (String)v.get(key);
+                    addTo(rv, key, val);
+                }
+            }
+        }
+    }
+
+
+    Vector getDefines() {
+        Vector rv = new Vector();
+        collectRelevantVectors(rv, "Define");
+        return rv;
+    }
+
+    Vector getIncludes() {
+        Vector rv = new Vector();
+
+        // for generated includes
+        rv.add(get("OutputDir"));
+
+        collectRelevantVectors(rv, "AbsoluteInclude");
+
+        Vector ri = new Vector();
+        String sourceBase = getFieldString(null, "SourceBase");
+        collectRelevantVectors(ri, "RelativeInclude");
+        for (Iterator i = ri.iterator(); i.hasNext(); ) {
+            String f = (String)i.next();
+            rv.add(sourceBase + Util.sep + f);
+        }
+
+        return rv;
+    }
+
+    static Hashtable cfgData = new Hashtable();
+    static Hashtable globalData = new Hashtable();
+
+    static boolean appliesToTieredBuild(String cfg) {
+        return (cfg != null &&
+                (cfg.startsWith("compiler1") ||
+                 cfg.startsWith("compiler2")));
+    }
+
+    // Filters out the IncludeDB statement, which is the only command-
+    // line argument we explicitly specialize for the tiered build
+    static boolean appliesToTieredBuild(String cfg, String key) {
+        return (appliesToTieredBuild(cfg) &&
+                (key != null &&
+                 !key.equals("IncludeDB")));
+    }
+
+    static String getTieredBuildCfg(String cfg) {
+        assert appliesToTieredBuild(cfg) : "illegal configuration " + cfg;
+        return "tiered" + cfg.substring(9);
+    }
+
+    static Object getField(String cfg, String field) {
+        if (cfg == null) {
+            return globalData.get(field);
+        }
+
+        Hashtable ht =  (Hashtable)cfgData.get(cfg);
+        return ht == null ? null : ht.get(field);
+    }
+
+    static String getFieldString(String cfg, String field) {
+        return (String)getField(cfg, field);
+    }
+
+    static Vector getFieldVector(String cfg, String field) {
+        return (Vector)getField(cfg, field);
+    }
+
+    static void putField(String cfg, String field, Object value) {
+        putFieldImpl(cfg, field, value);
+        if (appliesToTieredBuild(cfg, field)) {
+            putFieldImpl(getTieredBuildCfg(cfg), field, value);
+        }
+    }
+
+    private static void putFieldImpl(String cfg, String field, Object value) {
+        if (cfg == null) {
+            globalData.put(field, value);
+            return;
+        }
+
+        Hashtable ht = (Hashtable)cfgData.get(cfg);
+        if (ht == null) {
+            ht = new Hashtable();
+            cfgData.put(cfg, ht);
+        }
+
+        ht.put(field, value);
+    }
+
+    static Object getFieldHash(String cfg, String field, String name) {
+        Hashtable ht = (Hashtable)getField(cfg, field);
+
+        return ht == null ? null : ht.get(name);
+    }
+
+    static void putFieldHash(String cfg, String field, String name, Object val) {
+        putFieldHashImpl(cfg, field, name, val);
+        if (appliesToTieredBuild(cfg)) {
+            putFieldHashImpl(getTieredBuildCfg(cfg), field, name, val);
+        }
+    }
+
+    private static void putFieldHashImpl(String cfg, String field, String name, Object val) {
+        Hashtable ht = (Hashtable)getField(cfg, field);
+
+        if (ht == null) {
+            ht = new Hashtable();
+            putFieldImpl(cfg, field, ht);
+        }
+
+        ht.put(name, val);
+    }
+
+    static void addFieldVector(String cfg, String field, String element) {
+        addFieldVectorImpl(cfg, field, element);
+        if (appliesToTieredBuild(cfg)) {
+            addFieldVectorImpl(getTieredBuildCfg(cfg), field, element);
+        }
+    }
+
+    private static void addFieldVectorImpl(String cfg, String field, String element) {
+        Vector v = (Vector)getField(cfg, field);
+
+        if (v == null) {
+            v = new Vector();
+            putFieldImpl(cfg, field, v);
+        }
+
+        v.add(element);
+    }
+
+    String expandFormat(String format) {
+        if (format == null) {
+            return null;
+        }
+
+        if (format.indexOf('%') == -1) {
+            return format;
+        }
+
+        StringBuffer sb = new StringBuffer();
+        int len = format.length();
+        for (int i=0; i<len; i++) {
+            char ch = format.charAt(i);
+            if (ch == '%') {
+                char ch1 = format.charAt(i+1);
+                switch (ch1) {
+                case '%':
+                    sb.append(ch1);
+                    break;
+                case 'b':
+                    sb.append(build());
+                    break;
+                case 'f':
+                    sb.append(flavour());
+                    break;
+                default:
+                    sb.append(ch);
+                    sb.append(ch1);
+                }
+                i++;
+            } else {
+                sb.append(ch);
+            }
+        }
+
+        return sb.toString();
+    }
+}
+
+abstract class GenericDebugConfig extends BuildConfig {
+    abstract String getOptFlag();
+
+    protected void init(Vector includes, Vector defines) {
+        defines.add("_DEBUG");
+        defines.add("ASSERT");
+
+        super.init(includes, defines);
+
+        getV("CompilerFlags").addAll(getCI().getDebugCompilerFlags(getOptFlag()));
+        getV("LinkerFlags").addAll(getCI().getDebugLinkerFlags());
+   }
+}
+
+class C1DebugConfig extends GenericDebugConfig {
+    String getOptFlag() {
+        return getCI().getNoOptFlag();
+    }
+
+    C1DebugConfig() {
+        initNames("compiler1", "debug", "fastdebug\\jre\\bin\\client\\jvm.dll");
+        init(getIncludes(), getDefines());
+    }
+}
+
+class C1FastDebugConfig extends GenericDebugConfig {
+    String getOptFlag() {
+        return getCI().getOptFlag();
+    }
+
+    C1FastDebugConfig() {
+        initNames("compiler1", "fastdebug", "fastdebug\\jre\\bin\\client\\jvm.dll");
+        init(getIncludes(), getDefines());
+    }
+}
+
+class C2DebugConfig extends GenericDebugConfig {
+    String getOptFlag() {
+        return getCI().getNoOptFlag();
+    }
+
+    C2DebugConfig() {
+        initNames("compiler2", "debug", "fastdebug\\jre\\bin\\server\\jvm.dll");
+        init(getIncludes(), getDefines());
+    }
+}
+
+class C2FastDebugConfig extends GenericDebugConfig {
+    String getOptFlag() {
+        return getCI().getOptFlag();
+    }
+
+    C2FastDebugConfig() {
+        initNames("compiler2", "fastdebug", "fastdebug\\jre\\bin\\server\\jvm.dll");
+        init(getIncludes(), getDefines());
+    }
+}
+
+class TieredDebugConfig extends GenericDebugConfig {
+    String getOptFlag() {
+        return getCI().getNoOptFlag();
+    }
+
+    TieredDebugConfig() {
+        initNames("tiered", "debug", "fastdebug\\jre\\bin\\server\\jvm.dll");
+        init(getIncludes(), getDefines());
+    }
+}
+
+class TieredFastDebugConfig extends GenericDebugConfig {
+    String getOptFlag() {
+        return getCI().getOptFlag();
+    }
+
+    TieredFastDebugConfig() {
+        initNames("tiered", "fastdebug", "fastdebug\\jre\\bin\\server\\jvm.dll");
+        init(getIncludes(), getDefines());
+    }
+}
+
+
+abstract class ProductConfig extends BuildConfig {
+    protected void init(Vector includes, Vector defines) {
+        defines.add("NDEBUG");
+        defines.add("PRODUCT");
+
+        super.init(includes, defines);
+
+        getV("CompilerFlags").addAll(getCI().getProductCompilerFlags());
+        getV("LinkerFlags").addAll(getCI().getProductLinkerFlags());
+    }
+}
+
+class C1ProductConfig extends ProductConfig {
+    C1ProductConfig() {
+        initNames("compiler1", "product", "jre\\bin\\client\\jvm.dll");
+        init(getIncludes(), getDefines());
+    }
+}
+
+class C2ProductConfig extends ProductConfig {
+    C2ProductConfig() {
+        initNames("compiler2", "product", "jre\\bin\\server\\jvm.dll");
+        init(getIncludes(), getDefines());
+    }
+}
+
+class TieredProductConfig extends ProductConfig {
+    TieredProductConfig() {
+        initNames("tiered", "product", "jre\\bin\\server\\jvm.dll");
+        init(getIncludes(), getDefines());
+    }
+}
+
+
+class CoreDebugConfig extends GenericDebugConfig {
+    String getOptFlag() {
+        return getCI().getNoOptFlag();
+    }
+
+    CoreDebugConfig() {
+        initNames("core", "debug", "fastdebug\\jre\\bin\\core\\jvm.dll");
+        init(getIncludes(), getDefines());
+    }
+}
+
+
+class CoreFastDebugConfig extends GenericDebugConfig {
+    String getOptFlag() {
+        return getCI().getOptFlag();
+    }
+
+    CoreFastDebugConfig() {
+        initNames("core", "fastdebug", "fastdebug\\jre\\bin\\core\\jvm.dll");
+        init(getIncludes(), getDefines());
+    }
+}
+
+
+class CoreProductConfig extends ProductConfig {
+    CoreProductConfig() {
+        initNames("core", "product", "jre\\bin\\core\\jvm.dll");
+        init(getIncludes(), getDefines());
+    }
+}
+
+class KernelDebugConfig extends GenericDebugConfig {
+    String getOptFlag() {
+        return getCI().getNoOptFlag();
+    }
+
+    KernelDebugConfig() {
+        initNames("kernel", "debug", "fastdebug\\jre\\bin\\kernel\\jvm.dll");
+        init(getIncludes(), getDefines());
+    }
+}
+
+
+class KernelFastDebugConfig extends GenericDebugConfig {
+    String getOptFlag() {
+        return getCI().getOptFlag();
+    }
+
+    KernelFastDebugConfig() {
+        initNames("kernel", "fastdebug", "fastdebug\\jre\\bin\\kernel\\jvm.dll");
+        init(getIncludes(), getDefines());
+    }
+}
+
+
+class KernelProductConfig extends ProductConfig {
+    KernelProductConfig() {
+        initNames("kernel", "product", "jre\\bin\\kernel\\jvm.dll");
+        init(getIncludes(), getDefines());
+    }
+}
+abstract class CompilerInterface {
+    abstract Vector getBaseCompilerFlags(Vector defines, Vector includes, String outDir);
+    abstract Vector getBaseLinkerFlags(String outDir, String outDll);
+    abstract Vector getDebugCompilerFlags(String opt);
+    abstract Vector getDebugLinkerFlags();
+    abstract Vector getProductCompilerFlags();
+    abstract Vector getProductLinkerFlags();
+    abstract String getOptFlag();
+    abstract String getNoOptFlag();
+    abstract String makeCfgName(String flavourBuild);
+
+    void addAttr(Vector receiver, String attr, String value) {
+        receiver.add(attr); receiver.add(value);
+    }
+}