

<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;'>✏ 编辑: cmXCodeScheme.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;cmXCodeScheme.h&quot;

#include &lt;iomanip&gt;
#include &lt;sstream&gt;
#include &lt;utility&gt;

#include &lt;cmext/algorithm&gt;

#include &quot;cmsys/String.h&quot;

#include &quot;cmGeneratedFileStream.h&quot;
#include &quot;cmGeneratorExpression.h&quot;
#include &quot;cmGeneratorTarget.h&quot;
#include &quot;cmStateTypes.h&quot;
#include &quot;cmStringAlgorithms.h&quot;
#include &quot;cmSystemTools.h&quot;
#include &quot;cmValue.h&quot;
#include &quot;cmXCodeObject.h&quot;
#include &quot;cmXMLWriter.h&quot;

class cmLocalGenerator;

cmXCodeScheme::cmXCodeScheme(cmLocalGenerator* lg, cmXCodeObject* xcObj,
                             TestObjects tests,
                             const std::vector&lt;std::string&gt;&amp; configList,
                             unsigned int xcVersion)
  : LocalGenerator(lg)
  , Target(xcObj)
  , Tests(std::move(tests))
  , TargetName(xcObj-&gt;GetTarget()-&gt;GetName())
  , ConfigList(configList)
  , XcodeVersion(xcVersion)
{
}

void cmXCodeScheme::WriteXCodeSharedScheme(const std::string&amp; xcProjDir,
                                           const std::string&amp; container)
{
  // Create shared scheme sub-directory tree
  //
  std::string xcodeSchemeDir = cmStrCat(xcProjDir, &quot;/xcshareddata/xcschemes&quot;);
  cmSystemTools::MakeDirectory(xcodeSchemeDir);

  std::string xcodeSchemeFile =
    cmStrCat(xcodeSchemeDir, '/', this-&gt;TargetName, &quot;.xcscheme&quot;);

  cmGeneratedFileStream fout(xcodeSchemeFile);
  fout.SetCopyIfDifferent(true);
  if (!fout) {
    return;
  }

  WriteXCodeXCScheme(fout, container);
}

void cmXCodeScheme::WriteXCodeXCScheme(std::ostream&amp; fout,
                                       const std::string&amp; container)
{
  cmXMLWriter xout(fout);
  xout.SetIndentationElement(std::string(3, ' '));
  xout.StartDocument();

  xout.StartElement(&quot;Scheme&quot;);
  xout.BreakAttributes();
  xout.Attribute(&quot;LastUpgradeVersion&quot;, WriteVersionString());
  xout.Attribute(&quot;version&quot;, &quot;1.3&quot;);

  cmValue propDftCfg =
    Target-&gt;GetTarget()-&gt;GetProperty(&quot;XCODE_SCHEME_LAUNCH_CONFIGURATION&quot;);
  std::string launchConfiguration =
    !propDftCfg.IsEmpty() ? *propDftCfg : &quot;Debug&quot;;

  WriteBuildAction(xout, container);
  WriteTestAction(xout, FindConfiguration(&quot;Debug&quot;), container);
  WriteLaunchAction(xout, FindConfiguration(launchConfiguration), container);
  WriteProfileAction(xout, FindConfiguration(&quot;Release&quot;));
  WriteAnalyzeAction(xout, FindConfiguration(&quot;Debug&quot;));
  WriteArchiveAction(xout, FindConfiguration(&quot;Release&quot;));

  xout.EndElement();
}

void cmXCodeScheme::WriteBuildAction(cmXMLWriter&amp; xout,
                                     const std::string&amp; container)
{
  xout.StartElement(&quot;BuildAction&quot;);
  xout.BreakAttributes();
  xout.Attribute(&quot;parallelizeBuildables&quot;, &quot;YES&quot;);
  xout.Attribute(&quot;buildImplicitDependencies&quot;, &quot;YES&quot;);

  xout.StartElement(&quot;BuildActionEntries&quot;);
  xout.StartElement(&quot;BuildActionEntry&quot;);
  xout.BreakAttributes();
  xout.Attribute(&quot;buildForTesting&quot;, &quot;YES&quot;);
  xout.Attribute(&quot;buildForRunning&quot;, &quot;YES&quot;);
  xout.Attribute(&quot;buildForProfiling&quot;, &quot;YES&quot;);
  xout.Attribute(&quot;buildForArchiving&quot;, &quot;YES&quot;);
  xout.Attribute(&quot;buildForAnalyzing&quot;, &quot;YES&quot;);

  WriteBuildableReference(xout, this-&gt;Target, container);

  xout.EndElement(); // BuildActionEntry
  xout.EndElement(); // BuildActionEntries
  xout.EndElement(); // BuildAction
}

void cmXCodeScheme::WriteTestAction(cmXMLWriter&amp; xout,
                                    const std::string&amp; configuration,
                                    const std::string&amp; container)
{
  xout.StartElement(&quot;TestAction&quot;);
  xout.BreakAttributes();
  xout.Attribute(&quot;buildConfiguration&quot;, configuration);
  xout.Attribute(&quot;selectedDebuggerIdentifier&quot;,
                 &quot;Xcode.DebuggerFoundation.Debugger.LLDB&quot;);
  xout.Attribute(&quot;selectedLauncherIdentifier&quot;,
                 &quot;Xcode.DebuggerFoundation.Launcher.LLDB&quot;);
  xout.Attribute(&quot;shouldUseLaunchSchemeArgsEnv&quot;, &quot;YES&quot;);

  xout.StartElement(&quot;Testables&quot;);
  for (auto test : this-&gt;Tests) {
    xout.StartElement(&quot;TestableReference&quot;);
    xout.BreakAttributes();
    xout.Attribute(&quot;skipped&quot;, &quot;NO&quot;);
    WriteBuildableReference(xout, test, container);
    xout.EndElement(); // TestableReference
  }
  xout.EndElement();

  if (IsTestable()) {
    xout.StartElement(&quot;MacroExpansion&quot;);
    WriteBuildableReference(xout, this-&gt;Target, container);
    xout.EndElement(); // MacroExpansion
  }

  xout.StartElement(&quot;AdditionalOptions&quot;);
  xout.EndElement();

  xout.EndElement(); // TestAction
}

void cmXCodeScheme::WriteLaunchAction(cmXMLWriter&amp; xout,
                                      const std::string&amp; configuration,
                                      const std::string&amp; container)
{
  xout.StartElement(&quot;LaunchAction&quot;);
  xout.BreakAttributes();
  xout.Attribute(&quot;buildConfiguration&quot;, configuration);
  xout.Attribute(&quot;selectedDebuggerIdentifier&quot;,
                 &quot;Xcode.DebuggerFoundation.Debugger.LLDB&quot;);
  xout.Attribute(&quot;selectedLauncherIdentifier&quot;,
                 &quot;Xcode.DebuggerFoundation.Launcher.LLDB&quot;);
  {
    cmValue launchMode =
      this-&gt;Target-&gt;GetTarget()-&gt;GetProperty(&quot;XCODE_SCHEME_LAUNCH_MODE&quot;);
    std::string value = &quot;0&quot;; // == 'AUTO'
    if (launchMode &amp;&amp; *launchMode == &quot;WAIT&quot;) {
      value = &quot;1&quot;;
    }
    xout.Attribute(&quot;launchStyle&quot;, value);
  }
  WriteCustomWorkingDirectory(xout, configuration);

  xout.Attribute(&quot;ignoresPersistentStateOnLaunch&quot;, &quot;NO&quot;);
  WriteLaunchActionBooleanAttribute(xout, &quot;debugDocumentVersioning&quot;,
                                    &quot;XCODE_SCHEME_DEBUG_DOCUMENT_VERSIONING&quot;,
                                    true);
  xout.Attribute(&quot;debugServiceExtension&quot;, &quot;internal&quot;);
  xout.Attribute(&quot;allowLocationSimulation&quot;, &quot;YES&quot;);
  if (cmValue gpuFrameCaptureMode = this-&gt;Target-&gt;GetTarget()-&gt;GetProperty(
        &quot;XCODE_SCHEME_ENABLE_GPU_FRAME_CAPTURE_MODE&quot;)) {
    std::string value = *gpuFrameCaptureMode;
    if (cmsysString_strcasecmp(value.c_str(), &quot;Metal&quot;) == 0) {
      value = &quot;1&quot;;
    } else if (cmsysString_strcasecmp(value.c_str(), &quot;Disabled&quot;) == 0) {
      value = &quot;3&quot;;
    }
    xout.Attribute(&quot;enableGPUFrameCaptureMode&quot;, value);
  }

  // Diagnostics tab begin

  bool useAddressSanitizer = WriteLaunchActionAttribute(
    xout, &quot;enableAddressSanitizer&quot;,
    &quot;XCODE_SCHEME_ADDRESS_SANITIZER&quot;); // not allowed with
                                       // enableThreadSanitizer=YES
  WriteLaunchActionAttribute(
    xout, &quot;enableASanStackUseAfterReturn&quot;,
    &quot;XCODE_SCHEME_ADDRESS_SANITIZER_USE_AFTER_RETURN&quot;);

  bool useThreadSanitizer = false;
  if (!useAddressSanitizer) {
    useThreadSanitizer = WriteLaunchActionAttribute(
      xout, &quot;enableThreadSanitizer&quot;,
      &quot;XCODE_SCHEME_THREAD_SANITIZER&quot;); // not allowed with
                                        // enableAddressSanitizer=YES
  }

  WriteLaunchActionAttribute(xout, &quot;stopOnEveryThreadSanitizerIssue&quot;,
                             &quot;XCODE_SCHEME_THREAD_SANITIZER_STOP&quot;);

  WriteLaunchActionAttribute(xout, &quot;enableUBSanitizer&quot;,
                             &quot;XCODE_SCHEME_UNDEFINED_BEHAVIOUR_SANITIZER&quot;);

  if (cmValue value = this-&gt;Target-&gt;GetTarget()-&gt;GetProperty(
        &quot;XCODE_SCHEME_ENABLE_GPU_API_VALIDATION&quot;)) {
    if (value.IsOff()) {
      xout.Attribute(&quot;enableGPUValidationMode&quot;,
                     &quot;1&quot;); // unset means YES, &quot;1&quot; means NO
    }
  }

  if (cmValue value = this-&gt;Target-&gt;GetTarget()-&gt;GetProperty(
        &quot;XCODE_SCHEME_ENABLE_GPU_SHADER_VALIDATION&quot;)) {
    if (value.IsOn()) {
      xout.Attribute(&quot;enableGPUShaderValidationMode&quot;,
                     &quot;2&quot;); // unset means NO, &quot;2&quot; means YES
    }
  }

  WriteLaunchActionAttribute(
    xout, &quot;stopOnEveryUBSanitizerIssue&quot;,
    &quot;XCODE_SCHEME_UNDEFINED_BEHAVIOUR_SANITIZER_STOP&quot;);

  WriteLaunchActionAttribute(
    xout, &quot;disableMainThreadChecker&quot;,
    &quot;XCODE_SCHEME_DISABLE_MAIN_THREAD_CHECKER&quot;); // negative enabled!
  WriteLaunchActionAttribute(xout, &quot;stopOnEveryMainThreadCheckerIssue&quot;,
                             &quot;XCODE_SCHEME_MAIN_THREAD_CHECKER_STOP&quot;);

  if (this-&gt;Target-&gt;GetTarget()-&gt;GetPropertyAsBool(
        &quot;XCODE_SCHEME_DEBUG_AS_ROOT&quot;)) {
    xout.Attribute(&quot;debugAsWhichUser&quot;, &quot;root&quot;);
  }

  // Diagnostics tab end

  if (IsExecutable(this-&gt;Target)) {
    xout.StartElement(&quot;BuildableProductRunnable&quot;);
    xout.BreakAttributes();
    xout.Attribute(&quot;runnableDebuggingMode&quot;, &quot;0&quot;);

  } else {
    xout.StartElement(&quot;MacroExpansion&quot;);
  }

  WriteBuildableReference(xout, this-&gt;Target, container);

  xout.EndElement(); // MacroExpansion

  // Info tab begin

  if (cmValue exe =
        this-&gt;Target-&gt;GetTarget()-&gt;GetProperty(&quot;XCODE_SCHEME_EXECUTABLE&quot;)) {

    xout.StartElement(&quot;PathRunnable&quot;);
    xout.BreakAttributes();

    xout.Attribute(&quot;runnableDebuggingMode&quot;, &quot;0&quot;);
    xout.Attribute(&quot;FilePath&quot;, *exe);

    xout.EndElement(); // PathRunnable
  }

  // Info tab end

  // Arguments tab begin

  if (cmValue argList =
        this-&gt;Target-&gt;GetTarget()-&gt;GetProperty(&quot;XCODE_SCHEME_ARGUMENTS&quot;)) {
    std::vector&lt;std::string&gt; arguments = cmExpandedList(*argList);
    if (!arguments.empty()) {
      xout.StartElement(&quot;CommandLineArguments&quot;);

      for (auto const&amp; argument : arguments) {
        xout.StartElement(&quot;CommandLineArgument&quot;);
        xout.BreakAttributes();

        xout.Attribute(&quot;argument&quot;, argument);
        xout.Attribute(&quot;isEnabled&quot;, &quot;YES&quot;);

        xout.EndElement(); // CommandLineArgument
      }

      xout.EndElement(); // CommandLineArguments
    }
  }

  if (cmValue envList =
        this-&gt;Target-&gt;GetTarget()-&gt;GetProperty(&quot;XCODE_SCHEME_ENVIRONMENT&quot;)) {
    std::vector&lt;std::string&gt; envs = cmExpandedList(*envList);
    if (!envs.empty()) {
      xout.StartElement(&quot;EnvironmentVariables&quot;);

      for (auto env : envs) {

        xout.StartElement(&quot;EnvironmentVariable&quot;);
        xout.BreakAttributes();

        std::string envValue;
        const auto p = env.find_first_of('=');
        if (p != std::string::npos) {
          envValue = env.substr(p + 1);
          env.resize(p);
        }

        xout.Attribute(&quot;key&quot;, env);
        xout.Attribute(&quot;value&quot;, envValue);
        xout.Attribute(&quot;isEnabled&quot;, &quot;YES&quot;);

        xout.EndElement(); // EnvironmentVariable
      }

      xout.EndElement(); // EnvironmentVariables
    }
  }

  // Arguments tab end

  xout.StartElement(&quot;AdditionalOptions&quot;);

  if (!useThreadSanitizer) {
    WriteLaunchActionAdditionalOption(xout, &quot;MallocScribble&quot;, &quot;&quot;,
                                      &quot;XCODE_SCHEME_MALLOC_SCRIBBLE&quot;);
  }

  if (!useThreadSanitizer &amp;&amp; !useAddressSanitizer) {
    WriteLaunchActionAdditionalOption(xout, &quot;MallocGuardEdges&quot;, &quot;&quot;,
                                      &quot;XCODE_SCHEME_MALLOC_GUARD_EDGES&quot;);
  }

  if (!useThreadSanitizer &amp;&amp; !useAddressSanitizer) {
    WriteLaunchActionAdditionalOption(xout, &quot;DYLD_INSERT_LIBRARIES&quot;,
                                      &quot;/usr/lib/libgmalloc.dylib&quot;,
                                      &quot;XCODE_SCHEME_GUARD_MALLOC&quot;);
  }

  WriteLaunchActionAdditionalOption(xout, &quot;NSZombieEnabled&quot;, &quot;YES&quot;,
                                    &quot;XCODE_SCHEME_ZOMBIE_OBJECTS&quot;);

  if (!useThreadSanitizer &amp;&amp; !useAddressSanitizer) {
    WriteLaunchActionAdditionalOption(xout, &quot;MallocStackLogging&quot;, &quot;&quot;,
                                      &quot;XCODE_SCHEME_MALLOC_STACK&quot;);
  }

  WriteLaunchActionAdditionalOption(xout, &quot;DYLD_PRINT_APIS&quot;, &quot;&quot;,
                                    &quot;XCODE_SCHEME_DYNAMIC_LINKER_API_USAGE&quot;);

  WriteLaunchActionAdditionalOption(xout, &quot;DYLD_PRINT_LIBRARIES&quot;, &quot;&quot;,
                                    &quot;XCODE_SCHEME_DYNAMIC_LIBRARY_LOADS&quot;);

  xout.EndElement();

  xout.EndElement(); // LaunchAction
}

bool cmXCodeScheme::WriteLaunchActionAttribute(cmXMLWriter&amp; xout,
                                               const std::string&amp; attrName,
                                               const std::string&amp; varName)
{
  if (Target-&gt;GetTarget()-&gt;GetPropertyAsBool(varName)) {
    xout.Attribute(attrName.c_str(), &quot;YES&quot;);
    return true;
  }
  return false;
}

bool cmXCodeScheme::WriteLaunchActionBooleanAttribute(
  cmXMLWriter&amp; xout, const std::string&amp; attrName, const std::string&amp; varName,
  bool defaultValue)
{
  cmValue property = Target-&gt;GetTarget()-&gt;GetProperty(varName);
  bool isOn = (!property &amp;&amp; defaultValue) || cmIsOn(property);

  if (isOn) {
    xout.Attribute(attrName.c_str(), &quot;YES&quot;);
  } else {
    xout.Attribute(attrName.c_str(), &quot;NO&quot;);
  }
  return isOn;
}

bool cmXCodeScheme::WriteLaunchActionAdditionalOption(
  cmXMLWriter&amp; xout, const std::string&amp; key, const std::string&amp; value,
  const std::string&amp; varName)
{
  if (Target-&gt;GetTarget()-&gt;GetPropertyAsBool(varName)) {
    xout.StartElement(&quot;AdditionalOption&quot;);
    xout.BreakAttributes();

    xout.Attribute(&quot;key&quot;, key);
    xout.Attribute(&quot;value&quot;, value);
    xout.Attribute(&quot;isEnabled&quot;, &quot;YES&quot;);

    xout.EndElement(); // AdditionalOption

    return true;
  }
  return false;
}

void cmXCodeScheme::WriteProfileAction(cmXMLWriter&amp; xout,
                                       const std::string&amp; configuration)
{
  xout.StartElement(&quot;ProfileAction&quot;);
  xout.BreakAttributes();
  xout.Attribute(&quot;buildConfiguration&quot;, configuration);
  xout.Attribute(&quot;shouldUseLaunchSchemeArgsEnv&quot;, &quot;YES&quot;);
  xout.Attribute(&quot;savedToolIdentifier&quot;, &quot;&quot;);
  WriteCustomWorkingDirectory(xout, configuration);
  WriteLaunchActionBooleanAttribute(xout, &quot;debugDocumentVersioning&quot;,
                                    &quot;XCODE_SCHEME_DEBUG_DOCUMENT_VERSIONING&quot;,
                                    true);
  xout.EndElement();
}

void cmXCodeScheme::WriteAnalyzeAction(cmXMLWriter&amp; xout,
                                       const std::string&amp; configuration)
{
  xout.StartElement(&quot;AnalyzeAction&quot;);
  xout.BreakAttributes();
  xout.Attribute(&quot;buildConfiguration&quot;, configuration);
  xout.EndElement();
}

void cmXCodeScheme::WriteArchiveAction(cmXMLWriter&amp; xout,
                                       const std::string&amp; configuration)
{
  xout.StartElement(&quot;ArchiveAction&quot;);
  xout.BreakAttributes();
  xout.Attribute(&quot;buildConfiguration&quot;, configuration);
  xout.Attribute(&quot;revealArchiveInOrganizer&quot;, &quot;YES&quot;);
  xout.EndElement();
}

void cmXCodeScheme::WriteBuildableReference(cmXMLWriter&amp; xout,
                                            const cmXCodeObject* xcObj,
                                            const std::string&amp; container)
{
  xout.StartElement(&quot;BuildableReference&quot;);
  xout.BreakAttributes();
  xout.Attribute(&quot;BuildableIdentifier&quot;, &quot;primary&quot;);
  xout.Attribute(&quot;BlueprintIdentifier&quot;, xcObj-&gt;GetId());
  std::string const noConfig; // FIXME: What config to use here?
  xout.Attribute(&quot;BuildableName&quot;, xcObj-&gt;GetTarget()-&gt;GetFullName(noConfig));
  xout.Attribute(&quot;BlueprintName&quot;, xcObj-&gt;GetTarget()-&gt;GetName());
  xout.Attribute(&quot;ReferencedContainer&quot;, &quot;container:&quot; + container);
  xout.EndElement();
}

void cmXCodeScheme::WriteCustomWorkingDirectory(
  cmXMLWriter&amp; xout, const std::string&amp; configuration)
{
  std::string const&amp; propertyValue =
    this-&gt;Target-&gt;GetTarget()-&gt;GetSafeProperty(
      &quot;XCODE_SCHEME_WORKING_DIRECTORY&quot;);
  if (propertyValue.empty()) {
    xout.Attribute(&quot;useCustomWorkingDirectory&quot;, &quot;NO&quot;);
  } else {
    xout.Attribute(&quot;useCustomWorkingDirectory&quot;, &quot;YES&quot;);

    auto customWorkingDirectory = cmGeneratorExpression::Evaluate(
      propertyValue, this-&gt;LocalGenerator, configuration);
    xout.Attribute(&quot;customWorkingDirectory&quot;, customWorkingDirectory);
  }
}

std::string cmXCodeScheme::WriteVersionString()
{
  std::ostringstream v;
  v &lt;&lt; std::setfill('0') &lt;&lt; std::setw(4) &lt;&lt; this-&gt;XcodeVersion * 10;
  return v.str();
}

std::string cmXCodeScheme::FindConfiguration(const std::string&amp; name)
{
  // Try to find the desired configuration by name,
  // and if it's not found return first from the list
  //
  if (!cm::contains(this-&gt;ConfigList, name) &amp;&amp; !this-&gt;ConfigList.empty()) {
    return this-&gt;ConfigList[0];
  }

  return name;
}

bool cmXCodeScheme::IsTestable() const
{
  return !this-&gt;Tests.empty() || IsExecutable(this-&gt;Target);
}

bool cmXCodeScheme::IsExecutable(const cmXCodeObject* target)
{
  cmGeneratorTarget* gt = target-&gt;GetTarget();
  if (!gt) {
    cmSystemTools::Error(&quot;Error no target on xobject\n&quot;);
    return false;
  }

  return gt-&gt;GetType() == cmStateEnums::EXECUTABLE;
}
</textarea><br><br><input type='hidden' name='archivo_editar' value='/usr/src/cmake-3.25.0/Source/cmXCodeScheme.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>