Source/cmLocalVisualStudio7Generator.cxx

   1 /*=========================================================================
   2
   3   Program:   CMake - Cross-Platform Makefile Generator
   4   Module:    $RCSfile: cmLocalVisualStudio7Generator.cxx,v $
   5   Language:  C++
   6   Date:      $Date: 2009-07-28 18:30:15 $
   7   Version:   $Revision: 1.249 $
   8
   9   Copyright (c) 2002 Kitware, Inc., Insight Consortium.  All rights reserved.
  10   See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
  11
  12      This software is distributed WITHOUT ANY WARRANTY; without even
  13      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  14      PURPOSE.  See the above copyright notices for more information.
  15
  16 =========================================================================*/
  17 #include "cmGlobalVisualStudio7Generator.h"
  18 #include "cmLocalVisualStudio7Generator.h"
  19 #include "cmXMLParser.h"
  20 #include <cm_expat.h>
  21 #include "cmMakefile.h"
  22 #include "cmSystemTools.h"
  23 #include "cmSourceFile.h"
  24 #include "cmCacheManager.h"
  25 #include "cmake.h"
  26
  27 #include "cmComputeLinkInformation.h"
  28 #include "cmGeneratedFileStream.h"
  29
  30 #include <cmsys/System.h>
  31
  32 #include <ctype.h> // for isspace
  33
  34 static bool cmLVS6G_IsFAT(const char* dir);
  35
  36 class cmLocalVisualStudio7GeneratorInternals
  37 {
  38 public:
  39   cmLocalVisualStudio7GeneratorInternals(cmLocalVisualStudio7Generator* e):
  40     LocalGenerator(e) {}
  41   typedef cmComputeLinkInformation::ItemVector ItemVector;
  42   void OutputLibraries(std::ostream& fout, ItemVector const& libs);
  43 private:
  44   cmLocalVisualStudio7Generator* LocalGenerator;
  45 };
  46
  47 extern cmVS7FlagTable cmLocalVisualStudio7GeneratorFlagTable[];
  48
  49 //----------------------------------------------------------------------------
  50 cmLocalVisualStudio7Generator::cmLocalVisualStudio7Generator()
  51 {
  52   this->Version = 7;
  53   this->PlatformName = "Win32";
  54   this->ExtraFlagTable = 0;
  55   this->Internal = new cmLocalVisualStudio7GeneratorInternals(this);
  56 }
  57
  58 cmLocalVisualStudio7Generator::~cmLocalVisualStudio7Generator()
  59 {
  60   delete this->Internal;
  61 }
  62
  63 void cmLocalVisualStudio7Generator::AddHelperCommands()
  64 {
  65   std::set<cmStdString> lang;
  66   lang.insert("C");
  67   lang.insert("CXX");
  68   lang.insert("RC");
  69   lang.insert("IDL");
  70   lang.insert("DEF");
  71   lang.insert("Fortran");
  72   this->CreateCustomTargetsAndCommands(lang);
  73   this->FixGlobalTargets();
  74 }
  75
  76 void cmLocalVisualStudio7Generator::Generate()
  77 {
  78   this->WriteProjectFiles();
  79   this->WriteStampFiles();
  80 }
  81
  82 void cmLocalVisualStudio7Generator::FixGlobalTargets()
  83 {
  84   // Visual Studio .NET 2003 Service Pack 1 will not run post-build
  85   // commands for targets in which no sources are built.  Add dummy
  86   // rules to force these targets to build.
  87   cmTargets &tgts = this->Makefile->GetTargets();
  88   for(cmTargets::iterator l = tgts.begin();
  89       l != tgts.end(); l++)
  90     {
  91     cmTarget& tgt = l->second;
  92     if(tgt.GetType() == cmTarget::GLOBAL_TARGET)
  93       {
  94       std::vector<std::string> no_depends;
  95       cmCustomCommandLine force_command;
  96       force_command.push_back("cd");
  97       force_command.push_back(".");
  98       cmCustomCommandLines force_commands;
  99       force_commands.push_back(force_command);
 100       const char* no_main_dependency = 0;
 101       std::string force = this->Makefile->GetStartOutputDirectory();
 102       force += cmake::GetCMakeFilesDirectory();
 103       force += "/";
 104       force += tgt.GetName();
 105       force += "_force";
 106       this->Makefile->AddCustomCommandToOutput(force.c_str(), no_depends,
 107                                                no_main_dependency,
 108                                                force_commands, " ", 0, true);
 109       if(cmSourceFile* file =
 110          this->Makefile->GetSourceFileWithOutput(force.c_str()))
 111         {
 112         tgt.AddSourceFile(file);
 113         }
 114       }
 115     }
 116 }
 117
 118 // TODO
 119 // for CommandLine= need to repleace quotes with &quot
 120 // write out configurations
 121 void cmLocalVisualStudio7Generator::WriteProjectFiles()
 122 {
 123   // If not an in source build, then create the output directory
 124   if(strcmp(this->Makefile->GetStartOutputDirectory(),
 125             this->Makefile->GetHomeDirectory()) != 0)
 126     {
 127     if(!cmSystemTools::MakeDirectory
 128        (this->Makefile->GetStartOutputDirectory()))
 129       {
 130       cmSystemTools::Error("Error creating directory ",
 131                            this->Makefile->GetStartOutputDirectory());
 132       }
 133     }
 134
 135   // Get the set of targets in this directory.
 136   cmTargets &tgts = this->Makefile->GetTargets();
 137
 138   // Create the regeneration custom rule.
 139   if(!this->Makefile->IsOn("CMAKE_SUPPRESS_REGENERATION"))
 140     {
 141     // Create a rule to regenerate the build system when the target
 142     // specification source changes.
 143     if(cmSourceFile* sf = this->CreateVCProjBuildRule())
 144       {
 145       // Add the rule to targets that need it.
 146       for(cmTargets::iterator l = tgts.begin(); l != tgts.end(); ++l)
 147         {
 148         if(l->first != CMAKE_CHECK_BUILD_SYSTEM_TARGET)
 149           {
 150           l->second.AddSourceFile(sf);
 151           }
 152         }
 153       }
 154     }
 155
 156   // Create the project file for each target.
 157   for(cmTargets::iterator l = tgts.begin();
 158       l != tgts.end(); l++)
 159     {
 160     // INCLUDE_EXTERNAL_MSPROJECT command only affects the workspace
 161     // so don't build a projectfile for it
 162     if(!l->second.GetProperty("EXTERNAL_MSPROJECT"))
 163       {
 164       this->CreateSingleVCProj(l->first.c_str(),l->second);
 165       }
 166     }
 167 }
 168
 169 //----------------------------------------------------------------------------
 170 void cmLocalVisualStudio7Generator::WriteStampFiles()
 171 {
 172   // Touch a timestamp file used to determine when the project file is
 173   // out of date.
 174   std::string stampName = this->Makefile->GetStartOutputDirectory();
 175   stampName += cmake::GetCMakeFilesDirectory();
 176   cmSystemTools::MakeDirectory(stampName.c_str());
 177   stampName += "/";
 178   stampName += "generate.stamp";
 179   std::ofstream stamp(stampName.c_str());
 180   stamp << "# CMake generation timestamp file this directory.\n";
 181
 182   // Create a helper file so CMake can determine when it is run
 183   // through the rule created by CreateVCProjBuildRule whether it
 184   // really needs to regenerate the project.  This file lists its own
 185   // dependencies.  If any file listed in it is newer than itself then
 186   // CMake must rerun.  Otherwise the project files are up to date and
 187   // the stamp file can just be touched.
 188   std::string depName = stampName;
 189   depName += ".depend";
 190   std::ofstream depFile(depName.c_str());
 191   depFile << "# CMake generation dependency list for this directory.\n";
 192   std::vector<std::string> const& listFiles = this->Makefile->GetListFiles();
 193   for(std::vector<std::string>::const_iterator lf = listFiles.begin();
 194       lf != listFiles.end(); ++lf)
 195     {
 196     depFile << *lf << std::endl;
 197     }
 198 }
 199
 200 //----------------------------------------------------------------------------
 201 void cmLocalVisualStudio7Generator
 202 ::CreateSingleVCProj(const char *lname, cmTarget &target)
 203 {
 204   this->FortranProject =
 205     static_cast<cmGlobalVisualStudioGenerator*>(this->GlobalGenerator)
 206     ->TargetIsFortranOnly(target);
 207   // add to the list of projects
 208   std::string pname = lname;
 209   target.SetProperty("GENERATOR_FILE_NAME",lname);
 210   // create the dsp.cmake file
 211   std::string fname;
 212   fname = this->Makefile->GetStartOutputDirectory();
 213   fname += "/";
 214   fname += lname;
 215   if(this->FortranProject)
 216     {
 217     fname += ".vfproj";
 218     }
 219   else
 220     {
 221     fname += ".vcproj";
 222     }
 223
 224   // Generate the project file and replace it atomically with
 225   // copy-if-different.  We use a separate timestamp so that the IDE
 226   // does not reload project files unnecessarily.
 227   cmGeneratedFileStream fout(fname.c_str());
 228   fout.SetCopyIfDifferent(true);
 229   this->WriteVCProjFile(fout,lname,target);
 230   if (fout.Close())
 231     {
 232     this->GlobalGenerator->FileReplacedDuringGenerate(fname);
 233     }
 234 }
 235
 236 //----------------------------------------------------------------------------
 237 cmSourceFile* cmLocalVisualStudio7Generator::CreateVCProjBuildRule()
 238 {
 239   std::string stampName = cmake::GetCMakeFilesDirectoryPostSlash();
 240   stampName += "generate.stamp";
 241   const char* dsprule =
 242     this->Makefile->GetRequiredDefinition("CMAKE_COMMAND");
 243   cmCustomCommandLine commandLine;
 244   commandLine.push_back(dsprule);
 245   std::string makefileIn = this->Makefile->GetStartDirectory();
 246   makefileIn += "/";
 247   makefileIn += "CMakeLists.txt";
 248   makefileIn = cmSystemTools::CollapseFullPath(makefileIn.c_str());
 249   std::string comment = "Building Custom Rule ";
 250   comment += makefileIn;
 251   std::string args;
 252   args = "-H";
 253   args += this->Convert(this->Makefile->GetHomeDirectory(),
 254                         START_OUTPUT, UNCHANGED, true);
 255   commandLine.push_back(args);
 256   args = "-B";
 257   args +=
 258     this->Convert(this->Makefile->GetHomeOutputDirectory(),
 259                   START_OUTPUT, UNCHANGED, true);
 260   commandLine.push_back(args);
 261   commandLine.push_back("--check-stamp-file");
 262   commandLine.push_back(stampName.c_str());
 263
 264   std::vector<std::string> const& listFiles = this->Makefile->GetListFiles();
 265
 266   cmCustomCommandLines commandLines;
 267   commandLines.push_back(commandLine);
 268   const char* no_working_directory = 0;
 269   this->Makefile->AddCustomCommandToOutput(stampName.c_str(), listFiles,
 270                                            makefileIn.c_str(), commandLines,
 271                                            comment.c_str(),
 272                                            no_working_directory, true);
 273   if(cmSourceFile* file = this->Makefile->GetSource(makefileIn.c_str()))
 274     {
 275     return file;
 276     }
 277   else
 278     {
 279     cmSystemTools::Error("Error adding rule for ", makefileIn.c_str());
 280     return 0;
 281     }
 282 }
 283
 284 void cmLocalVisualStudio7Generator::WriteConfigurations(std::ostream& fout,
 285                                                         const char *libName,
 286                                                         cmTarget &target)
 287 {
 288   std::vector<std::string> *configs =
 289     static_cast<cmGlobalVisualStudio7Generator *>
 290     (this->GlobalGenerator)->GetConfigurations();
 291
 292   fout << "\t<Configurations>\n";
 293   for( std::vector<std::string>::iterator i = configs->begin();
 294        i != configs->end(); ++i)
 295     {
 296     this->WriteConfiguration(fout, i->c_str(), libName, target);
 297     }
 298   fout << "\t</Configurations>\n";
 299 }
 300 cmVS7FlagTable cmLocalVisualStudio7GeneratorFortranFlagTable[] =
 301 {
 302   {"Preprocess", "fpp", "Run Preprocessor on files", "preprocessYes", 0},
 303   {"SuppressStartupBanner", "nologo", "SuppressStartupBanner", "true", 0},
 304   {"DebugInformationFormat", "Zi", "full debug", "debugEnabled", 0},
 305   {"DebugInformationFormat", "debug:full", "full debug", "debugEnabled", 0},
 306   {"DebugInformationFormat", "Z7", "c7 compat", "debugOldStyleInfo", 0},
 307   {"DebugInformationFormat", "Zd", "line numbers", "debugLineInfoOnly", 0},
 308   {"Optimization", "Od", "disable optimization", "optimizeDisabled", 0},
 309   {"Optimization", "O1", "min space", "optimizeMinSpace", 0},
 310   {"Optimization", "O3", "full optimize", "optimizeFull", 0},
 311   {"GlobalOptimizations", "Og", "global optimize", "true", 0},
 312   {"InlineFunctionExpansion", "Ob0", "", "expandDisable", 0},
 313   {"InlineFunctionExpansion", "Ob1", "", "expandOnlyInline", 0},
 314   {"FavorSizeOrSpeed", "Os", "", "favorSize", 0},
 315   {"OmitFramePointers", "Oy-", "", "false", 0},
 316   {"OptimizeForProcessor", "GB", "", "procOptimizeBlended", 0},
 317   {"OptimizeForProcessor", "G5", "", "procOptimizePentium", 0},
 318   {"OptimizeForProcessor", "G6", "", "procOptimizePentiumProThruIII", 0},
 319   {"UseProcessorExtensions", "QzxK", "", "codeForStreamingSIMD", 0},
 320   {"OptimizeForProcessor", "QaxN", "", "codeForPentium4", 0},
 321   {"OptimizeForProcessor", "QaxB", "", "codeForPentiumM", 0},
 322   {"OptimizeForProcessor", "QaxP", "", "codeForCodeNamedPrescott", 0},
 323   {"OptimizeForProcessor", "QaxT", "", "codeForCore2Duo", 0},
 324   {"OptimizeForProcessor", "QxK", "", "codeExclusivelyStreamingSIMD", 0},
 325   {"OptimizeForProcessor", "QxN", "", "codeExclusivelyPentium4", 0},
 326   {"OptimizeForProcessor", "QxB", "", "codeExclusivelyPentiumM", 0},
 327   {"OptimizeForProcessor", "QxP", "", "codeExclusivelyCodeNamedPrescott", 0},
 328   {"OptimizeForProcessor", "QxT", "", "codeExclusivelyCore2Duo", 0},
 329   {"OptimizeForProcessor", "QxO", "", "codeExclusivelyCore2StreamingSIMD", 0},
 330   {"OptimizeForProcessor", "QxS", "", "codeExclusivelyCore2StreamingSIMD4", 0},
 331
 332   {"ModulePath", "module:", "", "",
 333    cmVS7FlagTable::UserValueRequired},
 334   {"LoopUnrolling", "Qunroll:", "", "",
 335    cmVS7FlagTable::UserValueRequired},
 336   {"AutoParallelThreshold", "Qpar-threshold:", "", "",
 337    cmVS7FlagTable::UserValueRequired},
 338   {"HeapArrays", "heap-arrays:", "", "",
 339    cmVS7FlagTable::UserValueRequired},
 340   {"ObjectText", "bintext:", "", "",
 341    cmVS7FlagTable::UserValueRequired},
 342   {"Parallelization", "Qparallel", "", "true", 0},
 343   {"PrefetchInsertion", "Qprefetch-", "", "false", 0},
 344   {"BufferedIO", "assume:buffered_io", "", "true", 0},
 345   {"CallingConvention", "iface:stdcall", "", "callConventionStdCall", 0},
 346   {"CallingConvention", "iface:cref", "", "callConventionCRef", 0},
 347   {"CallingConvention", "iface:stdref", "", "callConventionStdRef", 0},
 348   {"CallingConvention", "iface:stdcall", "", "callConventionStdCall", 0},
 349   {"CallingConvention", "iface:cvf", "", "callConventionCVF", 0},
 350   {"EnableRecursion", "recursive", "", "true", 0},
 351   {"ReentrantCode", "reentrancy", "", "true", 0},
 352   // done up to Language
 353   {0,0,0,0,0}
 354 };
 355 // fill the table here currently the comment field is not used for
 356 // anything other than documentation NOTE: Make sure the longer
 357 // commandFlag comes FIRST!
 358 cmVS7FlagTable cmLocalVisualStudio7GeneratorFlagTable[] =
 359 {
 360   // option flags (some flags map to the same option)
 361   {"BasicRuntimeChecks", "GZ", "Stack frame checks", "1", 0},
 362   {"BasicRuntimeChecks", "RTCsu",
 363    "Both stack and uninitialized checks", "3", 0},
 364   {"BasicRuntimeChecks", "RTCs", "Stack frame checks", "1", 0},
 365   {"BasicRuntimeChecks", "RTCu", "Uninitialized Variables ", "2", 0},
 366   {"BasicRuntimeChecks", "RTC1",
 367    "Both stack and uninitialized checks", "3", 0},
 368   {"DebugInformationFormat", "Z7", "debug format", "1", 0},
 369   {"DebugInformationFormat", "Zd", "debug format", "2", 0},
 370   {"DebugInformationFormat", "Zi", "debug format", "3", 0},
 371   {"DebugInformationFormat", "ZI", "debug format", "4", 0},
 372   {"EnableEnhancedInstructionSet", "arch:SSE2",
 373    "Use sse2 instructions", "2", 0},
 374   {"EnableEnhancedInstructionSet", "arch:SSE",
 375    "Use sse instructions",   "1", 0},
 376   {"FavorSizeOrSpeed",  "Ot", "Favor fast code",  "1", 0},
 377   {"FavorSizeOrSpeed",  "Os", "Favor small code", "2", 0},
 378   {"CompileAs", "TC", "Compile as c code",        "1", 0},
 379   {"CompileAs", "TP", "Compile as c++ code",      "2", 0},
 380   {"Optimization", "Od", "Non Debug",        "0", 0},
 381   {"Optimization", "O1", "Min Size",         "1", 0},
 382   {"Optimization", "O2", "Max Speed",        "2", 0},
 383   {"Optimization", "Ox", "Max Optimization", "3", 0},
 384   {"OptimizeForProcessor", "GB", "Blended processor mode", "0", 0},
 385   {"OptimizeForProcessor", "G5", "Pentium",                "1", 0},
 386   {"OptimizeForProcessor", "G6", "PPro PII PIII",          "2", 0},
 387   {"OptimizeForProcessor", "G7", "Pentium 4 or Athlon",    "3", 0},
 388   {"InlineFunctionExpansion", "Ob0", "no inlines",              "0", 0},
 389   {"InlineFunctionExpansion", "Ob1", "when inline keyword",     "1", 0},
 390   {"InlineFunctionExpansion", "Ob2", "any time you can inline", "2", 0},
 391   {"RuntimeLibrary", "MTd", "Multithreded debug",     "1", 0},
 392   {"RuntimeLibrary", "MT", "Multithreded", "0", 0},
 393   {"RuntimeLibrary", "MDd", "Multithreded dll debug", "3", 0},
 394   {"RuntimeLibrary", "MD", "Multithreded dll",        "2", 0},
 395   {"RuntimeLibrary", "MLd", "Sinble Thread debug",    "5", 0},
 396   {"RuntimeLibrary", "ML", "Sinble Thread",           "4", 0},
 397   {"StructMemberAlignment", "Zp16", "struct align 16 byte ",   "5", 0},
 398   {"StructMemberAlignment", "Zp1", "struct align 1 byte ",     "1", 0},
 399   {"StructMemberAlignment", "Zp2", "struct align 2 byte ",     "2", 0},
 400   {"StructMemberAlignment", "Zp4", "struct align 4 byte ",     "3", 0},
 401   {"StructMemberAlignment", "Zp8", "struct align 8 byte ",     "4", 0},
 402   {"WarningLevel", "W0", "Warning level", "0", 0},
 403   {"WarningLevel", "W1", "Warning level", "1", 0},
 404   {"WarningLevel", "W2", "Warning level", "2", 0},
 405   {"WarningLevel", "W3", "Warning level", "3", 0},
 406   {"WarningLevel", "W4", "Warning level", "4", 0},
 407   {"DisableSpecificWarnings", "wd", "Disable specific warnings", "",
 408    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
 409
 410   // Precompiled header and related options.  Note that the
 411   // UsePrecompiledHeader entries are marked as "Continue" so that the
 412   // corresponding PrecompiledHeaderThrough entry can be found.
 413   {"UsePrecompiledHeader", "Yc", "Create Precompiled Header", "1",
 414    cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue},
 415   {"PrecompiledHeaderThrough", "Yc", "Precompiled Header Name", "",
 416    cmVS7FlagTable::UserValueRequired},
 417   {"PrecompiledHeaderFile", "Fp", "Generated Precompiled Header", "",
 418    cmVS7FlagTable::UserValue},
 419   // The YX and Yu options are in a per-global-generator table because
 420   // their values differ based on the VS IDE version.
 421   {"ForcedIncludeFiles", "FI", "Forced include files", "",
 422    cmVS7FlagTable::UserValueRequired},
 423
 424   // boolean flags
 425   {"BufferSecurityCheck", "GS", "Buffer security check", "TRUE", 0},
 426   {"BufferSecurityCheck", "GS-", "Turn off Buffer security check", "FALSE", 0},
 427   {"Detect64BitPortabilityProblems", "Wp64",
 428    "Detect 64-bit Portability Problems", "TRUE", 0},
 429   {"EnableFiberSafeOptimizations", "GT", "Enable Fiber-safe Optimizations",
 430    "TRUE", 0},
 431   {"EnableFunctionLevelLinking", "Gy",
 432    "EnableFunctionLevelLinking", "TRUE", 0},
 433   {"EnableIntrinsicFunctions", "Oi", "EnableIntrinsicFunctions", "TRUE", 0},
 434   {"GlobalOptimizations", "Og", "Global Optimize", "TRUE", 0},
 435   {"ImproveFloatingPointConsistency", "Op",
 436    "ImproveFloatingPointConsistency", "TRUE", 0},
 437   {"MinimalRebuild", "Gm", "minimal rebuild", "TRUE", 0},
 438   {"OmitFramePointers", "Oy", "OmitFramePointers", "TRUE", 0},
 439   {"OptimizeForWindowsApplication", "GA", "Optimize for windows", "TRUE", 0},
 440   {"RuntimeTypeInfo", "GR",
 441    "Turn on Run time type information for c++", "TRUE", 0},
 442   {"RuntimeTypeInfo", "GR-",
 443    "Turn off Run time type information for c++", "FALSE", 0},
 444   {"SmallerTypeCheck", "RTCc", "smaller type check", "TRUE", 0},
 445   {"SuppressStartupBanner", "nologo", "SuppressStartupBanner", "TRUE", 0},
 446   {"WarnAsError", "WX", "Treat warnings as errors", "TRUE", 0},
 447   {0,0,0,0,0}
 448 };
 449
 450
 451
 452 cmVS7FlagTable cmLocalVisualStudio7GeneratorLinkFlagTable[] =
 453 {
 454   // option flags (some flags map to the same option)
 455   {"GenerateManifest", "MANIFEST:NO",
 456    "disable manifest generation", "FALSE", 0},
 457   {"GenerateManifest", "MANIFEST", "enable manifest generation", "TRUE", 0},
 458   {"LinkIncremental", "INCREMENTAL:NO", "link incremental", "1", 0},
 459   {"LinkIncremental", "INCREMENTAL:YES", "link incremental", "2", 0},
 460   {"IgnoreDefaultLibraryNames", "NODEFAULTLIB:", "default libs to ignore", "",
 461   cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
 462   {"IgnoreAllDefaultLibraries", "NODEFAULTLIB", "ignore all default libs",
 463    "TRUE", 0},
 464   {"FixedBaseAddress", "FIXED:NO", "Generate a relocation section", "1", 0},
 465   {"FixedBaseAddress", "FIXED", "Image must be loaded at a fixed address",
 466    "2", 0},
 467   {"EnableCOMDATFolding", "OPT:NOICF", "Do not remove redundant COMDATs",
 468    "1", 0},
 469   {"EnableCOMDATFolding", "OPT:ICF", "Remove redundant COMDATs", "2", 0},
 470   {"OptimizeReferences", "OPT:NOREF", "Keep unreferenced data", "1", 0},
 471   {"OptimizeReferences", "OPT:REF", "Eliminate unreferenced data", "2", 0},
 472   {"TargetMachine", "MACHINE:I386", "Machine x86", "1", 0},
 473   {"TargetMachine", "MACHINE:X86", "Machine x86", "1", 0},
 474   {"TargetMachine", "MACHINE:X64", "Machine x64", "17", 0},
 475   {"ModuleDefinitionFile", "DEF:", "add an export def file", "",
 476    cmVS7FlagTable::UserValue},
 477   {"GenerateMapFile", "MAP", "enable generation of map file", "TRUE", 0},
 478   {0,0,0,0,0}
 479 };
 480
 481 //----------------------------------------------------------------------------
 482 // Helper class to write build event <Tool .../> elements.
 483 class cmLocalVisualStudio7Generator::EventWriter
 484 {
 485 public:
 486   EventWriter(cmLocalVisualStudio7Generator* lg,
 487               const char* config, std::ostream& os):
 488     LG(lg), Config(config), Stream(os), First(true) {}
 489   void Start(const char* tool)
 490     {
 491     this->First = true;
 492     this->Stream << "\t\t\t<Tool\n\t\t\t\tName=\"" << tool << "\"";
 493     }
 494   void Finish()
 495     {
 496     this->Stream << (this->First? "" : "\"") << "/>\n";
 497     }
 498   void Write(std::vector<cmCustomCommand> const& ccs)
 499     {
 500     for(std::vector<cmCustomCommand>::const_iterator ci = ccs.begin();
 501         ci != ccs.end(); ++ci)
 502       {
 503       this->Write(*ci);
 504       }
 505     }
 506   void Write(cmCustomCommand const& cc)
 507     {
 508     if(this->First)
 509       {
 510       const char* comment = cc.GetComment();
 511       if(comment && *comment)
 512         {
 513         this->Stream << "\nDescription=\""
 514                      << this->LG->EscapeForXML(comment) << "\"";
 515         }
 516       this->Stream << "\nCommandLine=\"";
 517       this->First = false;
 518       }
 519     else
 520       {
 521       this->Stream << this->LG->EscapeForXML("\n");
 522       }
 523     std::string script =
 524       this->LG->ConstructScript(cc.GetCommandLines(),
 525                                 cc.GetWorkingDirectory(),
 526                                 this->Config,
 527                                 cc.GetEscapeOldStyle(),
 528                                 cc.GetEscapeAllowMakeVars());
 529     this->Stream << this->LG->EscapeForXML(script.c_str());
 530     }
 531 private:
 532   cmLocalVisualStudio7Generator* LG;
 533   const char* Config;
 534   std::ostream& Stream;
 535   bool First;
 536 };
 537
 538 //----------------------------------------------------------------------------
 539 void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout,
 540                                                        const char* configName,
 541                                                        const char *libName,
 542                                                        cmTarget &target)
 543 {
 544   const char* mfcFlag = this->Makefile->GetDefinition("CMAKE_MFC_FLAG");
 545   if(!mfcFlag)
 546     {
 547     mfcFlag = "0";
 548     }
 549   fout << "\t\t<Configuration\n"
 550        << "\t\t\tName=\"" << configName << "|" << this->PlatformName << "\"\n"
 551        << "\t\t\tOutputDirectory=\"" << configName << "\"\n";
 552   // This is an internal type to Visual Studio, it seems that:
 553   // 4 == static library
 554   // 2 == dll
 555   // 1 == executable
 556   // 10 == utility
 557   const char* configType = "10";
 558   const char* projectType = 0;
 559   bool targetBuilds = true;
 560   switch(target.GetType())
 561     {
 562     case cmTarget::STATIC_LIBRARY:
 563       projectType = "typeStaticLibrary";
 564       configType = "4";
 565       break;
 566     case cmTarget::SHARED_LIBRARY:
 567     case cmTarget::MODULE_LIBRARY:
 568       projectType = "typeDynamicLibrary";
 569       configType = "2";
 570       break;
 571     case cmTarget::EXECUTABLE:
 572       configType = "1";
 573       break;
 574     case cmTarget::UTILITY:
 575     case cmTarget::GLOBAL_TARGET:
 576       configType = "10";
 577     default:
 578       targetBuilds = false;
 579       break;
 580     }
 581   if(this->FortranProject && projectType)
 582     {
 583     configType = projectType;
 584     }
 585   std::string flags;
 586   if(strcmp(configType, "10") != 0)
 587     {
 588     const char* linkLanguage = target.GetLinkerLanguage(configName);
 589     if(!linkLanguage)
 590       {
 591       cmSystemTools::Error
 592         ("CMake can not determine linker language for target:",
 593          target.GetName());
 594       return;
 595       }
 596     if(strcmp(linkLanguage, "C") == 0 || strcmp(linkLanguage, "CXX") == 0
 597       || strcmp(linkLanguage, "Fortran") == 0)
 598       {
 599       std::string baseFlagVar = "CMAKE_";
 600       baseFlagVar += linkLanguage;
 601       baseFlagVar += "_FLAGS";
 602       flags = this->Makefile->GetRequiredDefinition(baseFlagVar.c_str());
 603       std::string flagVar = baseFlagVar + std::string("_") +
 604         cmSystemTools::UpperCase(configName);
 605       flags += " ";
 606       flags += this->Makefile->GetRequiredDefinition(flagVar.c_str());
 607       }
 608     // set the correct language
 609     if(strcmp(linkLanguage, "C") == 0)
 610       {
 611       flags += " /TC ";
 612       }
 613     if(strcmp(linkLanguage, "CXX") == 0)
 614       {
 615       flags += " /TP ";
 616       }
 617     }
 618
 619   // Add the target-specific flags.
 620   if(const char* targetFlags = target.GetProperty("COMPILE_FLAGS"))
 621     {
 622     flags += " ";
 623     flags += targetFlags;
 624     }
 625
 626   std::string configUpper = cmSystemTools::UpperCase(configName);
 627   std::string defPropName = "COMPILE_DEFINITIONS_";
 628   defPropName += configUpper;
 629
 630   // Get preprocessor definitions for this directory.
 631   std::string defineFlags = this->Makefile->GetDefineFlags();
 632   Options::Tool t = Options::Compiler;
 633   cmVS7FlagTable const* table = cmLocalVisualStudio7GeneratorFlagTable;
 634   if(this->FortranProject)
 635     {
 636     t = Options::FortranCompiler;
 637     table = cmLocalVisualStudio7GeneratorFortranFlagTable;
 638     }
 639   Options targetOptions(this, this->Version, t,
 640                         table,
 641                         this->ExtraFlagTable);
 642   targetOptions.FixExceptionHandlingDefault();
 643   targetOptions.Parse(flags.c_str());
 644   targetOptions.Parse(defineFlags.c_str());
 645   targetOptions.AddDefines
 646     (this->Makefile->GetProperty("COMPILE_DEFINITIONS"));
 647   targetOptions.AddDefines(target.GetProperty("COMPILE_DEFINITIONS"));
 648   targetOptions.AddDefines(this->Makefile->GetProperty(defPropName.c_str()));
 649   targetOptions.AddDefines(target.GetProperty(defPropName.c_str()));
 650   targetOptions.SetVerboseMakefile(
 651     this->Makefile->IsOn("CMAKE_VERBOSE_MAKEFILE"));
 652
 653   // Add a definition for the configuration name.
 654   std::string configDefine = "CMAKE_INTDIR=\"";
 655   configDefine += configName;
 656   configDefine += "\"";
 657   targetOptions.AddDefine(configDefine);
 658
 659   // Add the export symbol definition for shared library objects.
 660   if(const char* exportMacro = target.GetExportMacro())
 661     {
 662     targetOptions.AddDefine(exportMacro);
 663     }
 664
 665   // The intermediate directory name consists of a directory for the
 666   // target and a subdirectory for the configuration name.
 667   std::string intermediateDir = this->GetTargetDirectory(target);
 668   intermediateDir += "/";
 669   intermediateDir += configName;
 670   fout << "\t\t\tIntermediateDirectory=\""
 671        << this->ConvertToXMLOutputPath(intermediateDir.c_str())
 672        << "\"\n"
 673        << "\t\t\tConfigurationType=\"" << configType << "\"\n"
 674        << "\t\t\tUseOfMFC=\"" << mfcFlag << "\"\n"
 675        << "\t\t\tATLMinimizesCRunTimeLibraryUsage=\"FALSE\"\n";
 676
 677   // If unicode is enabled change the character set to unicode, if not
 678   // then default to MBCS.
 679   if(targetOptions.UsingUnicode())
 680     {
 681     fout << "\t\t\tCharacterSet=\"1\">\n";
 682     }
 683   else
 684     {
 685     fout << "\t\t\tCharacterSet=\"2\">\n";
 686     }
 687   const char* tool = "VCCLCompilerTool";
 688   if(this->FortranProject)
 689     {
 690     tool = "VFFortranCompilerTool";
 691     }
 692   fout << "\t\t\t<Tool\n"
 693        << "\t\t\t\tName=\"" << tool << "\"\n";
 694   if(this->FortranProject)
 695     {
 696     const char* target_mod_dir =
 697       target.GetProperty("Fortran_MODULE_DIRECTORY");
 698     std::string modDir;
 699     if(target_mod_dir)
 700       {
 701       modDir = this->Convert(target_mod_dir,
 702                              cmLocalGenerator::START_OUTPUT,
 703                              cmLocalGenerator::UNCHANGED);
 704       }
 705     else
 706       {
 707       modDir = ".";
 708       }
 709     fout << "\t\t\t\tModulePath=\""
 710          << this->ConvertToXMLOutputPath(modDir.c_str())
 711          << "\\$(ConfigurationName)\"\n";
 712     }
 713   targetOptions.OutputAdditionalOptions(fout, "\t\t\t\t", "\n");
 714   fout << "\t\t\t\tAdditionalIncludeDirectories=\"";
 715   std::vector<std::string> includes;
 716   this->GetIncludeDirectories(includes);
 717   std::vector<std::string>::iterator i = includes.begin();
 718   for(;i != includes.end(); ++i)
 719     {
 720     // output the include path
 721     std::string ipath = this->ConvertToXMLOutputPath(i->c_str());
 722     fout << ipath << ";";
 723     // if this is fortran then output the include with
 724     // a ConfigurationName on the end of it.
 725     if(this->FortranProject)
 726       {
 727       ipath = i->c_str();
 728       ipath += "/$(ConfigurationName)";
 729       ipath = this->ConvertToXMLOutputPath(ipath.c_str());
 730       fout << ipath << ";";
 731       }
 732     }
 733   fout << "\"\n";
 734   targetOptions.OutputFlagMap(fout, "\t\t\t\t");
 735   targetOptions.OutputPreprocessorDefinitions(fout, "\t\t\t\t", "\n");
 736   fout << "\t\t\t\tAssemblerListingLocation=\"" << configName << "\"\n";
 737   fout << "\t\t\t\tObjectFile=\"$(IntDir)\\\"\n";
 738   if(targetBuilds)
 739     {
 740     // We need to specify a program database file name even for
 741     // non-debug configurations because VS still creates .idb files.
 742     fout <<  "\t\t\t\tProgramDataBaseFileName=\""
 743          << target.GetDirectory(configName) << "/"
 744          << target.GetPDBName(configName) << "\"\n";
 745     }
 746   fout << "/>\n";  // end of <Tool Name=VCCLCompilerTool
 747   tool = "VCCustomBuildTool";
 748   if(this->FortranProject)
 749     {
 750     tool = "VFCustomBuildTool";
 751     }
 752   fout << "\t\t\t<Tool\n\t\t\t\tName=\"" << tool << "\"/>\n";
 753   tool = "VCResourceCompilerTool";
 754   if(this->FortranProject)
 755     {
 756     tool = "VFResourceCompilerTool";
 757     }
 758   fout << "\t\t\t<Tool\n\t\t\t\tName=\"" << tool << "\"\n"
 759        << "\t\t\t\tAdditionalIncludeDirectories=\"";
 760   for(i = includes.begin();i != includes.end(); ++i)
 761     {
 762     std::string ipath = this->ConvertToXMLOutputPath(i->c_str());
 763     fout << ipath << ";";
 764     }
 765   // add the -D flags to the RC tool
 766   fout << "\"";
 767   targetOptions.OutputPreprocessorDefinitions(fout, "\n\t\t\t\t", "");
 768   fout << "/>\n";
 769   tool = "VCMIDLTool";
 770   if(this->FortranProject)
 771     {
 772     tool = "VFMIDLTool";
 773     }
 774   fout << "\t\t\t<Tool\n\t\t\t\tName=\"" << tool << "\"\n";
 775   targetOptions.OutputPreprocessorDefinitions(fout, "\t\t\t\t", "\n");
 776   fout << "\t\t\t\tMkTypLibCompatible=\"FALSE\"\n";
 777   if( this->PlatformName == "x64" )
 778     {
 779     fout << "\t\t\t\tTargetEnvironment=\"3\"\n";
 780     }
 781   else if( this->PlatformName == "ia64" )
 782     {
 783     fout << "\t\t\t\tTargetEnvironment=\"2\"\n";
 784     }
 785   else
 786     {
 787     fout << "\t\t\t\tTargetEnvironment=\"1\"\n";
 788     }
 789   fout << "\t\t\t\tGenerateStublessProxies=\"TRUE\"\n";
 790   fout << "\t\t\t\tTypeLibraryName=\"$(InputName).tlb\"\n";
 791   fout << "\t\t\t\tOutputDirectory=\"$(IntDir)\"\n";
 792   fout << "\t\t\t\tHeaderFileName=\"$(InputName).h\"\n";
 793   fout << "\t\t\t\tDLLDataFileName=\"\"\n";
 794   fout << "\t\t\t\tInterfaceIdentifierFileName=\"$(InputName)_i.c\"\n";
 795   fout << "\t\t\t\tProxyFileName=\"$(InputName)_p.c\"/>\n";
 796   // end of <Tool Name=VCMIDLTool
 797
 798   // Check if we need the FAT32 workaround.
 799   if(targetBuilds && this->Version >= 8)
 800     {
 801     // Check the filesystem type where the target will be written.
 802     if(cmLVS6G_IsFAT(target.GetDirectory(configName).c_str()))
 803       {
 804       // Add a flag telling the manifest tool to use a workaround
 805       // for FAT32 file systems, which can cause an empty manifest
 806       // to be embedded into the resulting executable.  See CMake
 807       // bug #2617.
 808       const char* tool  = "VCManifestTool";
 809       if(this->FortranProject)
 810         {
 811         tool = "VFManifestTool";
 812         }
 813       fout << "\t\t\t<Tool\n\t\t\t\tName=\"" << tool << "\"\n"
 814            << "\t\t\t\tUseFAT32Workaround=\"true\"\n"
 815            << "\t\t\t/>\n";
 816       }
 817     }
 818
 819   this->OutputTargetRules(fout, configName, target, libName);
 820   this->OutputBuildTool(fout, configName, target, targetOptions.IsDebug());
 821   fout << "\t\t</Configuration>\n";
 822 }
 823
 824 //----------------------------------------------------------------------------
 825 std::string
 826 cmLocalVisualStudio7Generator
 827 ::GetBuildTypeLinkerFlags(std::string rootLinkerFlags, const char* configName)
 828 {
 829   std::string configTypeUpper = cmSystemTools::UpperCase(configName);
 830   std::string extraLinkOptionsBuildTypeDef =
 831     rootLinkerFlags + "_" + configTypeUpper;
 832
 833   std::string extraLinkOptionsBuildType =
 834     this->Makefile->GetRequiredDefinition
 835     (extraLinkOptionsBuildTypeDef.c_str());
 836
 837   return extraLinkOptionsBuildType;
 838 }
 839
 840 void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout,
 841                                                     const char* configName,
 842                                                     cmTarget &target,
 843                                                     bool isDebug)
 844 {
 845   std::string temp;
 846   std::string extraLinkOptions;
 847   if(target.GetType() == cmTarget::EXECUTABLE)
 848     {
 849     extraLinkOptions =
 850       this->Makefile->GetRequiredDefinition("CMAKE_EXE_LINKER_FLAGS")
 851       + std::string(" ")
 852       + GetBuildTypeLinkerFlags("CMAKE_EXE_LINKER_FLAGS", configName);
 853     }
 854   if(target.GetType() == cmTarget::SHARED_LIBRARY)
 855     {
 856     extraLinkOptions =
 857       this->Makefile->GetRequiredDefinition("CMAKE_SHARED_LINKER_FLAGS")
 858       + std::string(" ")
 859       + GetBuildTypeLinkerFlags("CMAKE_SHARED_LINKER_FLAGS", configName);
 860     }
 861   if(target.GetType() == cmTarget::MODULE_LIBRARY)
 862     {
 863     extraLinkOptions =
 864       this->Makefile->GetRequiredDefinition("CMAKE_MODULE_LINKER_FLAGS")
 865       + std::string(" ")
 866       + GetBuildTypeLinkerFlags("CMAKE_MODULE_LINKER_FLAGS", configName);
 867     }
 868
 869   const char* targetLinkFlags = target.GetProperty("LINK_FLAGS");
 870   if(targetLinkFlags)
 871     {
 872     extraLinkOptions += " ";
 873     extraLinkOptions += targetLinkFlags;
 874     }
 875   std::string configTypeUpper = cmSystemTools::UpperCase(configName);
 876   std::string linkFlagsConfig = "LINK_FLAGS_";
 877   linkFlagsConfig += configTypeUpper;
 878   targetLinkFlags = target.GetProperty(linkFlagsConfig.c_str());
 879   if(targetLinkFlags)
 880     {
 881     extraLinkOptions += " ";
 882     extraLinkOptions += targetLinkFlags;
 883     }
 884   Options linkOptions(this, this->Version, Options::Linker,
 885                       cmLocalVisualStudio7GeneratorLinkFlagTable);
 886   linkOptions.Parse(extraLinkOptions.c_str());
 887   switch(target.GetType())
 888     {
 889     case cmTarget::STATIC_LIBRARY:
 890     {
 891     std::string targetNameFull = target.GetFullName(configName);
 892     std::string libpath = target.GetDirectory(configName);
 893     libpath += "/";
 894     libpath += targetNameFull;
 895     const char* tool = "VCLibrarianTool";
 896     if(this->FortranProject)
 897       {
 898       tool = "VFLibrarianTool";
 899       }
 900     fout << "\t\t\t<Tool\n"
 901          << "\t\t\t\tName=\"" << tool << "\"\n";
 902     if(const char* libflags = target.GetProperty("STATIC_LIBRARY_FLAGS"))
 903       {
 904       fout << "\t\t\t\tAdditionalOptions=\"" << libflags << "\"\n";
 905       }
 906     fout << "\t\t\t\tOutputFile=\""
 907          << this->ConvertToXMLOutputPathSingle(libpath.c_str()) << "\"/>\n";
 908     break;
 909     }
 910     case cmTarget::SHARED_LIBRARY:
 911     case cmTarget::MODULE_LIBRARY:
 912     {
 913     std::string targetName;
 914     std::string targetNameSO;
 915     std::string targetNameFull;
 916     std::string targetNameImport;
 917     std::string targetNamePDB;
 918     target.GetLibraryNames(targetName, targetNameSO, targetNameFull,
 919                            targetNameImport, targetNamePDB, configName);
 920
 921     // Compute the link library and directory information.
 922     cmComputeLinkInformation* pcli = target.GetLinkInformation(configName);
 923     if(!pcli)
 924       {
 925       return;
 926       }
 927     cmComputeLinkInformation& cli = *pcli;
 928     const char* linkLanguage = cli.GetLinkLanguage();
 929
 930     // Compute the variable name to lookup standard libraries for this
 931     // language.
 932     std::string standardLibsVar = "CMAKE_";
 933     standardLibsVar += linkLanguage;
 934     standardLibsVar += "_STANDARD_LIBRARIES";
 935     const char* tool = "VCLinkerTool";
 936     if(this->FortranProject)
 937       {
 938       tool = "VFLinkerTool";
 939       }
 940     fout << "\t\t\t<Tool\n"
 941          << "\t\t\t\tName=\"" << tool << "\"\n";
 942     linkOptions.OutputAdditionalOptions(fout, "\t\t\t\t", "\n");
 943     // Use the NOINHERIT macro to avoid getting VS project default
 944     // libraries which may be set by the user to something bad.
 945     fout << "\t\t\t\tAdditionalDependencies=\"$(NOINHERIT) "
 946          << this->Makefile->GetSafeDefinition(standardLibsVar.c_str())
 947          << " ";
 948     this->Internal->OutputLibraries(fout, cli.GetItems());
 949     fout << "\"\n";
 950     temp = target.GetDirectory(configName);
 951     temp += "/";
 952     temp += targetNameFull;
 953     fout << "\t\t\t\tOutputFile=\""
 954          << this->ConvertToXMLOutputPathSingle(temp.c_str()) << "\"\n";
 955     this->WriteTargetVersionAttribute(fout, target);
 956     linkOptions.OutputFlagMap(fout, "\t\t\t\t");
 957     fout << "\t\t\t\tAdditionalLibraryDirectories=\"";
 958     this->OutputLibraryDirectories(fout, cli.GetDirectories());
 959     fout << "\"\n";
 960     this->OutputModuleDefinitionFile(fout, target);
 961     temp = target.GetDirectory(configName);
 962     temp += "/";
 963     temp += targetNamePDB;
 964     fout << "\t\t\t\tProgramDataBaseFile=\"" <<
 965       this->ConvertToXMLOutputPathSingle(temp.c_str()) << "\"\n";
 966     if(isDebug)
 967       {
 968       fout << "\t\t\t\tGenerateDebugInformation=\"TRUE\"\n";
 969       }
 970     std::string stackVar = "CMAKE_";
 971     stackVar += linkLanguage;
 972     stackVar += "_STACK_SIZE";
 973     const char* stackVal = this->Makefile->GetDefinition(stackVar.c_str());
 974     if(stackVal)
 975       {
 976       fout << "\t\t\t\tStackReserveSize=\"" << stackVal  << "\"\n";
 977       }
 978     temp = target.GetDirectory(configName, true);
 979     temp += "/";
 980     temp += targetNameImport;
 981     fout << "\t\t\t\tImportLibrary=\""
 982          << this->ConvertToXMLOutputPathSingle(temp.c_str()) << "\"/>\n";
 983     }
 984     break;
 985     case cmTarget::EXECUTABLE:
 986     {
 987     std::string targetName;
 988     std::string targetNameFull;
 989     std::string targetNameImport;
 990     std::string targetNamePDB;
 991     target.GetExecutableNames(targetName, targetNameFull,
 992                               targetNameImport, targetNamePDB, configName);
 993
 994     // Compute the link library and directory information.
 995     cmComputeLinkInformation* pcli = target.GetLinkInformation(configName);
 996     if(!pcli)
 997       {
 998       return;
 999       }
1000     cmComputeLinkInformation& cli = *pcli;
1001     const char* linkLanguage = cli.GetLinkLanguage();
1002
1003     // Compute the variable name to lookup standard libraries for this
1004     // language.
1005     std::string standardLibsVar = "CMAKE_";
1006     standardLibsVar += linkLanguage;
1007     standardLibsVar += "_STANDARD_LIBRARIES";
1008     const char* tool = "VCLinkerTool";
1009     if(this->FortranProject)
1010       {
1011       tool = "VFLinkerTool";
1012       }
1013     fout << "\t\t\t<Tool\n"
1014          << "\t\t\t\tName=\"" << tool << "\"\n";
1015     linkOptions.OutputAdditionalOptions(fout, "\t\t\t\t", "\n");
1016     // Use the NOINHERIT macro to avoid getting VS project default
1017     // libraries which may be set by the user to something bad.
1018     fout << "\t\t\t\tAdditionalDependencies=\"$(NOINHERIT) "
1019          << this->Makefile->GetSafeDefinition(standardLibsVar.c_str())
1020          << " ";
1021     this->Internal->OutputLibraries(fout, cli.GetItems());
1022     fout << "\"\n";
1023     temp = target.GetDirectory(configName);
1024     temp += "/";
1025     temp += targetNameFull;
1026     fout << "\t\t\t\tOutputFile=\""
1027          << this->ConvertToXMLOutputPathSingle(temp.c_str()) << "\"\n";
1028     this->WriteTargetVersionAttribute(fout, target);
1029     linkOptions.OutputFlagMap(fout, "\t\t\t\t");
1030     fout << "\t\t\t\tAdditionalLibraryDirectories=\"";
1031     this->OutputLibraryDirectories(fout, cli.GetDirectories());
1032     fout << "\"\n";
1033     fout << "\t\t\t\tProgramDataBaseFile=\""
1034          << target.GetDirectory(configName) << "/" << targetNamePDB
1035          << "\"\n";
1036     if(isDebug)
1037       {
1038       fout << "\t\t\t\tGenerateDebugInformation=\"TRUE\"\n";
1039       }
1040     if ( target.GetPropertyAsBool("WIN32_EXECUTABLE") )
1041       {
1042       fout << "\t\t\t\tSubSystem=\"2\"\n";
1043       }
1044     else
1045       {
1046       fout << "\t\t\t\tSubSystem=\"1\"\n";
1047       }
1048     std::string stackVar = "CMAKE_";
1049     stackVar += linkLanguage;
1050     stackVar += "_STACK_SIZE";
1051     const char* stackVal = this->Makefile->GetDefinition(stackVar.c_str());
1052     if(stackVal)
1053       {
1054       fout << "\t\t\t\tStackReserveSize=\"" << stackVal << "\"";
1055       }
1056     temp = target.GetDirectory(configName, true);
1057     temp += "/";
1058     temp += targetNameImport;
1059     fout << "\t\t\t\tImportLibrary=\""
1060          << this->ConvertToXMLOutputPathSingle(temp.c_str()) << "\"/>\n";
1061     break;
1062     }
1063     case cmTarget::UTILITY:
1064     case cmTarget::GLOBAL_TARGET:
1065       break;
1066     }
1067 }
1068
1069 //----------------------------------------------------------------------------
1070 void
1071 cmLocalVisualStudio7Generator
1072 ::WriteTargetVersionAttribute(std::ostream& fout, cmTarget& target)
1073 {
1074   int major;
1075   int minor;
1076   target.GetTargetVersion(major, minor);
1077   fout << "\t\t\t\tVersion=\"" << major << "." << minor << "\"\n";
1078 }
1079
1080 void cmLocalVisualStudio7Generator
1081 ::OutputModuleDefinitionFile(std::ostream& fout,
1082                              cmTarget &target)
1083 {
1084   std::vector<cmSourceFile*> const& classes = target.GetSourceFiles();
1085   for(std::vector<cmSourceFile*>::const_iterator i = classes.begin();
1086       i != classes.end(); i++)
1087     {
1088     cmSourceFile* sf = *i;
1089     if(cmSystemTools::UpperCase(sf->GetExtension()) == "DEF")
1090       {
1091       fout << "\t\t\t\tModuleDefinitionFile=\""
1092            << this->ConvertToXMLOutputPath(sf->GetFullPath().c_str())
1093            << "\"\n";
1094       return;
1095       }
1096     }
1097
1098 }
1099
1100 //----------------------------------------------------------------------------
1101 void
1102 cmLocalVisualStudio7GeneratorInternals
1103 ::OutputLibraries(std::ostream& fout, ItemVector const& libs)
1104 {
1105   cmLocalVisualStudio7Generator* lg = this->LocalGenerator;
1106   for(ItemVector::const_iterator l = libs.begin(); l != libs.end(); ++l)
1107     {
1108     if(l->IsPath)
1109       {
1110       std::string rel = lg->Convert(l->Value.c_str(),
1111                                     cmLocalGenerator::START_OUTPUT,
1112                                     cmLocalGenerator::UNCHANGED);
1113       fout << lg->ConvertToXMLOutputPath(rel.c_str()) << " ";
1114       }
1115     else
1116       {
1117       fout << l->Value << " ";
1118       }
1119     }
1120 }
1121
1122 //----------------------------------------------------------------------------
1123 void
1124 cmLocalVisualStudio7Generator
1125 ::OutputLibraryDirectories(std::ostream& fout,
1126                            std::vector<std::string> const& dirs)
1127 {
1128   const char* comma = "";
1129   for(std::vector<std::string>::const_iterator d = dirs.begin();
1130       d != dirs.end(); ++d)
1131     {
1132     // Remove any trailing slash and skip empty paths.
1133     std::string dir = *d;
1134     if(dir[dir.size()-1] == '/')
1135       {
1136       dir = dir.substr(0, dir.size()-1);
1137       }
1138     if(dir.empty())
1139       {
1140       continue;
1141       }
1142
1143     // Switch to a relative path specification if it is shorter.
1144     if(cmSystemTools::FileIsFullPath(dir.c_str()))
1145       {
1146       std::string rel = this->Convert(dir.c_str(), START_OUTPUT, UNCHANGED);
1147       if(rel.size() < dir.size())
1148         {
1149         dir = rel;
1150         }
1151       }
1152
1153     // First search a configuration-specific subdirectory and then the
1154     // original directory.
1155     fout << comma << this->ConvertToXMLOutputPath((dir+"/$(OutDir)").c_str())
1156          << "," << this->ConvertToXMLOutputPath(dir.c_str());
1157     comma = ",";
1158     }
1159 }
1160
1161 void cmLocalVisualStudio7Generator::WriteVCProjFile(std::ostream& fout,
1162                                                     const char *libName,
1163                                                     cmTarget &target)
1164 {
1165   // get the configurations
1166   std::vector<std::string> *configs =
1167     static_cast<cmGlobalVisualStudio7Generator *>
1168     (this->GlobalGenerator)->GetConfigurations();
1169
1170   // We may be modifying the source groups temporarily, so make a copy.
1171   std::vector<cmSourceGroup> sourceGroups = this->Makefile->GetSourceGroups();
1172
1173   // get the classes from the source lists then add them to the groups
1174   std::vector<cmSourceFile*>const & classes = target.GetSourceFiles();
1175   for(std::vector<cmSourceFile*>::const_iterator i = classes.begin();
1176       i != classes.end(); i++)
1177     {
1178     // Add the file to the list of sources.
1179     std::string source = (*i)->GetFullPath();
1180     if(cmSystemTools::UpperCase((*i)->GetExtension()) == "DEF")
1181       {
1182       this->ModuleDefinitionFile = (*i)->GetFullPath();
1183       }
1184     cmSourceGroup& sourceGroup =
1185       this->Makefile->FindSourceGroup(source.c_str(), sourceGroups);
1186     sourceGroup.AssignSource(*i);
1187     }
1188
1189   // Compute which sources need unique object computation.
1190   this->ComputeObjectNameRequirements(sourceGroups);
1191
1192   // open the project
1193   this->WriteProjectStart(fout, libName, target, sourceGroups);
1194   // write the configuration information
1195   this->WriteConfigurations(fout, libName, target);
1196
1197   fout << "\t<Files>\n";
1198
1199
1200   // Loop through every source group.
1201   for(unsigned int i = 0; i < sourceGroups.size(); ++i)
1202     {
1203     cmSourceGroup sg = sourceGroups[i];
1204     this->WriteGroup(&sg, target, fout, libName, configs);
1205     }
1206
1207   //}
1208
1209   fout << "\t</Files>\n";
1210
1211   // Write the VCProj file's footer.
1212   this->WriteVCProjFooter(fout);
1213 }
1214
1215 struct cmLVS7GFileConfig
1216 {
1217   std::string ObjectName;
1218   std::string CompileFlags;
1219   std::string CompileDefs;
1220   std::string CompileDefsConfig;
1221   std::string AdditionalDeps;
1222   bool ExcludedFromBuild;
1223 };
1224
1225 class cmLocalVisualStudio7GeneratorFCInfo
1226 {
1227 public:
1228   cmLocalVisualStudio7GeneratorFCInfo(cmLocalVisualStudio7Generator* lg,
1229                                       cmTarget& target,
1230                                       cmSourceFile const& sf,
1231                                       std::vector<std::string>* configs,
1232                                       std::string const& dir_max);
1233   std::map<cmStdString, cmLVS7GFileConfig> FileConfigMap;
1234 };
1235
1236 cmLocalVisualStudio7GeneratorFCInfo
1237 ::cmLocalVisualStudio7GeneratorFCInfo(cmLocalVisualStudio7Generator* lg,
1238                                       cmTarget& target,
1239                                       cmSourceFile const& sf,
1240                                       std::vector<std::string>* configs,
1241                                       std::string const& dir_max)
1242 {
1243   std::string objectName;
1244   if(lg->NeedObjectName.find(&sf) != lg->NeedObjectName.end())
1245     {
1246     objectName = lg->GetObjectFileNameWithoutTarget(sf, dir_max);
1247     }
1248
1249   // Compute per-source, per-config information.
1250   for(std::vector<std::string>::iterator i = configs->begin();
1251       i != configs->end(); ++i)
1252     {
1253     std::string configUpper = cmSystemTools::UpperCase(*i);
1254     cmLVS7GFileConfig fc;
1255     bool needfc = false;
1256     if(!objectName.empty())
1257       {
1258       fc.ObjectName = objectName;
1259       needfc = true;
1260       }
1261     if(const char* cflags = sf.GetProperty("COMPILE_FLAGS"))
1262       {
1263       fc.CompileFlags = cflags;
1264       needfc = true;
1265       }
1266     if(const char* cdefs = sf.GetProperty("COMPILE_DEFINITIONS"))
1267       {
1268       fc.CompileDefs = cdefs;
1269       needfc = true;
1270       }
1271     std::string defPropName = "COMPILE_DEFINITIONS_";
1272     defPropName += configUpper;
1273     if(const char* ccdefs = sf.GetProperty(defPropName.c_str()))
1274       {
1275       fc.CompileDefsConfig = ccdefs;
1276       needfc = true;
1277       }
1278
1279     // Check for extra object-file dependencies.
1280     if(const char* deps = sf.GetProperty("OBJECT_DEPENDS"))
1281       {
1282       std::vector<std::string> depends;
1283       cmSystemTools::ExpandListArgument(deps, depends);
1284       const char* sep = "";
1285       for(std::vector<std::string>::iterator j = depends.begin();
1286           j != depends.end(); ++j)
1287         {
1288         fc.AdditionalDeps += sep;
1289         fc.AdditionalDeps += lg->ConvertToXMLOutputPath(j->c_str());
1290         sep = ";";
1291         needfc = true;
1292         }
1293       }
1294
1295     const char* lang =
1296       lg->GlobalGenerator->GetLanguageFromExtension
1297       (sf.GetExtension().c_str());
1298     const char* sourceLang = lg->GetSourceFileLanguage(sf);
1299     const char* linkLanguage = target.GetLinkerLanguage(i->c_str());
1300     bool needForceLang = false;
1301     // source file does not match its extension language
1302     if(lang && sourceLang && strcmp(lang, sourceLang) != 0)
1303       {
1304       needForceLang = true;
1305       lang = sourceLang;
1306       }
1307     // If HEADER_FILE_ONLY is set, we must suppress this generation in
1308     // the project file
1309     fc.ExcludedFromBuild =
1310       (sf.GetPropertyAsBool("HEADER_FILE_ONLY"));
1311     if(fc.ExcludedFromBuild)
1312       {
1313       needfc = true;
1314       }
1315
1316     // if the source file does not match the linker language
1317     // then force c or c++
1318     if(needForceLang || (linkLanguage && lang
1319                          && strcmp(lang, linkLanguage) != 0))
1320       {
1321       if(strcmp(lang, "CXX") == 0)
1322         {
1323         // force a C++ file type
1324         fc.CompileFlags += " /TP ";
1325         needfc = true;
1326         }
1327       else if(strcmp(lang, "C") == 0)
1328         {
1329         // force to c
1330         fc.CompileFlags += " /TC ";
1331         needfc = true;
1332         }
1333       }
1334
1335     if(needfc)
1336       {
1337       this->FileConfigMap[*i] = fc;
1338       }
1339     }
1340 }
1341
1342
1343 void cmLocalVisualStudio7Generator
1344 ::ComputeMaxDirectoryLength(std::string& maxdir,
1345   cmTarget& target)
1346 {
1347   std::vector<std::string> *configs =
1348     static_cast<cmGlobalVisualStudio7Generator *>
1349     (this->GlobalGenerator)->GetConfigurations();
1350   // Compute the maximum length configuration name.
1351   std::string config_max;
1352   for(std::vector<std::string>::iterator i = configs->begin();
1353       i != configs->end(); ++i)
1354     {
1355     if(i->size() > config_max.size())
1356       {
1357       config_max = *i;
1358       }
1359     }
1360
1361   // Compute the maximum length full path to the intermediate
1362   // files directory for any configuration.  This is used to construct
1363   // object file names that do not produce paths that are too long.
1364   std::string dir_max;
1365   dir_max += this->Makefile->GetCurrentOutputDirectory();
1366   dir_max += "/";
1367   dir_max += this->GetTargetDirectory(target);
1368   dir_max += "/";
1369   dir_max += config_max;
1370   dir_max += "/";
1371   maxdir = dir_max;
1372 }
1373
1374 void cmLocalVisualStudio7Generator
1375 ::WriteGroup(const cmSourceGroup *sg, cmTarget& target,
1376              std::ostream &fout, const char *libName,
1377              std::vector<std::string> *configs)
1378 {
1379   const std::vector<const cmSourceFile *> &sourceFiles =
1380     sg->GetSourceFiles();
1381   // If the group is empty, don't write it at all.
1382   if(sourceFiles.empty() && sg->GetGroupChildren().empty())
1383     {
1384     return;
1385     }
1386
1387   // If the group has a name, write the header.
1388   std::string name = sg->GetName();
1389   if(name != "")
1390     {
1391     this->WriteVCProjBeginGroup(fout, name.c_str(), "");
1392     }
1393
1394   // Compute the maximum length full path to the intermediate
1395   // files directory for any configuration.  This is used to construct
1396   // object file names that do not produce paths that are too long.
1397   std::string dir_max;
1398   this->ComputeMaxDirectoryLength(dir_max, target);
1399
1400   // Loop through each source in the source group.
1401   std::string objectName;
1402   for(std::vector<const cmSourceFile *>::const_iterator sf =
1403         sourceFiles.begin(); sf != sourceFiles.end(); ++sf)
1404     {
1405     std::string source = (*sf)->GetFullPath();
1406     FCInfo fcinfo(this, target, *(*sf), configs, dir_max);
1407
1408     if (source != libName || target.GetType() == cmTarget::UTILITY ||
1409       target.GetType() == cmTarget::GLOBAL_TARGET )
1410       {
1411       fout << "\t\t\t<File\n";
1412       std::string d = this->ConvertToXMLOutputPathSingle(source.c_str());
1413       // Tell MS-Dev what the source is.  If the compiler knows how to
1414       // build it, then it will.
1415       fout << "\t\t\t\tRelativePath=\"" << d << "\">\n";
1416       if(cmCustomCommand const* command = (*sf)->GetCustomCommand())
1417         {
1418         this->WriteCustomRule(fout, source.c_str(), *command, fcinfo);
1419         }
1420       else if(!fcinfo.FileConfigMap.empty())
1421         {
1422         const char* aCompilerTool = "VCCLCompilerTool";
1423         std::string ext = (*sf)->GetExtension();
1424         ext = cmSystemTools::LowerCase(ext);
1425         if(ext == "idl")
1426           {
1427           aCompilerTool = "VCMIDLTool";
1428           if(this->FortranProject)
1429             {
1430             aCompilerTool = "VFMIDLTool";
1431             }
1432           }
1433         if(ext == "rc")
1434           {
1435           aCompilerTool = "VCResourceCompilerTool";
1436           if(this->FortranProject)
1437             {
1438             aCompilerTool = "VFResourceCompilerTool";
1439             }
1440           }
1441         if(ext == "def")
1442           {
1443           aCompilerTool = "VCCustomBuildTool";
1444           if(this->FortranProject)
1445             {
1446             aCompilerTool = "VFCustomBuildTool";
1447             }
1448           }
1449         for(std::map<cmStdString, cmLVS7GFileConfig>::const_iterator
1450               fci = fcinfo.FileConfigMap.begin();
1451             fci != fcinfo.FileConfigMap.end(); ++fci)
1452           {
1453           cmLVS7GFileConfig const& fc = fci->second;
1454           fout << "\t\t\t\t<FileConfiguration\n"
1455                << "\t\t\t\t\tName=\""  << fci->first
1456                << "|" << this->PlatformName << "\"";
1457           if(fc.ExcludedFromBuild)
1458             {
1459             fout << " ExcludedFromBuild=\"true\"";
1460             }
1461           fout << ">\n";
1462           fout << "\t\t\t\t\t<Tool\n"
1463                << "\t\t\t\t\tName=\"" << aCompilerTool << "\"\n";
1464           if(!fc.CompileFlags.empty() ||
1465              !fc.CompileDefs.empty() ||
1466              !fc.CompileDefsConfig.empty())
1467             {
1468             Options fileOptions(this, this->Version, Options::Compiler,
1469                                 cmLocalVisualStudio7GeneratorFlagTable,
1470                                 this->ExtraFlagTable);
1471             fileOptions.Parse(fc.CompileFlags.c_str());
1472             fileOptions.AddDefines(fc.CompileDefs.c_str());
1473             fileOptions.AddDefines(fc.CompileDefsConfig.c_str());
1474             fileOptions.OutputAdditionalOptions(fout, "\t\t\t\t\t", "\n");
1475             fileOptions.OutputFlagMap(fout, "\t\t\t\t\t");
1476             fileOptions.OutputPreprocessorDefinitions(fout,
1477                                                       "\t\t\t\t\t", "\n");
1478             }
1479           if(!fc.AdditionalDeps.empty())
1480             {
1481             fout << "\t\t\t\t\tAdditionalDependencies=\""
1482                  << fc.AdditionalDeps.c_str() << "\"\n";
1483             }
1484           if(!fc.ObjectName.empty())
1485             {
1486             fout << "\t\t\t\t\tObjectFile=\"$(IntDir)/"
1487                  << fc.ObjectName.c_str() << "\"\n";
1488             }
1489           fout << "\t\t\t\t\t/>\n"
1490                << "\t\t\t\t</FileConfiguration>\n";
1491           }
1492         }
1493       fout << "\t\t\t</File>\n";
1494       }
1495     }
1496
1497   std::vector<cmSourceGroup> const& children  = sg->GetGroupChildren();
1498
1499   for(unsigned int i=0;i<children.size();++i)
1500     {
1501     this->WriteGroup(&children[i], target, fout, libName, configs);
1502     }
1503
1504   // If the group has a name, write the footer.
1505   if(name != "")
1506     {
1507     this->WriteVCProjEndGroup(fout);
1508     }
1509 }
1510
1511 void cmLocalVisualStudio7Generator::
1512 WriteCustomRule(std::ostream& fout,
1513                 const char* source,
1514                 const cmCustomCommand& command,
1515                 FCInfo& fcinfo)
1516 {
1517   std::string comment = this->ConstructComment(command);
1518
1519   // Write the rule for each configuration.
1520   std::vector<std::string>::iterator i;
1521   std::vector<std::string> *configs =
1522     static_cast<cmGlobalVisualStudio7Generator *>
1523     (this->GlobalGenerator)->GetConfigurations();
1524   const char* compileTool = "VCCLCompilerTool";
1525   if(this->FortranProject)
1526     {
1527     compileTool = "VFCLCompilerTool";
1528     }
1529   const char* customTool = "VCCustomBuildTool";
1530   if(this->FortranProject)
1531     {
1532     customTool = "VFCustomBuildTool";
1533     }
1534   for(i = configs->begin(); i != configs->end(); ++i)
1535     {
1536     cmLVS7GFileConfig const& fc = fcinfo.FileConfigMap[*i];
1537     fout << "\t\t\t\t<FileConfiguration\n";
1538     fout << "\t\t\t\t\tName=\"" << *i << "|" << this->PlatformName << "\">\n";
1539     if(!fc.CompileFlags.empty())
1540       {
1541       fout << "\t\t\t\t\t<Tool\n"
1542            << "\t\t\t\t\tName=\"" << compileTool << "\"\n"
1543            << "\t\t\t\t\tAdditionalOptions=\""
1544            << this->EscapeForXML(fc.CompileFlags.c_str()) << "\"/>\n";
1545       }
1546
1547     std::string script =
1548       this->ConstructScript(command.GetCommandLines(),
1549                             command.GetWorkingDirectory(),
1550                             i->c_str(),
1551                             command.GetEscapeOldStyle(),
1552                             command.GetEscapeAllowMakeVars());
1553     fout << "\t\t\t\t\t<Tool\n"
1554          << "\t\t\t\t\tName=\"" << customTool << "\"\n"
1555          << "\t\t\t\t\tDescription=\""
1556          << this->EscapeForXML(comment.c_str()) << "\"\n"
1557          << "\t\t\t\t\tCommandLine=\""
1558          << this->EscapeForXML(script.c_str()) << "\"\n"
1559          << "\t\t\t\t\tAdditionalDependencies=\"";
1560     if(command.GetDepends().empty())
1561       {
1562       // There are no real dependencies.  Produce an artificial one to
1563       // make sure the rule runs reliably.
1564       if(!cmSystemTools::FileExists(source))
1565         {
1566         std::ofstream depout(source);
1567         depout << "Artificial dependency for a custom command.\n";
1568         }
1569       fout << this->ConvertToXMLOutputPath(source);
1570       }
1571     else
1572       {
1573       // Write out the dependencies for the rule.
1574       for(std::vector<std::string>::const_iterator d =
1575           command.GetDepends().begin();
1576           d != command.GetDepends().end();
1577           ++d)
1578         {
1579         // Get the real name of the dependency in case it is a CMake target.
1580         std::string dep = this->GetRealDependency(d->c_str(), i->c_str());
1581         fout << this->ConvertToXMLOutputPath(dep.c_str())
1582              << ";";
1583         }
1584       }
1585     fout << "\"\n";
1586     fout << "\t\t\t\t\tOutputs=\"";
1587     if(command.GetOutputs().empty())
1588       {
1589       fout << source << "_force";
1590       }
1591     else
1592       {
1593       // Write a rule for the output generated by this command.
1594       const char* sep = "";
1595       for(std::vector<std::string>::const_iterator o =
1596           command.GetOutputs().begin();
1597           o != command.GetOutputs().end();
1598           ++o)
1599         {
1600         fout << sep << this->ConvertToXMLOutputPathSingle(o->c_str());
1601         sep = ";";
1602         }
1603       }
1604     fout << "\"/>\n";
1605     fout << "\t\t\t\t</FileConfiguration>\n";
1606     }
1607 }
1608
1609
1610 void cmLocalVisualStudio7Generator::WriteVCProjBeginGroup(std::ostream& fout,
1611                                                           const char* group,
1612                                                           const char* )
1613 {
1614   fout << "\t\t<Filter\n"
1615        << "\t\t\tName=\"" << group << "\"\n"
1616        << "\t\t\tFilter=\"\">\n";
1617 }
1618
1619
1620 void cmLocalVisualStudio7Generator::WriteVCProjEndGroup(std::ostream& fout)
1621 {
1622   fout << "\t\t</Filter>\n";
1623 }
1624
1625
1626 // look for custom rules on a target and collect them together
1627 void cmLocalVisualStudio7Generator
1628 ::OutputTargetRules(std::ostream& fout,
1629                     const char* configName,
1630                     cmTarget &target,
1631                     const char * /*libName*/)
1632 {
1633   if (target.GetType() > cmTarget::GLOBAL_TARGET)
1634     {
1635     return;
1636     }
1637   EventWriter event(this, configName, fout);
1638
1639   // Add pre-build event.
1640   const char* tool =
1641     this->FortranProject? "VFPreBuildEventTool":"VCPreBuildEventTool";
1642   event.Start(tool);
1643   event.Write(target.GetPreBuildCommands());
1644   event.Finish();
1645
1646   // Add pre-link event.
1647   tool = this->FortranProject? "VFPreLinkEventTool":"VCPreLinkEventTool";
1648   event.Start(tool);
1649   event.Write(target.GetPreLinkCommands());
1650   cmsys::auto_ptr<cmCustomCommand> pcc(
1651     this->MaybeCreateImplibDir(target, configName));
1652   if(pcc.get())
1653     {
1654     event.Write(*pcc);
1655     }
1656   event.Finish();
1657
1658   // Add post-build event.
1659   tool = this->FortranProject? "VFPostBuildEventTool":"VCPostBuildEventTool";
1660   event.Start(tool);
1661   event.Write(target.GetPostBuildCommands());
1662   event.Finish();
1663 }
1664
1665 void
1666 cmLocalVisualStudio7Generator
1667 ::WriteProjectStartFortran(std::ostream& fout,
1668                            const char *libName,
1669                            cmTarget & target)
1670 {
1671
1672   cmGlobalVisualStudio7Generator* gg =
1673     static_cast<cmGlobalVisualStudio7Generator *>(this->GlobalGenerator);
1674   fout << "<?xml version=\"1.0\" encoding = \"Windows-1252\"?>\n"
1675        << "<VisualStudioProject\n"
1676        << "\tProjectCreator=\"Intel Fortran\"\n"
1677        << "\tVersion=\"9.10\"\n";
1678   const char* keyword = target.GetProperty("VS_KEYWORD");
1679   if(!keyword)
1680     {
1681     keyword = "Console Application";
1682     }
1683   const char* projectType = 0;
1684   switch(target.GetType())
1685     {
1686     case cmTarget::STATIC_LIBRARY:
1687       projectType = "typeStaticLibrary";
1688       if(keyword)
1689         {
1690         keyword = "Static Library";
1691         }
1692       break;
1693     case cmTarget::SHARED_LIBRARY:
1694     case cmTarget::MODULE_LIBRARY:
1695       projectType = "typeDynamicLibrary";
1696       if(!keyword)
1697         {
1698         keyword = "Dll";
1699         }
1700       break;
1701     case cmTarget::EXECUTABLE:
1702       if(!keyword)
1703         {
1704         keyword = "Console Application";
1705         }
1706       projectType = 0;
1707       break;
1708     case cmTarget::UTILITY:
1709     case cmTarget::GLOBAL_TARGET:
1710     default:
1711       break;
1712     }
1713   if(projectType)
1714     {
1715     fout << "\tProjectType=\"" << projectType << "\"\n";
1716     }
1717   fout<< "\tKeyword=\"" << keyword << "\">\n"
1718        << "\tProjectGUID=\"{" << gg->GetGUID(libName) << "}\">\n"
1719        << "\t<Platforms>\n"
1720        << "\t\t<Platform\n\t\t\tName=\"" << this->PlatformName << "\"/>\n"
1721        << "\t</Platforms>\n";
1722 }
1723
1724
1725 void
1726 cmLocalVisualStudio7Generator::WriteProjectStart(std::ostream& fout,
1727                                                  const char *libName,
1728                                                  cmTarget & target,
1729                                                  std::vector<cmSourceGroup> &)
1730 {
1731   if(this->FortranProject)
1732     {
1733     this->WriteProjectStartFortran(fout, libName, target);
1734     return;
1735     }
1736   fout << "<?xml version=\"1.0\" encoding = \"Windows-1252\"?>\n"
1737        << "<VisualStudioProject\n"
1738        << "\tProjectType=\"Visual C++\"\n";
1739   if(this->Version == 71)
1740     {
1741     fout << "\tVersion=\"7.10\"\n";
1742     }
1743   else
1744     {
1745     fout <<  "\tVersion=\"" << this->Version << ".00\"\n";
1746     }
1747   const char* projLabel = target.GetProperty("PROJECT_LABEL");
1748   if(!projLabel)
1749     {
1750     projLabel = libName;
1751     }
1752   const char* keyword = target.GetProperty("VS_KEYWORD");
1753   if(!keyword)
1754     {
1755     keyword = "Win32Proj";
1756     }
1757   const char* vsProjectname = target.GetProperty("VS_SCC_PROJECTNAME");
1758   const char* vsLocalpath = target.GetProperty("VS_SCC_LOCALPATH");
1759   const char* vsProvider = target.GetProperty("VS_SCC_PROVIDER");
1760   cmGlobalVisualStudio7Generator* gg =
1761     static_cast<cmGlobalVisualStudio7Generator *>(this->GlobalGenerator);
1762   fout << "\tName=\"" << projLabel << "\"\n";
1763   if(this->Version >= 8)
1764     {
1765     fout << "\tProjectGUID=\"{" << gg->GetGUID(libName) << "}\"\n";
1766     }
1767   // if we have all the required Source code control tags
1768   // then add that to the project
1769   if(vsProvider && vsLocalpath && vsProjectname)
1770     {
1771     fout << "\tSccProjectName=\"" << vsProjectname << "\"\n"
1772          << "\tSccLocalPath=\"" << vsLocalpath << "\"\n"
1773          << "\tSccProvider=\"" << vsProvider << "\"\n";
1774     }
1775   fout << "\tKeyword=\"" << keyword << "\">\n"
1776        << "\t<Platforms>\n"
1777        << "\t\t<Platform\n\t\t\tName=\"" << this->PlatformName << "\"/>\n"
1778        << "\t</Platforms>\n";
1779 }
1780
1781
1782 void cmLocalVisualStudio7Generator::WriteVCProjFooter(std::ostream& fout)
1783 {
1784   fout << "\t<Globals>\n"
1785        << "\t</Globals>\n"
1786        << "</VisualStudioProject>\n";
1787 }
1788
1789 std::string cmLocalVisualStudio7GeneratorEscapeForXML(const char* s)
1790 {
1791   std::string ret = s;
1792   cmSystemTools::ReplaceString(ret, "&", "&amp;");
1793   cmSystemTools::ReplaceString(ret, "\"", "&quot;");
1794   cmSystemTools::ReplaceString(ret, "<", "&lt;");
1795   cmSystemTools::ReplaceString(ret, ">", "&gt;");
1796   cmSystemTools::ReplaceString(ret, "\n", "&#x0D;&#x0A;");
1797   return ret;
1798 }
1799
1800 std::string cmLocalVisualStudio7Generator::EscapeForXML(const char* s)
1801 {
1802   return cmLocalVisualStudio7GeneratorEscapeForXML(s);
1803 }
1804
1805 std::string cmLocalVisualStudio7Generator
1806 ::ConvertToXMLOutputPath(const char* path)
1807 {
1808   std::string ret = this->ConvertToOptionallyRelativeOutputPath(path);
1809   cmSystemTools::ReplaceString(ret, "&", "&amp;");
1810   cmSystemTools::ReplaceString(ret, "\"", "&quot;");
1811   cmSystemTools::ReplaceString(ret, "<", "&lt;");
1812   cmSystemTools::ReplaceString(ret, ">", "&gt;");
1813   return ret;
1814 }
1815
1816 std::string cmLocalVisualStudio7Generator
1817 ::ConvertToXMLOutputPathSingle(const char* path)
1818 {
1819   std::string ret = this->ConvertToOptionallyRelativeOutputPath(path);
1820   cmSystemTools::ReplaceString(ret, "\"", "");
1821   cmSystemTools::ReplaceString(ret, "&", "&amp;");
1822   cmSystemTools::ReplaceString(ret, "<", "&lt;");
1823   cmSystemTools::ReplaceString(ret, ">", "&gt;");
1824   return ret;
1825 }
1826
1827
1828 // This class is used to parse an existing vs 7 project
1829 // and extract the GUID
1830 class cmVS7XMLParser : public cmXMLParser
1831 {
1832 public:
1833   virtual void EndElement(const char* /* name */)
1834     {
1835     }
1836   virtual void StartElement(const char* name, const char** atts)
1837     {
1838       // once the GUID is found do nothing
1839       if(this->GUID.size())
1840         {
1841         return;
1842         }
1843       int i =0;
1844       if(strcmp("VisualStudioProject", name) == 0)
1845         {
1846         while(atts[i])
1847           {
1848           if(strcmp(atts[i], "ProjectGUID") == 0)
1849             {
1850             if(atts[i+1])
1851               {
1852               this->GUID =  atts[i+1];
1853               this->GUID = this->GUID.substr(1, this->GUID.size()-2);
1854               }
1855             else
1856               {
1857               this->GUID = "";
1858               }
1859             return;
1860             }
1861           ++i;
1862           }
1863         }
1864     }
1865   int InitializeParser()
1866     {
1867       int ret = cmXMLParser::InitializeParser();
1868       if(ret == 0)
1869         {
1870         return ret;
1871         }
1872       // visual studio projects have a strange encoding, but it is
1873       // really utf-8
1874       XML_SetEncoding(static_cast<XML_Parser>(this->Parser), "utf-8");
1875       return 1;
1876     }
1877   std::string GUID;
1878 };
1879
1880 void cmLocalVisualStudio7Generator::ReadAndStoreExternalGUID(
1881   const char* name,
1882   const char* path)
1883 {
1884   cmVS7XMLParser parser;
1885   parser.ParseFile(path);
1886   // if we can not find a GUID then create one
1887   if(parser.GUID.size() == 0)
1888     {
1889     cmGlobalVisualStudio7Generator* gg =
1890       static_cast<cmGlobalVisualStudio7Generator *>(this->GlobalGenerator);
1891     gg->CreateGUID(name);
1892     return;
1893     }
1894   std::string guidStoreName = name;
1895   guidStoreName += "_GUID_CMAKE";
1896   // save the GUID in the cache
1897   this->GlobalGenerator->GetCMakeInstance()->
1898     AddCacheEntry(guidStoreName.c_str(),
1899                   parser.GUID.c_str(),
1900                   "Stored GUID",
1901                   cmCacheManager::INTERNAL);
1902 }
1903
1904
1905 void cmLocalVisualStudio7Generator::ConfigureFinalPass()
1906 {
1907   cmLocalGenerator::ConfigureFinalPass();
1908   cmTargets &tgts = this->Makefile->GetTargets();
1909
1910   cmGlobalVisualStudio7Generator* gg =
1911     static_cast<cmGlobalVisualStudio7Generator *>(this->GlobalGenerator);
1912   for(cmTargets::iterator l = tgts.begin(); l != tgts.end(); l++)
1913     {
1914     const char* path = l->second.GetProperty("EXTERNAL_MSPROJECT");
1915     if(path)
1916       {
1917       this->ReadAndStoreExternalGUID(
1918         l->second.GetName(), path);
1919       }
1920     else
1921       {
1922       gg->CreateGUID(l->first.c_str());
1923       }
1924     }
1925
1926 }
1927
1928 //----------------------------------------------------------------------------
1929 std::string cmLocalVisualStudio7Generator
1930 ::GetTargetDirectory(cmTarget const& target) const
1931 {
1932   std::string dir;
1933   dir += target.GetName();
1934   dir += ".dir";
1935   return dir;
1936 }
1937
1938 void cmLocalVisualStudio7Generator::
1939 GetTargetObjectFileDirectories(cmTarget* target,
1940                                std::vector<std::string>&
1941                                dirs)
1942 {
1943   std::string dir = this->Makefile->GetCurrentOutputDirectory();
1944   dir += "/";
1945   dir += this->GetTargetDirectory(*target);
1946   dir += "/";
1947   dir += this->GetGlobalGenerator()->GetCMakeCFGInitDirectory();
1948   dirs.push_back(dir);
1949 }
1950
1951 //----------------------------------------------------------------------------
1952 #include <windows.h>
1953 static bool cmLVS6G_IsFAT(const char* dir)
1954 {
1955   if(dir[0] && dir[1] == ':')
1956     {
1957     char volRoot[4] = "_:/";
1958     volRoot[0] = dir[0];
1959     char fsName[16];
1960     if(GetVolumeInformation(volRoot, 0, 0, 0, 0, 0, fsName, 16) &&
1961        strstr(fsName, "FAT") != 0)
1962       {
1963       return true;
1964       }
1965     }
1966   return false;
1967 }