| /* |
| * Copyright 1999-2007 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.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 extends Platform { |
| public void setupFileTemplates() { |
| inclFileTemplate = new FileName(this, |
| "incls\\", "_", "", ".incl", "", "" |
| ); |
| giFileTemplate = new FileName(this, |
| "incls\\", "", "_precompiled", ".incl", "", "" |
| ); |
| gdFileTemplate = new FileName(this, |
| "", "", "Dependencies", "", "", "" |
| ); |
| } |
| |
| private static String[] suffixes = { ".cpp", ".c" }; |
| |
| public String[] outerSuffixes() { |
| return suffixes; |
| } |
| |
| public String objFileSuffix() { |
| return ".obj"; |
| } |
| |
| public String asmFileSuffix() { |
| return ".i"; |
| } |
| |
| public String dependentPrefix() { |
| return "$(VM_PATH)"; |
| } |
| |
| public boolean includeGIInEachIncl() { |
| return false; |
| } |
| |
| 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, like " + |
| "includeDB_core>"); |
| 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 boolean databaseAllFilesEqual(Database previousDB, |
| Database currentDB) { |
| Iterator i1 = previousDB.getAllFiles().iterator(); |
| Iterator i2 = currentDB.getAllFiles().iterator(); |
| |
| while (i1.hasNext() && i2.hasNext()) { |
| FileList fl1 = (FileList) i1.next(); |
| FileList fl2 = (FileList) i2.next(); |
| if (!fl1.getName().equals(fl2.getName())) { |
| return false; |
| } |
| } |
| |
| if (i1.hasNext() != i2.hasNext()) { |
| // Different lengths |
| return false; |
| } |
| |
| return true; |
| } |
| |
| 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 writePlatformSpecificFiles(Database previousDB, |
| Database currentDB, String[] args) |
| throws IllegalArgumentException, IOException { |
| |
| parseArguments(args); |
| |
| String projectFileName = BuildConfig.getFieldString(null, "ProjectFileName"); |
| String ext = getProjectExt(); |
| |
| // Compare contents of allFiles of previousDB and includeDB. |
| // If these haven't changed, then skip writing the .vcproj file. |
| if (false && databaseAllFilesEqual(previousDB, currentDB) && |
| new File(projectFileName).exists()) { |
| System.out.println( |
| " Databases unchanged; skipping overwrite of "+ext+" file." |
| ); |
| return; |
| } |
| |
| 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 setInclFileTemplate(FileName val) { |
| this.inclFileTemplate = val; |
| } |
| |
| void setGIFileTemplate(FileName val) { |
| this.giFileTemplate = val; |
| } |
| |
| |
| 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("-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(); |
| // we ignore files that we know are generated, so we coudn't |
| // find them in sources |
| BuildConfig.putFieldHash(cfg, "IgnoreFile", fileName, "1"); |
| BuildConfig.putFieldHash(cfg, "AdditionalGeneratedFile", |
| Util.normalize(dir + Util.sep + fileName), |
| fileName); |
| it.next(); |
| return; |
| } |
| } |
| empty(null, "** Error: wrong number of args to -additionalGeneratedFile"); |
| } |
| } |
| ), |
| |
| new HsArgRule("-includeDB", |
| "IncludeDB", |
| null, |
| HsArgHandler.STRING |
| ), |
| |
| 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"); |
| } |
| } |
