--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/src/share/tools/ProjectCreator/WinGammaPlatform.java Tue Nov 23 13:22:55 2010 -0800
@@ -0,0 +1,687 @@
+/*
+ * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+
+import java.io.*;
+import java.util.*;
+
+abstract class HsArgHandler extends ArgHandler {
+ static final int STRING = 1;
+ static final int VECTOR = 2;
+ static final int HASH = 3;
+
+ boolean nextNotKey(ArgIterator it) {
+ if (it.next()) {
+ String s = it.get();
+ return (s.length() == 0) || (s.charAt(0) != '-');
+ } else {
+ return false;
+ }
+ }
+
+ void empty(String key, String message) {
+ if (key != null) {
+ System.err.println("** Error: empty " + key);
+ }
+ if (message != null) {
+ System.err.println(message);
+ }
+ WinGammaPlatform.usage();
+ }
+
+ static String getCfg(String val) {
+ int under = val.indexOf('_');
+ int len = val.length();
+ if (under != -1 && under < len - 1) {
+ return val.substring(under+1, len);
+ } else {
+ return null;
+ }
+ }
+}
+
+class ArgRuleSpecific extends ArgRule {
+ ArgRuleSpecific(String arg, ArgHandler handler) {
+ super(arg, handler);
+ }
+
+ boolean match(String rulePattern, String arg) {
+ return rulePattern.startsWith(arg);
+ }
+}
+
+
+class SpecificHsArgHandler extends HsArgHandler {
+
+ String message, argKey, valKey;
+ int type;
+
+ public void handle(ArgIterator it) {
+ String cfg = getCfg(it.get());
+ if (nextNotKey(it)) {
+ String val = it.get();
+ switch (type) {
+ case VECTOR:
+ BuildConfig.addFieldVector(cfg, valKey, val);
+ break;
+ case HASH:
+ BuildConfig.putFieldHash(cfg, valKey, val, "1");
+ break;
+ case STRING:
+ BuildConfig.putField(cfg, valKey, val);
+ break;
+ default:
+ empty(valKey, "Unknown type: "+type);
+ }
+ it.next();
+
+ } else {
+ empty(argKey, message);
+ }
+ }
+
+ SpecificHsArgHandler(String argKey, String valKey, String message, int type) {
+ this.argKey = argKey;
+ this.valKey = valKey;
+ this.message = message;
+ this.type = type;
+ }
+}
+
+
+class HsArgRule extends ArgRuleSpecific {
+
+ HsArgRule(String argKey, String valKey, String message, int type) {
+ super(argKey, new SpecificHsArgHandler(argKey, valKey, message, type));
+ }
+
+}
+
+public abstract class WinGammaPlatform {
+
+ public boolean fileNameStringEquality(String s1, String s2) {
+ return s1.equalsIgnoreCase(s2);
+ }
+
+ static void usage() throws IllegalArgumentException {
+ System.err.println("WinGammaPlatform platform-specific options:");
+ System.err.println(" -sourceBase <path to directory (workspace) " +
+ "containing source files; no trailing slash>");
+ System.err.println(" -projectFileName <full pathname to which project file " +
+ "will be written; all parent directories must " +
+ "already exist>");
+ System.err.println(" If any of the above are specified, "+
+ "they must all be.");
+ System.err.println(" Additional, optional arguments, which can be " +
+ "specified multiple times:");
+ System.err.println(" -absoluteInclude <string containing absolute " +
+ "path to include directory>");
+ System.err.println(" -relativeInclude <string containing include " +
+ "directory relative to -sourceBase>");
+ System.err.println(" -define <preprocessor flag to be #defined " +
+ "(note: doesn't yet support " +
+ "#define (flag) (value))>");
+ System.err.println(" -startAt <subdir of sourceBase>");
+ System.err.println(" -additionalFile <file not in database but " +
+ "which should show up in project file>");
+ System.err.println(" -additionalGeneratedFile <absolute path to " +
+ "directory containing file; no trailing slash> " +
+ "<name of file generated later in the build process>");
+ throw new IllegalArgumentException();
+ }
+
+
+ public void addPerFileLine(Hashtable table,
+ String fileName,
+ String line) {
+ Vector v = (Vector) table.get(fileName);
+ if (v != null) {
+ v.add(line);
+ } else {
+ v = new Vector();
+ v.add(line);
+ table.put(fileName, v);
+ }
+ }
+
+ protected static class PerFileCondData {
+ public String releaseString;
+ public String debugString;
+ }
+
+ protected void addConditionalPerFileLine(Hashtable table,
+ String fileName,
+ String releaseLine,
+ String debugLine) {
+ PerFileCondData data = new PerFileCondData();
+ data.releaseString = releaseLine;
+ data.debugString = debugLine;
+ Vector v = (Vector) table.get(fileName);
+ if (v != null) {
+ v.add(data);
+ } else {
+ v = new Vector();
+ v.add(data);
+ table.put(fileName, v);
+ }
+ }
+
+ protected static class PrelinkCommandData {
+ String description;
+ String commands;
+ }
+
+ protected void addPrelinkCommand(Hashtable table,
+ String build,
+ String description,
+ String commands) {
+ PrelinkCommandData data = new PrelinkCommandData();
+ data.description = description;
+ data.commands = commands;
+ table.put(build, data);
+ }
+
+ public boolean findString(Vector v, String s) {
+ for (Iterator iter = v.iterator(); iter.hasNext(); ) {
+ if (((String) iter.next()).equals(s)) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ /* This returns a String containing the full path to the passed
+ file name, or null if an error occurred. If the file was not
+ found or was a duplicate and couldn't be resolved using the
+ preferred paths, the file name is added to the appropriate
+ Vector of Strings. */
+ private String findFileInDirectory(String fileName,
+ DirectoryTree directory,
+ Vector preferredPaths,
+ Vector filesNotFound,
+ Vector filesDuplicate) {
+ List locationsInTree = directory.findFile(fileName);
+ int rootNameLength = directory.getRootNodeName().length();
+ String name = null;
+ if ((locationsInTree == null) ||
+ (locationsInTree.size() == 0)) {
+ filesNotFound.add(fileName);
+ } else if (locationsInTree.size() > 1) {
+ // We shouldn't have duplicate file names in our workspace.
+ System.err.println();
+ System.err.println("There are multiple files named as: " + fileName);
+ System.exit(-1);
+ // The following code could be safely removed if we don't need duplicate
+ // file names.
+
+ // Iterate through them, trying to find one with a
+ // preferred path
+ search:
+ {
+ for (Iterator locIter = locationsInTree.iterator();
+ locIter.hasNext(); ) {
+ DirectoryTreeNode node =
+ (DirectoryTreeNode) locIter.next();
+ String tmpName = node.getName();
+ for (Iterator prefIter = preferredPaths.iterator();
+ prefIter.hasNext(); ) {
+ // We need to make sure the preferred path is
+ // found from the file path not including the root node name.
+ if (tmpName.indexOf((String)prefIter.next(),
+ rootNameLength) != -1) {
+ name = tmpName;
+ break search;
+ }
+ }
+ }
+ }
+
+ if (name == null) {
+ filesDuplicate.add(fileName);
+ }
+ } else {
+ name = ((DirectoryTreeNode) locationsInTree.get(0)).getName();
+ }
+
+ return name;
+ }
+
+ protected String envVarPrefixedFileName(String fileName,
+ int sourceBaseLen,
+ DirectoryTree tree,
+ Vector preferredPaths,
+ Vector filesNotFound,
+ Vector filesDuplicate) {
+ String fullName = findFileInDirectory(fileName,
+ tree,
+ preferredPaths,
+ filesNotFound,
+ filesDuplicate);
+ return fullName;
+ }
+
+ String getProjectName(String fullPath, String extension)
+ throws IllegalArgumentException, IOException {
+ File file = new File(fullPath).getCanonicalFile();
+ fullPath = file.getCanonicalPath();
+ String parent = file.getParent();
+
+ if (!fullPath.endsWith(extension)) {
+ throw new IllegalArgumentException("project file name \"" +
+ fullPath +
+ "\" does not end in "+extension);
+ }
+
+ if ((parent != null) &&
+ (!fullPath.startsWith(parent))) {
+ throw new RuntimeException(
+ "Internal error: parent of file name \"" + parent +
+ "\" does not match file name \"" + fullPath + "\""
+ );
+ }
+
+ int len = parent.length();
+ if (!parent.endsWith(Util.sep)) {
+ len += Util.sep.length();
+ }
+
+ int end = fullPath.length() - extension.length();
+
+ if (len == end) {
+ throw new RuntimeException(
+ "Internal error: file name was empty"
+ );
+ }
+
+ return fullPath.substring(len, end);
+ }
+
+ protected abstract String getProjectExt();
+
+ public void createVcproj(String[] args)
+ throws IllegalArgumentException, IOException {
+
+ parseArguments(args);
+
+ String projectFileName = BuildConfig.getFieldString(null, "ProjectFileName");
+ String ext = getProjectExt();
+
+ String projectName = getProjectName(projectFileName, ext);
+
+ writeProjectFile(projectFileName, projectName, createAllConfigs());
+ }
+
+ protected void writePrologue(String[] args) {
+ System.err.println("WinGammaPlatform platform-specific arguments:");
+ for (int i = 0; i < args.length; i++) {
+ System.err.print(args[i] + " ");
+ }
+ System.err.println();
+ }
+
+
+ void parseArguments(String[] args) {
+ new ArgsParser(args,
+ new ArgRule[]
+ {
+ new HsArgRule("-sourceBase",
+ "SourceBase",
+ " (Did you set the HotSpotWorkSpace environment variable?)",
+ HsArgHandler.STRING
+ ),
+
+ new HsArgRule("-buildBase",
+ "BuildBase",
+ " (Did you set the HotSpotBuildSpace environment variable?)",
+ HsArgHandler.STRING
+ ),
+
+ new HsArgRule("-projectFileName",
+ "ProjectFileName",
+ null,
+ HsArgHandler.STRING
+ ),
+
+ new HsArgRule("-jdkTargetRoot",
+ "JdkTargetRoot",
+ " (Did you set the HotSpotJDKDist environment variable?)",
+ HsArgHandler.STRING
+ ),
+
+ new HsArgRule("-compiler",
+ "CompilerVersion",
+ " (Did you set the VcVersion correctly?)",
+ HsArgHandler.STRING
+ ),
+
+ new HsArgRule("-platform",
+ "Platform",
+ null,
+ HsArgHandler.STRING
+ ),
+
+ new HsArgRule("-absoluteInclude",
+ "AbsoluteInclude",
+ null,
+ HsArgHandler.VECTOR
+ ),
+
+ new HsArgRule("-relativeInclude",
+ "RelativeInclude",
+ null,
+ HsArgHandler.VECTOR
+ ),
+
+ new HsArgRule("-define",
+ "Define",
+ null,
+ HsArgHandler.VECTOR
+ ),
+
+ new HsArgRule("-useToGeneratePch",
+ "UseToGeneratePch",
+ null,
+ HsArgHandler.STRING
+ ),
+
+ new ArgRuleSpecific("-perFileLine",
+ new HsArgHandler() {
+ public void handle(ArgIterator it) {
+ String cfg = getCfg(it.get());
+ if (nextNotKey(it)) {
+ String fileName = it.get();
+ if (nextNotKey(it)) {
+ String line = it.get();
+ BuildConfig.putFieldHash(cfg, "PerFileLine", fileName, line);
+ it.next();
+ return;
+ }
+ }
+ empty(null, "** Error: wrong number of args to -perFileLine");
+ }
+ }
+ ),
+
+ new ArgRuleSpecific("-conditionalPerFileLine",
+ new HsArgHandler() {
+ public void handle(ArgIterator it) {
+ String cfg = getCfg(it.get());
+ if (nextNotKey(it)) {
+ String fileName = it.get();
+ if (nextNotKey(it)) {
+ String productLine = it.get();
+ if (nextNotKey(it)) {
+ String debugLine = it.get();
+ BuildConfig.putFieldHash(cfg+"_debug", "CondPerFileLine",
+ fileName, debugLine);
+ BuildConfig.putFieldHash(cfg+"_product", "CondPerFileLine",
+ fileName, productLine);
+ it.next();
+ return;
+ }
+ }
+ }
+
+ empty(null, "** Error: wrong number of args to -conditionalPerFileLine");
+ }
+ }
+ ),
+
+ new HsArgRule("-disablePch",
+ "DisablePch",
+ null,
+ HsArgHandler.HASH
+ ),
+
+ new ArgRule("-startAt",
+ new HsArgHandler() {
+ public void handle(ArgIterator it) {
+ if (BuildConfig.getField(null, "StartAt") != null) {
+ empty(null, "** Error: multiple -startAt");
+ }
+ if (nextNotKey(it)) {
+ BuildConfig.putField(null, "StartAt", it.get());
+ it.next();
+ } else {
+ empty("-startAt", null);
+ }
+ }
+ }
+ ),
+
+ new HsArgRule("-ignoreFile",
+ "IgnoreFile",
+ null,
+ HsArgHandler.HASH
+ ),
+
+ new HsArgRule("-ignorePath",
+ "IgnorePath",
+ null,
+ HsArgHandler.VECTOR
+ ),
+
+ new HsArgRule("-additionalFile",
+ "AdditionalFile",
+ null,
+ HsArgHandler.VECTOR
+ ),
+
+ new ArgRuleSpecific("-additionalGeneratedFile",
+ new HsArgHandler() {
+ public void handle(ArgIterator it) {
+ String cfg = getCfg(it.get());
+ if (nextNotKey(it)) {
+ String dir = it.get();
+ if (nextNotKey(it)) {
+ String fileName = it.get();
+ BuildConfig.putFieldHash(cfg, "AdditionalGeneratedFile",
+ Util.normalize(dir + Util.sep + fileName),
+ fileName);
+ it.next();
+ return;
+ }
+ }
+ empty(null, "** Error: wrong number of args to -additionalGeneratedFile");
+ }
+ }
+ ),
+
+ new ArgRule("-prelink",
+ new HsArgHandler() {
+ public void handle(ArgIterator it) {
+ if (nextNotKey(it)) {
+ String build = it.get();
+ if (nextNotKey(it)) {
+ String description = it.get();
+ if (nextNotKey(it)) {
+ String command = it.get();
+ BuildConfig.putField(null, "PrelinkDescription", description);
+ BuildConfig.putField(null, "PrelinkCommand", command);
+ it.next();
+ return;
+ }
+ }
+ }
+
+ empty(null, "** Error: wrong number of args to -prelink");
+ }
+ }
+ )
+ },
+ new ArgHandler() {
+ public void handle(ArgIterator it) {
+
+ throw new RuntimeException("Arg Parser: unrecognized option "+it.get());
+ }
+ }
+ );
+ if (BuildConfig.getField(null, "SourceBase") == null ||
+ BuildConfig.getField(null, "BuildBase") == null ||
+ BuildConfig.getField(null, "ProjectFileName") == null ||
+ BuildConfig.getField(null, "CompilerVersion") == null) {
+ usage();
+ }
+
+ if (BuildConfig.getField(null, "UseToGeneratePch") == null) {
+ throw new RuntimeException("ERROR: need to specify one file to compute PCH, with -useToGeneratePch flag");
+ }
+
+ BuildConfig.putField(null, "PlatformObject", this);
+ }
+
+ Vector createAllConfigs() {
+ Vector allConfigs = new Vector();
+
+ allConfigs.add(new C1DebugConfig());
+
+ boolean b = true;
+ if (b) {
+ allConfigs.add(new C1FastDebugConfig());
+ allConfigs.add(new C1ProductConfig());
+
+ allConfigs.add(new C2DebugConfig());
+ allConfigs.add(new C2FastDebugConfig());
+ allConfigs.add(new C2ProductConfig());
+
+ allConfigs.add(new TieredDebugConfig());
+ allConfigs.add(new TieredFastDebugConfig());
+ allConfigs.add(new TieredProductConfig());
+
+ allConfigs.add(new CoreDebugConfig());
+ allConfigs.add(new CoreFastDebugConfig());
+ allConfigs.add(new CoreProductConfig());
+
+ allConfigs.add(new KernelDebugConfig());
+ allConfigs.add(new KernelFastDebugConfig());
+ allConfigs.add(new KernelProductConfig());
+ }
+
+ return allConfigs;
+ }
+
+ class FileAttribute {
+ int numConfigs;
+ Vector configs;
+ String shortName;
+ boolean noPch, pchRoot;
+
+ FileAttribute(String shortName, BuildConfig cfg, int numConfigs) {
+ this.shortName = shortName;
+ this.noPch = (cfg.lookupHashFieldInContext("DisablePch", shortName) != null);
+ this.pchRoot = shortName.equals(BuildConfig.getFieldString(null, "UseToGeneratePch"));
+ this.numConfigs = numConfigs;
+
+ configs = new Vector();
+ add(cfg.get("Name"));
+ }
+
+ void add(String confName) {
+ configs.add(confName);
+
+ // if presented in all configs
+ if (configs.size() == numConfigs) {
+ configs = null;
+ }
+ }
+ }
+
+ class FileInfo implements Comparable {
+ String full;
+ FileAttribute attr;
+
+ FileInfo(String full, FileAttribute attr) {
+ this.full = full;
+ this.attr = attr;
+ }
+
+ public int compareTo(Object o) {
+ FileInfo oo = (FileInfo)o;
+ // Don't squelch identical short file names where the full
+ // paths are different
+ if (!attr.shortName.equals(oo.attr.shortName))
+ return attr.shortName.compareTo(oo.attr.shortName);
+ return full.compareTo(oo.full);
+ }
+
+ boolean isHeader() {
+ return attr.shortName.endsWith(".h") || attr.shortName.endsWith(".hpp");
+ }
+ }
+
+
+ TreeSet sortFiles(Hashtable allFiles) {
+ TreeSet rv = new TreeSet();
+ Enumeration e = allFiles.keys();
+ while (e.hasMoreElements()) {
+ String fullPath = (String)e.nextElement();
+ rv.add(new FileInfo(fullPath, (FileAttribute)allFiles.get(fullPath)));
+ }
+ return rv;
+ }
+
+ Hashtable computeAttributedFiles(Vector allConfigs) {
+ Hashtable ht = new Hashtable();
+ int numConfigs = allConfigs.size();
+
+ for (Iterator i = allConfigs.iterator(); i.hasNext(); ) {
+ BuildConfig bc = (BuildConfig)i.next();
+ Hashtable confFiles = (Hashtable)bc.getSpecificField("AllFilesHash");
+ String confName = bc.get("Name");
+
+ for (Enumeration e=confFiles.keys(); e.hasMoreElements(); ) {
+ String filePath = (String)e.nextElement();
+ FileAttribute fa = (FileAttribute)ht.get(filePath);
+
+ if (fa == null) {
+ fa = new FileAttribute((String)confFiles.get(filePath), bc, numConfigs);
+ ht.put(filePath, fa);
+ } else {
+ fa.add(confName);
+ }
+ }
+ }
+
+ return ht;
+ }
+
+ Hashtable computeAttributedFiles(BuildConfig bc) {
+ Hashtable ht = new Hashtable();
+ Hashtable confFiles = (Hashtable)bc.getSpecificField("AllFilesHash");
+
+ for (Enumeration e = confFiles.keys(); e.hasMoreElements(); ) {
+ String filePath = (String)e.nextElement();
+ ht.put(filePath, new FileAttribute((String)confFiles.get(filePath), bc, 1));
+ }
+
+ return ht;
+ }
+
+ PrintWriter printWriter;
+
+ public void writeProjectFile(String projectFileName, String projectName,
+ Vector allConfigs) throws IOException {
+ throw new RuntimeException("use compiler version specific version");
+ }
+}