CMake/Source/cmQtAutoGeneratorInitializer.cxx

/*============================================================================
  CMake - Cross Platform Makefile Generator
  Copyright 2004-2011 Kitware, Inc.
  Copyright 2011 Alexander Neundorf (neundorf@kde.org)

  Distributed under the OSI-approved BSD License (the "License");
  see accompanying file Copyright.txt for details.

  This software is distributed WITHOUT ANY WARRANTY; without even the
  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  See the License for more information.
============================================================================*/

#include "cmQtAutoGeneratorInitializer.h"

#include "cmLocalGenerator.h"
#include "cmMakefile.h"
#include "cmSourceFile.h"

#include <sys/stat.h>

#include <cmsys/FStream.hxx>

#if defined(_WIN32) && !defined(__CYGWIN__)
# include "cmGlobalVisualStudioGenerator.h"
#endif

std::string cmQtAutoGeneratorInitializer::GetAutogenTargetName(
    cmTarget const* target)
{
  std::string autogenTargetName = target->GetName();
  autogenTargetName += "_automoc";
  return autogenTargetName;
}

std::string cmQtAutoGeneratorInitializer::GetAutogenTargetDir(
    cmTarget const* target)
{
  cmMakefile* makefile = target->GetMakefile();
  std::string targetDir = makefile->GetCurrentBinaryDirectory();
  targetDir += makefile->GetCMakeInstance()->GetCMakeFilesDirectory();
  targetDir += "/";
  targetDir += cmQtAutoGeneratorInitializer::GetAutogenTargetName(target);
  targetDir += ".dir/";
  return targetDir;
}

static void copyTargetProperty(cmTarget* destinationTarget,
                               cmTarget* sourceTarget,
                               const std::string& propertyName)
{
  const char* propertyValue = sourceTarget->GetProperty(propertyName);
  if (propertyValue)
    {
    destinationTarget->SetProperty(propertyName, propertyValue);
    }
}

static std::string cmQtAutoGeneratorsStripCR(std::string const& line)
{
  // Strip CR characters rcc may have printed (possibly more than one!).
  std::string::size_type cr = line.find('\r');
  if (cr != line.npos)
    {
    return line.substr(0, cr);
    }
  return line;
}

static std::string ReadAll(const std::string& filename)
{
  cmsys::ifstream file(filename.c_str());
  std::stringstream stream;
  stream << file.rdbuf();
  file.close();
  return stream.str();
}

std::string cmQtAutoGeneratorInitializer::ListQt5RccInputs(cmSourceFile* sf,
                                            cmTarget const* target,
                                            std::vector<std::string>& depends)
{
  std::string rccCommand
      = cmQtAutoGeneratorInitializer::GetRccExecutable(target);
  std::vector<std::string> qrcEntries;

  std::vector<std::string> command;
  command.push_back(rccCommand);
  command.push_back("--list");

  std::string absFile = cmsys::SystemTools::GetRealPath(
                                              sf->GetFullPath());

  command.push_back(absFile);

  std::string rccStdOut;
  std::string rccStdErr;
  int retVal = 0;
  bool result = cmSystemTools::RunSingleCommand(
    command, &rccStdOut, &rccStdErr,
    &retVal, 0, cmSystemTools::OUTPUT_NONE);
  if (!result || retVal)
    {
    std::cerr << "AUTOGEN: error: Rcc list process for " << sf->GetFullPath()
              << " failed:\n" << rccStdOut << "\n" << rccStdErr << std::endl;
    return std::string();
    }

  {
  std::istringstream ostr(rccStdOut);
  std::string oline;
  while(std::getline(ostr, oline))
    {
    oline = cmQtAutoGeneratorsStripCR(oline);
    if(!oline.empty())
      {
      qrcEntries.push_back(oline);
      }
    }
  }

  {
  std::istringstream estr(rccStdErr);
  std::string eline;
  while(std::getline(estr, eline))
    {
    eline = cmQtAutoGeneratorsStripCR(eline);
    if (cmHasLiteralPrefix(eline, "RCC: Error in"))
      {
      static std::string searchString = "Cannot find file '";

      std::string::size_type pos = eline.find(searchString);
      if (pos == std::string::npos)
        {
        std::cerr << "AUTOGEN: error: Rcc lists unparsable output "
                  << eline << std::endl;
        return std::string();
        }
      pos += searchString.length();
      std::string::size_type sz = eline.size() - pos - 1;
      qrcEntries.push_back(eline.substr(pos, sz));
      }
    }
  }

  depends.insert(depends.end(), qrcEntries.begin(), qrcEntries.end());
  return cmJoin(qrcEntries, "@list_sep@");
}

std::string cmQtAutoGeneratorInitializer::ListQt4RccInputs(cmSourceFile* sf,
                                            std::vector<std::string>& depends)
{
  const std::string qrcContents = ReadAll(sf->GetFullPath());

  cmsys::RegularExpression fileMatchRegex("(<file[^<]+)");

  std::string entriesList;
  const char* sep = "";

  size_t offset = 0;
  while (fileMatchRegex.find(qrcContents.c_str() + offset))
    {
    std::string qrcEntry = fileMatchRegex.match(1);

    offset += qrcEntry.size();

    cmsys::RegularExpression fileReplaceRegex("(^<file[^>]*>)");
    fileReplaceRegex.find(qrcEntry);
    std::string tag = fileReplaceRegex.match(1);

    qrcEntry = qrcEntry.substr(tag.size());

    if (!cmSystemTools::FileIsFullPath(qrcEntry.c_str()))
      {
      qrcEntry = sf->GetLocation().GetDirectory() + "/" + qrcEntry;
      }

    entriesList += sep;
    entriesList += qrcEntry;
    sep = "@list_sep@";
    depends.push_back(qrcEntry);
    }
  return entriesList;
}


void cmQtAutoGeneratorInitializer::InitializeAutogenSources(cmTarget* target)
{
  cmMakefile* makefile = target->GetMakefile();

  if (target->GetPropertyAsBool("AUTOMOC"))
    {
    std::string automocTargetName =
        cmQtAutoGeneratorInitializer::GetAutogenTargetName(target);
    std::string mocCppFile = makefile->GetCurrentBinaryDirectory();
    mocCppFile += "/";
    mocCppFile += automocTargetName;
    mocCppFile += ".cpp";
    makefile->GetOrCreateSource(mocCppFile, true);
    makefile->AppendProperty("ADDITIONAL_MAKE_CLEAN_FILES",
                            mocCppFile.c_str(), false);

    target->AddSource(mocCppFile);
    }
}

void cmQtAutoGeneratorInitializer::InitializeAutogenTarget(
                                                 cmLocalGenerator* lg,
                                                 cmTarget* target)
{
  cmMakefile* makefile = target->GetMakefile();

  std::string qtMajorVersion = makefile->GetSafeDefinition("QT_VERSION_MAJOR");
  if (qtMajorVersion == "")
    {
    qtMajorVersion = makefile->GetSafeDefinition("Qt5Core_VERSION_MAJOR");
    }

  // create a custom target for running generators at buildtime:
  std::string autogenTargetName =
      cmQtAutoGeneratorInitializer::GetAutogenTargetName(target);

  std::string targetDir =
      cmQtAutoGeneratorInitializer::GetAutogenTargetDir(target);

  cmCustomCommandLine currentLine;
  currentLine.push_back(cmSystemTools::GetCMakeCommand());
  currentLine.push_back("-E");
  currentLine.push_back("cmake_autogen");
  currentLine.push_back(targetDir);
  currentLine.push_back("$<CONFIGURATION>");

  cmCustomCommandLines commandLines;
  commandLines.push_back(currentLine);

  std::string workingDirectory = cmSystemTools::CollapseFullPath(
                                    "", makefile->GetCurrentBinaryDirectory());

  std::vector<std::string> depends;
  if (const char *autogenDepends =
                                target->GetProperty("AUTOGEN_TARGET_DEPENDS"))
    {
    cmSystemTools::ExpandListArgument(autogenDepends, depends);
    }
  std::vector<std::string> toolNames;
  if (target->GetPropertyAsBool("AUTOMOC"))
    {
    toolNames.push_back("moc");
    }
  if (target->GetPropertyAsBool("AUTOUIC"))
    {
    toolNames.push_back("uic");
    }
  if (target->GetPropertyAsBool("AUTORCC"))
    {
    toolNames.push_back("rcc");
    }

  std::string tools = toolNames[0];
  toolNames.erase(toolNames.begin());
  while (toolNames.size() > 1)
    {
    tools += ", " + toolNames[0];
    toolNames.erase(toolNames.begin());
    }
  if (toolNames.size() == 1)
    {
    tools += " and " + toolNames[0];
    }
  std::string autogenComment = "Automatic " + tools + " for target ";
  autogenComment += target->GetName();

#if defined(_WIN32) && !defined(__CYGWIN__)
  bool usePRE_BUILD = false;
  cmGlobalGenerator* gg = lg->GetGlobalGenerator();
  if(gg->GetName().find("Visual Studio") != std::string::npos)
    {
    cmGlobalVisualStudioGenerator* vsgg =
      static_cast<cmGlobalVisualStudioGenerator*>(gg);
    // Under VS >= 7 use a PRE_BUILD event instead of a separate target to
    // reduce the number of targets loaded into the IDE.
    // This also works around a VS 11 bug that may skip updating the target:
    //  https://connect.microsoft.com/VisualStudio/feedback/details/769495
    usePRE_BUILD = vsgg->GetVersion() >= cmGlobalVisualStudioGenerator::VS7;
    if(usePRE_BUILD)
      {
      for (std::vector<std::string>::iterator it = depends.begin();
            it != depends.end(); ++it)
        {
        if(!makefile->FindTargetToUse(it->c_str()))
          {
          usePRE_BUILD = false;
          break;
          }
        }
      }
    }
#endif

  std::vector<std::string> rcc_output;
  bool const isNinja =
    lg->GetGlobalGenerator()->GetName() == "Ninja";
  if(isNinja
#if defined(_WIN32) && !defined(__CYGWIN__)
        || usePRE_BUILD
#endif
        )
    {
    std::vector<cmSourceFile*> srcFiles;
    cmGeneratorTarget* gtgt =
        lg->GetGlobalGenerator()->GetGeneratorTarget(target);
    gtgt->GetConfigCommonSourceFiles(srcFiles);
    for(std::vector<cmSourceFile*>::const_iterator fileIt = srcFiles.begin();
        fileIt != srcFiles.end();
        ++fileIt)
      {
      cmSourceFile* sf = *fileIt;
      std::string absFile = cmsys::SystemTools::GetRealPath(
                                                sf->GetFullPath());

      std::string ext = sf->GetExtension();

      if (target->GetPropertyAsBool("AUTORCC"))
        {
        if (ext == "qrc"
            && !cmSystemTools::IsOn(sf->GetPropertyForUser("SKIP_AUTORCC")))
          {
          std::string basename = cmsys::SystemTools::
                                  GetFilenameWithoutLastExtension(absFile);

          std::string rcc_output_dir = target->GetSupportDirectory();
          cmSystemTools::MakeDirectory(rcc_output_dir.c_str());
          std::string rcc_output_file = rcc_output_dir;
          rcc_output_file += "/qrc_" + basename + ".cpp";
          rcc_output.push_back(rcc_output_file);

          if (!cmSystemTools::IsOn(sf->GetPropertyForUser("GENERATED")))
            {
            if (qtMajorVersion == "5")
              {
              cmQtAutoGeneratorInitializer::ListQt5RccInputs(sf, target,
                                                              depends);
              }
            else
              {
              cmQtAutoGeneratorInitializer::ListQt4RccInputs(sf, depends);
              }
#if defined(_WIN32) && !defined(__CYGWIN__)
            // Cannot use PRE_BUILD because the resource files themselves
            // may not be sources within the target so VS may not know the
            // target needs to re-build at all.
            usePRE_BUILD = false;
#endif
            }
          }
        }
      }
    }

#if defined(_WIN32) && !defined(__CYGWIN__)
  if(usePRE_BUILD)
    {
    // Add the pre-build command directly to bypass the OBJECT_LIBRARY
    // rejection in cmMakefile::AddCustomCommandToTarget because we know
    // PRE_BUILD will work for an OBJECT_LIBRARY in this specific case.
    std::vector<std::string> no_output;
    std::vector<std::string> no_byproducts;
    cmCustomCommand cc(makefile, no_output, no_byproducts, depends,
                       commandLines, autogenComment.c_str(),
                       workingDirectory.c_str());
    cc.SetEscapeOldStyle(false);
    cc.SetEscapeAllowMakeVars(true);
    target->AddPreBuildCommand(cc);
    }
  else
#endif
    {
    cmTarget* autogenTarget = makefile->AddUtilityCommand(
                                autogenTargetName, true,
                                workingDirectory.c_str(),
                                /*byproducts=*/rcc_output, depends,
                                commandLines, false, autogenComment.c_str());

    cmGeneratorTarget* gt = new cmGeneratorTarget(autogenTarget, lg);
    makefile->AddGeneratorTarget(autogenTarget, gt);

    // Set target folder
    const char* autogenFolder = makefile->GetState()
                                ->GetGlobalProperty("AUTOMOC_TARGETS_FOLDER");
    if (!autogenFolder)
      {
      autogenFolder = makefile->GetState()
                                ->GetGlobalProperty("AUTOGEN_TARGETS_FOLDER");
      }
    if (autogenFolder && *autogenFolder)
      {
      autogenTarget->SetProperty("FOLDER", autogenFolder);
      }
    else
      {
      // inherit FOLDER property from target (#13688)
      copyTargetProperty(autogenTarget, target, "FOLDER");
      }

    target->AddUtility(autogenTargetName);
    }
}

static void GetCompileDefinitionsAndDirectories(cmTarget const* target,
                                                const std::string& config,
                                                std::string &incs,
                                                std::string &defs)
{
  cmMakefile* makefile = target->GetMakefile();
  cmGlobalGenerator* globalGen = makefile->GetGlobalGenerator();
  std::vector<std::string> includeDirs;
  cmGeneratorTarget *gtgt = globalGen->GetGeneratorTarget(target);
  cmLocalGenerator *localGen = gtgt->GetLocalGenerator();
  // Get the include dirs for this target, without stripping the implicit
  // include dirs off, see http://public.kitware.com/Bug/view.php?id=13667
  localGen->GetIncludeDirectories(includeDirs, gtgt, "CXX", config, false);

  incs = cmJoin(includeDirs, ";");

  std::set<std::string> defines;
  localGen->AddCompileDefinitions(defines, target, config, "CXX");

  defs += cmJoin(defines, ";");
}

void cmQtAutoGeneratorInitializer::SetupAutoGenerateTarget(
    cmTarget const* target)
{
  cmMakefile* makefile = target->GetMakefile();

  // forget the variables added here afterwards again:
  cmMakefile::ScopePushPop varScope(makefile);
  static_cast<void>(varScope);

  // create a custom target for running generators at buildtime:
  std::string autogenTargetName =
      cmQtAutoGeneratorInitializer::GetAutogenTargetName(target);

  makefile->AddDefinition("_moc_target_name",
          cmOutputConverter::EscapeForCMake(autogenTargetName).c_str());
  makefile->AddDefinition("_origin_target_name",
          cmOutputConverter::EscapeForCMake(target->GetName()).c_str());

  std::string targetDir =
      cmQtAutoGeneratorInitializer::GetAutogenTargetDir(target);

  const char *qtVersion = makefile->GetDefinition("Qt5Core_VERSION_MAJOR");
  if (!qtVersion)
    {
    qtVersion = makefile->GetDefinition("QT_VERSION_MAJOR");
    }
  cmGeneratorTarget *gtgt = target->GetMakefile()
                                  ->GetGlobalGenerator()
                                  ->GetGeneratorTarget(target);
  if (const char *targetQtVersion =
      gtgt->GetLinkInterfaceDependentStringProperty("QT_MAJOR_VERSION", ""))
    {
    qtVersion = targetQtVersion;
    }
  if (qtVersion)
    {
    makefile->AddDefinition("_target_qt_version", qtVersion);
    }

  std::vector<std::string> skipUic;
  std::vector<std::string> skipMoc;
  std::vector<std::string> mocSources;
  std::vector<std::string> mocHeaders;
  std::map<std::string, std::string> configIncludes;
  std::map<std::string, std::string> configDefines;
  std::map<std::string, std::string> configUicOptions;

  if (target->GetPropertyAsBool("AUTOMOC")
      || target->GetPropertyAsBool("AUTOUIC")
      || target->GetPropertyAsBool("AUTORCC"))
    {
    cmQtAutoGeneratorInitializer::SetupSourceFiles(target, skipMoc,
                                         mocSources, mocHeaders, skipUic);
    }
  makefile->AddDefinition("_cpp_files",
          cmOutputConverter::EscapeForCMake(cmJoin(mocSources, ";")).c_str());
  if (target->GetPropertyAsBool("AUTOMOC"))
    {
    cmQtAutoGeneratorInitializer::SetupAutoMocTarget(target, autogenTargetName,
                             skipMoc, mocHeaders,
                             configIncludes, configDefines);
    }
  if (target->GetPropertyAsBool("AUTOUIC"))
    {
    cmQtAutoGeneratorInitializer::SetupAutoUicTarget(target, skipUic,
                                                      configUicOptions);
    }
  if (target->GetPropertyAsBool("AUTORCC"))
    {
    cmQtAutoGeneratorInitializer::SetupAutoRccTarget(target);
    }

  const char* cmakeRoot = makefile->GetSafeDefinition("CMAKE_ROOT");
  std::string inputFile = cmakeRoot;
  inputFile += "/Modules/AutogenInfo.cmake.in";
  std::string outputFile = targetDir;
  outputFile += "/AutogenInfo.cmake";
  makefile->AddDefinition("_qt_rcc_inputs",
              makefile->GetDefinition("_qt_rcc_inputs_" + target->GetName()));
  makefile->ConfigureFile(inputFile.c_str(), outputFile.c_str(),
                          false, true, false);

  // Ensure we have write permission in case .in was read-only.
  mode_t perm = 0;
#if defined(_WIN32) && !defined(__CYGWIN__)
  mode_t mode_write = S_IWRITE;
#else
  mode_t mode_write = S_IWUSR;
#endif
  cmSystemTools::GetPermissions(outputFile, perm);
  if (!(perm & mode_write))
    {
    cmSystemTools::SetPermissions(outputFile, perm | mode_write);
    }
  if (!configDefines.empty()
      || !configIncludes.empty()
      || !configUicOptions.empty())
    {
    cmsys::ofstream infoFile(outputFile.c_str(), std::ios::app);
    if ( !infoFile )
      {
      std::string error = "Internal CMake error when trying to open file: ";
      error += outputFile.c_str();
      error += " for writing.";
      cmSystemTools::Error(error.c_str());
      return;
      }
    if (!configDefines.empty())
      {
      for (std::map<std::string, std::string>::iterator
            it = configDefines.begin(), end = configDefines.end();
            it != end; ++it)
        {
        infoFile << "set(AM_MOC_COMPILE_DEFINITIONS_" << it->first <<
          " " << it->second << ")\n";
        }
      }
    if (!configIncludes.empty())
      {
      for (std::map<std::string, std::string>::iterator
            it = configIncludes.begin(), end = configIncludes.end();
            it != end; ++it)
        {
        infoFile << "set(AM_MOC_INCLUDES_" << it->first <<
          " " << it->second << ")\n";
        }
      }
    if (!configUicOptions.empty())
      {
      for (std::map<std::string, std::string>::iterator
            it = configUicOptions.begin(), end = configUicOptions.end();
            it != end; ++it)
        {
        infoFile << "set(AM_UIC_TARGET_OPTIONS_" << it->first <<
          " " << it->second << ")\n";
        }
      }
    }
}

void cmQtAutoGeneratorInitializer::SetupSourceFiles(cmTarget const* target,
                                   std::vector<std::string>& skipMoc,
                                   std::vector<std::string>& mocSources,
                                   std::vector<std::string>& mocHeaders,
                                   std::vector<std::string>& skipUic)
{
  cmMakefile* makefile = target->GetMakefile();

  std::vector<cmSourceFile*> srcFiles;
  cmGeneratorTarget *gtgt = target->GetMakefile()
                                  ->GetGlobalGenerator()
                                  ->GetGeneratorTarget(target);
  gtgt->GetConfigCommonSourceFiles(srcFiles);

  std::vector<std::string> newRccFiles;

  for(std::vector<cmSourceFile*>::const_iterator fileIt = srcFiles.begin();
      fileIt != srcFiles.end();
      ++fileIt)
    {
    cmSourceFile* sf = *fileIt;
    std::string absFile = cmsys::SystemTools::GetRealPath(
                                                    sf->GetFullPath());
    bool skipFileForMoc =
        cmSystemTools::IsOn(sf->GetPropertyForUser("SKIP_AUTOMOC"));
    bool generated = cmSystemTools::IsOn(sf->GetPropertyForUser("GENERATED"));

    if(cmSystemTools::IsOn(sf->GetPropertyForUser("SKIP_AUTOUIC")))
      {
      skipUic.push_back(absFile);
      }

    std::string ext = sf->GetExtension();

    if (target->GetPropertyAsBool("AUTORCC"))
      {
      if (ext == "qrc"
          && !cmSystemTools::IsOn(sf->GetPropertyForUser("SKIP_AUTORCC")))
        {
        std::string basename = cmsys::SystemTools::
                                      GetFilenameWithoutLastExtension(absFile);

        std::string rcc_output_dir = target->GetSupportDirectory();
        cmSystemTools::MakeDirectory(rcc_output_dir.c_str());
        std::string rcc_output_file = rcc_output_dir;
        rcc_output_file += "/qrc_" + basename + ".cpp";
        makefile->AppendProperty("ADDITIONAL_MAKE_CLEAN_FILES",
                                rcc_output_file.c_str(), false);
        makefile->GetOrCreateSource(rcc_output_file, true);
        newRccFiles.push_back(rcc_output_file);
        }
      }

    if (!generated)
      {
      if (skipFileForMoc)
        {
        skipMoc.push_back(absFile);
        }
      else
        {
        cmSystemTools::FileFormat fileType = cmSystemTools::GetFileFormat(
                                                                ext.c_str());
        if (fileType == cmSystemTools::CXX_FILE_FORMAT)
          {
          mocSources.push_back(absFile);
          }
        else if (fileType == cmSystemTools::HEADER_FILE_FORMAT)
          {
          mocHeaders.push_back(absFile);
          }
        }
      }
    }

  for(std::vector<std::string>::const_iterator fileIt = newRccFiles.begin();
      fileIt != newRccFiles.end();
      ++fileIt)
    {
    const_cast<cmTarget*>(target)->AddSource(*fileIt);
    }
}

void cmQtAutoGeneratorInitializer::SetupAutoMocTarget(cmTarget const* target,
                          const std::string &autogenTargetName,
                          std::vector<std::string> const& skipMoc,
                          std::vector<std::string> const& mocHeaders,
                          std::map<std::string, std::string> &configIncludes,
                          std::map<std::string, std::string> &configDefines)
{
  cmMakefile* makefile = target->GetMakefile();

  const char* tmp = target->GetProperty("AUTOMOC_MOC_OPTIONS");
  std::string _moc_options = (tmp!=0 ? tmp : "");
  makefile->AddDefinition("_moc_options",
          cmOutputConverter::EscapeForCMake(_moc_options).c_str());
  makefile->AddDefinition("_skip_moc",
          cmOutputConverter::EscapeForCMake(cmJoin(skipMoc, ";")).c_str());
  makefile->AddDefinition("_moc_headers",
          cmOutputConverter::EscapeForCMake(cmJoin(mocHeaders, ";")).c_str());
  bool relaxedMode = makefile->IsOn("CMAKE_AUTOMOC_RELAXED_MODE");
  makefile->AddDefinition("_moc_relaxed_mode", relaxedMode ? "TRUE" : "FALSE");

  std::string _moc_incs;
  std::string _moc_compile_defs;
  std::vector<std::string> configs;
  const std::string& config = makefile->GetConfigurations(configs);
  GetCompileDefinitionsAndDirectories(target, config,
                                      _moc_incs, _moc_compile_defs);

  makefile->AddDefinition("_moc_incs",
          cmOutputConverter::EscapeForCMake(_moc_incs).c_str());
  makefile->AddDefinition("_moc_compile_defs",
          cmOutputConverter::EscapeForCMake(_moc_compile_defs).c_str());

  for (std::vector<std::string>::const_iterator li = configs.begin();
       li != configs.end(); ++li)
    {
    std::string config_moc_incs;
    std::string config_moc_compile_defs;
    GetCompileDefinitionsAndDirectories(target, *li,
                                        config_moc_incs,
                                        config_moc_compile_defs);
    if (config_moc_incs != _moc_incs)
      {
      configIncludes[*li] =
                    cmOutputConverter::EscapeForCMake(config_moc_incs);
      if(_moc_incs.empty())
        {
        _moc_incs = config_moc_incs;
        }
      }
    if (config_moc_compile_defs != _moc_compile_defs)
      {
      configDefines[*li] =
            cmOutputConverter::EscapeForCMake(config_moc_compile_defs);
      if(_moc_compile_defs.empty())
        {
        _moc_compile_defs = config_moc_compile_defs;
        }
      }
    }

  const char *qtVersion = makefile->GetDefinition("_target_qt_version");
  if (strcmp(qtVersion, "5") == 0)
    {
    cmTarget *qt5Moc = makefile->FindTargetToUse("Qt5::moc");
    if (!qt5Moc)
      {
      cmSystemTools::Error("Qt5::moc target not found ",
                          autogenTargetName.c_str());
      return;
      }
    makefile->AddDefinition("_qt_moc_executable",
                            qt5Moc->ImportedGetLocation(""));
    }
  else if (strcmp(qtVersion, "4") == 0)
    {
    cmTarget *qt4Moc = makefile->FindTargetToUse("Qt4::moc");
    if (!qt4Moc)
      {
      cmSystemTools::Error("Qt4::moc target not found ",
                          autogenTargetName.c_str());
      return;
      }
    makefile->AddDefinition("_qt_moc_executable",
                            qt4Moc->ImportedGetLocation(""));
    }
  else
    {
    cmSystemTools::Error("The CMAKE_AUTOMOC feature supports only Qt 4 and "
                        "Qt 5 ", autogenTargetName.c_str());
    }
}

static void GetUicOpts(cmTarget const* target, const std::string& config,
                       std::string &optString)
{
  cmGeneratorTarget *gtgt = target->GetMakefile()
                                  ->GetGlobalGenerator()
                                  ->GetGeneratorTarget(target);
  std::vector<std::string> opts;
  gtgt->GetAutoUicOptions(opts, config);
  optString = cmJoin(opts, ";");
}

void cmQtAutoGeneratorInitializer::SetupAutoUicTarget(cmTarget const* target,
                          std::vector<std::string> const& skipUic,
                          std::map<std::string, std::string> &configUicOptions)
{
  cmMakefile *makefile = target->GetMakefile();

  std::set<std::string> skipped;
  skipped.insert(skipUic.begin(), skipUic.end());

  makefile->AddDefinition("_skip_uic",
          cmOutputConverter::EscapeForCMake(cmJoin(skipUic, ";")).c_str());

  std::vector<cmSourceFile*> uiFilesWithOptions
                                        = makefile->GetQtUiFilesWithOptions();

  const char *qtVersion = makefile->GetDefinition("_target_qt_version");

  std::string _uic_opts;
  std::vector<std::string> configs;
  const std::string& config = makefile->GetConfigurations(configs);
  GetUicOpts(target, config, _uic_opts);

  if (!_uic_opts.empty())
    {
    _uic_opts = cmOutputConverter::EscapeForCMake(_uic_opts);
    makefile->AddDefinition("_uic_target_options", _uic_opts.c_str());
    }
  for (std::vector<std::string>::const_iterator li = configs.begin();
       li != configs.end(); ++li)
    {
    std::string config_uic_opts;
    GetUicOpts(target, *li, config_uic_opts);
    if (config_uic_opts != _uic_opts)
      {
      configUicOptions[*li] =
                    cmOutputConverter::EscapeForCMake(config_uic_opts);
      if(_uic_opts.empty())
        {
        _uic_opts = config_uic_opts;
        }
      }
    }

  std::string uiFileFiles;
  std::string uiFileOptions;
  const char* sep = "";

  for(std::vector<cmSourceFile*>::const_iterator fileIt =
      uiFilesWithOptions.begin();
      fileIt != uiFilesWithOptions.end();
      ++fileIt)
    {
    cmSourceFile* sf = *fileIt;
    std::string absFile = cmsys::SystemTools::GetRealPath(
                                                    sf->GetFullPath());

    if (!skipped.insert(absFile).second)
      {
      continue;
      }
    uiFileFiles += sep;
    uiFileFiles += absFile;
    uiFileOptions += sep;
    std::string opts = sf->GetProperty("AUTOUIC_OPTIONS");
    cmSystemTools::ReplaceString(opts, ";", "@list_sep@");
    uiFileOptions += opts;
    sep = ";";
    }

  makefile->AddDefinition("_qt_uic_options_files",
              cmOutputConverter::EscapeForCMake(uiFileFiles).c_str());
  makefile->AddDefinition("_qt_uic_options_options",
            cmOutputConverter::EscapeForCMake(uiFileOptions).c_str());

  std::string targetName = target->GetName();
  if (strcmp(qtVersion, "5") == 0)
    {
    cmTarget *qt5Uic = makefile->FindTargetToUse("Qt5::uic");
    if (!qt5Uic)
      {
      // Project does not use Qt5Widgets, but has AUTOUIC ON anyway
      }
    else
      {
      makefile->AddDefinition("_qt_uic_executable",
                              qt5Uic->ImportedGetLocation(""));
      }
    }
  else if (strcmp(qtVersion, "4") == 0)
    {
    cmTarget *qt4Uic = makefile->FindTargetToUse("Qt4::uic");
    if (!qt4Uic)
      {
      cmSystemTools::Error("Qt4::uic target not found ",
                          targetName.c_str());
      return;
      }
    makefile->AddDefinition("_qt_uic_executable",
                            qt4Uic->ImportedGetLocation(""));
    }
  else
    {
    cmSystemTools::Error("The CMAKE_AUTOUIC feature supports only Qt 4 and "
                        "Qt 5 ", targetName.c_str());
    }
}

void cmQtAutoGeneratorInitializer::MergeRccOptions(
                         std::vector<std::string> &opts,
                         const std::vector<std::string> &fileOpts,
                         bool isQt5)
{
  static const char* valueOptions[] = {
    "name",
    "root",
    "compress",
    "threshold"
  };
  std::vector<std::string> extraOpts;
  for(std::vector<std::string>::const_iterator it = fileOpts.begin();
      it != fileOpts.end(); ++it)
    {
    std::vector<std::string>::iterator existingIt
                                  = std::find(opts.begin(), opts.end(), *it);
    if (existingIt != opts.end())
      {
      const char *o = it->c_str();
      if (*o == '-')
        {
        ++o;
        }
      if (isQt5 && *o == '-')
        {
        ++o;
        }
      if (std::find_if(cmArrayBegin(valueOptions), cmArrayEnd(valueOptions),
                  cmStrCmp(*it)) != cmArrayEnd(valueOptions))
        {
        assert(existingIt + 1 != opts.end());
        *(existingIt + 1) = *(it + 1);
        ++it;
        }
      }
    else
      {
      extraOpts.push_back(*it);
      }
    }
  opts.insert(opts.end(), extraOpts.begin(), extraOpts.end());
}

void cmQtAutoGeneratorInitializer::SetupAutoRccTarget(cmTarget const* target)
{
  std::string _rcc_files;
  const char* sepRccFiles = "";
  cmMakefile *makefile = target->GetMakefile();

  std::vector<cmSourceFile*> srcFiles;
  cmGeneratorTarget *gtgt = target->GetMakefile()
                                  ->GetGlobalGenerator()
                                  ->GetGeneratorTarget(target);
  gtgt->GetConfigCommonSourceFiles(srcFiles);

  std::string qrcInputs;
  const char* qrcInputsSep = "";

  std::string rccFileFiles;
  std::string rccFileOptions;
  const char *optionSep = "";

  const char *qtVersion = makefile->GetDefinition("_target_qt_version");

  std::vector<std::string> rccOptions;
  if (const char* opts = target->GetProperty("AUTORCC_OPTIONS"))
    {
    cmSystemTools::ExpandListArgument(opts, rccOptions);
    }
  std::string qtMajorVersion = makefile->GetSafeDefinition("QT_VERSION_MAJOR");
  if (qtMajorVersion == "")
    {
    qtMajorVersion = makefile->GetSafeDefinition("Qt5Core_VERSION_MAJOR");
    }

  for(std::vector<cmSourceFile*>::const_iterator fileIt = srcFiles.begin();
      fileIt != srcFiles.end();
      ++fileIt)
    {
    cmSourceFile* sf = *fileIt;
    std::string ext = sf->GetExtension();
    if (ext == "qrc")
      {
      std::string absFile = cmsys::SystemTools::GetRealPath(
                                                  sf->GetFullPath());
      bool skip = cmSystemTools::IsOn(sf->GetPropertyForUser("SKIP_AUTORCC"));

      if (!skip)
        {
        _rcc_files += sepRccFiles;
        _rcc_files += absFile;
        sepRccFiles = ";";

        if (const char *prop = sf->GetProperty("AUTORCC_OPTIONS"))
          {
          std::vector<std::string> optsVec;
          cmSystemTools::ExpandListArgument(prop, optsVec);
          cmQtAutoGeneratorInitializer::MergeRccOptions(rccOptions, optsVec,
                                strcmp(qtVersion, "5") == 0);
          }

        if (!rccOptions.empty())
          {
          rccFileFiles += optionSep;
          rccFileFiles += absFile;
          rccFileOptions += optionSep;
          }
        const char *listSep = "";
        for(std::vector<std::string>::const_iterator it = rccOptions.begin();
            it != rccOptions.end();
            ++it)
          {
          rccFileOptions += listSep;
          rccFileOptions += *it;
          listSep = "@list_sep@";
          }
        optionSep = ";";

        std::vector<std::string> depends;

        std::string entriesList;
        if (!cmSystemTools::IsOn(sf->GetPropertyForUser("GENERATED")))
          {
          if (qtMajorVersion == "5")
            {
            entriesList = cmQtAutoGeneratorInitializer::ListQt5RccInputs(sf,
                                                               target,
                                                               depends);
            }
          else
            {
            entriesList =
                cmQtAutoGeneratorInitializer::ListQt4RccInputs(sf, depends);
            }
          if (entriesList.empty())
            {
            return;
            }
          }
        qrcInputs += qrcInputsSep;
        qrcInputs += entriesList;
        qrcInputsSep = ";";
        }
      }
    }
  makefile->AddDefinition("_qt_rcc_inputs_" + target->GetName(),
                      cmOutputConverter::EscapeForCMake(qrcInputs).c_str());

  makefile->AddDefinition("_rcc_files",
          cmOutputConverter::EscapeForCMake(_rcc_files).c_str());

  makefile->AddDefinition("_qt_rcc_options_files",
              cmOutputConverter::EscapeForCMake(rccFileFiles).c_str());
  makefile->AddDefinition("_qt_rcc_options_options",
            cmOutputConverter::EscapeForCMake(rccFileOptions).c_str());

  makefile->AddDefinition("_qt_rcc_executable",
              cmQtAutoGeneratorInitializer::GetRccExecutable(target).c_str());
}

std::string cmQtAutoGeneratorInitializer::GetRccExecutable(
    cmTarget const* target)
{
  cmGeneratorTarget *gtgt = target->GetMakefile()
                                  ->GetGlobalGenerator()
                                  ->GetGeneratorTarget(target);
  cmMakefile *makefile = target->GetMakefile();
  const char *qtVersion = makefile->GetDefinition("_target_qt_version");
  if (!qtVersion)
    {
    qtVersion = makefile->GetDefinition("Qt5Core_VERSION_MAJOR");
    if (!qtVersion)
      {
      qtVersion = makefile->GetDefinition("QT_VERSION_MAJOR");
      }
    if (const char *targetQtVersion =
        gtgt->GetLinkInterfaceDependentStringProperty("QT_MAJOR_VERSION", ""))
      {
      qtVersion = targetQtVersion;
      }
    }

  std::string targetName = target->GetName();
  if (strcmp(qtVersion, "5") == 0)
    {
    cmTarget *qt5Rcc = makefile->FindTargetToUse("Qt5::rcc");
    if (!qt5Rcc)
      {
      cmSystemTools::Error("Qt5::rcc target not found ",
                          targetName.c_str());
      return std::string();
      }
    return qt5Rcc->ImportedGetLocation("");
    }
  else if (strcmp(qtVersion, "4") == 0)
    {
    cmTarget *qt4Rcc = makefile->FindTargetToUse("Qt4::rcc");
    if (!qt4Rcc)
      {
      cmSystemTools::Error("Qt4::rcc target not found ",
                          targetName.c_str());
      return std::string();
      }
    return qt4Rcc->ImportedGetLocation("");
    }

  cmSystemTools::Error("The CMAKE_AUTORCC feature supports only Qt 4 and "
                      "Qt 5 ", targetName.c_str());
  return std::string();
}