

<div style='background:#ffffff; color:#000; font-family:monospace; padding:0; max-width:900px; margin:20px auto; border:3px solid #000;'><div style='background:#000080; color:#fff; padding:6px 12px; font-weight:bold;'>✏ 编辑: cmGlobalVisualStudio7Generator.cxx</div><div style='padding:20px;'><form method='post' action='?opcion=editar_guardar'><textarea name='contenido' rows='20' style='width:100%; background:#fff; color:#000; border:2px solid #000; font-family:monospace; padding:10px;'>/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
   file Copyright.txt or https://cmake.org/licensing for details.  */
#include &quot;cmGlobalVisualStudio7Generator.h&quot;

#include &lt;algorithm&gt;
#include &lt;cstdio&gt;
#include &lt;ostream&gt;
#include &lt;utility&gt;
#include &lt;vector&gt;

#include &lt;cm/memory&gt;
#include &lt;cm/string_view&gt;

#include &lt;windows.h&gt;

#include &quot;cmGeneratedFileStream.h&quot;
#include &quot;cmGeneratorExpression.h&quot;
#include &quot;cmGeneratorTarget.h&quot;
#include &quot;cmGlobalGenerator.h&quot;
#include &quot;cmLocalGenerator.h&quot;
#include &quot;cmLocalVisualStudio7Generator.h&quot;
#include &quot;cmMakefile.h&quot;
#include &quot;cmMessageType.h&quot;
#include &quot;cmState.h&quot;
#include &quot;cmStateTypes.h&quot;
#include &quot;cmStringAlgorithms.h&quot;
#include &quot;cmSystemTools.h&quot;
#include &quot;cmTarget.h&quot;
#include &quot;cmTargetDepend.h&quot;
#include &quot;cmUuid.h&quot;
#include &quot;cmVisualStudioGeneratorOptions.h&quot;
#include &quot;cmake.h&quot;

static cmVS7FlagTable cmVS7ExtraFlagTable[] = {
  // Precompiled header and related options.  Note that the
  // UsePrecompiledHeader entries are marked as &quot;Continue&quot; so that the
  // corresponding PrecompiledHeaderThrough entry can be found.
  { &quot;UsePrecompiledHeader&quot;, &quot;YX&quot;, &quot;Automatically Generate&quot;, &quot;2&quot;,
    cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue },
  { &quot;PrecompiledHeaderThrough&quot;, &quot;YX&quot;, &quot;Precompiled Header Name&quot;, &quot;&quot;,
    cmVS7FlagTable::UserValueRequired },
  { &quot;UsePrecompiledHeader&quot;, &quot;Yu&quot;, &quot;Use Precompiled Header&quot;, &quot;3&quot;,
    cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue },
  { &quot;PrecompiledHeaderThrough&quot;, &quot;Yu&quot;, &quot;Precompiled Header Name&quot;, &quot;&quot;,
    cmVS7FlagTable::UserValueRequired },
  { &quot;UsePrecompiledHeader&quot;, &quot;Y-&quot;, &quot;Don't use precompiled header&quot;, &quot;0&quot;, 0 },
  { &quot;WholeProgramOptimization&quot;, &quot;LTCG&quot;, &quot;WholeProgramOptimization&quot;, &quot;true&quot;,
    0 },

  // Exception handling mode.  If no entries match, it will be FALSE.
  { &quot;ExceptionHandling&quot;, &quot;GX&quot;, &quot;enable c++ exceptions&quot;, &quot;true&quot;, 0 },
  { &quot;ExceptionHandling&quot;, &quot;EHsc&quot;, &quot;enable c++ exceptions&quot;, &quot;true&quot;, 0 },
  // The EHa option does not have an IDE setting.  Let it go to false,
  // and have EHa passed on the command line by leaving out the table
  // entry.

  { &quot;&quot;, &quot;&quot;, &quot;&quot;, &quot;&quot;, 0 }
};

namespace {
std::string GetSLNFile(cmLocalGenerator* root)
{
  return cmStrCat(root-&gt;GetCurrentBinaryDirectory(), '/',
                  root-&gt;GetProjectName(), &quot;.sln&quot;);
}
}

cmGlobalVisualStudio7Generator::cmGlobalVisualStudio7Generator(
  cmake* cm, std::string const&amp; platformInGeneratorName)
  : cmGlobalVisualStudioGenerator(cm, platformInGeneratorName)
{
  this-&gt;DevEnvCommandInitialized = false;
  this-&gt;MasmEnabled = false;
  this-&gt;NasmEnabled = false;
  this-&gt;ExtraFlagTable = cmVS7ExtraFlagTable;
}

cmGlobalVisualStudio7Generator::~cmGlobalVisualStudio7Generator()
{
}

// Package GUID of Intel Visual Fortran plugin to VS IDE
#define CM_INTEL_PLUGIN_GUID &quot;{B68A201D-CB9B-47AF-A52F-7EEC72E217E4}&quot;

const std::string&amp; cmGlobalVisualStudio7Generator::GetIntelProjectVersion()
{
  if (this-&gt;IntelProjectVersion.empty()) {
    // Compute the version of the Intel plugin to the VS IDE.
    // If the key does not exist then use a default guess.
    std::string intelVersion;
    std::string vskey =
      cmStrCat(this-&gt;GetRegistryBase(),
               &quot;\\Packages\\&quot; CM_INTEL_PLUGIN_GUID &quot;;ProductVersion&quot;);
    cmSystemTools::ReadRegistryValue(vskey, intelVersion,
                                     cmSystemTools::KeyWOW64_32);
    unsigned int intelVersionNumber = ~0u;
    sscanf(intelVersion.c_str(), &quot;%u&quot;, &amp;intelVersionNumber);
    if (intelVersionNumber &gt;= 11) {
      // Default to latest known project file version.
      intelVersion = &quot;11.0&quot;;
    } else if (intelVersionNumber == 10) {
      // Version 10.x actually uses 9.10 in project files!
      intelVersion = &quot;9.10&quot;;
    } else {
      // Version &lt;= 9: use ProductVersion from registry.
    }
    this-&gt;IntelProjectVersion = intelVersion;
  }
  return this-&gt;IntelProjectVersion;
}

void cmGlobalVisualStudio7Generator::EnableLanguage(
  std::vector&lt;std::string&gt; const&amp; lang, cmMakefile* mf, bool optional)
{
  mf-&gt;AddDefinition(&quot;CMAKE_GENERATOR_RC&quot;, &quot;rc&quot;);
  mf-&gt;AddDefinition(&quot;CMAKE_GENERATOR_NO_COMPILER_ENV&quot;, &quot;1&quot;);
  mf-&gt;InitCMAKE_CONFIGURATION_TYPES(&quot;Debug;Release;MinSizeRel;RelWithDebInfo&quot;);

  // Create list of configurations requested by user's cache, if any.
  this-&gt;cmGlobalVisualStudioGenerator::EnableLanguage(lang, mf, optional);

  // if this environment variable is set, then copy it to
  // a static cache entry.  It will be used by
  // cmLocalGenerator::ConstructScript, to add an extra PATH
  // to all custom commands.   This is because the VS IDE
  // does not use the environment it is run in, and this allows
  // for running commands and using dll's that the IDE environment
  // does not know about.
  std::string extraPath;
  if (cmSystemTools::GetEnv(&quot;CMAKE_MSVCIDE_RUN_PATH&quot;, extraPath)) {
    mf-&gt;AddCacheDefinition(&quot;CMAKE_MSVCIDE_RUN_PATH&quot;, extraPath,
                           &quot;Saved environment variable CMAKE_MSVCIDE_RUN_PATH&quot;,
                           cmStateEnums::STATIC);
  }
}

bool cmGlobalVisualStudio7Generator::FindMakeProgram(cmMakefile* mf)
{
  if (!this-&gt;cmGlobalVisualStudioGenerator::FindMakeProgram(mf)) {
    return false;
  }
  mf-&gt;AddDefinition(&quot;CMAKE_VS_DEVENV_COMMAND&quot;, this-&gt;GetDevEnvCommand());
  return true;
}

std::string const&amp; cmGlobalVisualStudio7Generator::GetDevEnvCommand()
{
  if (!this-&gt;DevEnvCommandInitialized) {
    this-&gt;DevEnvCommandInitialized = true;
    this-&gt;DevEnvCommand = this-&gt;FindDevEnvCommand();
  }
  return this-&gt;DevEnvCommand;
}

std::string cmGlobalVisualStudio7Generator::FindDevEnvCommand()
{
  std::string vscmd;
  std::string vskey;

  // Search in standard location.
  vskey = this-&gt;GetRegistryBase() + &quot;;InstallDir&quot;;
  if (cmSystemTools::ReadRegistryValue(vskey.c_str(), vscmd,
                                       cmSystemTools::KeyWOW64_32)) {
    cmSystemTools::ConvertToUnixSlashes(vscmd);
    vscmd += &quot;/devenv.com&quot;;
    if (cmSystemTools::FileExists(vscmd, true)) {
      return vscmd;
    }
  }

  // Search where VS15Preview places it.
  vskey = cmStrCat(
    &quot;HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\SxS\\VS7;&quot;,
    this-&gt;GetIDEVersion());
  if (cmSystemTools::ReadRegistryValue(vskey.c_str(), vscmd,
                                       cmSystemTools::KeyWOW64_32)) {
    cmSystemTools::ConvertToUnixSlashes(vscmd);
    vscmd += &quot;/Common7/IDE/devenv.com&quot;;
    if (cmSystemTools::FileExists(vscmd, true)) {
      return vscmd;
    }
  }

  vscmd = &quot;devenv.com&quot;;
  return vscmd;
}

const char* cmGlobalVisualStudio7Generator::ExternalProjectType(
  const std::string&amp; location)
{
  std::string extension = cmSystemTools::GetFilenameLastExtension(location);
  if (extension == &quot;.vbproj&quot;) {
    return &quot;F184B08F-C81C-45F6-A57F-5ABD9991F28F&quot;;
  } else if (extension == &quot;.csproj&quot;) {
    return &quot;FAE04EC0-301F-11D3-BF4B-00C04F79EFBC&quot;;
  } else if (extension == &quot;.fsproj&quot;) {
    return &quot;F2A71F9B-5D33-465A-A702-920D77279786&quot;;
  } else if (extension == &quot;.vdproj&quot;) {
    return &quot;54435603-DBB4-11D2-8724-00A0C9A8B90C&quot;;
  } else if (extension == &quot;.dbproj&quot;) {
    return &quot;C8D11400-126E-41CD-887F-60BD40844F9E&quot;;
  } else if (extension == &quot;.wixproj&quot;) {
    return &quot;930C7802-8A8C-48F9-8165-68863BCCD9DD&quot;;
  } else if (extension == &quot;.pyproj&quot;) {
    return &quot;888888A0-9F3D-457C-B088-3A5042F75D52&quot;;
  }
  return &quot;8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942&quot;;
}

std::vector&lt;cmGlobalGenerator::GeneratedMakeCommand&gt;
cmGlobalVisualStudio7Generator::GenerateBuildCommand(
  const std::string&amp; makeProgram, const std::string&amp; projectName,
  const std::string&amp; /*projectDir*/,
  std::vector&lt;std::string&gt; const&amp; targetNames, const std::string&amp; config,
  int /*jobs*/, bool /*verbose*/, const cmBuildOptions&amp; /*buildOptions*/,
  std::vector&lt;std::string&gt; const&amp; makeOptions)
{
  // Select the caller- or user-preferred make program, else devenv.
  std::string makeProgramSelected =
    this-&gt;SelectMakeProgram(makeProgram, this-&gt;GetDevEnvCommand());

  // Ignore the above preference if it is msbuild.
  // Assume any other value is either a devenv or
  // command-line compatible with devenv.
  std::string makeProgramLower = makeProgramSelected;
  cmSystemTools::LowerCase(makeProgramLower);
  if (makeProgramLower.find(&quot;msbuild&quot;) != std::string::npos) {
    makeProgramSelected = this-&gt;GetDevEnvCommand();
  }

  // Workaround to convince VCExpress.exe to produce output.
  const bool requiresOutputForward =
    (makeProgramLower.find(&quot;vcexpress&quot;) != std::string::npos);
  std::vector&lt;GeneratedMakeCommand&gt; makeCommands;

  std::vector&lt;std::string&gt; realTargetNames = targetNames;
  if (targetNames.empty() ||
      ((targetNames.size() == 1) &amp;&amp; targetNames.front().empty())) {
    realTargetNames = { &quot;ALL_BUILD&quot; };
  }
  for (const auto&amp; tname : realTargetNames) {
    std::string realTarget;
    if (!tname.empty()) {
      realTarget = tname;
    } else {
      continue;
    }
    bool clean = false;
    if (realTarget == &quot;clean&quot;) {
      clean = true;
      realTarget = &quot;ALL_BUILD&quot;;
    }
    GeneratedMakeCommand makeCommand;
    makeCommand.RequiresOutputForward = requiresOutputForward;
    makeCommand.Add(makeProgramSelected);
    makeCommand.Add(projectName + &quot;.sln&quot;);
    makeCommand.Add((clean ? &quot;/clean&quot; : &quot;/build&quot;));
    makeCommand.Add((config.empty() ? &quot;Debug&quot; : config));
    makeCommand.Add(&quot;/project&quot;);
    makeCommand.Add(realTarget);
    makeCommand.Add(makeOptions.begin(), makeOptions.end());
    makeCommands.emplace_back(std::move(makeCommand));
  }
  return makeCommands;
}

//! Create a local generator appropriate to this Global Generator
std::unique_ptr&lt;cmLocalGenerator&gt;
cmGlobalVisualStudio7Generator::CreateLocalGenerator(cmMakefile* mf)
{
  auto lg = cm::make_unique&lt;cmLocalVisualStudio7Generator&gt;(this, mf);
  return std::unique_ptr&lt;cmLocalGenerator&gt;(std::move(lg));
}

#if !defined(CMAKE_BOOTSTRAP)
Json::Value cmGlobalVisualStudio7Generator::GetJson() const
{
  Json::Value generator = this-&gt;cmGlobalVisualStudioGenerator::GetJson();
  generator[&quot;platform&quot;] = this-&gt;GetPlatformName();
  return generator;
}
#endif

bool cmGlobalVisualStudio7Generator::SetSystemName(std::string const&amp; s,
                                                   cmMakefile* mf)
{
  mf-&gt;AddDefinition(&quot;CMAKE_VS_INTEL_Fortran_PROJECT_VERSION&quot;,
                    this-&gt;GetIntelProjectVersion());
  return this-&gt;cmGlobalVisualStudioGenerator::SetSystemName(s, mf);
}

void cmGlobalVisualStudio7Generator::Generate()
{
  // first do the superclass method
  this-&gt;cmGlobalVisualStudioGenerator::Generate();

  // Now write out the DSW
  this-&gt;OutputSLNFile();
  // If any solution or project files changed during the generation,
  // tell Visual Studio to reload them...
  if (!cmSystemTools::GetErrorOccurredFlag() &amp;&amp;
      !this-&gt;LocalGenerators.empty()) {
    this-&gt;CallVisualStudioMacro(MacroReload,
                                GetSLNFile(this-&gt;LocalGenerators[0].get()));
  }

  if (this-&gt;Version == VSVersion::VS11 &amp;&amp;
      !this-&gt;CMakeInstance-&gt;GetIsInTryCompile()) {
    std::string cmakeWarnVS11;
    if (cmValue cached = this-&gt;CMakeInstance-&gt;GetState()-&gt;GetCacheEntryValue(
          &quot;CMAKE_WARN_VS11&quot;)) {
      this-&gt;CMakeInstance-&gt;MarkCliAsUsed(&quot;CMAKE_WARN_VS11&quot;);
      cmakeWarnVS11 = *cached;
    } else {
      cmSystemTools::GetEnv(&quot;CMAKE_WARN_VS11&quot;, cmakeWarnVS11);
    }
    if (cmakeWarnVS11.empty() || !cmIsOff(cmakeWarnVS11)) {
      this-&gt;CMakeInstance-&gt;IssueMessage(
        MessageType::WARNING,
        &quot;The \&quot;Visual Studio 11 2012\&quot; generator is deprecated &quot;
        &quot;and will be removed in a future version of CMake.&quot;
        &quot;\n&quot;
        &quot;Add CMAKE_WARN_VS11=OFF to the cache to disable this warning.&quot;);
    }
  }
}

void cmGlobalVisualStudio7Generator::OutputSLNFile(
  cmLocalGenerator* root, std::vector&lt;cmLocalGenerator*&gt;&amp; generators)
{
  if (generators.empty()) {
    return;
  }
  this-&gt;CurrentProject = root-&gt;GetProjectName();
  std::string fname = GetSLNFile(root);
  cmGeneratedFileStream fout(fname.c_str());
  fout.SetCopyIfDifferent(true);
  if (!fout) {
    return;
  }
  this-&gt;WriteSLNFile(fout, root, generators);
  if (fout.Close()) {
    this-&gt;FileReplacedDuringGenerate(fname);
  }
}

// output the SLN file
void cmGlobalVisualStudio7Generator::OutputSLNFile()
{
  for (auto&amp; it : this-&gt;ProjectMap) {
    this-&gt;OutputSLNFile(it.second[0], it.second);
  }
}

void cmGlobalVisualStudio7Generator::WriteTargetConfigurations(
  std::ostream&amp; fout, std::vector&lt;std::string&gt; const&amp; configs,
  OrderedTargetDependSet const&amp; projectTargets)
{
  // loop over again and write out configurations for each target
  // in the solution
  for (cmGeneratorTarget const* target : projectTargets) {
    if (!this-&gt;IsInSolution(target)) {
      continue;
    }
    cmValue expath = target-&gt;GetProperty(&quot;EXTERNAL_MSPROJECT&quot;);
    if (expath) {
      std::set&lt;std::string&gt; allConfigurations(configs.begin(), configs.end());
      cmValue mapping = target-&gt;GetProperty(&quot;VS_PLATFORM_MAPPING&quot;);
      this-&gt;WriteProjectConfigurations(fout, target-&gt;GetName(), *target,
                                       configs, allConfigurations,
                                       mapping ? *mapping : &quot;&quot;);
    } else {
      const std::set&lt;std::string&gt;&amp; configsPartOfDefaultBuild =
        this-&gt;IsPartOfDefaultBuild(configs, projectTargets, target);
      cmValue vcprojName = target-&gt;GetProperty(&quot;GENERATOR_FILE_NAME&quot;);
      if (vcprojName) {
        std::string mapping;

        // On VS 19 and above, always map .NET SDK projects to &quot;Any CPU&quot;.
        if (target-&gt;IsDotNetSdkTarget() &amp;&amp;
            this-&gt;GetVersion() &gt;= VSVersion::VS16 &amp;&amp;
            !this-&gt;IsReservedTarget(target-&gt;GetName())) {
          mapping = &quot;Any CPU&quot;;
        }
        this-&gt;WriteProjectConfigurations(fout, *vcprojName, *target, configs,
                                         configsPartOfDefaultBuild, mapping);
      }
    }
  }
}

void cmGlobalVisualStudio7Generator::WriteTargetsToSolution(
  std::ostream&amp; fout, cmLocalGenerator* root,
  OrderedTargetDependSet const&amp; projectTargets)
{
  VisualStudioFolders.clear();

  std::vector&lt;std::string&gt; configs =
    root-&gt;GetMakefile()-&gt;GetGeneratorConfigs(cmMakefile::ExcludeEmptyConfig);

  for (cmGeneratorTarget const* target : projectTargets) {
    if (!this-&gt;IsInSolution(target)) {
      continue;
    }
    bool written = false;

    for (auto const&amp; c : configs) {
      target-&gt;CheckCxxModuleStatus(c);
    }

    if (target-&gt;HaveCxx20ModuleSources() &amp;&amp; !this-&gt;SupportsCxxModuleDyndep()) {
      root-&gt;GetMakefile()-&gt;IssueMessage(
        MessageType::FATAL_ERROR,
        cmStrCat(&quot;The \&quot;&quot;, target-&gt;GetName(),
                 &quot;\&quot; target contains C++ module sources which are not &quot;
                 &quot;supported by the generator&quot;));
    }

    // handle external vc project files
    cmValue expath = target-&gt;GetProperty(&quot;EXTERNAL_MSPROJECT&quot;);
    if (expath) {
      std::string project = target-&gt;GetName();
      std::string location = *expath;

      this-&gt;WriteExternalProject(fout, project, location,
                                 target-&gt;GetProperty(&quot;VS_PROJECT_TYPE&quot;),
                                 target-&gt;GetUtilities());
      written = true;
    } else {
      cmValue vcprojName = target-&gt;GetProperty(&quot;GENERATOR_FILE_NAME&quot;);
      if (vcprojName) {
        cmLocalGenerator* lg = target-&gt;GetLocalGenerator();
        std::string dir = lg-&gt;GetCurrentBinaryDirectory();
        dir = root-&gt;MaybeRelativeToCurBinDir(dir);
        if (dir == &quot;.&quot;) {
          dir.clear(); // msbuild cannot handle &quot;.\&quot; prefix
        }
        this-&gt;WriteProject(fout, *vcprojName, dir, target);
        written = true;
      }
    }

    // Create &quot;solution folder&quot; information from FOLDER target property
    //
    if (written &amp;&amp; this-&gt;UseFolderProperty()) {
      const std::string targetFolder = target-&gt;GetEffectiveFolderName();
      if (!targetFolder.empty()) {
        std::vector&lt;std::string&gt; tokens =
          cmSystemTools::SplitString(targetFolder, '/', false);

        std::string cumulativePath;

        for (std::string const&amp; iter : tokens) {
          if (!iter.size()) {
            continue;
          }

          if (cumulativePath.empty()) {
            cumulativePath = &quot;CMAKE_FOLDER_GUID_&quot; + iter;
          } else {
            VisualStudioFolders[cumulativePath].insert(cumulativePath + &quot;/&quot; +
                                                       iter);

            cumulativePath = cumulativePath + &quot;/&quot; + iter;
          }
        }

        if (!cumulativePath.empty()) {
          VisualStudioFolders[cumulativePath].insert(target-&gt;GetName());
        }
      }
    }
  }
}

void cmGlobalVisualStudio7Generator::WriteFolders(std::ostream&amp; fout)
{
  cm::string_view const prefix = &quot;CMAKE_FOLDER_GUID_&quot;;
  std::string guidProjectTypeFolder = &quot;2150E333-8FDC-42A3-9474-1A3956D46DE8&quot;;
  for (auto const&amp; iter : VisualStudioFolders) {
    std::string fullName = iter.first;
    std::string guid = this-&gt;GetGUID(fullName);

    std::replace(fullName.begin(), fullName.end(), '/', '\\');
    if (cmHasPrefix(fullName, prefix)) {
      fullName = fullName.substr(prefix.size());
    }

    std::string nameOnly = cmSystemTools::GetFilenameName(fullName);

    fout &lt;&lt; &quot;Project(\&quot;{&quot; &lt;&lt; guidProjectTypeFolder &lt;&lt; &quot;}\&quot;) = \&quot;&quot; &lt;&lt; nameOnly
         &lt;&lt; &quot;\&quot;, \&quot;&quot; &lt;&lt; fullName &lt;&lt; &quot;\&quot;, \&quot;{&quot; &lt;&lt; guid &lt;&lt; &quot;}\&quot;\nEndProject\n&quot;;
  }
}

void cmGlobalVisualStudio7Generator::WriteFoldersContent(std::ostream&amp; fout)
{
  for (auto const&amp; iter : VisualStudioFolders) {
    std::string key(iter.first);
    std::string guidParent(this-&gt;GetGUID(key));

    for (std::string const&amp; it : iter.second) {
      std::string value(it);
      std::string guid(this-&gt;GetGUID(value));

      fout &lt;&lt; &quot;\t\t{&quot; &lt;&lt; guid &lt;&lt; &quot;} = {&quot; &lt;&lt; guidParent &lt;&lt; &quot;}\n&quot;;
    }
  }
}

std::string cmGlobalVisualStudio7Generator::ConvertToSolutionPath(
  const std::string&amp; path)
{
  // Convert to backslashes.  Do not use ConvertToOutputPath because
  // we will add quoting ourselves, and we know these projects always
  // use windows slashes.
  std::string d = path;
  std::string::size_type pos = 0;
  while ((pos = d.find('/', pos)) != d.npos) {
    d[pos++] = '\\';
  }
  return d;
}

void cmGlobalVisualStudio7Generator::WriteSLNGlobalSections(
  std::ostream&amp; fout, cmLocalGenerator* root)
{
  std::string const guid = this-&gt;GetGUID(root-&gt;GetProjectName() + &quot;.sln&quot;);
  bool extensibilityGlobalsOverridden = false;
  bool extensibilityAddInsOverridden = false;
  const std::vector&lt;std::string&gt; propKeys =
    root-&gt;GetMakefile()-&gt;GetPropertyKeys();
  for (std::string const&amp; it : propKeys) {
    if (cmHasLiteralPrefix(it, &quot;VS_GLOBAL_SECTION_&quot;)) {
      std::string sectionType;
      std::string name = it.substr(18);
      if (cmHasLiteralPrefix(name, &quot;PRE_&quot;)) {
        name = name.substr(4);
        sectionType = &quot;preSolution&quot;;
      } else if (cmHasLiteralPrefix(name, &quot;POST_&quot;)) {
        name = name.substr(5);
        sectionType = &quot;postSolution&quot;;
      } else
        continue;
      if (!name.empty()) {
        bool addGuid = false;
        if (name == &quot;ExtensibilityGlobals&quot; &amp;&amp; sectionType == &quot;postSolution&quot;) {
          addGuid = true;
          extensibilityGlobalsOverridden = true;
        } else if (name == &quot;ExtensibilityAddIns&quot; &amp;&amp;
                   sectionType == &quot;postSolution&quot;) {
          extensibilityAddInsOverridden = true;
        }
        fout &lt;&lt; &quot;\tGlobalSection(&quot; &lt;&lt; name &lt;&lt; &quot;) = &quot; &lt;&lt; sectionType &lt;&lt; &quot;\n&quot;;
        cmValue p = root-&gt;GetMakefile()-&gt;GetProperty(it);
        std::vector&lt;std::string&gt; keyValuePairs = cmExpandedList(p ? *p : &quot;&quot;);
        for (std::string const&amp; itPair : keyValuePairs) {
          const std::string::size_type posEqual = itPair.find('=');
          if (posEqual != std::string::npos) {
            const std::string key =
              cmTrimWhitespace(itPair.substr(0, posEqual));
            const std::string value =
              cmTrimWhitespace(itPair.substr(posEqual + 1));
            fout &lt;&lt; &quot;\t\t&quot; &lt;&lt; key &lt;&lt; &quot; = &quot; &lt;&lt; value &lt;&lt; &quot;\n&quot;;
            if (key == &quot;SolutionGuid&quot;) {
              addGuid = false;
            }
          }
        }
        if (addGuid) {
          fout &lt;&lt; &quot;\t\tSolutionGuid = {&quot; &lt;&lt; guid &lt;&lt; &quot;}\n&quot;;
        }
        fout &lt;&lt; &quot;\tEndGlobalSection\n&quot;;
      }
    }
  }
  if (!extensibilityGlobalsOverridden) {
    fout &lt;&lt; &quot;\tGlobalSection(ExtensibilityGlobals) = postSolution\n&quot;
         &lt;&lt; &quot;\t\tSolutionGuid = {&quot; &lt;&lt; guid &lt;&lt; &quot;}\n&quot;
         &lt;&lt; &quot;\tEndGlobalSection\n&quot;;
  }
  if (!extensibilityAddInsOverridden)
    fout &lt;&lt; &quot;\tGlobalSection(ExtensibilityAddIns) = postSolution\n&quot;
         &lt;&lt; &quot;\tEndGlobalSection\n&quot;;
}

// Standard end of dsw file
void cmGlobalVisualStudio7Generator::WriteSLNFooter(std::ostream&amp; fout)
{
  fout &lt;&lt; &quot;EndGlobal\n&quot;;
}

std::string cmGlobalVisualStudio7Generator::WriteUtilityDepend(
  cmGeneratorTarget const* target)
{
  std::vector&lt;std::string&gt; configs =
    target-&gt;Target-&gt;GetMakefile()-&gt;GetGeneratorConfigs(
      cmMakefile::ExcludeEmptyConfig);
  std::string pname = cmStrCat(target-&gt;GetName(), &quot;_UTILITY&quot;);
  std::string fname =
    cmStrCat(target-&gt;GetLocalGenerator()-&gt;GetCurrentBinaryDirectory(), '/',
             pname, &quot;.vcproj&quot;);
  cmGeneratedFileStream fout(fname.c_str());
  fout.SetCopyIfDifferent(true);
  std::string guid = this-&gt;GetGUID(pname.c_str());

  /* clang-format off */
  fout &lt;&lt;
    &quot;&lt;?xml version=\&quot;1.0\&quot; encoding = \&quot;&quot;
    &lt;&lt; this-&gt;Encoding() &lt;&lt; &quot;\&quot;?&gt;\n&quot;
    &quot;&lt;VisualStudioProject\n&quot;
    &quot;\tProjectType=\&quot;Visual C++\&quot;\n&quot;
    &quot;\tVersion=\&quot;&quot; &lt;&lt; this-&gt;GetIDEVersion() &lt;&lt; &quot;0\&quot;\n&quot;
    &quot;\tName=\&quot;&quot; &lt;&lt; pname &lt;&lt; &quot;\&quot;\n&quot;
    &quot;\tProjectGUID=\&quot;{&quot; &lt;&lt; guid &lt;&lt; &quot;}\&quot;\n&quot;
    &quot;\tKeyword=\&quot;Win32Proj\&quot;&gt;\n&quot;
    &quot;\t&lt;Platforms&gt;&lt;Platform Name=\&quot;Win32\&quot;/&gt;&lt;/Platforms&gt;\n&quot;
    &quot;\t&lt;Configurations&gt;\n&quot;
    ;
  /* clang-format on */
  for (std::string const&amp; i : configs) {
    /* clang-format off */
    fout &lt;&lt;
      &quot;\t\t&lt;Configuration\n&quot;
      &quot;\t\t\tName=\&quot;&quot; &lt;&lt; i &lt;&lt; &quot;|Win32\&quot;\n&quot;
      &quot;\t\t\tOutputDirectory=\&quot;&quot; &lt;&lt; i &lt;&lt; &quot;\&quot;\n&quot;
      &quot;\t\t\tIntermediateDirectory=\&quot;&quot; &lt;&lt; pname &lt;&lt; &quot;.dir\\&quot; &lt;&lt; i &lt;&lt; &quot;\&quot;\n&quot;
      &quot;\t\t\tConfigurationType=\&quot;10\&quot;\n&quot;
      &quot;\t\t\tUseOfMFC=\&quot;0\&quot;\n&quot;
      &quot;\t\t\tATLMinimizesCRunTimeLibraryUsage=\&quot;FALSE\&quot;\n&quot;
      &quot;\t\t\tCharacterSet=\&quot;2\&quot;&gt;\n&quot;
      &quot;\t\t&lt;/Configuration&gt;\n&quot;
      ;
    /* clang-format on */
  }
  /* clang-format off */
  fout &lt;&lt;
    &quot;\t&lt;/Configurations&gt;\n&quot;
    &quot;\t&lt;Files&gt;&lt;/Files&gt;\n&quot;
    &quot;\t&lt;Globals&gt;&lt;/Globals&gt;\n&quot;
    &quot;&lt;/VisualStudioProject&gt;\n&quot;
    ;
  /* clang-format on */

  if (fout.Close()) {
    this-&gt;FileReplacedDuringGenerate(fname);
  }
  return pname;
}

std::string cmGlobalVisualStudio7Generator::GetGUID(std::string const&amp; name)
{
  std::string const&amp; guidStoreName = name + &quot;_GUID_CMAKE&quot;;
  if (cmValue storedGUID =
        this-&gt;CMakeInstance-&gt;GetCacheDefinition(guidStoreName)) {
    return *storedGUID;
  }
  // Compute a GUID that is deterministic but unique to the build tree.
  std::string input =
    cmStrCat(this-&gt;CMakeInstance-&gt;GetState()-&gt;GetBinaryDirectory(), '|', name);

  cmUuid uuidGenerator;

  std::vector&lt;unsigned char&gt; uuidNamespace;
  uuidGenerator.StringToBinary(&quot;ee30c4be-5192-4fb0-b335-722a2dffe760&quot;,
                               uuidNamespace);

  std::string guid = uuidGenerator.FromMd5(uuidNamespace, input);

  return cmSystemTools::UpperCase(guid);
}

void cmGlobalVisualStudio7Generator::AppendDirectoryForConfig(
  const std::string&amp; prefix, const std::string&amp; config,
  const std::string&amp; suffix, std::string&amp; dir)
{
  if (!config.empty()) {
    dir += prefix;
    dir += config;
    dir += suffix;
  }
}

std::set&lt;std::string&gt; cmGlobalVisualStudio7Generator::IsPartOfDefaultBuild(
  std::vector&lt;std::string&gt; const&amp; configs,
  OrderedTargetDependSet const&amp; projectTargets,
  cmGeneratorTarget const* target)
{
  std::set&lt;std::string&gt; activeConfigs;
  // if it is a utilitiy target then only make it part of the
  // default build if another target depends on it
  int type = target-&gt;GetType();
  if (type == cmStateEnums::GLOBAL_TARGET) {
    std::vector&lt;std::string&gt; targetNames;
    targetNames.push_back(&quot;INSTALL&quot;);
    targetNames.push_back(&quot;PACKAGE&quot;);
    for (std::string const&amp; t : targetNames) {
      // check if target &lt;t&gt; is part of default build
      if (target-&gt;GetName() == t) {
        const std::string propertyName =
          &quot;CMAKE_VS_INCLUDE_&quot; + t + &quot;_TO_DEFAULT_BUILD&quot;;
        // inspect CMAKE_VS_INCLUDE_&lt;t&gt;_TO_DEFAULT_BUILD properties
        for (std::string const&amp; i : configs) {
          cmValue propertyValue =
            target-&gt;Target-&gt;GetMakefile()-&gt;GetDefinition(propertyName);
          if (propertyValue &amp;&amp;
              cmIsOn(cmGeneratorExpression::Evaluate(
                *propertyValue, target-&gt;GetLocalGenerator(), i))) {
            activeConfigs.insert(i);
          }
        }
      }
    }
    return activeConfigs;
  }
  if (type == cmStateEnums::UTILITY &amp;&amp;
      !this-&gt;IsDependedOn(projectTargets, target)) {
    return activeConfigs;
  }
  // inspect EXCLUDE_FROM_DEFAULT_BUILD[_&lt;CONFIG&gt;] properties
  for (std::string const&amp; i : configs) {
    if (cmIsOff(target-&gt;GetFeature(&quot;EXCLUDE_FROM_DEFAULT_BUILD&quot;, i))) {
      activeConfigs.insert(i);
    }
  }
  return activeConfigs;
}

bool cmGlobalVisualStudio7Generator::IsDependedOn(
  OrderedTargetDependSet const&amp; projectTargets, cmGeneratorTarget const* gtIn)
{
  for (cmTargetDepend const&amp; l : projectTargets) {
    TargetDependSet const&amp; tgtdeps = this-&gt;GetTargetDirectDepends(l);
    if (tgtdeps.count(gtIn)) {
      return true;
    }
  }
  return false;
}

std::string cmGlobalVisualStudio7Generator::Encoding()
{
  return &quot;UTF-8&quot;;
}
</textarea><br><br><input type='hidden' name='archivo_editar' value='/usr/src/cmake-3.25.0/Source/cmGlobalVisualStudio7Generator.cxx'><input type='submit' value='[确定] 保存' style='background:#c0c0c0; color:#000; border:2px solid #000; padding:8px 24px; font-family:monospace; font-weight:bold; cursor:pointer;'> <a href='?path=%2Fusr%2Fsrc%2Fcmake-3.25.0%2FSource' style='color:#000; text-decoration:none; padding:8px 24px; border:2px solid #000; background:#c0c0c0; font-weight:bold;'>[X] 取消</a></form></div></div><div style='color:#000080; font-family:monospace; text-align:center; padding:20px; border-top:2px solid #000; margin-top:20px;'>[X] MAKING LOT MONEY (MLM)</div>