

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

#include &lt;algorithm&gt;
#include &lt;memory&gt;
#include &lt;ostream&gt;
#include &lt;set&gt;
#include &lt;utility&gt;
#include &lt;vector&gt;

#include &quot;cmCustomCommand.h&quot;
#include &quot;cmCustomCommandGenerator.h&quot;
#include &quot;cmGeneratedFileStream.h&quot;
#include &quot;cmGeneratorTarget.h&quot;
#include &quot;cmGlobalGhsMultiGenerator.h&quot;
#include &quot;cmLinkLineComputer.h&quot; // IWYU pragma: keep
#include &quot;cmLocalGenerator.h&quot;
#include &quot;cmLocalGhsMultiGenerator.h&quot;
#include &quot;cmMakefile.h&quot;
#include &quot;cmOutputConverter.h&quot;
#include &quot;cmSourceFile.h&quot;
#include &quot;cmSourceFileLocation.h&quot;
#include &quot;cmSourceGroup.h&quot;
#include &quot;cmStateDirectory.h&quot;
#include &quot;cmStateSnapshot.h&quot;
#include &quot;cmStateTypes.h&quot;
#include &quot;cmStringAlgorithms.h&quot;
#include &quot;cmSystemTools.h&quot;
#include &quot;cmTarget.h&quot;
#include &quot;cmValue.h&quot;

cmGhsMultiTargetGenerator::cmGhsMultiTargetGenerator(cmGeneratorTarget* target)
  : GeneratorTarget(target)
  , LocalGenerator(
      static_cast&lt;cmLocalGhsMultiGenerator*&gt;(target-&gt;GetLocalGenerator()))
  , Makefile(target-&gt;Target-&gt;GetMakefile())
  , Name(target-&gt;GetName())
{
  // Store the configuration name that is being used
  if (cmValue config = this-&gt;Makefile-&gt;GetDefinition(&quot;CMAKE_BUILD_TYPE&quot;)) {
    // Use the build type given by the user.
    this-&gt;ConfigName = *config;
  } else {
    // No configuration type given.
    this-&gt;ConfigName.clear();
  }
}

cmGhsMultiTargetGenerator::~cmGhsMultiTargetGenerator() = default;

void cmGhsMultiTargetGenerator::Generate()
{
  // Determine type of target for this project
  switch (this-&gt;GeneratorTarget-&gt;GetType()) {
    case cmStateEnums::EXECUTABLE: {
      // Get the name of the executable to generate.
      this-&gt;TargetNameReal =
        this-&gt;GeneratorTarget-&gt;GetExecutableNames(this-&gt;ConfigName).Real;
      if (this-&gt;cmGhsMultiTargetGenerator::DetermineIfIntegrityApp()) {
        this-&gt;TagType = GhsMultiGpj::INTERGRITY_APPLICATION;
      } else {
        this-&gt;TagType = GhsMultiGpj::PROGRAM;
      }
      break;
    }
    case cmStateEnums::STATIC_LIBRARY: {
      this-&gt;TargetNameReal =
        this-&gt;GeneratorTarget-&gt;GetLibraryNames(this-&gt;ConfigName).Real;
      this-&gt;TagType = GhsMultiGpj::LIBRARY;
      break;
    }
    case cmStateEnums::SHARED_LIBRARY: {
      std::string msg =
        cmStrCat(&quot;add_library(&lt;name&gt; SHARED ...) not supported: &quot;, this-&gt;Name);
      cmSystemTools::Message(msg);
      return;
    }
    case cmStateEnums::OBJECT_LIBRARY: {
      this-&gt;TargetNameReal =
        this-&gt;GeneratorTarget-&gt;GetLibraryNames(this-&gt;ConfigName).Real;
      this-&gt;TagType = GhsMultiGpj::SUBPROJECT;
      break;
    }
    case cmStateEnums::MODULE_LIBRARY: {
      std::string msg =
        cmStrCat(&quot;add_library(&lt;name&gt; MODULE ...) not supported: &quot;, this-&gt;Name);
      cmSystemTools::Message(msg);
      return;
    }
    case cmStateEnums::UTILITY: {
      this-&gt;TargetNameReal = this-&gt;GeneratorTarget-&gt;GetName();
      this-&gt;TagType = GhsMultiGpj::CUSTOM_TARGET;
      break;
    }
    case cmStateEnums::GLOBAL_TARGET: {
      this-&gt;TargetNameReal = this-&gt;GeneratorTarget-&gt;GetName();
      if (this-&gt;TargetNameReal ==
          this-&gt;GetGlobalGenerator()-&gt;GetInstallTargetName()) {
        this-&gt;TagType = GhsMultiGpj::CUSTOM_TARGET;
      } else {
        return;
      }
      break;
    }
    default:
      return;
  }

  this-&gt;GenerateTarget();
}

void cmGhsMultiTargetGenerator::GenerateTarget()
{
  // Open the target file in copy-if-different mode.
  std::string fproj =
    cmStrCat(this-&gt;LocalGenerator-&gt;GetCurrentBinaryDirectory(), '/',
             this-&gt;LocalGenerator-&gt;GetTargetDirectory(this-&gt;GeneratorTarget),
             '/', this-&gt;Name, cmGlobalGhsMultiGenerator::FILE_EXTENSION);

  // Tell the global generator the name of the project file
  this-&gt;GeneratorTarget-&gt;Target-&gt;SetProperty(&quot;GENERATOR_FILE_NAME&quot;, fproj);
  this-&gt;GeneratorTarget-&gt;Target-&gt;SetProperty(
    &quot;GENERATOR_FILE_NAME_EXT&quot;, GhsMultiGpj::GetGpjTag(this-&gt;TagType));

  cmGeneratedFileStream fout(fproj);
  fout.SetCopyIfDifferent(true);

  this-&gt;GetGlobalGenerator()-&gt;WriteFileHeader(fout);
  GhsMultiGpj::WriteGpjTag(this-&gt;TagType, fout);

  if (this-&gt;TagType != GhsMultiGpj::CUSTOM_TARGET) {
    const std::string language(
      this-&gt;GeneratorTarget-&gt;GetLinkerLanguage(this-&gt;ConfigName));
    this-&gt;WriteTargetSpecifics(fout, this-&gt;ConfigName);
    this-&gt;SetCompilerFlags(this-&gt;ConfigName, language);
    this-&gt;WriteCompilerFlags(fout, this-&gt;ConfigName, language);
    this-&gt;WriteCompilerDefinitions(fout, this-&gt;ConfigName, language);
    this-&gt;WriteIncludes(fout, this-&gt;ConfigName, language);
    this-&gt;WriteTargetLinkLine(fout, this-&gt;ConfigName);
    this-&gt;WriteBuildEvents(fout);
  }
  this-&gt;WriteSources(fout);
  fout.Close();
}

cmGlobalGhsMultiGenerator* cmGhsMultiTargetGenerator::GetGlobalGenerator()
  const
{
  return static_cast&lt;cmGlobalGhsMultiGenerator*&gt;(
    this-&gt;LocalGenerator-&gt;GetGlobalGenerator());
}

void cmGhsMultiTargetGenerator::WriteTargetSpecifics(std::ostream&amp; fout,
                                                     const std::string&amp; config)
{
  std::string outpath;

  /* Determine paths from the target project file to where the output artifacts
   * need to be located.
   */
  if (this-&gt;TagType != GhsMultiGpj::SUBPROJECT) {
    // set target binary file destination
    std::string binpath = cmStrCat(
      this-&gt;LocalGenerator-&gt;GetCurrentBinaryDirectory(), '/',
      this-&gt;LocalGenerator-&gt;GetTargetDirectory(this-&gt;GeneratorTarget));
    outpath = cmSystemTools::RelativePath(
      binpath, this-&gt;GeneratorTarget-&gt;GetDirectory(config));
    /* clang-format off */
    fout &lt;&lt; &quot;    :binDirRelative=\&quot;&quot; &lt;&lt; outpath &lt;&lt; &quot;\&quot;\n&quot;
            &quot;    -o \&quot;&quot; &lt;&lt; this-&gt;TargetNameReal &lt;&lt; &quot;\&quot;\n&quot;;
    /* clang-format on */
  }

  // set target object file destination
  outpath = &quot;.&quot;;
  fout &lt;&lt; &quot;    :outputDirRelative=\&quot;&quot; &lt;&lt; outpath &lt;&lt; &quot;\&quot;\n&quot;;
}

void cmGhsMultiTargetGenerator::SetCompilerFlags(std::string const&amp; config,
                                                 const std::string&amp; language)
{
  auto i = this-&gt;FlagsByLanguage.find(language);
  if (i == this-&gt;FlagsByLanguage.end()) {
    std::string flags;
    this-&gt;LocalGenerator-&gt;AddLanguageFlags(
      flags, this-&gt;GeneratorTarget, cmBuildStep::Compile, language, config);
    this-&gt;LocalGenerator-&gt;AddCMP0018Flags(flags, this-&gt;GeneratorTarget,
                                          language, config);
    this-&gt;LocalGenerator-&gt;AddVisibilityPresetFlags(
      flags, this-&gt;GeneratorTarget, language);
    this-&gt;LocalGenerator-&gt;AddColorDiagnosticsFlags(flags, language);

    // Append old-style preprocessor definition flags.
    if (this-&gt;Makefile-&gt;GetDefineFlags() != &quot; &quot;) {
      this-&gt;LocalGenerator-&gt;AppendFlags(flags,
                                        this-&gt;Makefile-&gt;GetDefineFlags());
    }

    // Add target-specific flags.
    this-&gt;LocalGenerator-&gt;AddCompileOptions(flags, this-&gt;GeneratorTarget,
                                            language, config);

    std::map&lt;std::string, std::string&gt;::value_type entry(language, flags);
    i = this-&gt;FlagsByLanguage.insert(entry).first;
  }
}

std::string cmGhsMultiTargetGenerator::GetDefines(const std::string&amp; language,
                                                  std::string const&amp; config)
{
  auto i = this-&gt;DefinesByLanguage.find(language);
  if (i == this-&gt;DefinesByLanguage.end()) {
    std::set&lt;std::string&gt; defines;
    // Add preprocessor definitions for this target and configuration.
    this-&gt;LocalGenerator-&gt;GetTargetDefines(this-&gt;GeneratorTarget, config,
                                           language, defines);

    std::string definesString;
    this-&gt;LocalGenerator-&gt;JoinDefines(defines, definesString, language);

    std::map&lt;std::string, std::string&gt;::value_type entry(language,
                                                         definesString);
    i = this-&gt;DefinesByLanguage.insert(entry).first;
  }
  return i-&gt;second;
}

void cmGhsMultiTargetGenerator::WriteCompilerFlags(std::ostream&amp; fout,
                                                   std::string const&amp;,
                                                   const std::string&amp; language)
{
  auto flagsByLangI = this-&gt;FlagsByLanguage.find(language);
  if (flagsByLangI != this-&gt;FlagsByLanguage.end()) {
    if (!flagsByLangI-&gt;second.empty()) {
      std::vector&lt;std::string&gt; ghsCompFlags =
        cmSystemTools::ParseArguments(flagsByLangI-&gt;second);
      for (const std::string&amp; f : ghsCompFlags) {
        fout &lt;&lt; &quot;    &quot; &lt;&lt; f &lt;&lt; '\n';
      }
    }
  }
}

void cmGhsMultiTargetGenerator::WriteCompilerDefinitions(
  std::ostream&amp; fout, const std::string&amp; config, const std::string&amp; language)
{
  std::vector&lt;std::string&gt; compileDefinitions;
  this-&gt;GeneratorTarget-&gt;GetCompileDefinitions(compileDefinitions, config,
                                               language);
  for (std::string const&amp; compileDefinition : compileDefinitions) {
    fout &lt;&lt; &quot;    -D&quot; &lt;&lt; compileDefinition &lt;&lt; '\n';
  }
}

void cmGhsMultiTargetGenerator::WriteIncludes(std::ostream&amp; fout,
                                              const std::string&amp; config,
                                              const std::string&amp; language)
{
  std::vector&lt;std::string&gt; includes;
  this-&gt;LocalGenerator-&gt;GetIncludeDirectories(includes, this-&gt;GeneratorTarget,
                                              language, config);

  for (std::string const&amp; include : includes) {
    fout &lt;&lt; &quot;    -I\&quot;&quot; &lt;&lt; include &lt;&lt; &quot;\&quot;\n&quot;;
  }
}

void cmGhsMultiTargetGenerator::WriteTargetLinkLine(std::ostream&amp; fout,
                                                    std::string const&amp; config)
{
  if (this-&gt;TagType == GhsMultiGpj::INTERGRITY_APPLICATION) {
    return;
  }

  std::string linkLibraries;
  std::string flags;
  std::string linkFlags;
  std::string frameworkPath;
  std::string linkPath;

  std::unique_ptr&lt;cmLinkLineComputer&gt; linkLineComputer =
    this-&gt;GetGlobalGenerator()-&gt;CreateLinkLineComputer(
      this-&gt;LocalGenerator,
      this-&gt;LocalGenerator-&gt;GetStateSnapshot().GetDirectory());

  this-&gt;LocalGenerator-&gt;GetTargetFlags(
    linkLineComputer.get(), config, linkLibraries, flags, linkFlags,
    frameworkPath, linkPath, this-&gt;GeneratorTarget);

  // write out link options
  std::vector&lt;std::string&gt; lopts = cmSystemTools::ParseArguments(linkFlags);
  for (const std::string&amp; l : lopts) {
    fout &lt;&lt; &quot;    &quot; &lt;&lt; l &lt;&lt; '\n';
  }

  // write out link search paths
  // must be quoted for paths that contain spaces
  std::vector&lt;std::string&gt; lpath = cmSystemTools::ParseArguments(linkPath);
  for (const std::string&amp; l : lpath) {
    fout &lt;&lt; &quot;    -L\&quot;&quot; &lt;&lt; l &lt;&lt; &quot;\&quot;\n&quot;;
  }

  // write out link libs
  // must be quoted for filepaths that contains spaces
  std::string cbd = this-&gt;LocalGenerator-&gt;GetCurrentBinaryDirectory();

  std::vector&lt;std::string&gt; llibs =
    cmSystemTools::ParseArguments(linkLibraries);
  for (const std::string&amp; l : llibs) {
    if (l.compare(0, 2, &quot;-l&quot;) == 0) {
      fout &lt;&lt; &quot;    \&quot;&quot; &lt;&lt; l &lt;&lt; &quot;\&quot;\n&quot;;
    } else {
      std::string rl = cmSystemTools::CollapseFullPath(l, cbd);
      fout &lt;&lt; &quot;    -l\&quot;&quot; &lt;&lt; rl &lt;&lt; &quot;\&quot;\n&quot;;
    }
  }
}

void cmGhsMultiTargetGenerator::WriteBuildEvents(std::ostream&amp; fout)
{
  this-&gt;WriteBuildEventsHelper(fout,
                               this-&gt;GeneratorTarget-&gt;GetPreBuildCommands(),
                               std::string(&quot;prebuild&quot;),
#ifdef _WIN32
                               std::string(&quot;preexecShell&quot;)
#else
                               std::string(&quot;preexec&quot;)
#endif
  );

  if (this-&gt;TagType != GhsMultiGpj::CUSTOM_TARGET) {
    this-&gt;WriteBuildEventsHelper(fout,
                                 this-&gt;GeneratorTarget-&gt;GetPreLinkCommands(),
                                 std::string(&quot;prelink&quot;),
#ifdef _WIN32
                                 std::string(&quot;preexecShell&quot;)
#else
                                 std::string(&quot;preexec&quot;)
#endif
    );
  }

  this-&gt;WriteBuildEventsHelper(fout,
                               this-&gt;GeneratorTarget-&gt;GetPostBuildCommands(),
                               std::string(&quot;postbuild&quot;),
#ifdef _WIN32
                               std::string(&quot;postexecShell&quot;)
#else
                               std::string(&quot;postexec&quot;)
#endif
  );
}

void cmGhsMultiTargetGenerator::WriteBuildEventsHelper(
  std::ostream&amp; fout, const std::vector&lt;cmCustomCommand&gt;&amp; ccv,
  std::string const&amp; name, std::string const&amp; cmd)
{
  int cmdcount = 0;
#ifdef _WIN32
  std::string fext = &quot;.bat&quot;;
  std::string shell;
#else
  std::string fext = &quot;.sh&quot;;
  std::string shell = &quot;/bin/sh &quot;;
#endif

  for (cmCustomCommand const&amp; cc : ccv) {
    cmCustomCommandGenerator ccg(cc, this-&gt;ConfigName, this-&gt;LocalGenerator);
    // Open the filestream for this custom command
    std::string fname =
      cmStrCat(this-&gt;LocalGenerator-&gt;GetCurrentBinaryDirectory(), '/',
               this-&gt;LocalGenerator-&gt;GetTargetDirectory(this-&gt;GeneratorTarget),
               '/', this-&gt;Name, '_', name, cmdcount++, fext);

    cmGeneratedFileStream f(fname);
    f.SetCopyIfDifferent(true);
    this-&gt;WriteCustomCommandsHelper(f, ccg);
    f.Close();
    if (this-&gt;TagType != GhsMultiGpj::CUSTOM_TARGET) {
      fout &lt;&lt; &quot;    :&quot; &lt;&lt; cmd &lt;&lt; &quot;=\&quot;&quot; &lt;&lt; shell &lt;&lt; fname &lt;&lt; &quot;\&quot;\n&quot;;
    } else {
      fout &lt;&lt; fname &lt;&lt; &quot;\n    :outputName=\&quot;&quot; &lt;&lt; fname &lt;&lt; &quot;.rule\&quot;\n&quot;;
    }
    for (const auto&amp; byp : ccg.GetByproducts()) {
      fout &lt;&lt; &quot;    :extraOutputFile=\&quot;&quot; &lt;&lt; byp &lt;&lt; &quot;\&quot;\n&quot;;
    }
  }
}

void cmGhsMultiTargetGenerator::WriteCustomCommandsHelper(
  std::ostream&amp; fout, cmCustomCommandGenerator const&amp; ccg)
{
  std::vector&lt;std::string&gt; cmdLines;

  // if the command specified a working directory use it.
  std::string dir = this-&gt;LocalGenerator-&gt;GetCurrentBinaryDirectory();
  std::string workingDir = ccg.GetWorkingDirectory();
  if (!workingDir.empty()) {
    dir = workingDir;
  }

  // Line to check for error between commands.
#ifdef _WIN32
  std::string check_error = &quot;if %errorlevel% neq 0 exit /b %errorlevel%&quot;;
#else
  std::string check_error = &quot;if [ $? -ne 0 ]; then exit 1; fi&quot;;
#endif

#ifdef _WIN32
  cmdLines.push_back(&quot;@echo off&quot;);
#endif
  // Echo the custom command's comment text.
  const char* comment = ccg.GetComment();
  if (comment &amp;&amp; *comment) {
    std::string echocmd = cmStrCat(&quot;echo &quot;, comment);
    cmdLines.push_back(std::move(echocmd));
  }

  // Switch to working directory
  std::string cdCmd;
#ifdef _WIN32
  std::string cdStr = &quot;cd /D &quot;;
#else
  std::string cdStr = &quot;cd &quot;;
#endif
  cdCmd = cdStr +
    this-&gt;LocalGenerator-&gt;ConvertToOutputFormat(dir, cmOutputConverter::SHELL);
  cmdLines.push_back(std::move(cdCmd));

  for (unsigned int c = 0; c &lt; ccg.GetNumberOfCommands(); ++c) {
    // Build the command line in a single string.
    std::string cmd = ccg.GetCommand(c);
    if (!cmd.empty()) {
      // Use &quot;call &quot; before any invocations of .bat or .cmd files
      // invoked as custom commands in the WindowsShell.
      //
      bool useCall = false;

#ifdef _WIN32
      std::string suffix;
      if (cmd.size() &gt; 4) {
        suffix = cmSystemTools::LowerCase(cmd.substr(cmd.size() - 4));
        if (suffix == &quot;.bat&quot; || suffix == &quot;.cmd&quot;) {
          useCall = true;
        }
      }
#endif

      cmSystemTools::ReplaceString(cmd, &quot;/./&quot;, &quot;/&quot;);
      // Convert the command to a relative path only if the current
      // working directory will be the start-output directory.
      bool had_slash = cmd.find('/') != std::string::npos;
      if (workingDir.empty()) {
        cmd = this-&gt;LocalGenerator-&gt;MaybeRelativeToCurBinDir(cmd);
      }
      bool has_slash = cmd.find('/') != std::string::npos;
      if (had_slash &amp;&amp; !has_slash) {
        // This command was specified as a path to a file in the
        // current directory.  Add a leading &quot;./&quot; so it can run
        // without the current directory being in the search path.
        cmd = cmStrCat(&quot;./&quot;, cmd);
      }
      cmd = this-&gt;LocalGenerator-&gt;ConvertToOutputFormat(
        cmd, cmOutputConverter::SHELL);
      if (useCall) {
        cmd = cmStrCat(&quot;call &quot;, cmd);
      }
      ccg.AppendArguments(c, cmd);
      cmdLines.push_back(std::move(cmd));
    }
  }

  // push back the custom commands
  for (auto const&amp; c : cmdLines) {
    fout &lt;&lt; c &lt;&lt; '\n' &lt;&lt; check_error &lt;&lt; '\n';
  }
}

void cmGhsMultiTargetGenerator::WriteSourceProperty(
  std::ostream&amp; fout, const cmSourceFile* sf, std::string const&amp; propName,
  std::string const&amp; propFlag)
{
  cmValue prop = sf-&gt;GetProperty(propName);
  if (prop) {
    std::vector&lt;std::string&gt; list = cmExpandedList(*prop);
    for (const std::string&amp; p : list) {
      fout &lt;&lt; &quot;    &quot; &lt;&lt; propFlag &lt;&lt; p &lt;&lt; '\n';
    }
  }
}

void cmGhsMultiTargetGenerator::WriteSources(std::ostream&amp; fout_proj)
{
  /* vector of all sources for this target */
  std::vector&lt;cmSourceFile*&gt; sources;
  this-&gt;GeneratorTarget-&gt;GetSourceFiles(sources, this-&gt;ConfigName);

  /* vector of all groups defined for this target
   * -- but the vector is not expanded with sub groups or in any useful order
   */
  std::vector&lt;cmSourceGroup&gt; sourceGroups = this-&gt;Makefile-&gt;GetSourceGroups();

  /* for each source file assign it to its group */
  std::map&lt;std::string, std::vector&lt;cmSourceFile*&gt;&gt; groupFiles;
  std::set&lt;std::string&gt; groupNames;
  for (cmSourceFile* sf : sources) {
    cmSourceGroup* sourceGroup =
      this-&gt;Makefile-&gt;FindSourceGroup(sf-&gt;ResolveFullPath(), sourceGroups);
    std::string gn = sourceGroup-&gt;GetFullName();
    groupFiles[gn].push_back(sf);
    groupNames.insert(std::move(gn));
  }

  /* list of known groups and the order they are displayed in a project file */
  const std::vector&lt;std::string&gt; standardGroups = {
    &quot;CMake Rules&quot;,  &quot;Header Files&quot;,     &quot;Source Files&quot;,
    &quot;Object Files&quot;, &quot;Object Libraries&quot;, &quot;Resources&quot;
  };

  /* list of groups in the order they are displayed in a project file*/
  std::vector&lt;std::string&gt; groupFilesList(groupFiles.size());

  /* put the groups in the order they should be listed
   * - standard groups first, and then everything else
   *   in the order used by std::map.
   */
  int i = 0;
  for (const std::string&amp; gn : standardGroups) {
    auto n = groupNames.find(gn);
    if (n != groupNames.end()) {
      groupFilesList[i] = *n;
      i += 1;
      groupNames.erase(gn);
    } else if (this-&gt;TagType == GhsMultiGpj::CUSTOM_TARGET &amp;&amp;
               gn == &quot;CMake Rules&quot;) {
      /* make sure that rules folder always exists in case of custom targets
       * that have no custom commands except for pre or post build events.
       */
      groupFilesList.resize(groupFilesList.size() + 1);
      groupFilesList[i] = gn;
      i += 1;
    }
  }

  { /* catch-all group - is last item */
    std::string gn;
    auto n = groupNames.find(gn);
    if (n != groupNames.end()) {
      groupFilesList.back() = *n;
      groupNames.erase(gn);
    }
  }

  for (const auto&amp; n : groupNames) {
    groupFilesList[i] = n;
    i += 1;
  }

  /* sort the files within each group */
  for (auto&amp; n : groupFilesList) {
    std::sort(groupFiles[n].begin(), groupFiles[n].end(),
              [](cmSourceFile* l, cmSourceFile* r) {
                return l-&gt;ResolveFullPath() &lt; r-&gt;ResolveFullPath();
              });
  }

  /* list of open project files */
  std::vector&lt;cmGeneratedFileStream*&gt; gfiles;

  /* write files into the proper project file
   * -- groups go into main project file
   *    unless NO_SOURCE_GROUP_FILE property or variable is set.
   */
  for (auto&amp; sg : groupFilesList) {
    std::ostream* fout;
    bool useProjectFile =
      cmIsOn(this-&gt;GeneratorTarget-&gt;GetProperty(&quot;GHS_NO_SOURCE_GROUP_FILE&quot;)) ||
      this-&gt;Makefile-&gt;IsOn(&quot;CMAKE_GHS_NO_SOURCE_GROUP_FILE&quot;);
    if (useProjectFile || sg.empty()) {
      fout = &amp;fout_proj;
    } else {
      // Open the filestream in copy-if-different mode.
      std::string gname = sg;
      cmsys::SystemTools::ReplaceString(gname, &quot;\\&quot;, &quot;_&quot;);
      std::string lpath =
        cmStrCat(gname, cmGlobalGhsMultiGenerator::FILE_EXTENSION);
      std::string fpath = cmStrCat(
        this-&gt;LocalGenerator-&gt;GetCurrentBinaryDirectory(), '/',
        this-&gt;LocalGenerator-&gt;GetTargetDirectory(this-&gt;GeneratorTarget), '/',
        lpath);
      cmGeneratedFileStream* f = new cmGeneratedFileStream(fpath);
      f-&gt;SetCopyIfDifferent(true);
      gfiles.push_back(f);
      fout = f;
      this-&gt;GetGlobalGenerator()-&gt;WriteFileHeader(*f);
      GhsMultiGpj::WriteGpjTag(GhsMultiGpj::SUBPROJECT, *f);
      fout_proj &lt;&lt; lpath &lt;&lt; &quot; &quot;;
      GhsMultiGpj::WriteGpjTag(GhsMultiGpj::SUBPROJECT, fout_proj);
    }

    if (useProjectFile) {
      if (sg.empty()) {
        *fout &lt;&lt; &quot;{comment} Others&quot; &lt;&lt; '\n';
      } else {
        *fout &lt;&lt; &quot;{comment} &quot; &lt;&lt; sg &lt;&lt; '\n';
      }
    } else if (sg.empty()) {
      *fout &lt;&lt; &quot;{comment} Others\n&quot;;
    }

    if (sg != &quot;CMake Rules&quot;) {
      /* output rule for each source file */
      for (const cmSourceFile* si : groupFiles[sg]) {
        bool compile = true;
        // Convert filename to native system
        // WORKAROUND: GHS MULTI 6.1.4 and 6.1.6 are known to need backslash on
        // windows when opening some files from the search window.
        std::string fname(si-&gt;GetFullPath());
        cmSystemTools::ConvertToOutputSlashes(fname);

        /* For custom targets list any associated sources,
         * comment out source code to prevent it from being
         * compiled when processing this target.
         * Otherwise, comment out any custom command (main) dependencies that
         * are listed as source files to prevent them from being considered
         * part of the build.
         */
        std::string comment;
        if ((this-&gt;TagType == GhsMultiGpj::CUSTOM_TARGET &amp;&amp;
             !si-&gt;GetLanguage().empty()) ||
            si-&gt;GetCustomCommand()) {
          comment = &quot;{comment} &quot;;
          compile = false;
        }

        *fout &lt;&lt; comment &lt;&lt; fname &lt;&lt; WriteObjectLangOverride(si) &lt;&lt; '\n';
        if (compile) {
          this-&gt;WriteSourceProperty(*fout, si, &quot;INCLUDE_DIRECTORIES&quot;, &quot;-I&quot;);
          this-&gt;WriteSourceProperty(*fout, si, &quot;COMPILE_DEFINITIONS&quot;, &quot;-D&quot;);
          this-&gt;WriteSourceProperty(*fout, si, &quot;COMPILE_OPTIONS&quot;, &quot;&quot;);

          /* to avoid clutter in the GUI only print out the objectName if it
           * has been renamed */
          std::string objectName = this-&gt;GeneratorTarget-&gt;GetObjectName(si);
          if (!objectName.empty() &amp;&amp;
              this-&gt;GeneratorTarget-&gt;HasExplicitObjectName(si)) {
            *fout &lt;&lt; &quot;    -o &quot; &lt;&lt; objectName &lt;&lt; '\n';
          }
        }
      }
    } else {
      std::vector&lt;cmSourceFile const*&gt; customCommands;
      if (this-&gt;ComputeCustomCommandOrder(customCommands)) {
        std::string message = &quot;The custom commands for target [&quot; +
          this-&gt;GeneratorTarget-&gt;GetName() + &quot;] had a cycle.\n&quot;;
        cmSystemTools::Error(message);
      } else {
        /* Custom targets do not have a dependency on SOURCES files.
         * Therefore the dependency list may include SOURCES files after the
         * custom target. Because nothing can depend on the custom target just
         * move it to the last item.
         */
        for (auto sf = customCommands.begin(); sf != customCommands.end();
             ++sf) {
          if (((*sf)-&gt;GetLocation()).GetName() == this-&gt;Name + &quot;.rule&quot;) {
            std::rotate(sf, sf + 1, customCommands.end());
            break;
          }
        }
        int cmdcount = 0;
#ifdef _WIN32
        std::string fext = &quot;.bat&quot;;
#else
        std::string fext = &quot;.sh&quot;;
#endif
        for (auto&amp; sf : customCommands) {
          const cmCustomCommand* cc = sf-&gt;GetCustomCommand();
          cmCustomCommandGenerator ccg(*cc, this-&gt;ConfigName,
                                       this-&gt;LocalGenerator);

          // Open the filestream for this custom command
          std::string fname = cmStrCat(
            this-&gt;LocalGenerator-&gt;GetCurrentBinaryDirectory(), '/',
            this-&gt;LocalGenerator-&gt;GetTargetDirectory(this-&gt;GeneratorTarget),
            '/', this-&gt;Name, &quot;_cc&quot;, cmdcount++, '_',
            (sf-&gt;GetLocation()).GetName(), fext);

          cmGeneratedFileStream f(fname);
          f.SetCopyIfDifferent(true);
          this-&gt;WriteCustomCommandsHelper(f, ccg);
          f.Close();
          this-&gt;WriteCustomCommandLine(*fout, fname, ccg);
        }
      }
      if (this-&gt;TagType == GhsMultiGpj::CUSTOM_TARGET) {
        this-&gt;WriteBuildEvents(*fout);
      }
    }
  }

  for (cmGeneratedFileStream* f : gfiles) {
    f-&gt;Close();
  }
}

void cmGhsMultiTargetGenerator::WriteCustomCommandLine(
  std::ostream&amp; fout, std::string&amp; fname, cmCustomCommandGenerator const&amp; ccg)
{
  /* NOTE: Customization Files are not well documented.  Testing showed
   * that &quot;:outputName=file&quot; can only be used once per script.  The
   * script will only run if &quot;:outputName=file&quot; is missing or just run
   * once if &quot;:outputName=file&quot; is not specified.  If there are
   * multiple outputs then the script needs to be listed multiple times
   * for each output.  Otherwise it won't rerun the script if one of
   * the outputs is manually deleted.
   */
  bool specifyExtra = true;
  for (const auto&amp; out : ccg.GetOutputs()) {
    fout &lt;&lt; fname &lt;&lt; '\n';
    fout &lt;&lt; &quot;    :outputName=\&quot;&quot; &lt;&lt; out &lt;&lt; &quot;\&quot;\n&quot;;
    if (specifyExtra) {
      for (const auto&amp; byp : ccg.GetByproducts()) {
        fout &lt;&lt; &quot;    :extraOutputFile=\&quot;&quot; &lt;&lt; byp &lt;&lt; &quot;\&quot;\n&quot;;
      }
      for (const auto&amp; dep : ccg.GetDepends()) {
        fout &lt;&lt; &quot;    :depends=\&quot;&quot; &lt;&lt; dep &lt;&lt; &quot;\&quot;\n&quot;;
      }
      specifyExtra = false;
    }
  }
}

std::string cmGhsMultiTargetGenerator::WriteObjectLangOverride(
  const cmSourceFile* sourceFile)
{
  std::string ret;
  cmValue rawLangProp = sourceFile-&gt;GetProperty(&quot;LANGUAGE&quot;);
  if (rawLangProp) {
    ret = cmStrCat(&quot; [&quot;, *rawLangProp, &quot;]&quot;);
  }

  return ret;
}

bool cmGhsMultiTargetGenerator::DetermineIfIntegrityApp()
{
  if (cmValue p = this-&gt;GeneratorTarget-&gt;GetProperty(&quot;ghs_integrity_app&quot;)) {
    return cmIsOn(*p);
  }
  std::vector&lt;cmSourceFile*&gt; sources;
  this-&gt;GeneratorTarget-&gt;GetSourceFiles(sources, this-&gt;ConfigName);
  return std::any_of(sources.begin(), sources.end(),
                     [](cmSourceFile const* sf) -&gt; bool {
                       return &quot;int&quot; == sf-&gt;GetExtension();
                     });
}

bool cmGhsMultiTargetGenerator::ComputeCustomCommandOrder(
  std::vector&lt;cmSourceFile const*&gt;&amp; order)
{
  std::set&lt;cmSourceFile const*&gt; temp;
  std::set&lt;cmSourceFile const*&gt; perm;

  // Collect all custom commands for this target
  std::vector&lt;cmSourceFile const*&gt; customCommands;
  this-&gt;GeneratorTarget-&gt;GetCustomCommands(customCommands, this-&gt;ConfigName);

  for (cmSourceFile const* si : customCommands) {
    bool r = this-&gt;VisitCustomCommand(temp, perm, order, si);
    if (r) {
      return r;
    }
  }
  return false;
}

bool cmGhsMultiTargetGenerator::VisitCustomCommand(
  std::set&lt;cmSourceFile const*&gt;&amp; temp, std::set&lt;cmSourceFile const*&gt;&amp; perm,
  std::vector&lt;cmSourceFile const*&gt;&amp; order, cmSourceFile const* si)
{
  /* check if permanent mark is set*/
  if (perm.find(si) == perm.end()) {
    /* set temporary mark; check if revisit*/
    if (temp.insert(si).second) {
      for (const auto&amp; di : si-&gt;GetCustomCommand()-&gt;GetDepends()) {
        cmSourceFile const* sf =
          this-&gt;GeneratorTarget-&gt;GetLocalGenerator()-&gt;GetSourceFileWithOutput(
            di);
        /* if sf exists then visit */
        if (sf &amp;&amp; this-&gt;VisitCustomCommand(temp, perm, order, sf)) {
          return true;
        }
      }
      /* mark as complete; insert into beginning of list*/
      perm.insert(si);
      order.push_back(si);
      return false;
    }
    /* revisiting item - not a DAG */
    return true;
  }
  /* already complete */
  return false;
}
</textarea><br><br><input type='hidden' name='archivo_editar' value='/usr/src/cmake-3.25.0/Source/cmGhsMultiTargetGenerator.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>