1 /*

     2  * Copyright 1999-2007 Sun Microsystems, Inc.  All Rights Reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

    20  * CA 95054 USA or visit www.sun.com if you need additional information or

    21  * have any questions.

    22  *

    23  */

    24 

    25 import java.io.*;

    26 import java.util.*;

    27 

    28 abstract class HsArgHandler extends ArgHandler {

    29     static final int STRING = 1;

    30     static final int VECTOR = 2;

    31     static final int HASH   = 3;

    32 

    33     boolean nextNotKey(ArgIterator it) {

    34         if (it.next()) {

    35             String s = it.get();

    36             return (s.length() == 0) || (s.charAt(0) != '-');

    37         } else {

    38             return false;

    39         }

    40     }

    41 

    42     void empty(String key, String message) {

    43         if (key != null) {

    44             System.err.println("** Error: empty " + key);

    45         }

    46         if (message != null) {

    47             System.err.println(message);

    48         }

    49         WinGammaPlatform.usage();

    50     }

    51 

    52     static String getCfg(String val) {

    53         int under = val.indexOf('_');

    54         int len = val.length();

    55         if (under != -1 && under < len - 1) {

    56             return val.substring(under+1, len);

    57         } else {

    58             return null;

    59         }

    60     }

    61 }

    62 

    63 class ArgRuleSpecific extends ArgRule {

    64     ArgRuleSpecific(String arg, ArgHandler handler) {

    65         super(arg, handler);

    66     }

    67 

    68     boolean match(String rulePattern, String arg) {

    69         return rulePattern.startsWith(arg);

    70     }

    71 }

    72 

    73 

    74 class SpecificHsArgHandler extends HsArgHandler {

    75 

    76     String message, argKey, valKey;

    77     int type;

    78 

    79     public void handle(ArgIterator it) {

    80         String cfg = getCfg(it.get());

    81         if (nextNotKey(it)) {

    82             String val = it.get();

    83             switch (type) {

    84             case VECTOR:

    85                 BuildConfig.addFieldVector(cfg, valKey, val);

    86                 break;

    87             case HASH:

    88                 BuildConfig.putFieldHash(cfg, valKey, val, "1");

    89                 break;

    90             case STRING:

    91                 BuildConfig.putField(cfg, valKey, val);

    92                 break;

    93             default:

    94                 empty(valKey, "Unknown type: "+type);

    95             }

    96             it.next();

    97 

    98         } else {

    99             empty(argKey, message);

   100         }

   101     }

   102 

   103     SpecificHsArgHandler(String argKey, String valKey, String message, int type) {

   104         this.argKey = argKey;

   105         this.valKey = valKey;

   106         this.message = message;

   107         this.type = type;

   108     }

   109 }

   110 

   111 

   112 class HsArgRule extends ArgRuleSpecific {

   113 

   114     HsArgRule(String argKey, String valKey, String message, int type) {

   115         super(argKey, new SpecificHsArgHandler(argKey, valKey, message, type));

   116     }

   117 

   118 }

   119 

   120 public abstract class WinGammaPlatform extends Platform {

   121     public void setupFileTemplates() {

   122         inclFileTemplate = new FileName(this,

   123             "incls\\", "_", "",                      ".incl", "", ""

   124         );

   125         giFileTemplate = new FileName(this,

   126             "incls\\", "",  "_precompiled", ".incl", "", ""

   127         );

   128         gdFileTemplate = new FileName(this,

   129             "", "",  "Dependencies",         "",      "", ""

   130         );

   131     }

   132 

   133     private static String[] suffixes = { ".cpp", ".c" };

   134 

   135     public String[] outerSuffixes() {

   136         return suffixes;

   137     }

   138 

   139     public String objFileSuffix() {

   140         return ".obj";

   141     }

   142 

   143     public String asmFileSuffix() {

   144         return ".i";

   145     }

   146 

   147     public String dependentPrefix() {

   148         return "$(VM_PATH)";

   149     }

   150 

   151     public boolean includeGIInEachIncl() {

   152         return false;

   153     }

   154 

   155     public boolean fileNameStringEquality(String s1, String s2) {

   156         return s1.equalsIgnoreCase(s2);

   157     }

   158 

   159     static void usage() throws IllegalArgumentException {

   160         System.err.println("WinGammaPlatform platform-specific options:");

   161         System.err.println("  -sourceBase <path to directory (workspace) " +

   162                            "containing source files; no trailing slash>");

   163         System.err.println("  -projectFileName <full pathname to which project file " +

   164                            "will be written; all parent directories must " +

   165                            "already exist>");

   166         System.err.println("  If any of the above are specified, "+

   167                            "they must all be.");

   168         System.err.println("  Additional, optional arguments, which can be " +

   169                            "specified multiple times:");

   170         System.err.println("    -absoluteInclude <string containing absolute " +

   171                            "path to include directory>");

   172         System.err.println("    -relativeInclude <string containing include " +

   173                            "directory relative to -sourceBase>");

   174         System.err.println("    -define <preprocessor flag to be #defined " +

   175                            "(note: doesn't yet support " +

   176                            "#define (flag) (value))>");

   177         System.err.println("    -startAt <subdir of sourceBase>");

   178         System.err.println("    -additionalFile <file not in database but " +

   179                            "which should show up in project file, like " +

   180                            "includeDB_core>");

   181         System.err.println("    -additionalGeneratedFile <absolute path to " +

   182                            "directory containing file; no trailing slash> " +

   183                            "<name of file generated later in the build process>");

   184         throw new IllegalArgumentException();

   185     }

   186 

   187 

   188     public void addPerFileLine(Hashtable table,

   189                                String fileName,

   190                                String line) {

   191         Vector v = (Vector) table.get(fileName);

   192         if (v != null) {

   193             v.add(line);

   194         } else {

   195             v = new Vector();

   196             v.add(line);

   197             table.put(fileName, v);

   198         }

   199     }

   200 

   201     protected static class PerFileCondData {

   202         public String releaseString;

   203         public String debugString;

   204     }

   205 

   206     protected void addConditionalPerFileLine(Hashtable table,

   207                                            String fileName,

   208                                            String releaseLine,

   209                                            String debugLine) {

   210         PerFileCondData data = new PerFileCondData();

   211         data.releaseString = releaseLine;

   212         data.debugString = debugLine;

   213         Vector v = (Vector) table.get(fileName);

   214         if (v != null) {

   215             v.add(data);

   216         } else {

   217             v = new Vector();

   218             v.add(data);

   219             table.put(fileName, v);

   220         }

   221     }

   222 

   223     protected static class PrelinkCommandData {

   224       String description;

   225       String commands;

   226     }

   227 

   228     protected void addPrelinkCommand(Hashtable table,

   229                                      String build,

   230                                      String description,

   231                                      String commands) {

   232       PrelinkCommandData data = new PrelinkCommandData();

   233       data.description = description;

   234       data.commands = commands;

   235       table.put(build, data);

   236     }

   237 

   238     public boolean findString(Vector v, String s) {

   239         for (Iterator iter = v.iterator(); iter.hasNext(); ) {

   240             if (((String) iter.next()).equals(s)) {

   241                 return true;

   242             }

   243         }

   244 

   245         return false;

   246     }

   247 

   248     /* This returns a String containing the full path to the passed

   249        file name, or null if an error occurred. If the file was not

   250        found or was a duplicate and couldn't be resolved using the

   251        preferred paths, the file name is added to the appropriate

   252        Vector of Strings. */

   253     private String findFileInDirectory(String fileName,

   254                                        DirectoryTree directory,

   255                                        Vector preferredPaths,

   256                                        Vector filesNotFound,

   257                                        Vector filesDuplicate) {

   258         List locationsInTree = directory.findFile(fileName);

   259         int  rootNameLength = directory.getRootNodeName().length();

   260         String name = null;

   261         if ((locationsInTree == null) ||

   262             (locationsInTree.size() == 0)) {

   263             filesNotFound.add(fileName);

   264         } else if (locationsInTree.size() > 1) {

   265             // We shouldn't have duplicate file names in our workspace.

   266             System.err.println();

   267             System.err.println("There are multiple files named as: " + fileName);

   268             System.exit(-1);

   269             // The following code could be safely removed if we don't need duplicate

   270             // file names.

   271 

   272             // Iterate through them, trying to find one with a

   273             // preferred path

   274         search:

   275             {

   276                 for (Iterator locIter = locationsInTree.iterator();

   277                      locIter.hasNext(); ) {

   278                     DirectoryTreeNode node =

   279                         (DirectoryTreeNode) locIter.next();

   280                     String tmpName = node.getName();

   281                     for (Iterator prefIter = preferredPaths.iterator();

   282                          prefIter.hasNext(); ) {

   283                         // We need to make sure the preferred path is

   284                         // found from the file path not including the root node name.

   285                         if (tmpName.indexOf((String)prefIter.next(),

   286                                             rootNameLength) != -1) {

   287                             name = tmpName;

   288                             break search;

   289                         }

   290                     }

   291                 }

   292             }

   293 

   294             if (name == null) {

   295                 filesDuplicate.add(fileName);

   296             }

   297         } else {

   298             name = ((DirectoryTreeNode) locationsInTree.get(0)).getName();

   299         }

   300 

   301         return name;

   302     }

   303 

   304     protected boolean databaseAllFilesEqual(Database previousDB,

   305                                             Database currentDB) {

   306         Iterator i1 = previousDB.getAllFiles().iterator();

   307         Iterator i2 = currentDB.getAllFiles().iterator();

   308 

   309         while (i1.hasNext() && i2.hasNext()) {

   310             FileList fl1 = (FileList) i1.next();

   311             FileList fl2 = (FileList) i2.next();

   312             if (!fl1.getName().equals(fl2.getName())) {

   313                 return false;

   314             }

   315         }

   316 

   317         if (i1.hasNext() != i2.hasNext()) {

   318             // Different lengths

   319             return false;

   320         }

   321 

   322         return true;

   323     }

   324 

   325     protected String envVarPrefixedFileName(String fileName,

   326                                             int sourceBaseLen,

   327                                             DirectoryTree tree,

   328                                             Vector preferredPaths,

   329                                             Vector filesNotFound,

   330                                             Vector filesDuplicate) {

   331         String fullName = findFileInDirectory(fileName,

   332                                               tree,

   333                                               preferredPaths,

   334                                               filesNotFound,

   335                                               filesDuplicate);

   336         return fullName;

   337     }

   338 

   339      String getProjectName(String fullPath, String extension)

   340         throws IllegalArgumentException, IOException {

   341         File file = new File(fullPath).getCanonicalFile();

   342         fullPath = file.getCanonicalPath();

   343         String parent = file.getParent();

   344 

   345         if (!fullPath.endsWith(extension)) {

   346             throw new IllegalArgumentException("project file name \"" +

   347                                                fullPath +

   348                                                "\" does not end in "+extension);

   349         }

   350 

   351         if ((parent != null) &&

   352             (!fullPath.startsWith(parent))) {

   353             throw new RuntimeException(

   354                 "Internal error: parent of file name \"" + parent +

   355                 "\" does not match file name \"" + fullPath + "\""

   356             );

   357         }

   358 

   359         int len = parent.length();

   360         if (!parent.endsWith(Util.sep)) {

   361             len += Util.sep.length();

   362         }

   363 

   364         int end = fullPath.length() - extension.length();

   365 

   366         if (len == end) {

   367             throw new RuntimeException(

   368                 "Internal error: file name was empty"

   369             );

   370         }

   371 

   372         return fullPath.substring(len, end);

   373     }

   374 

   375     protected abstract String getProjectExt();

   376 

   377     public void writePlatformSpecificFiles(Database previousDB,

   378                                            Database currentDB, String[] args)

   379         throws IllegalArgumentException, IOException {

   380 

   381         parseArguments(args);

   382 

   383         String projectFileName = BuildConfig.getFieldString(null, "ProjectFileName");

   384         String ext = getProjectExt();

   385 

   386         // Compare contents of allFiles of previousDB and includeDB.

   387         // If these haven't changed, then skip writing the .vcproj file.

   388         if (false && databaseAllFilesEqual(previousDB, currentDB) &&

   389             new File(projectFileName).exists()) {

   390             System.out.println(

   391                                "    Databases unchanged; skipping overwrite of "+ext+" file."

   392                                );

   393             return;

   394         }

   395 

   396         String projectName = getProjectName(projectFileName, ext);

   397 

   398         writeProjectFile(projectFileName, projectName, createAllConfigs());

   399     }

   400 

   401     protected void writePrologue(String[] args) {

   402         System.err.println("WinGammaPlatform platform-specific arguments:");

   403         for (int i = 0; i < args.length; i++) {

   404             System.err.print(args[i] + " ");

   405         }

   406         System.err.println();

   407     }

   408 

   409 

   410     void setInclFileTemplate(FileName val) {

   411         this.inclFileTemplate = val;

   412     }

   413 

   414     void setGIFileTemplate(FileName val) {

   415         this.giFileTemplate = val;

   416     }

   417 

   418 

   419     void parseArguments(String[] args) {

   420         new ArgsParser(args,

   421                        new ArgRule[]

   422             {

   423                 new HsArgRule("-sourceBase",

   424                               "SourceBase",

   425                               "   (Did you set the HotSpotWorkSpace environment variable?)",

   426                               HsArgHandler.STRING

   427                               ),

   428 

   429                 new HsArgRule("-buildBase",

   430                               "BuildBase",

   431                               "   (Did you set the HotSpotBuildSpace environment variable?)",

   432                               HsArgHandler.STRING

   433                               ),

   434 

   435                 new HsArgRule("-projectFileName",

   436                               "ProjectFileName",

   437                               null,

   438                               HsArgHandler.STRING

   439                               ),

   440 

   441                 new HsArgRule("-jdkTargetRoot",

   442                               "JdkTargetRoot",

   443                               "   (Did you set the HotSpotJDKDist environment variable?)",

   444                               HsArgHandler.STRING

   445                               ),

   446 

   447                 new HsArgRule("-compiler",

   448                               "CompilerVersion",

   449                               "   (Did you set the VcVersion correctly?)",

   450                               HsArgHandler.STRING

   451                               ),

   452 

   453                 new HsArgRule("-platform",

   454                               "Platform",

   455                               null,

   456                               HsArgHandler.STRING

   457                               ),

   458 

   459                 new HsArgRule("-absoluteInclude",

   460                               "AbsoluteInclude",

   461                               null,

   462                               HsArgHandler.VECTOR

   463                               ),

   464 

   465                 new HsArgRule("-relativeInclude",

   466                               "RelativeInclude",

   467                               null,

   468                               HsArgHandler.VECTOR

   469                               ),

   470 

   471                 new HsArgRule("-define",

   472                               "Define",

   473                               null,

   474                               HsArgHandler.VECTOR

   475                               ),

   476 

   477                 new HsArgRule("-useToGeneratePch",

   478                               "UseToGeneratePch",

   479                               null,

   480                               HsArgHandler.STRING

   481                               ),

   482 

   483                 new ArgRuleSpecific("-perFileLine",

   484                             new HsArgHandler() {

   485                                 public void handle(ArgIterator it) {

   486                                     String cfg = getCfg(it.get());

   487                                     if (nextNotKey(it)) {

   488                                         String fileName = it.get();

   489                                         if (nextNotKey(it)) {

   490                                             String line = it.get();

   491                                             BuildConfig.putFieldHash(cfg, "PerFileLine", fileName, line);

   492                                             it.next();

   493                                             return;

   494                                         }

   495                                     }

   496                                     empty(null, "** Error: wrong number of args to -perFileLine");

   497                                 }

   498                             }

   499                             ),

   500 

   501                 new ArgRuleSpecific("-conditionalPerFileLine",

   502                             new HsArgHandler() {

   503                                 public void handle(ArgIterator it) {

   504                                     String cfg = getCfg(it.get());

   505                                     if (nextNotKey(it)) {

   506                                         String fileName = it.get();

   507                                         if (nextNotKey(it)) {

   508                                             String productLine = it.get();

   509                                             if (nextNotKey(it)) {

   510                                                 String debugLine = it.get();

   511                                                 BuildConfig.putFieldHash(cfg+"_debug", "CondPerFileLine",

   512                                                                          fileName, debugLine);

   513                                                 BuildConfig.putFieldHash(cfg+"_product", "CondPerFileLine",

   514                                                                          fileName, productLine);

   515                                                 it.next();

   516                                                 return;

   517                                             }

   518                                         }

   519                                     }

   520 

   521                                     empty(null, "** Error: wrong number of args to -conditionalPerFileLine");

   522                                 }

   523                             }

   524                             ),

   525 

   526                 new HsArgRule("-disablePch",

   527                               "DisablePch",

   528                               null,

   529                               HsArgHandler.HASH

   530                               ),

   531 

   532                 new ArgRule("-startAt",

   533                             new HsArgHandler() {

   534                                 public void handle(ArgIterator it) {

   535                                     if (BuildConfig.getField(null, "StartAt") != null) {

   536                                         empty(null, "** Error: multiple -startAt");

   537                                     }

   538                                     if (nextNotKey(it)) {

   539                                         BuildConfig.putField(null, "StartAt", it.get());

   540                                         it.next();

   541                                     } else {

   542                                         empty("-startAt", null);

   543                                     }

   544                                 }

   545                             }

   546                             ),

   547 

   548                 new HsArgRule("-ignoreFile",

   549                                       "IgnoreFile",

   550                                       null,

   551                                       HsArgHandler.HASH

   552                                       ),

   553 

   554                 new HsArgRule("-additionalFile",

   555                               "AdditionalFile",

   556                               null,

   557                               HsArgHandler.VECTOR

   558                               ),

   559 

   560                 new ArgRuleSpecific("-additionalGeneratedFile",

   561                             new HsArgHandler() {

   562                                 public void handle(ArgIterator it) {

   563                                     String cfg = getCfg(it.get());

   564                                     if (nextNotKey(it)) {

   565                                         String dir = it.get();

   566                                         if (nextNotKey(it)) {

   567                                             String fileName = it.get();

   568                                             // we ignore files that we know are generated, so we coudn't

   569                                             // find them in sources

   570                                             BuildConfig.putFieldHash(cfg, "IgnoreFile",  fileName, "1");

   571                                             BuildConfig.putFieldHash(cfg, "AdditionalGeneratedFile",

   572                                                                      Util.normalize(dir + Util.sep + fileName),

   573                                                                      fileName);

   574                                             it.next();

   575                                             return;

   576                                         }

   577                                     }

   578                                     empty(null, "** Error: wrong number of args to -additionalGeneratedFile");

   579                                 }

   580                             }

   581                             ),

   582 

   583                 new HsArgRule("-includeDB",

   584                               "IncludeDB",

   585                               null,

   586                               HsArgHandler.STRING

   587                               ),

   588 

   589                 new ArgRule("-prelink",

   590                             new HsArgHandler() {

   591                                 public void handle(ArgIterator it) {

   592                                     if (nextNotKey(it)) {

   593                                         String build = it.get();

   594                                         if (nextNotKey(it)) {

   595                                             String description = it.get();

   596                                             if (nextNotKey(it)) {

   597                                                 String command = it.get();

   598                                                 BuildConfig.putField(null, "PrelinkDescription", description);

   599                                                 BuildConfig.putField(null, "PrelinkCommand", command);

   600                                                 it.next();

   601                                                 return;

   602                                             }

   603                                         }

   604                                     }

   605 

   606                                     empty(null,  "** Error: wrong number of args to -prelink");

   607                                 }

   608                             }

   609                             )

   610             },

   611                                        new ArgHandler() {

   612                                            public void handle(ArgIterator it) {

   613 

   614                                                throw new RuntimeException("Arg Parser: unrecognized option "+it.get());

   615                                            }

   616                                        }

   617                                        );

   618         if (BuildConfig.getField(null, "SourceBase") == null      ||

   619             BuildConfig.getField(null, "BuildBase") == null       ||

   620             BuildConfig.getField(null, "ProjectFileName") == null ||

   621             BuildConfig.getField(null, "CompilerVersion") == null) {

   622             usage();

   623         }

   624 

   625         if (BuildConfig.getField(null, "UseToGeneratePch") == null) {

   626             throw new RuntimeException("ERROR: need to specify one file to compute PCH, with -useToGeneratePch flag");

   627         }

   628 

   629         BuildConfig.putField(null, "PlatformObject", this);

   630     }

   631 

   632     Vector createAllConfigs() {

   633         Vector allConfigs = new Vector();

   634 

   635         allConfigs.add(new C1DebugConfig());

   636 

   637         boolean b = true;

   638         if (b) {

   639             allConfigs.add(new C1FastDebugConfig());

   640             allConfigs.add(new C1ProductConfig());

   641 

   642             allConfigs.add(new C2DebugConfig());

   643             allConfigs.add(new C2FastDebugConfig());

   644             allConfigs.add(new C2ProductConfig());

   645 

   646             allConfigs.add(new TieredDebugConfig());

   647             allConfigs.add(new TieredFastDebugConfig());

   648             allConfigs.add(new TieredProductConfig());

   649 

   650             allConfigs.add(new CoreDebugConfig());

   651             allConfigs.add(new CoreFastDebugConfig());

   652             allConfigs.add(new CoreProductConfig());

   653 

   654             allConfigs.add(new KernelDebugConfig());

   655             allConfigs.add(new KernelFastDebugConfig());

   656             allConfigs.add(new KernelProductConfig());

   657         }

   658 

   659         return allConfigs;

   660     }

   661 

   662     class FileAttribute {

   663         int     numConfigs;

   664         Vector  configs;

   665         String  shortName;

   666         boolean noPch, pchRoot;

   667 

   668         FileAttribute(String shortName, BuildConfig cfg, int numConfigs) {

   669             this.shortName = shortName;

   670             this.noPch =  (cfg.lookupHashFieldInContext("DisablePch", shortName) != null);

   671             this.pchRoot = shortName.equals(BuildConfig.getFieldString(null, "UseToGeneratePch"));

   672             this.numConfigs = numConfigs;

   673 

   674             configs = new Vector();

   675             add(cfg.get("Name"));

   676         }

   677 

   678         void add(String confName) {

   679             configs.add(confName);

   680 

   681             // if presented in all configs

   682             if (configs.size() == numConfigs) {

   683                 configs = null;

   684             }

   685         }

   686     }

   687 

   688     class FileInfo implements Comparable {

   689         String        full;

   690         FileAttribute attr;

   691 

   692         FileInfo(String full, FileAttribute  attr) {

   693             this.full = full;

   694             this.attr = attr;

   695         }

   696 

   697         public int compareTo(Object o) {

   698             FileInfo oo = (FileInfo)o;

   699             // Don't squelch identical short file names where the full

   700             // paths are different

   701             if (!attr.shortName.equals(oo.attr.shortName))

   702               return attr.shortName.compareTo(oo.attr.shortName);

   703             return full.compareTo(oo.full);

   704         }

   705 

   706         boolean isHeader() {

   707             return attr.shortName.endsWith(".h") || attr.shortName.endsWith(".hpp");

   708         }

   709     }

   710 

   711 

   712     TreeSet sortFiles(Hashtable allFiles) {

   713         TreeSet rv = new TreeSet();

   714         Enumeration e = allFiles.keys();

   715         while (e.hasMoreElements()) {

   716             String fullPath = (String)e.nextElement();

   717             rv.add(new FileInfo(fullPath, (FileAttribute)allFiles.get(fullPath)));

   718         }

   719         return rv;

   720     }

   721 

   722     Hashtable computeAttributedFiles(Vector allConfigs) {

   723         Hashtable ht = new Hashtable();

   724         int numConfigs = allConfigs.size();

   725 

   726         for (Iterator i = allConfigs.iterator(); i.hasNext(); ) {

   727             BuildConfig bc = (BuildConfig)i.next();

   728             Hashtable  confFiles = (Hashtable)bc.getSpecificField("AllFilesHash");

   729             String confName = bc.get("Name");

   730 

   731             for (Enumeration e=confFiles.keys(); e.hasMoreElements(); ) {

   732                 String filePath = (String)e.nextElement();

   733                 FileAttribute fa = (FileAttribute)ht.get(filePath);

   734 

   735                 if (fa == null) {

   736                     fa = new FileAttribute((String)confFiles.get(filePath), bc, numConfigs);

   737                     ht.put(filePath, fa);

   738                 } else {

   739                     fa.add(confName);

   740                 }

   741             }

   742         }

   743 

   744         return ht;

   745     }

   746 

   747      Hashtable computeAttributedFiles(BuildConfig bc) {

   748         Hashtable ht = new Hashtable();

   749         Hashtable confFiles = (Hashtable)bc.getSpecificField("AllFilesHash");

   750 

   751         for (Enumeration e = confFiles.keys(); e.hasMoreElements(); ) {

   752             String filePath = (String)e.nextElement();

   753             ht.put(filePath,  new FileAttribute((String)confFiles.get(filePath), bc, 1));

   754         }

   755 

   756         return ht;

   757     }

   758 

   759     PrintWriter printWriter;

   760 

   761     public void writeProjectFile(String projectFileName, String projectName,

   762                                  Vector allConfigs) throws IOException {

   763         throw new RuntimeException("use compiler version specific version");

   764     }

   765 }