cmGlobalVisualStudio10Generator.cxx 19.1 KB
Newer Older
1 2
/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
   file Copyright.txt or https://cmake.org/licensing for details.  */
3
#include "windows.h" // this must be first to define GetCurrentDirectory
4

5
#include "cmGlobalVisualStudio10Generator.h"
6

7
#include "cmAlgorithms.h"
8
#include "cmGeneratorTarget.h"
9 10
#include "cmLocalVisualStudio10Generator.h"
#include "cmMakefile.h"
11
#include "cmSourceFile.h"
12 13
#include "cmVisualStudioSlnData.h"
#include "cmVisualStudioSlnParser.h"
14 15
#include "cmake.h"

16 17 18
static const char vs10generatorName[] = "Visual Studio 10 2010";

// Map generator name without year to name with year.
19
static const char* cmVS10GenName(const std::string& name, std::string& genName)
20
{
21 22
  if (strncmp(name.c_str(), vs10generatorName,
              sizeof(vs10generatorName) - 6) != 0) {
23
    return 0;
24
  }
25
  const char* p = name.c_str() + sizeof(vs10generatorName) - 6;
26
  if (cmHasLiteralPrefix(p, " 2010")) {
27
    p += 5;
28
  }
29 30 31
  genName = std::string(vs10generatorName) + p;
  return p;
}
32

33 34 35 36
class cmGlobalVisualStudio10Generator::Factory
  : public cmGlobalGeneratorFactory
{
public:
37 38
  cmGlobalGenerator* CreateGlobalGenerator(const std::string& name,
                                           cmake* cm) const CM_OVERRIDE
39
  {
40 41
    std::string genName;
    const char* p = cmVS10GenName(name, genName);
42 43 44 45
    if (!p) {
      return 0;
    }
    if (!*p) {
46
      return new cmGlobalVisualStudio10Generator(cm, genName, "");
47 48 49 50 51
    }
    if (*p++ != ' ') {
      return 0;
    }
    if (strcmp(p, "Win64") == 0) {
52
      return new cmGlobalVisualStudio10Generator(cm, genName, "x64");
53 54
    }
    if (strcmp(p, "IA64") == 0) {
55
      return new cmGlobalVisualStudio10Generator(cm, genName, "Itanium");
56
    }
57 58
    return 0;
  }
59

60
  void GetDocumentation(cmDocumentationEntry& entry) const CM_OVERRIDE
61
  {
62
    entry.Name = std::string(vs10generatorName) + " [arch]";
63 64 65
    entry.Brief = "Generates Visual Studio 2010 project files.  "
                  "Optional [arch] can be \"Win64\" or \"IA64\".";
  }
66

67
  void GetGenerators(std::vector<std::string>& names) const CM_OVERRIDE
68
  {
69 70 71
    names.push_back(vs10generatorName);
    names.push_back(vs10generatorName + std::string(" IA64"));
    names.push_back(vs10generatorName + std::string(" Win64"));
72
  }
73

74
  bool SupportsToolset() const CM_OVERRIDE { return true; }
75
  bool SupportsPlatform() const CM_OVERRIDE { return true; }
76 77 78 79 80 81 82
};

cmGlobalGeneratorFactory* cmGlobalVisualStudio10Generator::NewFactory()
{
  return new Factory;
}

83 84
cmGlobalVisualStudio10Generator::cmGlobalVisualStudio10Generator(
  cmake* cm, const std::string& name, const std::string& platformName)
85
  : cmGlobalVisualStudio8Generator(cm, name, platformName)
86
{
87 88 89
  std::string vc10Express;
  this->ExpressEdition = cmSystemTools::ReadRegistryValue(
    "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VCExpress\\10.0\\Setup\\VC;"
90 91
    "ProductDir",
    vc10Express, cmSystemTools::KeyWOW64_32);
92
  this->SystemIsWindowsCE = false;
93 94
  this->SystemIsWindowsPhone = false;
  this->SystemIsWindowsStore = false;
95
  this->MSBuildCommandInitialized = false;
96
  this->DefaultPlatformToolset = "v100";
97
  this->Version = VS10;
98 99
}

100 101
bool cmGlobalVisualStudio10Generator::MatchesGeneratorName(
  const std::string& name) const
102 103
{
  std::string genName;
104
  if (cmVS10GenName(name, genName)) {
105
    return genName == this->GetName();
106
  }
107 108 109
  return false;
}

110 111
bool cmGlobalVisualStudio10Generator::SetSystemName(std::string const& s,
                                                    cmMakefile* mf)
112
{
113 114
  this->SystemName = s;
  this->SystemVersion = mf->GetSafeDefinition("CMAKE_SYSTEM_VERSION");
115
  if (!this->InitializeSystem(mf)) {
116
    return false;
117
  }
118 119 120
  return this->cmGlobalVisualStudio8Generator::SetSystemName(s, mf);
}

121 122
bool cmGlobalVisualStudio10Generator::SetGeneratorPlatform(
  std::string const& p, cmMakefile* mf)
123
{
124
  if (!this->cmGlobalVisualStudio8Generator::SetGeneratorPlatform(p, mf)) {
125
    return false;
126 127 128 129
  }
  if (this->GetPlatformName() == "Itanium" ||
      this->GetPlatformName() == "x64") {
    if (this->IsExpressEdition() && !this->Find64BitTools(mf)) {
130 131
      return false;
    }
132
  }
133
  return true;
134 135
}

136 137
bool cmGlobalVisualStudio10Generator::SetGeneratorToolset(
  std::string const& ts, cmMakefile* mf)
138
{
139
  if (this->SystemIsWindowsCE && ts.empty() &&
140
      this->DefaultPlatformToolset.empty()) {
141
    std::ostringstream e;
142 143 144 145
    e << this->GetName() << " Windows CE version '" << this->SystemVersion
      << "' requires CMAKE_GENERATOR_TOOLSET to be set.";
    mf->IssueMessage(cmake::FATAL_ERROR, e.str());
    return false;
146
  }
147

148 149 150
  if (!this->ParseGeneratorToolset(ts, mf)) {
    return false;
  }
151
  if (const char* toolset = this->GetPlatformToolset()) {
152
    mf->AddDefinition("CMAKE_VS_PLATFORM_TOOLSET", toolset);
153
  }
154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177
  if (const char* hostArch = this->GetPlatformToolsetHostArchitecture()) {
    mf->AddDefinition("CMAKE_VS_PLATFORM_TOOLSET_HOST_ARCHITECTURE", hostArch);
  }
  return true;
}

bool cmGlobalVisualStudio10Generator::ParseGeneratorToolset(
  std::string const& ts, cmMakefile* mf)
{
  if (ts.find_first_of(",=") != ts.npos) {
    std::ostringstream e;
    /* clang-format off */
    e <<
      "Generator\n"
      "  " << this->GetName() << "\n"
      "does not recognize the toolset\n"
      "  " << ts << "\n"
      "that was specified.";
    /* clang-format on */
    mf->IssueMessage(cmake::FATAL_ERROR, e.str());
    return false;
  }

  this->GeneratorToolset = ts;
178 179 180
  return true;
}

181
bool cmGlobalVisualStudio10Generator::InitializeSystem(cmMakefile* mf)
182
{
183 184
  if (this->SystemName == "Windows") {
    if (!this->InitializeWindows(mf)) {
185 186
      return false;
    }
187
  } else if (this->SystemName == "WindowsCE") {
188
    this->SystemIsWindowsCE = true;
189
    if (!this->InitializeWindowsCE(mf)) {
190 191
      return false;
    }
192
  } else if (this->SystemName == "WindowsPhone") {
193
    this->SystemIsWindowsPhone = true;
194
    if (!this->InitializeWindowsPhone(mf)) {
195
      return false;
196
    }
197
  } else if (this->SystemName == "WindowsStore") {
198
    this->SystemIsWindowsStore = true;
199
    if (!this->InitializeWindowsStore(mf)) {
200
      return false;
201
    }
202 203
  } else if (this->SystemName == "Android") {
    if (this->DefaultPlatformName != "Win32") {
204
      std::ostringstream e;
205 206 207 208
      e << "CMAKE_SYSTEM_NAME is 'Android' but CMAKE_GENERATOR "
        << "specifies a platform too: '" << this->GetName() << "'";
      mf->IssueMessage(cmake::FATAL_ERROR, e.str());
      return false;
209
    }
210
    std::string v = this->GetInstalledNsightTegraVersion();
211
    if (v.empty()) {
212
      mf->IssueMessage(cmake::FATAL_ERROR,
213 214 215
                       "CMAKE_SYSTEM_NAME is 'Android' but "
                       "'NVIDIA Nsight Tegra Visual Studio Edition' "
                       "is not installed.");
216
      return false;
217
    }
218 219 220 221
    this->DefaultPlatformName = "Tegra-Android";
    this->DefaultPlatformToolset = "Default";
    this->NsightTegraVersion = v;
    mf->AddDefinition("CMAKE_VS_NsightTegra_VERSION", v.c_str());
222
  }
223

224 225 226
  return true;
}

227 228 229 230 231
bool cmGlobalVisualStudio10Generator::InitializeWindows(cmMakefile*)
{
  return true;
}

232 233
bool cmGlobalVisualStudio10Generator::InitializeWindowsCE(cmMakefile* mf)
{
234
  if (this->DefaultPlatformName != "Win32") {
235
    std::ostringstream e;
236 237 238 239
    e << "CMAKE_SYSTEM_NAME is 'WindowsCE' but CMAKE_GENERATOR "
      << "specifies a platform too: '" << this->GetName() << "'";
    mf->IssueMessage(cmake::FATAL_ERROR, e.str());
    return false;
240
  }
241 242 243 244 245 246

  this->DefaultPlatformToolset = this->SelectWindowsCEToolset();

  return true;
}

247 248
bool cmGlobalVisualStudio10Generator::InitializeWindowsPhone(cmMakefile* mf)
{
249
  std::ostringstream e;
250 251 252 253 254 255 256
  e << this->GetName() << " does not support Windows Phone.";
  mf->IssueMessage(cmake::FATAL_ERROR, e.str());
  return false;
}

bool cmGlobalVisualStudio10Generator::InitializeWindowsStore(cmMakefile* mf)
{
257
  std::ostringstream e;
258 259 260 261 262
  e << this->GetName() << " does not support Windows Store.";
  mf->IssueMessage(cmake::FATAL_ERROR, e.str());
  return false;
}

263
bool cmGlobalVisualStudio10Generator::SelectWindowsPhoneToolset(
264 265 266 267 268 269
  std::string& toolset) const
{
  toolset = "";
  return false;
}

270
bool cmGlobalVisualStudio10Generator::SelectWindowsStoreToolset(
271 272 273 274 275 276
  std::string& toolset) const
{
  toolset = "";
  return false;
}

277 278
std::string cmGlobalVisualStudio10Generator::SelectWindowsCEToolset() const
{
279
  if (this->SystemVersion == "8.0") {
280
    return "CE800";
281
  }
282 283 284
  return "";
}

285 286 287
void cmGlobalVisualStudio10Generator::WriteSLNHeader(std::ostream& fout)
{
  fout << "Microsoft Visual Studio Solution File, Format Version 11.00\n";
288
  if (this->ExpressEdition) {
289
    fout << "# Visual C++ Express 2010\n";
290
  } else {
291
    fout << "# Visual Studio 2010\n";
292
  }
293 294 295
}

///! Create a local generator appropriate to this Global Generator
296
cmLocalGenerator* cmGlobalVisualStudio10Generator::CreateLocalGenerator(
297
  cmMakefile* mf)
298
{
299
  return new cmLocalVisualStudio10Generator(this, mf);
300 301
}

302 303
void cmGlobalVisualStudio10Generator::Generate()
{
304
  this->LongestSource = LongestSourcePath();
305
  this->cmGlobalVisualStudio8Generator::Generate();
306
  if (this->LongestSource.Length > 0) {
307
    cmLocalGenerator* lg = this->LongestSource.Target->GetLocalGenerator();
308
    std::ostringstream e;
309
    /* clang-format off */
310 311 312 313 314 315 316 317 318 319 320 321 322
    e <<
      "The binary and/or source directory paths may be too long to generate "
      "Visual Studio 10 files for this project.  "
      "Consider choosing shorter directory names to build this project with "
      "Visual Studio 10.  "
      "A more detailed explanation follows."
      "\n"
      "There is a bug in the VS 10 IDE that renders property dialog fields "
      "blank for files referenced by full path in the project file.  "
      "However, CMake must reference at least one file by full path:\n"
      "  " << this->LongestSource.SourceFile->GetFullPath() << "\n"
      "This is because some Visual Studio tools would append the relative "
      "path to the end of the referencing directory path, as in:\n"
323
      "  " << lg->GetCurrentBinaryDirectory() << "/"
324 325 326 327 328
      << this->LongestSource.SourceRel << "\n"
      "and then incorrectly complain that the file does not exist because "
      "the path length is too long for some internal buffer or API.  "
      "To avoid this problem CMake must use a full path for this file "
      "which then triggers the VS 10 property dialog bug.";
329
    /* clang-format on */
330
    lg->IssueMessage(cmake::WARNING, e.str().c_str());
331
  }
332 333
}

334 335
void cmGlobalVisualStudio10Generator::EnableLanguage(
  std::vector<std::string> const& lang, cmMakefile* mf, bool optional)
336 337 338 339
{
  cmGlobalVisualStudio8Generator::EnableLanguage(lang, mf, optional);
}

340
const char* cmGlobalVisualStudio10Generator::GetPlatformToolset() const
341
{
342
  if (!this->GeneratorToolset.empty()) {
343
    return this->GeneratorToolset.c_str();
344 345
  }
  if (!this->DefaultPlatformToolset.empty()) {
346
    return this->DefaultPlatformToolset.c_str();
347
  }
348 349 350
  return 0;
}

351 352 353 354 355 356 357 358 359
const char*
cmGlobalVisualStudio10Generator::GetPlatformToolsetHostArchitecture() const
{
  if (!this->GeneratorToolsetHostArchitecture.empty()) {
    return this->GeneratorToolsetHostArchitecture.c_str();
  }
  return CM_NULLPTR;
}

360 361 362 363 364 365 366
void cmGlobalVisualStudio10Generator::FindMakeProgram(cmMakefile* mf)
{
  this->cmGlobalVisualStudio8Generator::FindMakeProgram(mf);
  mf->AddDefinition("CMAKE_VS_MSBUILD_COMMAND",
                    this->GetMSBuildCommand().c_str());
}

367 368
std::string const& cmGlobalVisualStudio10Generator::GetMSBuildCommand()
{
369
  if (!this->MSBuildCommandInitialized) {
370 371
    this->MSBuildCommandInitialized = true;
    this->MSBuildCommand = this->FindMSBuildCommand();
372
  }
373 374 375 376 377 378
  return this->MSBuildCommand;
}

std::string cmGlobalVisualStudio10Generator::FindMSBuildCommand()
{
  std::string msbuild;
379 380 381 382
  std::string mskey;

  // Search in standard location.
  mskey = "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\MSBuild\\ToolsVersions\\";
383 384
  mskey += this->GetToolsVersion();
  mskey += ";MSBuildToolsPath";
385 386
  if (cmSystemTools::ReadRegistryValue(mskey.c_str(), msbuild,
                                       cmSystemTools::KeyWOW64_32)) {
387
    cmSystemTools::ConvertToUnixSlashes(msbuild);
388 389 390 391
    msbuild += "/MSBuild.exe";
    if (cmSystemTools::FileExists(msbuild, true)) {
      return msbuild;
    }
392
  }
393

394 395 396 397 398 399 400 401 402 403 404 405 406 407
  // Search where VS15Preview places it.
  mskey = "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\SxS\\VS7;";
  mskey += this->GetIDEVersion();
  if (cmSystemTools::ReadRegistryValue(mskey.c_str(), msbuild,
                                       cmSystemTools::KeyWOW64_32)) {
    cmSystemTools::ConvertToUnixSlashes(msbuild);
    msbuild += "/MSBuild/";
    msbuild += this->GetIDEVersion();
    msbuild += "/Bin/MSBuild.exe";
    if (cmSystemTools::FileExists(msbuild, true)) {
      return msbuild;
    }
  }

408
  msbuild = "MSBuild.exe";
409 410
  return msbuild;
}
411

412 413
std::string cmGlobalVisualStudio10Generator::FindDevEnvCommand()
{
414
  if (this->ExpressEdition) {
415 416 417 418
    // Visual Studio Express >= 10 do not have "devenv.com" or
    // "VCExpress.exe" that we can use to build reliably.
    // Tell the caller it needs to use MSBuild instead.
    return "";
419
  }
420 421 422 423 424
  // Skip over the cmGlobalVisualStudio8Generator implementation because
  // we expect a real devenv and do not want to look for VCExpress.
  return this->cmGlobalVisualStudio71Generator::FindDevEnvCommand();
}

425
void cmGlobalVisualStudio10Generator::GenerateBuildCommand(
426 427 428 429
  std::vector<std::string>& makeCommand, const std::string& makeProgram,
  const std::string& projectName, const std::string& projectDir,
  const std::string& targetName, const std::string& config, bool fast,
  bool verbose, std::vector<std::string> const& makeOptions)
430
{
431 432 433 434 435 436 437
  // Select the caller- or user-preferred make program, else MSBuild.
  std::string makeProgramSelected =
    this->SelectMakeProgram(makeProgram, this->GetMSBuildCommand());

  // Check if the caller explicitly requested a devenv tool.
  std::string makeProgramLower = makeProgramSelected;
  cmSystemTools::LowerCase(makeProgramLower);
438 439
  bool useDevEnv = (makeProgramLower.find("devenv") != std::string::npos ||
                    makeProgramLower.find("vcexpress") != std::string::npos);
440 441 442 443 444

  // MSBuild is preferred (and required for VS Express), but if the .sln has
  // an Intel Fortran .vfproj then we have to use devenv. Parse it to find out.
  cmSlnData slnData;
  {
445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460
    std::string slnFile;
    if (!projectDir.empty()) {
      slnFile = projectDir;
      slnFile += "/";
    }
    slnFile += projectName;
    slnFile += ".sln";
    cmVisualStudioSlnParser parser;
    if (parser.ParseFile(slnFile, slnData,
                         cmVisualStudioSlnParser::DataGroupProjects)) {
      std::vector<cmSlnProjectEntry> slnProjects = slnData.GetProjects();
      for (std::vector<cmSlnProjectEntry>::iterator i = slnProjects.begin();
           !useDevEnv && i != slnProjects.end(); ++i) {
        std::string proj = i->GetRelativePath();
        if (proj.size() > 7 && proj.substr(proj.size() - 7) == ".vfproj") {
          useDevEnv = true;
461 462 463 464
        }
      }
    }
  }
465
  if (useDevEnv) {
466
    // Use devenv to build solutions containing Intel Fortran projects.
467
    cmGlobalVisualStudio7Generator::GenerateBuildCommand(
468 469
      makeCommand, makeProgram, projectName, projectDir, targetName, config,
      fast, verbose, makeOptions);
470
    return;
471
  }
472

473
  makeCommand.push_back(makeProgramSelected);
474

475
  std::string realTarget = targetName;
476
  // msbuild.exe CxxOnly.sln /t:Build /p:Configuration=Debug /target:ALL_BUILD
477
  if (realTarget.empty()) {
478
    realTarget = "ALL_BUILD";
479 480 481
  }
  if (realTarget == "clean") {
    makeCommand.push_back(std::string(projectName) + ".sln");
482
    makeCommand.push_back("/t:Clean");
483
  } else {
484
    std::string targetProject(realTarget);
485
    targetProject += ".vcxproj";
486
    if (targetProject.find('/') == std::string::npos) {
487
      // it might be in a subdir
488
      if (cmSlnProjectEntry const* proj =
489
            slnData.GetProjectByName(realTarget)) {
490 491
        targetProject = proj->GetRelativePath();
        cmSystemTools::ConvertToUnixSlashes(targetProject);
492
      }
493
    }
494 495
    makeCommand.push_back(targetProject);
  }
496
  std::string configArg = "/p:Configuration=";
497
  if (!config.empty()) {
498
    configArg += config;
499
  } else {
500
    configArg += "Debug";
501
  }
502
  makeCommand.push_back(configArg);
503
  makeCommand.push_back(std::string("/p:VisualStudioVersion=") +
504
                        this->GetIDEVersion());
505 506
  makeCommand.insert(makeCommand.end(), makeOptions.begin(),
                     makeOptions.end());
507
}
508 509 510

bool cmGlobalVisualStudio10Generator::Find64BitTools(cmMakefile* mf)
{
511 512 513 514
  if (this->DefaultPlatformToolset == "v100") {
    // The v100 64-bit toolset does not exist in the express edition.
    this->DefaultPlatformToolset.clear();
  }
515
  if (this->GetPlatformToolset()) {
516
    return true;
517
  }
518 519 520
  // This edition does not come with 64-bit tools.  Look for them.
  //
  // TODO: Detect available tools?  x64\v100 exists but does not work?
521
  // HKLM\\SOFTWARE\\Microsoft\\MSBuild\\ToolsVersions\\4.0;VCTargetsPath
522 523 524
  // c:/Program Files (x86)/MSBuild/Microsoft.Cpp/v4.0/Platforms/
  //   {Itanium,Win32,x64}/PlatformToolsets/{v100,v90,Windows7.1SDK}
  std::string winSDK_7_1;
525 526 527 528
  if (cmSystemTools::ReadRegistryValue(
        "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Microsoft SDKs\\"
        "Windows\\v7.1;InstallationFolder",
        winSDK_7_1)) {
529
    std::ostringstream m;
530 531
    m << "Found Windows SDK v7.1: " << winSDK_7_1;
    mf->DisplayStatus(m.str().c_str(), -1);
532
    this->DefaultPlatformToolset = "Windows7.1SDK";
533
    return true;
534
  } else {
535
    std::ostringstream e;
536
    /* clang-format off */
537 538 539
    e << "Cannot enable 64-bit tools with Visual Studio 2010 Express.\n"
      << "Install the Microsoft Windows SDK v7.1 to get 64-bit tools:\n"
      << "  http://msdn.microsoft.com/en-us/windows/bb980924.aspx";
540
    /* clang-format on */
541 542 543
    mf->IssueMessage(cmake::FATAL_ERROR, e.str().c_str());
    cmSystemTools::SetFatalErrorOccured();
    return false;
544
  }
545
}
546

547 548
std::string cmGlobalVisualStudio10Generator::GenerateRuleFile(
  std::string const& output) const
549 550 551 552 553 554 555 556 557 558 559 560 561
{
  // The VS 10 generator needs to create the .rule files on disk.
  // Hide them away under the CMakeFiles directory.
  std::string ruleDir = this->GetCMakeInstance()->GetHomeOutputDirectory();
  ruleDir += cmake::GetCMakeFilesDirectory();
  ruleDir += "/";
  ruleDir += cmSystemTools::ComputeStringMD5(
    cmSystemTools::GetFilenamePath(output).c_str());
  std::string ruleFile = ruleDir + "/";
  ruleFile += cmSystemTools::GetFilenameName(output);
  ruleFile += ".rule";
  return ruleFile;
}
562

563 564 565
void cmGlobalVisualStudio10Generator::PathTooLong(cmGeneratorTarget* target,
                                                  cmSourceFile const* sf,
                                                  std::string const& sfRel)
566
{
567
  size_t len =
568 569 570
    (strlen(target->GetLocalGenerator()->GetCurrentBinaryDirectory()) + 1 +
     sfRel.length());
  if (len > this->LongestSource.Length) {
571 572 573 574
    this->LongestSource.Length = len;
    this->LongestSource.Target = target;
    this->LongestSource.SourceFile = sf;
    this->LongestSource.SourceRel = sfRel;
575
  }
576
}
577

578 579 580 581 582
bool cmGlobalVisualStudio10Generator::IsNsightTegra() const
{
  return !this->NsightTegraVersion.empty();
}

583 584 585 586 587
std::string cmGlobalVisualStudio10Generator::GetNsightTegraVersion() const
{
  return this->NsightTegraVersion;
}

588 589 590 591 592
std::string cmGlobalVisualStudio10Generator::GetInstalledNsightTegraVersion()
{
  std::string version;
  cmSystemTools::ReadRegistryValue(
    "HKEY_LOCAL_MACHINE\\SOFTWARE\\NVIDIA Corporation\\Nsight Tegra;"
593 594
    "Version",
    version, cmSystemTools::KeyWOW64_32);
595 596
  return version;
}