Source/cmVisualStudioGeneratorOptions.cxx

   1 #include "cmVisualStudioGeneratorOptions.h"
   2 #include "cmSystemTools.h"
   3 #include <cmsys/System.h>
   4 #include "cmVisualStudio10TargetGenerator.h"
   5
   6 inline std::string cmVisualStudio10GeneratorOptionsEscapeForXML(const char* s)
   7 {
   8   std::string ret = s;
   9   cmSystemTools::ReplaceString(ret, "&", "&amp;");
  10   cmSystemTools::ReplaceString(ret, "<", "&lt;");
  11   cmSystemTools::ReplaceString(ret, ">", "&gt;");
  12   return ret;
  13 }
  14
  15 inline std::string cmVisualStudioGeneratorOptionsEscapeForXML(const char* s)
  16 {
  17   std::string ret = s;
  18   cmSystemTools::ReplaceString(ret, "&", "&amp;");
  19   cmSystemTools::ReplaceString(ret, "\"", "&quot;");
  20   cmSystemTools::ReplaceString(ret, "<", "&lt;");
  21   cmSystemTools::ReplaceString(ret, ">", "&gt;");
  22   cmSystemTools::ReplaceString(ret, "\n", "&#x0D;&#x0A;");
  23   return ret;
  24 }
  25
  26 //----------------------------------------------------------------------------
  27 cmVisualStudioGeneratorOptions
  28 ::cmVisualStudioGeneratorOptions(cmLocalGenerator* lg,
  29                                  int version,
  30                                  Tool tool,
  31                                  cmVS7FlagTable const* table,
  32                                  cmVS7FlagTable const* extraTable,
  33                                  cmVisualStudio10TargetGenerator* g):
  34   cmIDEOptions(),
  35   LocalGenerator(lg), Version(version), CurrentTool(tool),
  36   TargetGenerator(g)
  37 {
  38   // Store the given flag tables.
  39   cmIDEFlagTable const** ft = this->FlagTable;
  40   if(table) { *ft++ = table; }
  41   if(extraTable) { *ft++ = extraTable; }
  42
  43   // Preprocessor definitions are not allowed for linker tools.
  44   this->AllowDefine = (tool != Linker);
  45
  46   // Slash options are allowed for VS.
  47   this->AllowSlash = true;
  48 }
  49
  50 //----------------------------------------------------------------------------
  51 void cmVisualStudioGeneratorOptions::FixExceptionHandlingDefault()
  52 {
  53   // Exception handling is on by default because the platform file has
  54   // "/EHsc" in the flags.  Normally, that will override this
  55   // initialization to off, but the user has the option of removing
  56   // the flag to disable exception handling.  When the user does
  57   // remove the flag we need to override the IDE default of on.
  58   switch (this->Version)
  59     {
  60     case 7:
  61     case 71:
  62       this->FlagMap["ExceptionHandling"] = "FALSE";
  63       break;
  64     case 10:
  65       // by default VS puts <ExceptionHandling></ExceptionHandling> empty
  66       // for a project, to make our projects look the same put a new line
  67       // and space over for the closing </ExceptionHandling> as the default
  68       // value
  69       this->FlagMap["ExceptionHandling"] = "\n      ";
  70       break;
  71     default:
  72       this->FlagMap["ExceptionHandling"] = "0";
  73     break;
  74     }
  75 }
  76
  77 //----------------------------------------------------------------------------
  78 void cmVisualStudioGeneratorOptions::SetVerboseMakefile(bool verbose)
  79 {
  80   // If verbose makefiles have been requested and the /nologo option
  81   // was not given explicitly in the flags we want to add an attribute
  82   // to the generated project to disable logo suppression.  Otherwise
  83   // the GUI default is to enable suppression.
  84   if(verbose &&
  85      this->FlagMap.find("SuppressStartupBanner") == this->FlagMap.end())
  86     {
  87     if(this->Version == 10)
  88       {
  89       this->FlagMap["SuppressStartupBanner"] = "false";
  90       }
  91     else
  92       {
  93       this->FlagMap["SuppressStartupBanner"] = "FALSE";
  94       }
  95     }
  96 }
  97
  98 bool cmVisualStudioGeneratorOptions::IsDebug()
  99 {
 100   return this->FlagMap.find("DebugInformationFormat") != this->FlagMap.end();
 101 }
 102
 103 //----------------------------------------------------------------------------
 104 bool cmVisualStudioGeneratorOptions::UsingUnicode()
 105 {
 106   // Look for the a _UNICODE definition.
 107   for(std::vector<std::string>::const_iterator di = this->Defines.begin();
 108       di != this->Defines.end(); ++di)
 109     {
 110     if(*di == "_UNICODE")
 111       {
 112       return true;
 113       }
 114     }
 115   return false;
 116 }
 117
 118 //----------------------------------------------------------------------------
 119 void cmVisualStudioGeneratorOptions::Parse(const char* flags)
 120 {
 121   // Parse the input string as a windows command line since the string
 122   // is intended for writing directly into the build files.
 123   std::vector<std::string> args;
 124   cmSystemTools::ParseWindowsCommandLine(flags, args);
 125
 126   // Process flags that need to be represented specially in the IDE
 127   // project file.
 128   for(std::vector<std::string>::iterator ai = args.begin();
 129       ai != args.end(); ++ai)
 130     {
 131     this->HandleFlag(ai->c_str());
 132     }
 133 }
 134
 135 //----------------------------------------------------------------------------
 136 void cmVisualStudioGeneratorOptions::StoreUnknownFlag(const char* flag)
 137 {
 138   // This option is not known.  Store it in the output flags.
 139   this->FlagString += " ";
 140   this->FlagString +=
 141     cmSystemTools::EscapeWindowsShellArgument(
 142       flag,
 143       cmsysSystem_Shell_Flag_AllowMakeVariables |
 144       cmsysSystem_Shell_Flag_VSIDE);
 145 }
 146
 147 //----------------------------------------------------------------------------
 148 void cmVisualStudioGeneratorOptions::SetConfiguration(const char* config)
 149 {
 150   this->Configuration = config;
 151 }
 152
 153 //----------------------------------------------------------------------------
 154 void
 155 cmVisualStudioGeneratorOptions
 156 ::OutputPreprocessorDefinitions(std::ostream& fout,
 157                                 const char* prefix,
 158                                 const char* suffix)
 159 {
 160   if(this->Defines.empty())
 161     {
 162     return;
 163     }
 164   if(this->Version == 10)
 165     {
 166     // if there are configuration specifc flags, then
 167     // use the configuration specific tag for PreprocessorDefinitions
 168     if(this->Configuration.size())
 169       {
 170       fout << prefix;
 171       this->TargetGenerator->WritePlatformConfigTag(
 172         "PreprocessorDefinitions",
 173         this->Configuration.c_str(),
 174         0,
 175         0, 0, &fout);
 176       }
 177     else
 178       {
 179       fout << prefix << "<PreprocessorDefinitions>";
 180       }
 181     }
 182   else
 183     {
 184     fout << prefix <<  "PreprocessorDefinitions=\"";
 185     }
 186   const char* comma = "";
 187   for(std::vector<std::string>::const_iterator di = this->Defines.begin();
 188       di != this->Defines.end(); ++di)
 189     {
 190     // Escape the definition for the compiler.
 191     std::string define;
 192     if(this->Version != 10)
 193       {
 194       define =
 195         this->LocalGenerator->EscapeForShell(di->c_str(), true);
 196       }
 197     else
 198       {
 199       define = *di;
 200       }
 201     // Escape this flag for the IDE.
 202     if(this->Version == 10)
 203       {
 204       define = cmVisualStudio10GeneratorOptionsEscapeForXML(define.c_str());
 205       }
 206     else
 207       {
 208       define = cmVisualStudioGeneratorOptionsEscapeForXML(define.c_str());
 209       }
 210     // Store the flag in the project file.
 211     fout << comma << define;
 212     if(this->Version == 10)
 213       {
 214       comma = ";";
 215       }
 216     else
 217       {
 218       comma = ",";
 219       }
 220     }
 221   if(this->Version == 10)
 222     {
 223     fout <<  ";%(PreprocessorDefinitions)</PreprocessorDefinitions>" << suffix;
 224     }
 225   else
 226     {
 227     fout << "\"" << suffix;
 228     }
 229 }
 230
 231 //----------------------------------------------------------------------------
 232 void
 233 cmVisualStudioGeneratorOptions
 234 ::OutputFlagMap(std::ostream& fout, const char* indent)
 235 {
 236   if(this->Version == 10)
 237     {
 238     for(std::map<cmStdString, cmStdString>::iterator m = this->FlagMap.begin();
 239         m != this->FlagMap.end(); ++m)
 240       {
 241       fout << indent;
 242       if(this->Configuration.size())
 243         {
 244         this->TargetGenerator->WritePlatformConfigTag(
 245           m->first.c_str(),
 246           this->Configuration.c_str(),
 247           0,
 248           0, 0, &fout);
 249         }
 250       else
 251         {
 252         fout << "<" << m->first << ">";
 253         }
 254       fout  << m->second << "</" << m->first << ">\n";
 255       }
 256     }
 257   else
 258     {
 259     for(std::map<cmStdString, cmStdString>::iterator m = this->FlagMap.begin();
 260         m != this->FlagMap.end(); ++m)
 261       {
 262       fout << indent << m->first << "=\"" << m->second << "\"\n";
 263       }
 264     }
 265 }
 266
 267 //----------------------------------------------------------------------------
 268 void
 269 cmVisualStudioGeneratorOptions
 270 ::OutputAdditionalOptions(std::ostream& fout,
 271                           const char* prefix,
 272                           const char* suffix)
 273 {
 274   if(!this->FlagString.empty())
 275     {
 276     if(this->Version == 10)
 277       {
 278       fout << prefix;
 279       if(this->Configuration.size())
 280         {
 281         this->TargetGenerator->WritePlatformConfigTag(
 282           "AdditionalOptions",
 283           this->Configuration.c_str(),
 284           0,
 285           0, 0, &fout);
 286         }
 287       else
 288         {
 289         fout << "<AdditionalOptions>";
 290         }
 291       fout << this->FlagString.c_str()
 292            << " %(AdditionalOptions)</AdditionalOptions>\n";
 293       }
 294     else
 295       {
 296       fout << prefix << "AdditionalOptions=\"";
 297       fout <<
 298         cmVisualStudioGeneratorOptionsEscapeForXML(this->FlagString.c_str());
 299       fout << "\"" << suffix;
 300       }
 301     }
 302 }