CMake/Source/cmQtAutoGenerators.cxx

2410 lines
78 KiB
C++
Raw Normal View History

2011-10-22 21:43:34 +04:00
/*============================================================================
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 "cmGlobalGenerator.h"
#include "cmLocalGenerator.h"
#include "cmMakefile.h"
#include "cmSourceFile.h"
#include "cmSystemTools.h"
#include "cmState.h"
2015-03-08 15:51:20 +03:00
#include "cmAlgorithms.h"
#if defined(_WIN32) && !defined(__CYGWIN__)
# include "cmGlobalVisualStudioGenerator.h"
#endif
#include <sys/stat.h>
#include <cmsys/Terminal.h>
#include <cmsys/ios/sstream>
#include <cmsys/FStream.hxx>
#include <assert.h>
#include <string.h>
#if defined(__APPLE__)
#include <unistd.h>
#endif
2011-08-14 18:43:04 +04:00
#include "cmQtAutoGenerators.h"
static bool requiresMocing(const std::string& text, std::string &macroName)
{
// this simple check is much much faster than the regexp
if (strstr(text.c_str(), "Q_OBJECT") == NULL
&& strstr(text.c_str(), "Q_GADGET") == NULL)
{
return false;
}
cmsys::RegularExpression qObjectRegExp("[\n][ \t]*Q_OBJECT[^a-zA-Z0-9_]");
if (qObjectRegExp.find(text))
{
macroName = "Q_OBJECT";
return true;
}
cmsys::RegularExpression qGadgetRegExp("[\n][ \t]*Q_GADGET[^a-zA-Z0-9_]");
if (qGadgetRegExp.find(text))
{
macroName = "Q_GADGET";
return true;
}
return false;
}
static std::string findMatchingHeader(const std::string& absPath,
const std::string& mocSubDir,
const std::string& basename,
const std::vector<std::string>& headerExtensions)
{
std::string header;
for(std::vector<std::string>::const_iterator ext = headerExtensions.begin();
ext != headerExtensions.end();
++ext)
{
std::string sourceFilePath = absPath + basename + "." + (*ext);
if (cmsys::SystemTools::FileExists(sourceFilePath.c_str()))
{
header = sourceFilePath;
break;
}
if (!mocSubDir.empty())
{
sourceFilePath = mocSubDir + basename + "." + (*ext);
if (cmsys::SystemTools::FileExists(sourceFilePath.c_str()))
{
header = sourceFilePath;
break;
}
}
}
return header;
}
static std::string extractSubDir(const std::string& absPath,
const std::string& currentMoc)
{
std::string subDir;
if (currentMoc.find_first_of('/') != std::string::npos)
{
subDir = absPath
+ cmsys::SystemTools::GetFilenamePath(currentMoc) + '/';
}
return subDir;
}
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 ReadAll(const std::string& filename)
{
cmsys::ifstream file(filename.c_str());
cmsys_ios::stringstream stream;
stream << file.rdbuf();
file.close();
return stream.str();
}
cmQtAutoGenerators::cmQtAutoGenerators()
:Verbose(cmsys::SystemTools::GetEnv("VERBOSE") != 0)
2011-08-14 18:43:04 +04:00
,ColorOutput(true)
,RunMocFailed(false)
,RunUicFailed(false)
,RunRccFailed(false)
,GenerateAll(false)
{
2011-08-14 18:43:04 +04:00
std::string colorEnv = "";
cmsys::SystemTools::GetEnv("COLOR", colorEnv);
if(!colorEnv.empty())
{
if(cmSystemTools::IsOn(colorEnv.c_str()))
{
this->ColorOutput = true;
}
else
{
this->ColorOutput = false;
}
}
}
2013-12-10 18:45:27 +04:00
static std::string getAutogenTargetName(cmTarget const* target)
{
std::string autogenTargetName = target->GetName();
autogenTargetName += "_automoc";
return autogenTargetName;
}
2013-12-10 18:45:27 +04:00
static std::string getAutogenTargetDir(cmTarget const* target)
{
cmMakefile* makefile = target->GetMakefile();
std::string targetDir = makefile->GetCurrentBinaryDirectory();
targetDir += makefile->GetCMakeInstance()->GetCMakeFilesDirectory();
targetDir += "/";
targetDir += getAutogenTargetName(target);
targetDir += ".dir/";
return targetDir;
}
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;
}
std::string cmQtAutoGenerators::ListQt5RccInputs(cmSourceFile* sf,
cmTarget const* target,
std::vector<std::string>& depends)
{
std::string rccCommand = this->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(
2014-11-23 13:05:50 +03:00
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 cmQtAutoGenerators::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;
}
bool cmQtAutoGenerators::InitializeAutogenTarget(cmLocalGenerator* lg,
cmTarget* target)
{
cmMakefile* makefile = target->GetMakefile();
// don't do anything if there is no Qt4 or Qt5Core (which contains moc):
std::string qtMajorVersion = makefile->GetSafeDefinition("QT_VERSION_MAJOR");
if (qtMajorVersion == "")
{
qtMajorVersion = makefile->GetSafeDefinition("Qt5Core_VERSION_MAJOR");
}
if (qtMajorVersion != "4" && qtMajorVersion != "5")
{
return false;
}
if (target->GetPropertyAsBool("AUTOMOC"))
{
std::string automocTargetName = 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);
}
// create a custom target for running generators at buildtime:
std::string autogenTargetName = getAutogenTargetName(target);
std::string targetDir = 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;
target->GetConfigCommonSourceFiles(srcFiles);
for(std::vector<cmSourceFile*>::const_iterator fileIt = srcFiles.begin();
fileIt != srcFiles.end();
++fileIt)
{
cmSourceFile* sf = *fileIt;
std::string absFile = cmsys::SystemTools::GetRealPath(
2014-11-23 13:05:50 +03:00
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")
{
this->ListQt5RccInputs(sf, target, depends);
}
else
{
this->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;
Add an option for explicit BYPRODUCTS of custom commands (#14963) A common idiom in CMake-based build systems is to have custom commands that generate files not listed explicitly as outputs so that these files do not have to be newer than the inputs. The file modification times of such "byproducts" are updated only when their content changes. Then other build rules can depend on the byproducts explicitly so that their dependents rebuild when the content of the original byproducts really does change. This "undeclared byproduct" approach is necessary for Makefile, VS, and Xcode build tools because if a byproduct were listed as an output of a rule then the rule would always rerun when the input is newer than the byproduct but the byproduct may never be updated. Ninja solves this problem by offering a 'restat' feature to check whether an output was really modified after running a rule and tracking the fact that it is up to date separately from its timestamp. However, Ninja also stats all dependencies up front and will only restat files that are listed as outputs of rules with the 'restat' option enabled. Therefore an undeclared byproduct that does not exist at the start of the build will be considered missing and the build will fail even if other dependencies would cause the byproduct to be available before its dependents build. CMake works around this limitation by adding 'phony' build rules for custom command dependencies in the build tree that do not have any explicit specification of what produces them. This is not optimal because it prevents Ninja from reporting an error when an input to a rule really is missing. A better approach is to allow projects to explicitly specify the byproducts of their custom commands so that no phony rules are needed for them. In order to work with the non-Ninja generators, the byproducts must be known separately from the outputs. Add a new "BYPRODUCTS" option to the add_custom_command and add_custom_target commands to specify byproducts explicitly. Teach the Ninja generator to specify byproducts as outputs of the custom commands. In the case of POST_BUILD, PRE_LINK, and PRE_BUILD events on targets that link, the byproducts must be specified as outputs of the link rule that runs the commands. Activate 'restat' for such rules so that Ninja knows it needs to check the byproducts, but not for link rules that have no byproducts.
2014-11-14 02:54:52 +03:00
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());
autogenTarget->Compute();
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);
}
return true;
}
2013-12-10 18:45:27 +04:00
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
2013-12-10 18:45:27 +04:00
localGen->GetIncludeDirectories(includeDirs, gtgt, "CXX", config, false);
incs = cmJoin(includeDirs, ";");
std::set<std::string> defines;
localGen->AddCompileDefinitions(defines, target, config, "CXX");
defs += cmJoin(defines, ";");
}
2013-12-10 18:45:27 +04:00
void cmQtAutoGenerators::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 = 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 = 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::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"))
{
this->SetupSourceFiles(target);
}
makefile->AddDefinition("_cpp_files",
cmOutputConverter::EscapeForCMake(this->Sources).c_str());
if (target->GetPropertyAsBool("AUTOMOC"))
{
this->SetupAutoMocTarget(target, autogenTargetName,
configIncludes, configDefines);
}
if (target->GetPropertyAsBool("AUTOUIC"))
{
this->SetupAutoUicTarget(target, configUicOptions);
}
if (target->GetPropertyAsBool("AUTORCC"))
{
this->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 cmQtAutoGenerators::SetupSourceFiles(cmTarget const* target)
{
cmMakefile* makefile = target->GetMakefile();
const char* sepFiles = "";
const char* sepHeaders = "";
std::vector<cmSourceFile*> srcFiles;
target->GetConfigCommonSourceFiles(srcFiles);
const char *skipMocSep = "";
const char *skipUicSep = "";
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 skipMoc = cmSystemTools::IsOn(sf->GetPropertyForUser("SKIP_AUTOMOC"));
bool generated = cmSystemTools::IsOn(sf->GetPropertyForUser("GENERATED"));
if(cmSystemTools::IsOn(sf->GetPropertyForUser("SKIP_AUTOUIC")))
{
this->SkipUic += skipUicSep;
this->SkipUic += absFile;
skipUicSep = ";";
}
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 (skipMoc)
{
this->SkipMoc += skipMocSep;
this->SkipMoc += absFile;
skipMocSep = ";";
}
else
{
cmSystemTools::FileFormat fileType = cmSystemTools::GetFileFormat(
ext.c_str());
if (fileType == cmSystemTools::CXX_FILE_FORMAT)
{
this->Sources += sepFiles;
this->Sources += absFile;
sepFiles = ";";
}
else if (fileType == cmSystemTools::HEADER_FILE_FORMAT)
{
this->Headers += sepHeaders;
this->Headers += absFile;
sepHeaders = ";";
}
}
}
}
for(std::vector<std::string>::const_iterator fileIt = newRccFiles.begin();
fileIt != newRccFiles.end();
++fileIt)
{
const_cast<cmTarget*>(target)->AddSource(*fileIt);
}
}
void cmQtAutoGenerators::SetupAutoMocTarget(cmTarget const* target,
const std::string &autogenTargetName,
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(this->SkipMoc).c_str());
makefile->AddDefinition("_moc_headers",
cmOutputConverter::EscapeForCMake(this->Headers).c_str());
2013-10-02 15:49:19 +04:00
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());
}
}
void cmQtAutoGenerators::MergeUicOptions(std::vector<std::string> &opts,
const std::vector<std::string> &fileOpts,
bool isQt5)
{
static const char* valueOptions[] = {
"tr",
"translate",
"postfix",
"generator",
"include", // Since Qt 5.3
"g"
};
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),
2014-01-17 22:38:27 +04:00
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());
}
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, ";");
}
2013-12-10 18:45:27 +04:00
void cmQtAutoGenerators::SetupAutoUicTarget(cmTarget const* target,
std::map<std::string, std::string> &configUicOptions)
{
cmMakefile *makefile = target->GetMakefile();
std::set<std::string> skipped;
std::vector<std::string> skipVec;
cmSystemTools::ExpandListArgument(this->SkipUic, skipVec);
skipped.insert(skipVec.begin(), skipVec.end());
makefile->AddDefinition("_skip_uic",
cmOutputConverter::EscapeForCMake(this->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());
2014-02-07 02:31:47 +04:00
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 ",
2014-02-07 02:31:47 +04:00
targetName.c_str());
return;
}
makefile->AddDefinition("_qt_uic_executable",
qt4Uic->ImportedGetLocation(""));
}
else
{
cmSystemTools::Error("The CMAKE_AUTOUIC feature supports only Qt 4 and "
2014-02-07 02:31:47 +04:00
"Qt 5 ", targetName.c_str());
}
}
void cmQtAutoGenerators::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),
2014-01-17 22:38:27 +04:00
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());
}
2013-12-10 18:45:27 +04:00
void cmQtAutoGenerators::SetupAutoRccTarget(cmTarget const* target)
{
std::string _rcc_files;
const char* sepRccFiles = "";
cmMakefile *makefile = target->GetMakefile();
std::vector<cmSourceFile*> srcFiles;
target->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);
this->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 = this->ListQt5RccInputs(sf, target, depends);
}
else
{
entriesList = this->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",
this->GetRccExecutable(target).c_str());
}
std::string cmQtAutoGenerators::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;
}
}
2014-02-07 02:31:47 +04:00
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 ",
2014-02-07 02:31:47 +04:00
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 ",
2014-02-07 02:31:47 +04:00
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();
}
bool cmQtAutoGenerators::Run(const std::string& targetDirectory,
const std::string& config)
{
bool success = true;
cmake cm;
cm.SetHomeOutputDirectory(targetDirectory);
cm.SetHomeDirectory(targetDirectory);
cmGlobalGenerator gg(&cm);
cmLocalGenerator* lg = gg.MakeLocalGenerator();
lg->GetMakefile()->SetCurrentBinaryDirectory(targetDirectory);
lg->GetMakefile()->SetCurrentSourceDirectory(targetDirectory);
gg.SetCurrentMakefile(lg->GetMakefile());
this->ReadAutogenInfoFile(lg->GetMakefile(), targetDirectory, config);
this->ReadOldMocDefinitionsFile(lg->GetMakefile(), targetDirectory);
this->Init();
if (this->QtMajorVersion == "4" || this->QtMajorVersion == "5")
{
success = this->RunAutogen(lg->GetMakefile());
}
this->WriteOldMocDefinitionsFile(targetDirectory);
delete lg;
return success;
}
2013-10-02 15:50:31 +04:00
bool cmQtAutoGenerators::ReadAutogenInfoFile(cmMakefile* makefile,
2014-02-25 02:38:30 +04:00
const std::string& targetDirectory,
const std::string& config)
{
2014-02-25 02:38:30 +04:00
std::string filename(
cmSystemTools::CollapseFullPath(targetDirectory));
cmSystemTools::ConvertToUnixSlashes(filename);
filename += "/AutogenInfo.cmake";
if (!makefile->ReadListFile(filename.c_str()))
{
cmSystemTools::Error("Error processing file: ", filename.c_str());
return false;
}
this->QtMajorVersion = makefile->GetSafeDefinition("AM_QT_VERSION_MAJOR");
if (this->QtMajorVersion == "")
{
2011-11-10 03:57:21 +04:00
this->QtMajorVersion = makefile->GetSafeDefinition(
"AM_Qt5Core_VERSION_MAJOR");
}
this->Sources = makefile->GetSafeDefinition("AM_SOURCES");
{
std::string rccSources = makefile->GetSafeDefinition("AM_RCC_SOURCES");
cmSystemTools::ExpandListArgument(rccSources, this->RccSources);
}
this->SkipMoc = makefile->GetSafeDefinition("AM_SKIP_MOC");
this->SkipUic = makefile->GetSafeDefinition("AM_SKIP_UIC");
this->Headers = makefile->GetSafeDefinition("AM_HEADERS");
2011-08-10 22:45:22 +04:00
this->IncludeProjectDirsBefore = makefile->IsOn(
"AM_CMAKE_INCLUDE_DIRECTORIES_PROJECT_BEFORE");
this->Srcdir = makefile->GetSafeDefinition("AM_CMAKE_CURRENT_SOURCE_DIR");
this->Builddir = makefile->GetSafeDefinition("AM_CMAKE_CURRENT_BINARY_DIR");
this->MocExecutable = makefile->GetSafeDefinition("AM_QT_MOC_EXECUTABLE");
this->UicExecutable = makefile->GetSafeDefinition("AM_QT_UIC_EXECUTABLE");
this->RccExecutable = makefile->GetSafeDefinition("AM_QT_RCC_EXECUTABLE");
{
std::string compileDefsPropOrig = "AM_MOC_COMPILE_DEFINITIONS";
std::string compileDefsProp = compileDefsPropOrig;
if(!config.empty())
{
compileDefsProp += "_";
compileDefsProp += config;
}
const char *compileDefs = makefile->GetDefinition(compileDefsProp);
this->MocCompileDefinitionsStr = compileDefs ? compileDefs
: makefile->GetSafeDefinition(compileDefsPropOrig);
}
{
std::string includesPropOrig = "AM_MOC_INCLUDES";
std::string includesProp = includesPropOrig;
if(!config.empty())
{
includesProp += "_";
includesProp += config;
}
const char *includes = makefile->GetDefinition(includesProp);
this->MocIncludesStr = includes ? includes
: makefile->GetSafeDefinition(includesPropOrig);
}
this->MocOptionsStr = makefile->GetSafeDefinition("AM_MOC_OPTIONS");
this->ProjectBinaryDir = makefile->GetSafeDefinition("AM_CMAKE_BINARY_DIR");
this->ProjectSourceDir = makefile->GetSafeDefinition("AM_CMAKE_SOURCE_DIR");
this->TargetName = makefile->GetSafeDefinition("AM_TARGET_NAME");
this->OriginTargetName
= makefile->GetSafeDefinition("AM_ORIGIN_TARGET_NAME");
{
const char *uicOptionsFiles
= makefile->GetSafeDefinition("AM_UIC_OPTIONS_FILES");
std::string uicOptionsPropOrig = "AM_UIC_TARGET_OPTIONS";
std::string uicOptionsProp = uicOptionsPropOrig;
if(!config.empty())
{
uicOptionsProp += "_";
uicOptionsProp += config;
}
const char *uicTargetOptions
= makefile->GetSafeDefinition(uicOptionsProp);
cmSystemTools::ExpandListArgument(
uicTargetOptions ? uicTargetOptions
: makefile->GetSafeDefinition(uicOptionsPropOrig),
this->UicTargetOptions);
const char *uicOptionsOptions
= makefile->GetSafeDefinition("AM_UIC_OPTIONS_OPTIONS");
std::vector<std::string> uicFilesVec;
cmSystemTools::ExpandListArgument(uicOptionsFiles, uicFilesVec);
std::vector<std::string> uicOptionsVec;
cmSystemTools::ExpandListArgument(uicOptionsOptions, uicOptionsVec);
if (uicFilesVec.size() != uicOptionsVec.size())
{
return false;
}
for (std::vector<std::string>::iterator fileIt = uicFilesVec.begin(),
optionIt = uicOptionsVec.begin();
fileIt != uicFilesVec.end();
++fileIt, ++optionIt)
{
cmSystemTools::ReplaceString(*optionIt, "@list_sep@", ";");
this->UicOptions[*fileIt] = *optionIt;
}
}
{
const char *rccOptionsFiles
= makefile->GetSafeDefinition("AM_RCC_OPTIONS_FILES");
const char *rccOptionsOptions
= makefile->GetSafeDefinition("AM_RCC_OPTIONS_OPTIONS");
std::vector<std::string> rccFilesVec;
cmSystemTools::ExpandListArgument(rccOptionsFiles, rccFilesVec);
std::vector<std::string> rccOptionsVec;
cmSystemTools::ExpandListArgument(rccOptionsOptions, rccOptionsVec);
if (rccFilesVec.size() != rccOptionsVec.size())
{
return false;
}
for (std::vector<std::string>::iterator fileIt = rccFilesVec.begin(),
optionIt = rccOptionsVec.begin();
fileIt != rccFilesVec.end();
++fileIt, ++optionIt)
{
cmSystemTools::ReplaceString(*optionIt, "@list_sep@", ";");
this->RccOptions[*fileIt] = *optionIt;
}
const char *rccInputs = makefile->GetSafeDefinition("AM_RCC_INPUTS");
std::vector<std::string> rccInputLists;
cmSystemTools::ExpandListArgument(rccInputs, rccInputLists);
if (this->RccSources.size() != rccInputLists.size())
{
cmSystemTools::Error("Error processing file: ", filename.c_str());
return false;
}
for (std::vector<std::string>::iterator fileIt = this->RccSources.begin(),
inputIt = rccInputLists.begin();
fileIt != this->RccSources.end();
++fileIt, ++inputIt)
{
cmSystemTools::ReplaceString(*inputIt, "@list_sep@", ";");
std::vector<std::string> rccInputFiles;
cmSystemTools::ExpandListArgument(*inputIt, rccInputFiles);
this->RccInputs[*fileIt] = rccInputFiles;
}
}
this->CurrentCompileSettingsStr = this->MakeCompileSettingsString(makefile);
this->RelaxedMode = makefile->IsOn("AM_RELAXED_MODE");
return true;
}
std::string cmQtAutoGenerators::MakeCompileSettingsString(cmMakefile* makefile)
{
std::string s;
s += makefile->GetSafeDefinition("AM_MOC_COMPILE_DEFINITIONS");
s += " ~~~ ";
s += makefile->GetSafeDefinition("AM_MOC_INCLUDES");
s += " ~~~ ";
s += makefile->GetSafeDefinition("AM_MOC_OPTIONS");
s += " ~~~ ";
s += makefile->IsOn("AM_CMAKE_INCLUDE_DIRECTORIES_PROJECT_BEFORE") ? "TRUE"
: "FALSE";
s += " ~~~ ";
return s;
}
bool cmQtAutoGenerators::ReadOldMocDefinitionsFile(cmMakefile* makefile,
2014-02-25 02:38:30 +04:00
const std::string& targetDirectory)
{
2014-02-25 02:38:30 +04:00
std::string filename(
cmSystemTools::CollapseFullPath(targetDirectory));
cmSystemTools::ConvertToUnixSlashes(filename);
filename += "/AutomocOldMocDefinitions.cmake";
if (makefile->ReadListFile(filename.c_str()))
{
this->OldCompileSettingsStr =
makefile->GetSafeDefinition("AM_OLD_COMPILE_SETTINGS");
}
return true;
}
void
2014-02-25 02:38:30 +04:00
cmQtAutoGenerators::WriteOldMocDefinitionsFile(
const std::string& targetDirectory)
{
2014-02-25 02:38:30 +04:00
std::string filename(
cmSystemTools::CollapseFullPath(targetDirectory));
cmSystemTools::ConvertToUnixSlashes(filename);
filename += "/AutomocOldMocDefinitions.cmake";
cmsys::ofstream outfile;
outfile.open(filename.c_str(),
std::ios::trunc);
outfile << "set(AM_OLD_COMPILE_SETTINGS "
<< cmOutputConverter::EscapeForCMake(
this->CurrentCompileSettingsStr) << ")\n";
outfile.close();
}
void cmQtAutoGenerators::Init()
{
this->OutMocCppFilename = this->Builddir;
this->OutMocCppFilename += this->TargetName;
this->OutMocCppFilename += ".cpp";
std::vector<std::string> cdefList;
cmSystemTools::ExpandListArgument(this->MocCompileDefinitionsStr, cdefList);
for(std::vector<std::string>::const_iterator it = cdefList.begin();
it != cdefList.end();
++it)
{
this->MocDefinitions.push_back("-D" + (*it));
}
cmSystemTools::ExpandListArgument(this->MocOptionsStr, this->MocOptions);
std::vector<std::string> incPaths;
cmSystemTools::ExpandListArgument(this->MocIncludesStr, incPaths);
std::set<std::string> frameworkPaths;
for(std::vector<std::string>::const_iterator it = incPaths.begin();
it != incPaths.end();
++it)
{
const std::string &path = *it;
this->MocIncludes.push_back("-I" + path);
if (cmHasLiteralSuffix(path, ".framework/Headers"))
{
// Go up twice to get to the framework root
std::vector<std::string> pathComponents;
cmsys::SystemTools::SplitPath(path, pathComponents);
std::string frameworkPath =cmsys::SystemTools::JoinPath(
pathComponents.begin(), pathComponents.end() - 2);
frameworkPaths.insert(frameworkPath);
}
}
for (std::set<std::string>::const_iterator it = frameworkPaths.begin();
it != frameworkPaths.end(); ++it)
{
this->MocIncludes.push_back("-F");
this->MocIncludes.push_back(*it);
}
if (this->IncludeProjectDirsBefore)
{
const std::string binDir = "-I" + this->ProjectBinaryDir;
const std::string srcDir = "-I" + this->ProjectSourceDir;
std::list<std::string> sortedMocIncludes;
std::list<std::string>::iterator it = this->MocIncludes.begin();
while (it != this->MocIncludes.end())
{
if (this->StartsWith(*it, binDir))
{
sortedMocIncludes.push_back(*it);
it = this->MocIncludes.erase(it);
}
else
{
++it;
}
}
it = this->MocIncludes.begin();
while (it != this->MocIncludes.end())
{
if (this->StartsWith(*it, srcDir))
{
sortedMocIncludes.push_back(*it);
it = this->MocIncludes.erase(it);
}
else
{
++it;
}
}
sortedMocIncludes.insert(sortedMocIncludes.end(),
this->MocIncludes.begin(), this->MocIncludes.end());
this->MocIncludes = sortedMocIncludes;
}
}
bool cmQtAutoGenerators::RunAutogen(cmMakefile* makefile)
{
if (!cmsys::SystemTools::FileExists(this->OutMocCppFilename.c_str())
|| (this->OldCompileSettingsStr != this->CurrentCompileSettingsStr))
{
this->GenerateAll = true;
}
2011-08-10 22:45:22 +04:00
// the program goes through all .cpp files to see which moc files are
// included. It is not really interesting how the moc file is named, but
// what file the moc is created from. Once a moc is included the same moc
// may not be included in the _automoc.cpp file anymore. OTOH if there's a
// header containing Q_OBJECT where no corresponding moc file is included
// anywhere a moc_<filename>.cpp file is created and included in
// the _automoc.cpp file.
// key = moc source filepath, value = moc output filepath
std::map<std::string, std::string> includedMocs;
// collect all headers which may need to be mocced
std::set<std::string> headerFiles;
std::vector<std::string> sourceFiles;
cmSystemTools::ExpandListArgument(this->Sources, sourceFiles);
const std::vector<std::string>& headerExtensions =
makefile->GetHeaderExtensions();
std::map<std::string, std::vector<std::string> > includedUis;
std::map<std::string, std::vector<std::string> > skippedUis;
std::vector<std::string> uicSkipped;
cmSystemTools::ExpandListArgument(this->SkipUic, uicSkipped);
for (std::vector<std::string>::const_iterator it = sourceFiles.begin();
it != sourceFiles.end();
++it)
{
const bool skipUic = std::find(uicSkipped.begin(), uicSkipped.end(), *it)
!= uicSkipped.end();
std::map<std::string, std::vector<std::string> >& uiFiles
= skipUic ? skippedUis : includedUis;
const std::string &absFilename = *it;
if (this->Verbose)
{
std::cout << "AUTOGEN: Checking " << absFilename << std::endl;
}
if (this->RelaxedMode)
{
this->ParseCppFile(absFilename, headerExtensions, includedMocs,
uiFiles);
}
else
{
this->StrictParseCppFile(absFilename, headerExtensions, includedMocs,
uiFiles);
}
this->SearchHeadersForCppFile(absFilename, headerExtensions, headerFiles);
}
{
std::vector<std::string> mocSkipped;
cmSystemTools::ExpandListArgument(this->SkipMoc, mocSkipped);
for (std::vector<std::string>::const_iterator it = mocSkipped.begin();
it != mocSkipped.end();
++it)
{
if (std::find(uicSkipped.begin(), uicSkipped.end(), *it)
!= uicSkipped.end())
{
const std::string &absFilename = *it;
if (this->Verbose)
{
std::cout << "AUTOGEN: Checking " << absFilename << std::endl;
}
this->ParseForUic(absFilename, includedUis);
}
}
}
std::vector<std::string> headerFilesVec;
cmSystemTools::ExpandListArgument(this->Headers, headerFilesVec);
headerFiles.insert(headerFilesVec.begin(), headerFilesVec.end());
// key = moc source filepath, value = moc output filename
std::map<std::string, std::string> notIncludedMocs;
this->ParseHeaders(headerFiles, includedMocs, notIncludedMocs, includedUis);
// run moc on all the moc's that are #included in source files
2011-08-10 22:45:22 +04:00
for(std::map<std::string, std::string>::const_iterator
it = includedMocs.begin();
it != includedMocs.end();
++it)
{
this->GenerateMoc(it->first, it->second);
}
for(std::map<std::string, std::vector<std::string> >::const_iterator
it = includedUis.begin();
it != includedUis.end();
++it)
{
for (std::vector<std::string>::const_iterator nit = it->second.begin();
nit != it->second.end();
++nit)
{
this->GenerateUi(it->first, *nit);
}
}
if(!this->RccExecutable.empty())
{
this->GenerateQrc();
}
cmsys_ios::stringstream outStream;
outStream << "/* This file is autogenerated, do not edit*/\n";
bool automocCppChanged = false;
if (notIncludedMocs.empty())
{
outStream << "enum some_compilers { need_more_than_nothing };\n";
}
else
{
2011-08-10 22:45:22 +04:00
// run moc on the remaining headers and include them in
// the _automoc.cpp file
for(std::map<std::string, std::string>::const_iterator
it = notIncludedMocs.begin();
it != notIncludedMocs.end();
++it)
{
bool mocSuccess = this->GenerateMoc(it->first, it->second);
if (mocSuccess)
{
automocCppChanged = true;
}
outStream << "#include \"" << it->second << "\"\n";
}
}
if (this->RunMocFailed)
{
std::cerr << "moc failed..." << std::endl;
return false;
}
if (this->RunUicFailed)
{
std::cerr << "uic failed..." << std::endl;
return false;
}
if (this->RunRccFailed)
{
std::cerr << "rcc failed..." << std::endl;
return false;
}
outStream.flush();
std::string automocSource = outStream.str();
if (!automocCppChanged)
{
// compare contents of the _automoc.cpp file
const std::string oldContents = ReadAll(this->OutMocCppFilename);
if (oldContents == automocSource)
{
// nothing changed: don't touch the _automoc.cpp file
return true;
}
}
// source file that includes all remaining moc files (_automoc.cpp file)
cmsys::ofstream outfile;
outfile.open(this->OutMocCppFilename.c_str(),
std::ios::trunc);
outfile << automocSource;
outfile.close();
return true;
}
void cmQtAutoGenerators::ParseCppFile(const std::string& absFilename,
const std::vector<std::string>& headerExtensions,
std::map<std::string, std::string>& includedMocs,
std::map<std::string, std::vector<std::string> > &includedUis)
{
cmsys::RegularExpression mocIncludeRegExp(
"[\n][ \t]*#[ \t]*include[ \t]+"
"[\"<](([^ \">]+/)?moc_[^ \">/]+\\.cpp|[^ \">]+\\.moc)[\">]");
const std::string contentsString = ReadAll(absFilename);
if (contentsString.empty())
{
std::cerr << "AUTOGEN: warning: " << absFilename << ": file is empty\n"
<< std::endl;
return;
}
this->ParseForUic(absFilename, contentsString, includedUis);
if (this->MocExecutable.empty())
{
return;
}
const std::string absPath = cmsys::SystemTools::GetFilenamePath(
cmsys::SystemTools::GetRealPath(absFilename)) + '/';
const std::string scannedFileBasename = cmsys::SystemTools::
GetFilenameWithoutLastExtension(absFilename);
std::string macroName;
const bool requiresMoc = requiresMocing(contentsString, macroName);
bool dotMocIncluded = false;
bool mocUnderscoreIncluded = false;
std::string ownMocUnderscoreFile;
std::string ownDotMocFile;
std::string ownMocHeaderFile;
2011-08-19 22:16:53 +04:00
std::string::size_type matchOffset = 0;
2012-11-07 20:13:09 +04:00
// first a simple string check for "moc" is *much* faster than the regexp,
// and if the string search already fails, we don't have to try the
// expensive regexp
if ((strstr(contentsString.c_str(), "moc") != NULL)
&& (mocIncludeRegExp.find(contentsString)))
{
// for every moc include in the file
do
{
const std::string currentMoc = mocIncludeRegExp.match(1);
//std::cout << "found moc include: " << currentMoc << std::endl;
std::string basename = cmsys::SystemTools::
GetFilenameWithoutLastExtension(currentMoc);
const bool moc_style = cmHasLiteralPrefix(basename, "moc_");
// If the moc include is of the moc_foo.cpp style we expect
// the Q_OBJECT class declaration in a header file.
// If the moc include is of the foo.moc style we need to look for
// a Q_OBJECT macro in the current source file, if it contains the
// macro we generate the moc file from the source file.
// Q_OBJECT
if (moc_style)
{
// basename should be the part of the moc filename used for
// finding the correct header, so we need to remove the moc_ part
basename = basename.substr(4);
std::string mocSubDir = extractSubDir(absPath, currentMoc);
std::string headerToMoc = findMatchingHeader(
absPath, mocSubDir, basename, headerExtensions);
if (!headerToMoc.empty())
{
includedMocs[headerToMoc] = currentMoc;
if (basename == scannedFileBasename)
{
mocUnderscoreIncluded = true;
ownMocUnderscoreFile = currentMoc;
ownMocHeaderFile = headerToMoc;
}
}
else
{
2014-02-17 14:02:28 +04:00
std::cerr << "AUTOGEN: error: " << absFilename << ": The file "
<< "includes the moc file \"" << currentMoc << "\", "
<< "but could not find header \"" << basename
<< '{' << this->Join(headerExtensions, ',') << "}\" ";
if (mocSubDir.empty())
{
std::cerr << "in " << absPath << "\n" << std::endl;
}
else
{
std::cerr << "neither in " << absPath
<< " nor in " << mocSubDir << "\n" << std::endl;
}
::exit(EXIT_FAILURE);
}
}
else
{
std::string fileToMoc = absFilename;
if ((basename != scannedFileBasename) || (requiresMoc==false))
{
std::string mocSubDir = extractSubDir(absPath, currentMoc);
std::string headerToMoc = findMatchingHeader(
absPath, mocSubDir, basename, headerExtensions);
if (!headerToMoc.empty())
{
// this is for KDE4 compatibility:
fileToMoc = headerToMoc;
if ((requiresMoc==false) &&(basename==scannedFileBasename))
{
std::cerr << "AUTOGEN: warning: " << absFilename << ": The file "
"includes the moc file \"" << currentMoc <<
"\", but does not contain a " << macroName
<< " macro. Running moc on "
<< "\"" << headerToMoc << "\" ! Include \"moc_"
<< basename << ".cpp\" for a compatiblity with "
"strict mode (see CMAKE_AUTOMOC_RELAXED_MODE).\n"
<< std::endl;
}
else
{
std::cerr << "AUTOGEN: warning: " << absFilename << ": The file "
"includes the moc file \"" << currentMoc <<
"\" instead of \"moc_" << basename << ".cpp\". "
"Running moc on "
<< "\"" << headerToMoc << "\" ! Include \"moc_"
<< basename << ".cpp\" for compatiblity with "
"strict mode (see CMAKE_AUTOMOC_RELAXED_MODE).\n"
<< std::endl;
}
}
else
{
std::cerr <<"AUTOGEN: error: " << absFilename << ": The file "
"includes the moc file \"" << currentMoc <<
"\", which seems to be the moc file from a different "
"source file. CMake also could not find a matching "
"header.\n" << std::endl;
::exit(EXIT_FAILURE);
}
}
else
{
dotMocIncluded = true;
ownDotMocFile = currentMoc;
}
includedMocs[fileToMoc] = currentMoc;
}
matchOffset += mocIncludeRegExp.end();
} while(mocIncludeRegExp.find(contentsString.c_str() + matchOffset));
}
// In this case, check whether the scanned file itself contains a Q_OBJECT.
// If this is the case, the moc_foo.cpp should probably be generated from
// foo.cpp instead of foo.h, because otherwise it won't build.
// But warn, since this is not how it is supposed to be used.
if ((dotMocIncluded == false) && (requiresMoc == true))
{
if (mocUnderscoreIncluded == true)
{
// this is for KDE4 compatibility:
std::cerr << "AUTOGEN: warning: " << absFilename << ": The file "
<< "contains a " << macroName << " macro, but does not "
"include "
<< "\"" << scannedFileBasename << ".moc\", but instead "
"includes "
<< "\"" << ownMocUnderscoreFile << "\". Running moc on "
<< "\"" << absFilename << "\" ! Better include \""
<< scannedFileBasename << ".moc\" for compatiblity with "
"strict mode (see CMAKE_AUTOMOC_RELAXED_MODE).\n"
<< std::endl;
includedMocs[absFilename] = ownMocUnderscoreFile;
includedMocs.erase(ownMocHeaderFile);
}
else
{
// otherwise always error out since it will not compile:
std::cerr << "AUTOGEN: error: " << absFilename << ": The file "
<< "contains a " << macroName << " macro, but does not "
"include "
<< "\"" << scannedFileBasename << ".moc\" !\n"
<< std::endl;
::exit(EXIT_FAILURE);
}
}
}
void cmQtAutoGenerators::StrictParseCppFile(const std::string& absFilename,
const std::vector<std::string>& headerExtensions,
std::map<std::string, std::string>& includedMocs,
std::map<std::string, std::vector<std::string> >& includedUis)
{
cmsys::RegularExpression mocIncludeRegExp(
"[\n][ \t]*#[ \t]*include[ \t]+"
"[\"<](([^ \">]+/)?moc_[^ \">/]+\\.cpp|[^ \">]+\\.moc)[\">]");
const std::string contentsString = ReadAll(absFilename);
if (contentsString.empty())
{
std::cerr << "AUTOGEN: warning: " << absFilename << ": file is empty\n"
<< std::endl;
return;
}
this->ParseForUic(absFilename, contentsString, includedUis);
if (this->MocExecutable.empty())
{
return;
}
const std::string absPath = cmsys::SystemTools::GetFilenamePath(
cmsys::SystemTools::GetRealPath(absFilename)) + '/';
const std::string scannedFileBasename = cmsys::SystemTools::
GetFilenameWithoutLastExtension(absFilename);
bool dotMocIncluded = false;
std::string::size_type matchOffset = 0;
2012-11-07 20:13:09 +04:00
// first a simple string check for "moc" is *much* faster than the regexp,
// and if the string search already fails, we don't have to try the
// expensive regexp
if ((strstr(contentsString.c_str(), "moc") != NULL)
&& (mocIncludeRegExp.find(contentsString)))
{
// for every moc include in the file
do
{
const std::string currentMoc = mocIncludeRegExp.match(1);
std::string basename = cmsys::SystemTools::
GetFilenameWithoutLastExtension(currentMoc);
const bool mocUnderscoreStyle = cmHasLiteralPrefix(basename, "moc_");
// If the moc include is of the moc_foo.cpp style we expect
// the Q_OBJECT class declaration in a header file.
// If the moc include is of the foo.moc style we need to look for
// a Q_OBJECT macro in the current source file, if it contains the
// macro we generate the moc file from the source file.
if (mocUnderscoreStyle)
{
// basename should be the part of the moc filename used for
// finding the correct header, so we need to remove the moc_ part
basename = basename.substr(4);
std::string mocSubDir = extractSubDir(absPath, currentMoc);
std::string headerToMoc = findMatchingHeader(
absPath, mocSubDir, basename, headerExtensions);
if (!headerToMoc.empty())
{
includedMocs[headerToMoc] = currentMoc;
}
else
{
std::cerr << "AUTOGEN: error: " << absFilename << " The file "
<< "includes the moc file \"" << currentMoc << "\", "
<< "but could not find header \"" << basename
<< '{' << this->Join(headerExtensions, ',') << "}\" ";
if (mocSubDir.empty())
{
std::cerr << "in " << absPath << "\n" << std::endl;
}
else
{
std::cerr << "neither in " << absPath
<< " nor in " << mocSubDir << "\n" << std::endl;
}
::exit(EXIT_FAILURE);
}
}
else
{
if (basename != scannedFileBasename)
{
std::cerr <<"AUTOGEN: error: " << absFilename << ": The file "
"includes the moc file \"" << currentMoc <<
"\", which seems to be the moc file from a different "
"source file. This is not supported. "
"Include \"" << scannedFileBasename << ".moc\" to run "
"moc on this source file.\n" << std::endl;
::exit(EXIT_FAILURE);
}
dotMocIncluded = true;
includedMocs[absFilename] = currentMoc;
}
matchOffset += mocIncludeRegExp.end();
} while(mocIncludeRegExp.find(contentsString.c_str() + matchOffset));
}
// In this case, check whether the scanned file itself contains a Q_OBJECT.
// If this is the case, the moc_foo.cpp should probably be generated from
// foo.cpp instead of foo.h, because otherwise it won't build.
// But warn, since this is not how it is supposed to be used.
std::string macroName;
if ((dotMocIncluded == false) && (requiresMocing(contentsString,
macroName)))
{
// otherwise always error out since it will not compile:
std::cerr << "AUTOGEN: error: " << absFilename << ": The file "
<< "contains a " << macroName << " macro, but does not include "
<< "\"" << scannedFileBasename << ".moc\" !\n"
<< std::endl;
::exit(EXIT_FAILURE);
}
}
void cmQtAutoGenerators::ParseForUic(const std::string& absFilename,
std::map<std::string, std::vector<std::string> >& includedUis)
{
if (this->UicExecutable.empty())
{
return;
}
const std::string contentsString = ReadAll(absFilename);
if (contentsString.empty())
{
std::cerr << "AUTOGEN: warning: " << absFilename << ": file is empty\n"
<< std::endl;
return;
}
this->ParseForUic(absFilename, contentsString, includedUis);
}
void cmQtAutoGenerators::ParseForUic(const std::string& absFilename,
const std::string& contentsString,
std::map<std::string, std::vector<std::string> >& includedUis)
{
if (this->UicExecutable.empty())
{
return;
}
cmsys::RegularExpression uiIncludeRegExp(
"[\n][ \t]*#[ \t]*include[ \t]+"
"[\"<](([^ \">]+/)?ui_[^ \">/]+\\.h)[\">]");
std::string::size_type matchOffset = 0;
const std::string realName =
cmsys::SystemTools::GetRealPath(absFilename);
matchOffset = 0;
if ((strstr(contentsString.c_str(), "ui_") != NULL)
&& (uiIncludeRegExp.find(contentsString)))
{
do
{
const std::string currentUi = uiIncludeRegExp.match(1);
std::string basename = cmsys::SystemTools::
GetFilenameWithoutLastExtension(currentUi);
// basename should be the part of the ui filename used for
// finding the correct header, so we need to remove the ui_ part
basename = basename.substr(3);
includedUis[realName].push_back(basename);
matchOffset += uiIncludeRegExp.end();
} while(uiIncludeRegExp.find(contentsString.c_str() + matchOffset));
}
}
void
cmQtAutoGenerators::SearchHeadersForCppFile(const std::string& absFilename,
const std::vector<std::string>& headerExtensions,
std::set<std::string>& absHeaders)
{
// search for header files and private header files we may need to moc:
const std::string basename =
cmsys::SystemTools::GetFilenameWithoutLastExtension(absFilename);
const std::string absPath = cmsys::SystemTools::GetFilenamePath(
cmsys::SystemTools::GetRealPath(absFilename)) + '/';
for(std::vector<std::string>::const_iterator ext = headerExtensions.begin();
ext != headerExtensions.end();
++ext)
{
const std::string headerName = absPath + basename + "." + (*ext);
if (cmsys::SystemTools::FileExists(headerName.c_str()))
{
absHeaders.insert(headerName);
break;
}
}
for(std::vector<std::string>::const_iterator ext = headerExtensions.begin();
ext != headerExtensions.end();
++ext)
{
const std::string privateHeaderName = absPath+basename+"_p."+(*ext);
if (cmsys::SystemTools::FileExists(privateHeaderName.c_str()))
{
absHeaders.insert(privateHeaderName);
break;
}
}
}
void cmQtAutoGenerators::ParseHeaders(const std::set<std::string>& absHeaders,
const std::map<std::string, std::string>& includedMocs,
std::map<std::string, std::string>& notIncludedMocs,
std::map<std::string, std::vector<std::string> >& includedUis)
{
for(std::set<std::string>::const_iterator hIt=absHeaders.begin();
hIt!=absHeaders.end();
++hIt)
{
const std::string& headerName = *hIt;
const std::string contents = ReadAll(headerName);
if (!this->MocExecutable.empty()
&& includedMocs.find(headerName) == includedMocs.end())
{
if (this->Verbose)
{
std::cout << "AUTOGEN: Checking " << headerName << std::endl;
}
const std::string basename = cmsys::SystemTools::
GetFilenameWithoutLastExtension(headerName);
const std::string currentMoc = "moc_" + basename + ".cpp";
std::string macroName;
if (requiresMocing(contents, macroName))
{
//std::cout << "header contains Q_OBJECT macro";
notIncludedMocs[headerName] = currentMoc;
}
}
this->ParseForUic(headerName, contents, includedUis);
}
}
bool cmQtAutoGenerators::GenerateMoc(const std::string& sourceFile,
const std::string& mocFileName)
{
const std::string mocFilePath = this->Builddir + mocFileName;
int sourceNewerThanMoc = 0;
bool success = cmsys::SystemTools::FileTimeCompare(sourceFile,
mocFilePath,
&sourceNewerThanMoc);
if (this->GenerateAll || !success || sourceNewerThanMoc >= 0)
{
// make sure the directory for the resulting moc file exists
std::string mocDir = mocFilePath.substr(0, mocFilePath.rfind('/'));
if (!cmsys::SystemTools::FileExists(mocDir.c_str(), false))
{
cmsys::SystemTools::MakeDirectory(mocDir.c_str());
}
2011-08-14 18:43:04 +04:00
std::string msg = "Generating ";
msg += mocFileName;
cmSystemTools::MakefileColorEcho(cmsysTerminal_Color_ForegroundBlue
|cmsysTerminal_Color_ForegroundBold,
msg.c_str(), true, this->ColorOutput);
std::vector<std::string> command;
command.push_back(this->MocExecutable);
command.insert(command.end(),
this->MocIncludes.begin(), this->MocIncludes.end());
command.insert(command.end(),
this->MocDefinitions.begin(), this->MocDefinitions.end());
command.insert(command.end(),
this->MocOptions.begin(), this->MocOptions.end());
#ifdef _WIN32
command.push_back("-DWIN32");
#endif
command.push_back("-o");
command.push_back(mocFilePath);
command.push_back(sourceFile);
if (this->Verbose)
{
for(std::vector<std::string>::const_iterator cmdIt = command.begin();
2011-08-17 02:49:12 +04:00
cmdIt != command.end();
++cmdIt)
{
2011-08-17 02:49:12 +04:00
std::cout << *cmdIt << " ";
}
2011-08-14 19:17:01 +04:00
std::cout << std::endl;
}
std::string output;
int retVal = 0;
bool result = cmSystemTools::RunSingleCommand(command, &output, &output,
&retVal);
if (!result || retVal)
{
std::cerr << "AUTOGEN: error: process for " << mocFilePath <<" failed:\n"
2011-08-10 22:45:22 +04:00
<< output << std::endl;
this->RunMocFailed = true;
cmSystemTools::RemoveFile(mocFilePath);
}
return true;
}
return false;
}
bool cmQtAutoGenerators::GenerateUi(const std::string& realName,
const std::string& uiFileName)
{
if (!cmsys::SystemTools::FileExists(this->Builddir.c_str(), false))
{
cmsys::SystemTools::MakeDirectory(this->Builddir.c_str());
}
const std::string path = cmsys::SystemTools::GetFilenamePath(
realName) + '/';
std::string ui_output_file = "ui_" + uiFileName + ".h";
std::string ui_input_file = path + uiFileName + ".ui";
int sourceNewerThanUi = 0;
bool success = cmsys::SystemTools::FileTimeCompare(ui_input_file,
this->Builddir + ui_output_file,
&sourceNewerThanUi);
if (this->GenerateAll || !success || sourceNewerThanUi >= 0)
{
std::string msg = "Generating ";
msg += ui_output_file;
cmSystemTools::MakefileColorEcho(cmsysTerminal_Color_ForegroundBlue
|cmsysTerminal_Color_ForegroundBold,
msg.c_str(), true, this->ColorOutput);
std::vector<std::string> command;
command.push_back(this->UicExecutable);
std::vector<std::string> opts = this->UicTargetOptions;
std::map<std::string, std::string>::const_iterator optionIt
= this->UicOptions.find(ui_input_file);
if (optionIt != this->UicOptions.end())
{
std::vector<std::string> fileOpts;
cmSystemTools::ExpandListArgument(optionIt->second, fileOpts);
this->MergeUicOptions(opts, fileOpts, this->QtMajorVersion == "5");
}
command.insert(command.end(), opts.begin(), opts.end());
command.push_back("-o");
command.push_back(this->Builddir + ui_output_file);
command.push_back(ui_input_file);
if (this->Verbose)
{
for(std::vector<std::string>::const_iterator cmdIt = command.begin();
cmdIt != command.end();
++cmdIt)
{
std::cout << *cmdIt << " ";
}
std::cout << std::endl;
}
std::string output;
int retVal = 0;
bool result = cmSystemTools::RunSingleCommand(command, &output, &output,
&retVal);
if (!result || retVal)
{
std::cerr << "AUTOUIC: error: process for " << ui_output_file <<
" needed by\n \"" << realName << "\"\nfailed:\n" << output
<< std::endl;
this->RunUicFailed = true;
cmSystemTools::RemoveFile(ui_output_file);
return false;
}
return true;
}
return false;
}
bool cmQtAutoGenerators::InputFilesNewerThanQrc(const std::string& qrcFile,
const std::string& rccOutput)
{
std::vector<std::string> const& files = this->RccInputs[qrcFile];
for (std::vector<std::string>::const_iterator it = files.begin();
it != files.end(); ++it)
{
int inputNewerThanQrc = 0;
2014-11-23 13:05:50 +03:00
bool success = cmsys::SystemTools::FileTimeCompare(*it,
rccOutput,
&inputNewerThanQrc);
if (!success || inputNewerThanQrc >= 0)
{
return true;
}
}
return false;
}
bool cmQtAutoGenerators::GenerateQrc()
{
for(std::vector<std::string>::const_iterator si = this->RccSources.begin();
si != this->RccSources.end(); ++si)
{
std::string ext = cmsys::SystemTools::GetFilenameLastExtension(*si);
if (ext != ".qrc")
{
continue;
}
std::vector<std::string> command;
command.push_back(this->RccExecutable);
std::string basename = cmsys::SystemTools::
GetFilenameWithoutLastExtension(*si);
std::string rcc_output_file = this->Builddir
+ "CMakeFiles/" + this->OriginTargetName
+ ".dir/qrc_" + basename + ".cpp";
int sourceNewerThanQrc = 0;
bool generateQrc = !cmsys::SystemTools::FileTimeCompare(*si,
2014-11-23 13:05:50 +03:00
rcc_output_file,
&sourceNewerThanQrc);
generateQrc = generateQrc || (sourceNewerThanQrc >= 0);
generateQrc = generateQrc || this->InputFilesNewerThanQrc(*si,
rcc_output_file);
if (this->GenerateAll || generateQrc)
{
std::map<std::string, std::string>::const_iterator optionIt
= this->RccOptions.find(*si);
if (optionIt != this->RccOptions.end())
{
cmSystemTools::ExpandListArgument(optionIt->second, command);
}
command.push_back("-name");
command.push_back(basename);
command.push_back("-o");
command.push_back(rcc_output_file);
command.push_back(*si);
if (this->Verbose)
{
for(std::vector<std::string>::const_iterator cmdIt = command.begin();
cmdIt != command.end();
++cmdIt)
{
std::cout << *cmdIt << " ";
}
std::cout << std::endl;
}
std::string output;
int retVal = 0;
bool result = cmSystemTools::RunSingleCommand(command, &output, &output,
&retVal);
if (!result || retVal)
{
std::cerr << "AUTORCC: error: process for " << rcc_output_file <<
" failed:\n" << output << std::endl;
this->RunRccFailed = true;
cmSystemTools::RemoveFile(rcc_output_file);
return false;
}
}
}
return true;
}
std::string cmQtAutoGenerators::Join(const std::vector<std::string>& lst,
char separator)
{
if (lst.empty())
{
return "";
}
std::string result;
for (std::vector<std::string>::const_iterator it = lst.begin();
it != lst.end();
++it)
{
result += "." + (*it) + separator;
}
result.erase(result.end() - 1);
return result;
}
bool cmQtAutoGenerators::StartsWith(const std::string& str,
const std::string& with)
{
return (str.substr(0, with.length()) == with);
}
bool cmQtAutoGenerators::EndsWith(const std::string& str,
const std::string& with)
{
if (with.length() > (str.length()))
{
return false;
}
return (str.substr(str.length() - with.length(), with.length()) == with);
}