|
|
@@ -0,0 +1,1074 @@
|
|
|
+/*============================================================================
|
|
|
+ CMake - Cross Platform Makefile Generator
|
|
|
+ Copyright 2004-2011 Kitware, Inc.
|
|
|
+ Copyright 2011 Alexander Neundorf ([email protected])
|
|
|
+
|
|
|
+ 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();
|
|
|
+}
|
Brad King