CMake/Source/cmSourceGroupCommand.cxx

/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
   file LICENSE.rst or https://cmake.org/licensing for details.  */
#include "cmSourceGroupCommand.h"

#include <functional>
#include <map>
#include <memory>
#include <set>
#include <unordered_map>
#include <utility>

#include <cm/optional>
#include <cm/string_view>
#include <cmext/algorithm>
#include <cmext/string_view>

#include "cmArgumentParser.h"
#include "cmArgumentParserTypes.h"
#include "cmCMakePath.h"
#include "cmDiagnostics.h"
#include "cmExecutionStatus.h"
#include "cmMakefile.h"
#include "cmSourceFile.h"
#include "cmSourceFileLocation.h"
#include "cmSourceGroup.h"
#include "cmStringAlgorithms.h"
#include "cmSystemTools.h"
#include "cmTarget.h"

namespace {
template <typename Args>
bool ProcessTree(Args const& args, cmExecutionStatus& status)
{
  cmMakefile& mf = status.GetMakefile();

  auto const& currentSourceDir = mf.GetCurrentSourceDirectory();
  std::vector<std::string> files;
  if (args.Files) {
    files.reserve(args.Files->size());

    for (auto const& file : *args.Files) {
      if (file.empty()) {
        continue;
      }
      std::string fullPath =
        cmSystemTools::CollapseFullPath(file, currentSourceDir);
      files.emplace_back(std::move(fullPath));
    }
  } else {
    std::vector<std::unique_ptr<cmSourceFile>> const& sources =
      mf.GetSourceFiles();
    for (auto const& src : sources) {
      if (!src->GetIsGenerated()) {
        files.push_back(cmSystemTools::CollapseFullPath(
          src->GetLocation().GetFullPath(), currentSourceDir));
      }
    }
  }

  // final checks
  cmCMakePath const root{ cmSystemTools::CollapseFullPath(*args.Tree) };
  cmCMakePath const prefix{
    cmCMakePath{ args.Prefix ? *args.Prefix : "" }.Normal()
  };

  auto it = files.begin();
  while (it != files.end()) {
    if (it->empty() || cmSystemTools::FileIsDirectory(*it) ||
        (it->back() == '/' || it->back() == '\\')) {
      // Ignore any empty files or directories
      it = files.erase(it);
      continue;
    }

    cmCMakePath file{ *it };
    if (!root.IsPrefix(file)) {
      status.SetError(cmStrCat('"', root.GenericString(),
                               "\" is not a prefix of file \"",
                               file.GenericString(), '"'));
      return false;
    }

    // source groups generation
    cmCMakePath sourceGroup = prefix / file.Relative(root);
    if (sourceGroup.HasParentPath()) {
      sourceGroup = sourceGroup.GetParentPath();
    }
    std::vector<std::string> tokenizedSG =
      cmTokenize(sourceGroup.GenericString(), '/', cmTokenizerMode::New);

    auto* sg = mf.GetOrCreateSourceGroup(tokenizedSG);
    if (!sg) {
      status.SetError(cmStrCat("could not create source group for file \"",
                               file.GenericString(), '"'));
      return false;
    }
    sg->AddGroupFile(file.GenericString());

    ++it;
  }
  return true;
}
} // namespace

bool cmSourceGroupCommand(std::vector<std::string> const& args,
                          cmExecutionStatus& status)
{
  if (args.empty()) {
    status.SetError("called with incorrect number of arguments");
    return false;
  }

  static cm::string_view const Keywords[]{ "TREE"_s, "PREFIX"_s, "FILES"_s,
                                           "REGULAR_EXPRESSION"_s };
  cmMakefile& mf = status.GetMakefile();

  if (args.size() == 2 && !cm::contains(Keywords, args[0]) &&
      !cm::contains(Keywords, args[1])) {
    // The pre-1.8 version of the command is being invoked.
    cmSourceGroup* sg = mf.GetOrCreateSourceGroup(args[0]);
    if (!sg) {
      status.SetError("Could not create or find source group.");
      return false;
    }
    sg->SetGroupRegex(args[1]);
    return true;
  }

  struct Arguments : public ArgumentParser::ParseResult
  {
    cm::optional<std::string> GroupName;
    cm::optional<ArgumentParser::MaybeEmpty<std::vector<std::string>>> Files;
    cm::optional<std::string> Regex;
    cm::optional<ArgumentParser::MaybeEmpty<std::vector<std::string>>>
      FileSets;
    cm::optional<ArgumentParser::NonEmpty<std::string>> Tree;
    cm::optional<ArgumentParser::MaybeEmpty<std::string>> Prefix;

    std::map<std::string, std::set<std::string>> FileSetsPerTarget;
  };

  auto unsupportedKeyword =
    [&mf](Arguments&, cm::string_view key,
          cm::string_view /*value */) -> ArgumentParser::Continue {
    mf.IssueDiagnostic(
      cmDiagnostics::CMD_AUTHOR,
      cmStrCat("keyword \"", key, "\" will be ignored in this context."));
    return ArgumentParser::Continue::Yes;
  };
  // to distinguish REGULAR_EXPRESSION without values from with an empty string
  auto handleRegex = [](Arguments& result,
                        cm::string_view value) -> ArgumentParser::Continue {
    if (value.data()) {
      result.Regex = std::string{ value };
    }
    return ArgumentParser::Continue::No;
  };
  auto handleTarget = [](Arguments& result,
                         cm::string_view value) -> ArgumentParser::Continue {
    if (!result.FileSets) {
      result.AddKeywordError(
        "TARGET", cmStrCat("FILE_SETS is required for TARGET ", value, '.'));
      return ArgumentParser::Continue::No;
    }
    if (!result.FileSets->empty()) {
      result.FileSetsPerTarget[std::string{ value }].insert(
        result.FileSets->begin(), result.FileSets->end());
    }
    result.FileSets.reset();

    return ArgumentParser::Continue::Yes;
  };

  std::vector<std::string> unexpectedArgs;
  auto parser =
    cmArgumentParser<Arguments>{}.Bind("FILES"_s, &Arguments::Files);

  if (cm::contains(args, "TREE")) {
    // this is the TREE syntax
    parser.Bind("TREE"_s, &Arguments::Tree)
      .Bind("PREFIX"_s, &Arguments::Prefix)
      .Bind("REGULAR_EXPRESSION"_s, unsupportedKeyword)
      .Bind("FILE_SETS"_s, unsupportedKeyword)
      .Bind("TARGET"_s, unsupportedKeyword);
  } else {
    // assume that first argument is the group name
    parser.Bind(0, &Arguments::GroupName)
      .Bind("REGULAR_EXPRESSION"_s, handleRegex, 0)
      .Bind("FILE_SETS"_s, &Arguments::FileSets)
      .Bind("TARGET"_s, handleTarget)
      .Bind("TREE"_s, unsupportedKeyword)
      .Bind("PREFIX"_s, unsupportedKeyword);
  }

  auto parsedArgs = parser.Parse(args, &unexpectedArgs);

  // do various checks for arguments consistency
  if (!parsedArgs.Check("", &unexpectedArgs, status)) {
    cmSystemTools::SetFatalErrorOccurred();
    return false;
  }
  if (!parsedArgs.Tree && !parsedArgs.GroupName) {
    status.SetError("missing source group name.");
    cmSystemTools::SetFatalErrorOccurred();
    return false;
  }
  if (!parsedArgs.Tree && parsedArgs.FileSets) {
    status.SetError(cmStrCat("TARGET is required for FILE_SETS ",
                             cmJoin(*parsedArgs.FileSets, ", "), '.'));
    return false;
  }

  if (parsedArgs.Tree) {
    if (!ProcessTree(parsedArgs, status)) {
      cmSystemTools::SetFatalErrorOccurred();
      return false;
    }
  } else {
    if (!parsedArgs.Files && !parsedArgs.Regex &&
        parsedArgs.FileSetsPerTarget.empty()) {
      // group is not created
      return true;
    }

    auto* sg = mf.GetOrCreateSourceGroup(*parsedArgs.GroupName);
    if (!sg) {
      status.SetError("could not create or find source group");
      cmSystemTools::SetFatalErrorOccurred();
      return false;
    }

    if (parsedArgs.Regex) {
      if (!sg->SetGroupRegex(*parsedArgs.Regex)) {
        status.SetError(cmStrCat("regular expression \"", *parsedArgs.Regex,
                                 "\" is invalid"));
        return false;
      }
    }
    if (parsedArgs.Files) {
      auto const& currentSourceDir = mf.GetCurrentSourceDirectory();
      for (auto const& file : *parsedArgs.Files) {
        sg->AddGroupFile(
          cmSystemTools::CollapseFullPath(file, currentSourceDir));
      }
    }
    for (auto& item : parsedArgs.FileSetsPerTarget) {
      // check validity of arguments
      auto it = mf.GetTargets().find(item.first);
      if (it == mf.GetTargets().end()) {
        mf.IssueDiagnostic(
          cmDiagnostics::CMD_AUTHOR,
          cmStrCat(
            "TARGET \"", item.first,
            "\" is not defined in this directory. It will be ignored."));
        continue;
      }

      cmTarget const& target = it->second;
      for (auto it2 = item.second.begin(); it2 != item.second.end();) {
        if (!target.GetFileSet(*it2)) {
          mf.IssueDiagnostic(cmDiagnostics::CMD_AUTHOR,
                             cmStrCat("FILE_SET \"", *it2,
                                      "\" is not known for TARGET \"",
                                      item.first, "\". It will ignored."));
          it2 = item.second.erase(it2);
        } else {
          ++it2;
        }
      }
      if (!item.second.empty()) {
        sg->AddGroupFileSets(item.first, item.second);
      }
    }
  }

  return true;
}