src/share/tools/ProjectCreator/WinGammaPlatformVC7.java

Print this page
rev 3265 : 0000000: Updated projectcreator
Summary: Refactoring
Reviewed-by:
Contributed-by: nils.eliasson@oracle.com


   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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 import java.io.FileWriter;
  26 import java.io.IOException;
  27 import java.io.PrintWriter;
  28 import java.util.Hashtable;
  29 import java.util.Iterator;
  30 import java.util.TreeSet;
  31 import java.util.Vector;
  32 
  33 public class WinGammaPlatformVC7 extends WinGammaPlatform {
  34 
  35     String projectVersion() {return "7.10";};
  36 
  37     public void writeProjectFile(String projectFileName, String projectName,
  38                                  Vector<BuildConfig> allConfigs) throws IOException {
  39         System.out.println();
  40         System.out.println("    Writing .vcproj file: "+projectFileName);
  41         // If we got this far without an error, we're safe to actually
  42         // write the .vcproj file
  43         printWriter = new PrintWriter(new FileWriter(projectFileName));
  44 
  45         printWriter.println("<?xml version=\"1.0\" encoding=\"windows-1251\"?>");
  46         startTag(
  47             "VisualStudioProject",
  48             new String[] {
  49                 "ProjectType", "Visual C++",
  50                 "Version", projectVersion(),
  51                 "Name", projectName,
  52                 "ProjectGUID", "{8822CB5C-1C41-41C2-8493-9F6E1994338B}",
  53                 "SccProjectName", "",
  54                 "SccLocalPath", ""
  55             }
  56             );
  57         startTag("Platforms");
  58         tag("Platform", new String[] {"Name", (String) BuildConfig.getField(null, "PlatformName")});
  59         endTag("Platforms");


  60 
  61         startTag("Configurations");
  62 
  63         for (Iterator i = allConfigs.iterator(); i.hasNext(); ) {
  64             writeConfiguration((BuildConfig)i.next());
  65         }
  66 
  67         endTag("Configurations");
  68 
  69         tag("References");
  70 
  71         writeFiles(allConfigs);
  72 
  73         tag("Globals");
  74 
  75         endTag("VisualStudioProject");
  76         printWriter.close();
  77 
  78         System.out.println("    Done.");
  79     }
  80 
  81 
  82     abstract class NameFilter {
  83                 protected String fname;
  84 
  85         abstract boolean match(FileInfo fi);
  86 
  87         String  filterString() { return ""; }
  88         String name() { return this.fname;}
  89 
  90         @Override
  91         // eclipse auto-generated
  92         public int hashCode() {
  93             final int prime = 31;
  94             int result = 1;
  95             result = prime * result + getOuterType().hashCode();
  96             result = prime * result + ((fname == null) ? 0 : fname.hashCode());
  97             return result;
  98         }
  99 
 100         @Override
 101         // eclipse auto-generated
 102         public boolean equals(Object obj) {
 103             if (this == obj)
 104                 return true;
 105             if (obj == null)
 106                 return false;
 107             if (getClass() != obj.getClass())
 108                 return false;
 109             NameFilter other = (NameFilter) obj;
 110             if (!getOuterType().equals(other.getOuterType()))
 111                 return false;
 112             if (fname == null) {
 113                 if (other.fname != null)
 114                     return false;
 115             } else if (!fname.equals(other.fname))
 116                 return false;
 117             return true;
 118         }
 119 
 120         // eclipse auto-generated
 121         private WinGammaPlatformVC7 getOuterType() {
 122             return WinGammaPlatformVC7.this;
 123         }
 124     }
 125 
 126     class DirectoryFilter extends NameFilter {
 127         String dir;
 128         int baseLen, dirLen;
 129 
 130         DirectoryFilter(String dir, String sbase) {
 131             this.dir = dir;
 132             this.baseLen = sbase.length();
 133             this.dirLen = dir.length();
 134             this.fname = dir;
 135         }
 136 
 137         DirectoryFilter(String fname, String dir, String sbase) {
 138             this.dir = dir;
 139             this.baseLen = sbase.length();
 140             this.dirLen = dir.length();
 141             this.fname = fname;
 142         }
 143 
 144 
 145         boolean match(FileInfo fi) {
 146             int lastSlashIndex = fi.full.lastIndexOf('/');
 147             String fullDir = fi.full.substring(0, lastSlashIndex);
 148             return fullDir.endsWith(dir);
 149         }
 150 
 151         @Override
 152         // eclipse auto-generated
 153         public int hashCode() {
 154             final int prime = 31;
 155             int result = super.hashCode();
 156             result = prime * result + getOuterType().hashCode();
 157             result = prime * result + baseLen;
 158             result = prime * result + ((dir == null) ? 0 : dir.hashCode());
 159             result = prime * result + dirLen;
 160             return result;
 161         }
 162 
 163         @Override
 164         // eclipse auto-generated
 165         public boolean equals(Object obj) {
 166             if (this == obj)
 167                 return true;
 168             if (!super.equals(obj))
 169                 return false;
 170             if (getClass() != obj.getClass())
 171                 return false;
 172             DirectoryFilter other = (DirectoryFilter) obj;
 173             if (!getOuterType().equals(other.getOuterType()))
 174                 return false;
 175             if (baseLen != other.baseLen)
 176                 return false;
 177             if (dir == null) {
 178                 if (other.dir != null)
 179                     return false;
 180             } else if (!dir.equals(other.dir))
 181                 return false;
 182             if (dirLen != other.dirLen)
 183                 return false;
 184             return true;
 185         }
 186 
 187         // eclipse auto-generated
 188         private WinGammaPlatformVC7 getOuterType() {
 189             return WinGammaPlatformVC7.this;
 190         }
 191     }
 192 
 193     class TerminatorFilter extends NameFilter {
 194         TerminatorFilter(String fname) {
 195             this.fname = fname;
 196 
 197         }
 198         boolean match(FileInfo fi) {
 199             return true;
 200         }
 201 
 202     }
 203 
 204     class SpecificNameFilter extends NameFilter {
 205         String pats[];
 206 
 207         SpecificNameFilter(String fname, String[] pats) {
 208             this.fname = fname;
 209             this.pats = pats;
 210         }
 211 
 212         boolean match(FileInfo fi) {
 213             for (int i=0; i<pats.length; i++) {
 214                 if (fi.attr.shortName.matches(pats[i])) {
 215                     return true;
 216                 }
 217             }
 218             return false;
 219         }
 220 
 221     }
 222 
 223     class SpecificPathFilter extends NameFilter {
 224         String pats[];
 225 
 226         SpecificPathFilter(String fname, String[] pats) {
 227             this.fname = fname;
 228             this.pats = pats;
 229         }
 230 
 231         boolean match(FileInfo fi) {
 232             for (int i=0; i<pats.length; i++) {
 233                 if (fi.full.matches(pats[i])) {
 234                     return true;
 235                 }
 236             }
 237             return false;
 238         }
 239 
 240     }
 241 
 242     class ContainerFilter extends NameFilter {
 243         Vector children;
 244 
 245         ContainerFilter(String fname) {
 246             this.fname = fname;
 247             children = new Vector();
 248 
 249         }
 250         boolean match(FileInfo fi) {
 251             return false;
 252         }
 253 
 254         Iterator babies() { return children.iterator(); }
 255 
 256         void add(NameFilter f) {
 257             children.add(f);
 258         }
 259     }
 260 
 261 
 262     void writeCustomToolConfig(Vector configs, String[] customToolAttrs) {
 263         for (Iterator i = configs.iterator(); i.hasNext(); ) {
 264             startTag("FileConfiguration",
 265                      new String[] {
 266                          "Name",  (String)i.next()
 267                      }
 268                      );
 269             tag("Tool", customToolAttrs);
 270 
 271             endTag("FileConfiguration");
 272         }
 273     }
 274 
 275     // here we define filters, which define layout of what can be seen in 'Solution View' of MSVC
 276     // Basically there are two types of entities - container filters and real filters
 277     //   - container filter just provides a container to group together real filters
 278     //   - real filter can select elements from the set according to some rule, put it into XML
 279     //     and remove from the list
 280     Vector<NameFilter> makeFilters(TreeSet<FileInfo> files) {
 281         Vector<NameFilter> rv = new Vector<NameFilter>();
 282         String sbase = Util.normalize(BuildConfig.getFieldString(null, "SourceBase")+"/src/");
 283 
 284         String currentDir = "";
 285         DirectoryFilter container = null;
 286         for(FileInfo fileInfo : files) {
 287 
 288             if (!fileInfo.full.startsWith(sbase)) {
 289                 continue;
 290             }
 291 
 292             int lastSlash = fileInfo.full.lastIndexOf('/');
 293             String dir = fileInfo.full.substring(sbase.length(), lastSlash);
 294             if(dir.equals("share/vm")) {
 295                 // skip files directly in share/vm - should only be precompiled.hpp which is handled below
 296                 continue;
 297             }
 298             if (!dir.equals(currentDir)) {
 299                 currentDir = dir;
 300                 if (container != null && !rv.contains(container)) {
 301                     rv.add(container);
 302                 }
 303 
 304                 // remove "share/vm/" from names
 305                 String name = dir;
 306                 if (dir.startsWith("share/vm/")) {
 307                     name = dir.substring("share/vm/".length(), dir.length());
 308                 }
 309                 DirectoryFilter newfilter = new DirectoryFilter(name, dir, sbase);
 310                 int i = rv.indexOf(newfilter);
 311                 if(i == -1) {
 312                     container = newfilter;
 313                 } else {
 314                     // if the filter already exists, reuse it
 315                     container = (DirectoryFilter) rv.get(i);
 316                 }
 317             }
 318         }
 319         if (container != null && !rv.contains(container)) {
 320             rv.add(container);
 321         }
 322 
 323         ContainerFilter generated = new ContainerFilter("Generated");
 324         ContainerFilter c1Generated = new ContainerFilter("C1");
 325         c1Generated.add(new SpecificPathFilter("C++ Interpreter Generated", new String[] {".*compiler1/generated/jvmtifiles/bytecodeInterpreterWithChecks.+"}));
 326         c1Generated.add(new SpecificPathFilter("jvmtifiles", new String[] {".*compiler1/generated/jvmtifiles/.*"}));
 327         generated.add(c1Generated);
 328         ContainerFilter c2Generated = new ContainerFilter("C2");
 329         c2Generated.add(new SpecificPathFilter("C++ Interpreter Generated", new String[] {".*compiler2/generated/jvmtifiles/bytecodeInterpreterWithChecks.+"}));
 330         c2Generated.add(new SpecificPathFilter("adfiles", new String[] {".*compiler2/generated/adfiles/.*"}));
 331         c2Generated.add(new SpecificPathFilter("jvmtifiles", new String[] {".*compiler2/generated/jvmtifiles/.*"}));
 332         generated.add(c2Generated);
 333         ContainerFilter coreGenerated = new ContainerFilter("Core");
 334         coreGenerated.add(new SpecificPathFilter("C++ Interpreter Generated", new String[] {".*core/generated/jvmtifiles/bytecodeInterpreterWithChecks.+"}));
 335         coreGenerated.add(new SpecificPathFilter("jvmtifiles", new String[] {".*core/generated/jvmtifiles/.*"}));
 336         generated.add(coreGenerated);
 337         ContainerFilter tieredGenerated = new ContainerFilter("Tiered");
 338         tieredGenerated.add(new SpecificPathFilter("C++ Interpreter Generated", new String[] {".*tiered/generated/jvmtifiles/bytecodeInterpreterWithChecks.+"}));
 339         tieredGenerated.add(new SpecificPathFilter("adfiles", new String[] {".*tiered/generated/adfiles/.*"}));
 340         tieredGenerated.add(new SpecificPathFilter("jvmtifiles", new String[] {".*tiered/generated/jvmtifiles/.*"}));
 341         generated.add(tieredGenerated);
 342         ContainerFilter kernelGenerated = new ContainerFilter("Kernel");
 343         kernelGenerated.add(new SpecificPathFilter("C++ Interpreter Generated", new String[] {".*kernel/generated/jvmtifiles/bytecodeInterpreterWithChecks.+"}));
 344         kernelGenerated.add(new SpecificPathFilter("jvmtifiles", new String[] {".*kernel/generated/jvmtifiles/.*"}));
 345         generated.add(kernelGenerated);
 346         rv.add(generated);
 347 
 348         rv.add(new SpecificNameFilter("Precompiled Header", new String[] {"precompiled.hpp"}));
 349 
 350         // this one is to catch files not caught by other filters
 351         rv.add(new TerminatorFilter("Source Files"));
 352 
 353         return rv;
 354     }
 355 
 356     void writeFiles(Vector<BuildConfig> allConfigs) {
 357 
 358         Hashtable allFiles = computeAttributedFiles(allConfigs);
 359 
 360         Vector allConfigNames = new Vector();
 361         for (Iterator i = allConfigs.iterator(); i.hasNext(); ) {
 362             allConfigNames.add(((BuildConfig)i.next()).get("Name"));
 363         }
 364 
 365         TreeSet sortedFiles = sortFiles(allFiles);
 366 
 367         startTag("Files");

 368 
 369         for (Iterator i = makeFilters(sortedFiles).iterator(); i.hasNext(); ) {
 370             doWriteFiles(sortedFiles, allConfigNames, (NameFilter)i.next());
 371         }
 372 
 373 
 374         startTag("Filter",
 375                  new String[] {
 376                      "Name", "Resource Files",
 377                      "Filter", "ico;cur;bmp;dlg;rc2;rct;bin;cnt;rtf;gif;jpg;jpeg;jpe"

 378                  }
 379                  );
 380         endTag("Filter");
 381 
 382         endTag("Files");
 383     }
 384 
 385     void doWriteFiles(TreeSet allFiles, Vector allConfigNames, NameFilter filter) {
 386         startTag("Filter",
 387                  new String[] {
 388                      "Name",   filter.name(),
 389                      "Filter", filter.filterString()
 390                  }
 391                  );
 392 
 393         if (filter instanceof ContainerFilter) {


 394 
 395             Iterator i = ((ContainerFilter)filter).babies();
 396             while (i.hasNext()) {
 397                 doWriteFiles(allFiles, allConfigNames, (NameFilter)i.next());
 398             }
 399 
 400         } else {
 401 
 402             Iterator i = allFiles.iterator();
 403             while (i.hasNext()) {
 404                 FileInfo fi = (FileInfo)i.next();
 405 
 406                 if (!filter.match(fi)) {
 407                     continue;
 408                 }
 409 
 410                 startTag("File",
 411                          new String[] {
 412                              "RelativePath", fi.full.replace('/', '\\')
 413                          }
 414                          );
 415 
 416                 FileAttribute a = fi.attr;
 417                 if (a.pchRoot) {
 418                     writeCustomToolConfig(allConfigNames,
 419                                           new String[] {
 420                                               "Name", "VCCLCompilerTool",
 421                                               "UsePrecompiledHeader", "1"
 422                                           });
 423                 }
 424 
 425                 if (a.noPch) {
 426                     writeCustomToolConfig(allConfigNames,
 427                                           new String[] {
 428                                               "Name", "VCCLCompilerTool",
 429                                               "UsePrecompiledHeader", "0"
 430                                           });
 431                 }
 432 
 433                 if (a.configs != null) {
 434                     for (Iterator j=allConfigNames.iterator(); j.hasNext();) {
 435                         String cfg = (String)j.next();
 436                         if (!a.configs.contains(cfg)) {
 437                             startTag("FileConfiguration",
 438                                      new String[] {
 439                                          "Name", cfg,
 440                                          "ExcludedFromBuild", "TRUE"
 441                                      });
 442                             endTag("FileConfiguration");
 443 
 444                         }
 445                     }
 446                 }
 447 
 448                 endTag("File");
 449 
 450                 // we not gonna look at this file anymore
 451                 i.remove();
 452             }
 453         }
 454 
 455         endTag("Filter");
 456     }
 457 
 458 
 459     void writeConfiguration(BuildConfig cfg) {
 460         startTag("Configuration",
 461                  new String[] {
 462                      "Name", cfg.get("Name"),
 463                      "OutputDirectory",  cfg.get("OutputDir"),
 464                      "IntermediateDirectory",  cfg.get("OutputDir"),
 465                      "ConfigurationType", "2",
 466                      "UseOfMFC", "0",
 467                      "ATLMinimizesCRunTimeLibraryUsage", "FALSE"
 468                  }
 469                  );
 470 
 471 
 472 
 473         tagV("Tool", cfg.getV("CompilerFlags"));
 474 
 475         tag("Tool",
 476             new String[] {
 477                 "Name", "VCCustomBuildTool"
 478             }
 479             );
 480 
 481         tagV("Tool", cfg.getV("LinkerFlags"));
 482 
 483         tag("Tool",
 484             new String[] {
 485                "Name", "VCPostBuildEventTool",
 486                 "Description", BuildConfig.getFieldString(null, "PostbuildDescription"),
 487                 //Caution: String.replace(String,String) is available from JDK5 onwards only
 488                 "CommandLine", cfg.expandFormat(BuildConfig.getFieldString(null, "PostbuildCommand").replace
 489                    ("\t", "&#x0D;&#x0A;"))
 490             }
 491             );






 492 
 493         tag("Tool",
 494             new String[] {
 495                 "Name", "VCPreBuildEventTool"
 496             }
 497             );
















 498 
 499         tag("Tool",
 500             new String[] {
 501                 "Name", "VCPreLinkEventTool",
 502                 "Description", BuildConfig.getFieldString(null, "PrelinkDescription"),
 503                 //Caution: String.replace(String,String) is available from JDK5 onwards only
 504                 "CommandLine", cfg.expandFormat(BuildConfig.getFieldString(null, "PrelinkCommand").replace
 505                    ("\t", "&#x0D;&#x0A;"))
 506             }
 507             );
 508 
 509         tag("Tool",
 510             new String[] {
 511                 "Name", "VCResourceCompilerTool",
 512                 // XXX???
 513                 "PreprocessorDefinitions", "NDEBUG",
 514                 "Culture", "1033"
 515             }
 516             );
 517 
 518         tag("Tool",
 519             new String[] {
 520                 "Name", "VCMIDLTool",
 521                 "PreprocessorDefinitions", "NDEBUG",
 522                 "MkTypLibCompatible", "TRUE",
 523                 "SuppressStartupBanner", "TRUE",
 524                 "TargetEnvironment", "1",
 525                 "TypeLibraryName", cfg.get("OutputDir") + Util.sep + "vm.tlb",
 526                 "HeaderFileName", ""
 527             }
 528             );
 529 
 530         endTag("Configuration");
 531     }
 532 
 533     int indent;
 534 
 535     private void startTagPrim(String name,
 536             String[] attrs,
 537             boolean close) {
 538         startTagPrim(name, attrs, close, true);
 539     }
 540 
 541     private void startTagPrim(String name,
 542                               String[] attrs,
 543                               boolean close,
 544                               boolean newline) {
 545         doIndent();
 546         printWriter.print("<"+name);
 547         indent++;
 548 
 549         if (attrs != null && attrs.length > 0) {
 550             for (int i=0; i<attrs.length; i+=2) {
 551                 printWriter.print(" " + attrs[i]+"=\""+attrs[i+1]+"\"");
 552                 if (i < attrs.length - 2) {
 553                 }
 554             }
 555         }
 556 
 557         if (close) {
 558             indent--;
 559             printWriter.print(" />");
 560         } else {
 561                 printWriter.print(">");
 562         }
 563         if(newline) {
 564                 printWriter.println();
 565         }
 566     }
 567 
 568     void startTag(String name, String... attrs) {
 569         startTagPrim(name, attrs, false);
 570     }
 571 
 572     void startTagV(String name, Vector attrs) {
 573         String s[] = new String [attrs.size()];
 574          for (int i=0; i<attrs.size(); i++) {
 575              s[i] = (String)attrs.elementAt(i);
 576          }
 577         startTagPrim(name, s, false);
 578     }
 579 
 580     void endTag(String name) {
 581         indent--;
 582         doIndent();
 583         printWriter.println("</"+name+">");
 584     }
 585 
 586     void tag(String name, String... attrs) {
 587         startTagPrim(name, attrs, true);
 588     }
 589 
 590     void tagData(String name, String data) {
 591         doIndent();
 592         printWriter.print("<"+name+">");
 593         printWriter.print(data);
 594         printWriter.println("</"+name+">");
 595     }
 596 
 597     void tagData(String name, String data, String... attrs) {
 598         startTagPrim(name, attrs, false, false);
 599         printWriter.print(data);
 600         printWriter.println("</"+name+">");
 601         indent--;
 602     }
 603 
 604     void tagV(String name, Vector attrs) {
 605          String s[] = new String [attrs.size()];
 606          for (int i=0; i<attrs.size(); i++) {
 607              s[i] = (String)attrs.elementAt(i);
 608          }
 609          startTagPrim(name, s, true);
 610     }
 611 
 612 
 613     void doIndent() {
 614         for (int i=0; i<indent; i++) {
 615             printWriter.print("  ");
 616         }
 617     }
 618 
 619     protected String getProjectExt() {
 620         return ".vcproj";
 621     }
 622 }
 623 
 624 class CompilerInterfaceVC7 extends CompilerInterface {
 625     void getBaseCompilerFlags_common(Vector defines, Vector includes, String outDir,Vector rv) {
 626 
 627         // advanced M$ IDE (2003) can only recognize name if it's first or
 628         // second attribute in the tag - go guess
 629         addAttr(rv, "Name", "VCCLCompilerTool");
 630         addAttr(rv, "AdditionalIncludeDirectories", Util.join(",", includes));
 631         addAttr(rv, "PreprocessorDefinitions",
 632                                 Util.join(";", defines).replace("\"","&quot;"));
 633         addAttr(rv, "PrecompiledHeaderThrough", "precompiled.hpp");
 634         addAttr(rv, "PrecompiledHeaderFile", outDir+Util.sep+"vm.pch");
 635         addAttr(rv, "AssemblerListingLocation", outDir);
 636         addAttr(rv, "ObjectFile", outDir+Util.sep);
 637         addAttr(rv, "ProgramDataBaseFileName", outDir+Util.sep+"jvm.pdb");




   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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 import java.io.FileWriter;
  26 import java.io.IOException;
  27 import java.io.PrintWriter;
  28 import java.nio.file.FileSystems;


  29 import java.util.Vector;
  30 
  31 public class WinGammaPlatformVC7 extends WinGammaPlatform {
  32 
  33     String projectVersion() {return "7.10";};
  34 
  35     public void writeProjectFile(String projectFileName, String projectName,
  36                                  Vector<BuildConfig> allConfigs) throws IOException {
  37         System.out.println();
  38         System.out.println("    Writing .vcproj file: "+projectFileName);
  39         // If we got this far without an error, we're safe to actually
  40         // write the .vcproj file
  41         printWriter = new PrintWriter(new FileWriter(projectFileName));
  42 
  43       printWriter
  44       .println("<?xml version=\"1.0\" encoding=\"windows-1251\"?>");
  45       startTag("VisualStudioProject", new String[] { "ProjectType",
  46             "Visual C++", "Version", projectVersion(), "Name", projectName,



  47             "ProjectGUID", "{8822CB5C-1C41-41C2-8493-9F6E1994338B}",
  48             "SccProjectName", "", "SccLocalPath", "" });



  49       startTag("Platforms");
  50       tag("Platform",
  51             new String[] { "Name",
  52             (String) BuildConfig.getField(null, "PlatformName") });
  53       endTag();
  54 
  55         startTag("Configurations");
  56 
  57       for (BuildConfig cfg : allConfigs) { 
  58          writeConfiguration(cfg);
  59       }
  60 
  61       endTag();
  62 
  63         tag("References");
  64 
  65         writeFiles(allConfigs);
  66 
  67         tag("Globals");
  68 
  69       endTag();
  70         printWriter.close();
  71 
  72         System.out.println("    Done.");
  73     }
  74 
  75    void writeCustomToolConfig(Vector<BuildConfig> configs, String[] customToolAttrs) {
  76       for (BuildConfig cfg : configs) { 





















































































































































































  77          startTag("FileConfiguration",
  78                new String[] { "Name", (String) cfg.get("Name") });



  79          tag("Tool", customToolAttrs);
  80 
  81          endTag();




































  82       }













































  83    }
  84 
  85    void writeFiles(Vector<BuildConfig> allConfigs) {
  86 
  87       // This code assummes there are no config specific includes.








  88       startTag("Files");
  89       String sourceBase = BuildConfig.getFieldString(null, "SourceBase");
  90 
  91       // Use first config for all global absolute includes.
  92       BuildConfig baseConfig = allConfigs.firstElement();
  93       Vector<String> rv = new Vector<String>();

  94 
  95       // Then use first config for all relative includes 
  96       Vector<String> ri = new Vector<String>();        
  97       baseConfig.collectRelevantVectors(ri, "RelativeSrcInclude");
  98       for (String f : ri) {
  99          rv.add(sourceBase + Util.sep + f);
 100       }        


 101 
 102       baseConfig.collectRelevantVectors(rv, "AbsoluteSrcInclude");     

 103 
 104       handleIncludes(rv, allConfigs);     






 105 
 106       startTag("Filter", new String[] { "Name", "Resource Files", "Filter",
 107       "ico;cur;bmp;dlg;rc2;rct;bin;cnt;rtf;gif;jpg;jpeg;jpe" });
 108       endTag();
 109 
 110       endTag();


 111    }
 112 
 113    // Will visit file tree for each include
 114    private void handleIncludes(Vector<String> includes, Vector<BuildConfig> allConfigs) {
 115       for (String path : includes)  {
 116          FileTreeCreatorVC7 ftc = new FileTreeCreatorVC7(FileSystems.getDefault().getPath(path) , allConfigs, this);
 117          try {
 118             ftc.writeFileTree();
 119          } catch (IOException e) {
 120             e.printStackTrace();
 121          }




 122       }

















 123    }
 124 


























 125    void writeConfiguration(BuildConfig cfg) {
 126       startTag("Configuration", new String[] { "Name", cfg.get("Name"),


 127             "OutputDirectory", cfg.get("OutputDir"),
 128             "IntermediateDirectory", cfg.get("OutputDir"),
 129             "ConfigurationType", "2", "UseOfMFC", "0",
 130             "ATLMinimizesCRunTimeLibraryUsage", "FALSE" });





 131 
 132       tagV("Tool", cfg.getV("CompilerFlags"));
 133 
 134       tag("Tool", new String[] { "Name", "VCCustomBuildTool" });




 135 
 136       tagV("Tool", cfg.getV("LinkerFlags"));
 137 
 138       tag("Tool",
 139             new String[] {
 140             "Name",
 141             "VCPostBuildEventTool",
 142             "Description",
 143             BuildConfig
 144             .getFieldString(null, "PostbuildDescription"),
 145             // Caution: String.replace(String,String) is available
 146             // from JDK5 onwards only
 147             "CommandLine",
 148             cfg.expandFormat(BuildConfig.getFieldString(null,
 149                   "PostbuildCommand").replace("\t",
 150                         "&#x0D;&#x0A;")) });
 151 
 152       tag("Tool", new String[] { "Name", "VCPreBuildEventTool" });
 153 
 154       tag("Tool",
 155             new String[] {
 156             "Name",
 157             "VCPreLinkEventTool",
 158             "Description",
 159             BuildConfig.getFieldString(null, "PrelinkDescription"),
 160             // Caution: String.replace(String,String) is available
 161             // from JDK5 onwards only
 162             "CommandLine",
 163             cfg.expandFormat(BuildConfig.getFieldString(null,
 164                   "PrelinkCommand").replace("\t", "&#x0D;&#x0A;")) });
 165 
 166       tag("Tool", new String[] { "Name", "VCResourceCompilerTool",
 167             "PreprocessorDefinitions", "NDEBUG", "Culture", "1033" });
 168 
 169       tag("Tool", new String[] { "Name", "VCMIDLTool",
 170             "PreprocessorDefinitions", "NDEBUG", "MkTypLibCompatible",
 171             "TRUE", "SuppressStartupBanner", "TRUE", "TargetEnvironment",
 172             "1", "TypeLibraryName",
 173             cfg.get("OutputDir") + Util.sep + "vm.tlb", "HeaderFileName",
 174       "" });
 175 
 176       endTag();














































































































 177    }
 178 
 179 





 180 
 181     protected String getProjectExt() {
 182         return ".vcproj";
 183     }
 184 }
 185 
 186 class CompilerInterfaceVC7 extends CompilerInterface {
 187     void getBaseCompilerFlags_common(Vector defines, Vector includes, String outDir,Vector rv) {
 188 
 189         // advanced M$ IDE (2003) can only recognize name if it's first or
 190         // second attribute in the tag - go guess
 191         addAttr(rv, "Name", "VCCLCompilerTool");
 192         addAttr(rv, "AdditionalIncludeDirectories", Util.join(",", includes));
 193         addAttr(rv, "PreprocessorDefinitions",
 194                                 Util.join(";", defines).replace("\"","&quot;"));
 195         addAttr(rv, "PrecompiledHeaderThrough", "precompiled.hpp");
 196         addAttr(rv, "PrecompiledHeaderFile", outDir+Util.sep+"vm.pch");
 197         addAttr(rv, "AssemblerListingLocation", outDir);
 198         addAttr(rv, "ObjectFile", outDir+Util.sep);
 199         addAttr(rv, "ProgramDataBaseFileName", outDir+Util.sep+"jvm.pdb");