527 lines
18 KiB
C++
527 lines
18 KiB
C++
/****************************************************************************
|
|
**
|
|
** Copyright (C) 2016 The Qt Company Ltd.
|
|
** Contact: https://www.qt.io/licensing/
|
|
**
|
|
** This file is part of the qmake application of the Qt Toolkit.
|
|
**
|
|
** $QT_BEGIN_LICENSE:GPL-EXCEPT$
|
|
** Commercial License Usage
|
|
** Licensees holding valid commercial Qt licenses may use this file in
|
|
** accordance with the commercial license agreement provided with the
|
|
** Software or, alternatively, in accordance with the terms contained in
|
|
** a written agreement between you and The Qt Company. For licensing terms
|
|
** and conditions see https://www.qt.io/terms-conditions. For further
|
|
** information use the contact form at https://www.qt.io/contact-us.
|
|
**
|
|
** GNU General Public License Usage
|
|
** Alternatively, this file may be used under the terms of the GNU
|
|
** General Public License version 3 as published by the Free Software
|
|
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
|
|
** included in the packaging of this file. Please review the following
|
|
** information to ensure the GNU General Public License requirements will
|
|
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
|
|
**
|
|
** $QT_END_LICENSE$
|
|
**
|
|
****************************************************************************/
|
|
|
|
#include "metamakefile.h"
|
|
#include "qdir.h"
|
|
#include "qdebug.h"
|
|
#include "makefile.h"
|
|
#include "project.h"
|
|
#include "cachekeys.h"
|
|
|
|
#include <algorithm>
|
|
#include <iterator>
|
|
#include <utility>
|
|
|
|
#define BUILDSMETATYPE 1
|
|
#define SUBDIRSMETATYPE 2
|
|
|
|
QT_BEGIN_NAMESPACE
|
|
|
|
MetaMakefileGenerator::~MetaMakefileGenerator()
|
|
{
|
|
if(own_project)
|
|
delete project;
|
|
}
|
|
|
|
#ifndef QT_QMAKE_PARSER_ONLY
|
|
|
|
class BuildsMetaMakefileGenerator : public MetaMakefileGenerator
|
|
{
|
|
private:
|
|
bool init_flag;
|
|
struct Build {
|
|
QString name, build;
|
|
MakefileGenerator *makefile;
|
|
};
|
|
QList<Build *> makefiles;
|
|
void clearBuilds();
|
|
MakefileGenerator *processBuild(const ProString &);
|
|
void accumulateVariableFromBuilds(const ProKey &name, Build *build) const;
|
|
void checkForConflictingTargets() const;
|
|
|
|
public:
|
|
|
|
BuildsMetaMakefileGenerator(QMakeProject *p, const QString &n, bool op) : MetaMakefileGenerator(p, n, op), init_flag(false) { }
|
|
~BuildsMetaMakefileGenerator() { clearBuilds(); }
|
|
|
|
bool init() override;
|
|
int type() const override { return BUILDSMETATYPE; }
|
|
bool write() override;
|
|
};
|
|
|
|
void
|
|
BuildsMetaMakefileGenerator::clearBuilds()
|
|
{
|
|
for(int i = 0; i < makefiles.count(); i++) {
|
|
Build *build = makefiles[i];
|
|
if(QMakeProject *p = build->makefile->projectFile()) {
|
|
if(p != project)
|
|
delete p;
|
|
}
|
|
delete build->makefile;
|
|
delete build;
|
|
}
|
|
makefiles.clear();
|
|
}
|
|
|
|
bool
|
|
BuildsMetaMakefileGenerator::init()
|
|
{
|
|
if(init_flag)
|
|
return false;
|
|
init_flag = true;
|
|
|
|
const ProStringList &builds = project->values("BUILDS");
|
|
bool use_single_build = builds.isEmpty();
|
|
if(builds.count() > 1 && Option::output.fileName() == "-") {
|
|
use_single_build = true;
|
|
warn_msg(WarnLogic, "Cannot direct to stdout when using multiple BUILDS.");
|
|
}
|
|
if(!use_single_build) {
|
|
for(int i = 0; i < builds.count(); i++) {
|
|
ProString build = builds[i];
|
|
MakefileGenerator *makefile = processBuild(build);
|
|
if(!makefile)
|
|
return false;
|
|
if(!makefile->supportsMetaBuild()) {
|
|
warn_msg(WarnLogic, "QMAKESPEC does not support multiple BUILDS.");
|
|
clearBuilds();
|
|
use_single_build = true;
|
|
break;
|
|
} else {
|
|
Build *b = new Build;
|
|
b->name = name;
|
|
if(builds.count() != 1)
|
|
b->build = build.toQString();
|
|
b->makefile = makefile;
|
|
makefiles += b;
|
|
}
|
|
}
|
|
}
|
|
if(use_single_build) {
|
|
Build *build = new Build;
|
|
build->name = name;
|
|
build->makefile = createMakefileGenerator(project, false);
|
|
if (build->makefile){
|
|
makefiles += build;
|
|
}else {
|
|
delete build;
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
BuildsMetaMakefileGenerator::write()
|
|
{
|
|
Build *glue = nullptr;
|
|
if(!makefiles.isEmpty() && !makefiles.first()->build.isNull()
|
|
&& Option::qmake_mode != Option::QMAKE_GENERATE_PRL) {
|
|
glue = new Build;
|
|
glue->name = name;
|
|
glue->makefile = createMakefileGenerator(project, true);
|
|
makefiles += glue;
|
|
}
|
|
|
|
bool ret = true;
|
|
const QString &output_name = Option::output.fileName();
|
|
for(int i = 0; ret && i < makefiles.count(); i++) {
|
|
Option::output.setFileName(output_name);
|
|
Build *build = makefiles[i];
|
|
|
|
bool using_stdout = false;
|
|
if(build->makefile && (Option::qmake_mode == Option::QMAKE_GENERATE_MAKEFILE ||
|
|
Option::qmake_mode == Option::QMAKE_GENERATE_PROJECT)
|
|
&& (!build->makefile->supportsMergedBuilds()
|
|
|| (build->makefile->supportsMergedBuilds() && (!glue || build == glue)))) {
|
|
//open output
|
|
if(!(Option::output.isOpen())) {
|
|
if(Option::output.fileName() == "-") {
|
|
Option::output.setFileName("");
|
|
Option::output_dir = qmake_getpwd();
|
|
Option::output.open(stdout, QIODevice::WriteOnly | QIODevice::Text);
|
|
using_stdout = true;
|
|
} else {
|
|
if(Option::output.fileName().isEmpty() &&
|
|
Option::qmake_mode == Option::QMAKE_GENERATE_MAKEFILE)
|
|
Option::output.setFileName(project->first("QMAKE_MAKEFILE").toQString());
|
|
QString build_name = build->name;
|
|
if(!build->build.isEmpty()) {
|
|
if(!build_name.isEmpty())
|
|
build_name += ".";
|
|
build_name += build->build;
|
|
}
|
|
if(!build->makefile->openOutput(Option::output, build_name)) {
|
|
fprintf(stderr, "Failure to open file: %s\n",
|
|
Option::output.fileName().isEmpty() ? "(stdout)" :
|
|
Option::output.fileName().toLatin1().constData());
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
using_stdout = true; //kind of..
|
|
}
|
|
|
|
if(!build->makefile) {
|
|
ret = false;
|
|
} else if(build == glue) {
|
|
checkForConflictingTargets();
|
|
accumulateVariableFromBuilds("QMAKE_INTERNAL_INCLUDED_FILES", build);
|
|
ret = build->makefile->writeProjectMakefile();
|
|
} else {
|
|
ret = build->makefile->write();
|
|
if (glue && glue->makefile->supportsMergedBuilds())
|
|
ret = glue->makefile->mergeBuildProject(build->makefile);
|
|
}
|
|
if(!using_stdout) {
|
|
Option::output.close();
|
|
if(!ret)
|
|
Option::output.remove();
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
MakefileGenerator
|
|
*BuildsMetaMakefileGenerator::processBuild(const ProString &build)
|
|
{
|
|
if(project) {
|
|
debug_msg(1, "Meta Generator: Parsing '%s' for build [%s].",
|
|
project->projectFile().toLatin1().constData(),build.toLatin1().constData());
|
|
|
|
//initialize the base
|
|
ProValueMap basevars;
|
|
ProStringList basecfgs = project->values(ProKey(build + ".CONFIG"));
|
|
basecfgs += build;
|
|
basecfgs += "build_pass";
|
|
basevars["BUILD_PASS"] = ProStringList(build);
|
|
ProStringList buildname = project->values(ProKey(build + ".name"));
|
|
basevars["BUILD_NAME"] = (buildname.isEmpty() ? ProStringList(build) : buildname);
|
|
|
|
//create project
|
|
QMakeProject *build_proj = new QMakeProject;
|
|
build_proj->setExtraVars(basevars);
|
|
build_proj->setExtraConfigs(basecfgs);
|
|
|
|
if (build_proj->read(project->projectFile()))
|
|
return createMakefileGenerator(build_proj);
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
void BuildsMetaMakefileGenerator::accumulateVariableFromBuilds(const ProKey &name, Build *dst) const
|
|
{
|
|
ProStringList &values = dst->makefile->projectFile()->values(name);
|
|
for (auto build : makefiles) {
|
|
if (build != dst)
|
|
values += build->makefile->projectFile()->values(name);
|
|
}
|
|
values.removeDuplicates();
|
|
}
|
|
|
|
void BuildsMetaMakefileGenerator::checkForConflictingTargets() const
|
|
{
|
|
if (makefiles.count() < 3) {
|
|
// Checking for conflicts only makes sense if we have more than one BUILD,
|
|
// and the last entry in makefiles is the "glue" Build.
|
|
return;
|
|
}
|
|
if (!project->isActiveConfig("build_all")) {
|
|
// Only complain if we're about to build all configurations.
|
|
return;
|
|
}
|
|
using TargetInfo = std::pair<Build *, ProString>;
|
|
QVector<TargetInfo> targets;
|
|
const int last = makefiles.count() - 1;
|
|
targets.resize(last);
|
|
for (int i = 0; i < last; ++i) {
|
|
Build *b = makefiles.at(i);
|
|
auto mkf = b->makefile;
|
|
auto prj = mkf->projectFile();
|
|
targets[i] = std::make_pair(b, prj->first(mkf->fullTargetVariable()));
|
|
}
|
|
std::stable_sort(targets.begin(), targets.end(),
|
|
[](const TargetInfo &lhs, const TargetInfo &rhs)
|
|
{
|
|
return lhs.second < rhs.second;
|
|
});
|
|
for (auto prev = targets.begin(), it = std::next(prev); it != targets.end(); ++prev, ++it) {
|
|
if (prev->second == it->second) {
|
|
warn_msg(WarnLogic, "Targets of builds '%s' and '%s' conflict: %s.",
|
|
qPrintable(prev->first->build),
|
|
qPrintable(it->first->build),
|
|
qPrintable(prev->second.toQString()));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
class SubdirsMetaMakefileGenerator : public MetaMakefileGenerator
|
|
{
|
|
protected:
|
|
bool init_flag;
|
|
struct Subdir {
|
|
Subdir() : makefile(nullptr), indent(0) { }
|
|
~Subdir() { delete makefile; }
|
|
QString input_dir;
|
|
QString output_dir, output_file;
|
|
MetaMakefileGenerator *makefile;
|
|
int indent;
|
|
};
|
|
QList<Subdir *> subs;
|
|
MakefileGenerator *processBuild(const QString &);
|
|
|
|
public:
|
|
SubdirsMetaMakefileGenerator(QMakeProject *p, const QString &n, bool op) : MetaMakefileGenerator(p, n, op), init_flag(false) { }
|
|
~SubdirsMetaMakefileGenerator();
|
|
|
|
bool init() override;
|
|
int type() const override { return SUBDIRSMETATYPE; }
|
|
bool write() override;
|
|
};
|
|
|
|
bool
|
|
SubdirsMetaMakefileGenerator::init()
|
|
{
|
|
if(init_flag)
|
|
return false;
|
|
init_flag = true;
|
|
bool hasError = false;
|
|
|
|
bool recurse = Option::recursive;
|
|
if (recurse && project->isActiveConfig("dont_recurse"))
|
|
recurse = false;
|
|
if(recurse) {
|
|
QString old_output_dir = Option::output_dir;
|
|
QString old_output = Option::output.fileName();
|
|
QString oldpwd = qmake_getpwd();
|
|
QString thispwd = oldpwd;
|
|
if(!thispwd.endsWith('/'))
|
|
thispwd += '/';
|
|
const ProStringList &subdirs = project->values("SUBDIRS");
|
|
static int recurseDepth = -1;
|
|
++recurseDepth;
|
|
for(int i = 0; i < subdirs.size(); ++i) {
|
|
Subdir *sub = new Subdir;
|
|
sub->indent = recurseDepth;
|
|
|
|
QFileInfo subdir(subdirs.at(i).toQString());
|
|
const ProKey fkey(subdirs.at(i) + ".file");
|
|
if (!project->isEmpty(fkey)) {
|
|
subdir = project->first(fkey).toQString();
|
|
} else {
|
|
const ProKey skey(subdirs.at(i) + ".subdir");
|
|
if (!project->isEmpty(skey))
|
|
subdir = project->first(skey).toQString();
|
|
}
|
|
QString sub_name;
|
|
if(subdir.isDir())
|
|
subdir = QFileInfo(subdir.filePath() + "/" + subdir.fileName() + Option::pro_ext);
|
|
else
|
|
sub_name = subdir.baseName();
|
|
if(!subdir.isRelative()) { //we can try to make it relative
|
|
QString subdir_path = subdir.filePath();
|
|
if(subdir_path.startsWith(thispwd))
|
|
subdir = QFileInfo(subdir_path.mid(thispwd.length()));
|
|
}
|
|
|
|
//handle sub project
|
|
QMakeProject *sub_proj = new QMakeProject;
|
|
for (int ind = 0; ind < sub->indent; ++ind)
|
|
printf(" ");
|
|
sub->input_dir = subdir.absolutePath();
|
|
if(subdir.isRelative() && old_output_dir != oldpwd) {
|
|
sub->output_dir = old_output_dir + (subdir.path() != "." ? "/" + subdir.path() : QString());
|
|
printf("Reading %s [%s]\n", subdir.absoluteFilePath().toLatin1().constData(), sub->output_dir.toLatin1().constData());
|
|
} else { //what about shadow builds?
|
|
sub->output_dir = sub->input_dir;
|
|
printf("Reading %s\n", subdir.absoluteFilePath().toLatin1().constData());
|
|
}
|
|
qmake_setpwd(sub->input_dir);
|
|
Option::output_dir = sub->output_dir;
|
|
bool tmpError = !sub_proj->read(subdir.fileName());
|
|
if (!sub_proj->isEmpty("QMAKE_FAILED_REQUIREMENTS")) {
|
|
fprintf(stderr, "Project file(%s) not recursed because all requirements not met:\n\t%s\n",
|
|
subdir.fileName().toLatin1().constData(),
|
|
sub_proj->values("QMAKE_FAILED_REQUIREMENTS").join(' ').toLatin1().constData());
|
|
delete sub;
|
|
delete sub_proj;
|
|
Option::output_dir = old_output_dir;
|
|
qmake_setpwd(oldpwd);
|
|
continue;
|
|
} else {
|
|
hasError |= tmpError;
|
|
}
|
|
sub->makefile = MetaMakefileGenerator::createMetaGenerator(sub_proj, sub_name);
|
|
const QString output_name = Option::output.fileName();
|
|
Option::output.setFileName(sub->output_file);
|
|
hasError |= !sub->makefile->write();
|
|
delete sub;
|
|
qmakeClearCaches();
|
|
sub = nullptr;
|
|
Option::output.setFileName(output_name);
|
|
Option::output_dir = old_output_dir;
|
|
qmake_setpwd(oldpwd);
|
|
|
|
}
|
|
--recurseDepth;
|
|
Option::output.setFileName(old_output);
|
|
Option::output_dir = old_output_dir;
|
|
qmake_setpwd(oldpwd);
|
|
}
|
|
|
|
Subdir *self = new Subdir;
|
|
self->input_dir = qmake_getpwd();
|
|
self->output_dir = Option::output_dir;
|
|
if(!recurse || (!Option::output.fileName().endsWith(Option::dir_sep) && !QFileInfo(Option::output).isDir()))
|
|
self->output_file = Option::output.fileName();
|
|
self->makefile = new BuildsMetaMakefileGenerator(project, name, false);
|
|
self->makefile->init();
|
|
subs.append(self);
|
|
|
|
return !hasError;
|
|
}
|
|
|
|
bool
|
|
SubdirsMetaMakefileGenerator::write()
|
|
{
|
|
bool ret = true;
|
|
const QString &pwd = qmake_getpwd();
|
|
const QString &output_dir = Option::output_dir;
|
|
const QString &output_name = Option::output.fileName();
|
|
for(int i = 0; ret && i < subs.count(); i++) {
|
|
const Subdir *sub = subs.at(i);
|
|
qmake_setpwd(sub->input_dir);
|
|
Option::output_dir = QFileInfo(sub->output_dir).absoluteFilePath();
|
|
Option::output.setFileName(sub->output_file);
|
|
if(i != subs.count()-1) {
|
|
for (int ind = 0; ind < sub->indent; ++ind)
|
|
printf(" ");
|
|
printf("Writing %s\n", QDir::cleanPath(Option::output_dir+"/"+
|
|
Option::output.fileName()).toLatin1().constData());
|
|
}
|
|
if (!(ret = sub->makefile->write()))
|
|
break;
|
|
//restore because I'm paranoid
|
|
qmake_setpwd(pwd);
|
|
Option::output.setFileName(output_name);
|
|
Option::output_dir = output_dir;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
SubdirsMetaMakefileGenerator::~SubdirsMetaMakefileGenerator()
|
|
{
|
|
for(int i = 0; i < subs.count(); i++)
|
|
delete subs[i];
|
|
subs.clear();
|
|
}
|
|
|
|
//Factory things
|
|
QT_BEGIN_INCLUDE_NAMESPACE
|
|
#include "unixmake.h"
|
|
#include "mingw_make.h"
|
|
#include "projectgenerator.h"
|
|
#include "pbuilder_pbx.h"
|
|
#include "msvc_nmake.h"
|
|
#include "msvc_vcproj.h"
|
|
#include "msvc_vcxproj.h"
|
|
QT_END_INCLUDE_NAMESPACE
|
|
|
|
MakefileGenerator *
|
|
MetaMakefileGenerator::createMakefileGenerator(QMakeProject *proj, bool noIO)
|
|
{
|
|
Option::postProcessProject(proj);
|
|
|
|
MakefileGenerator *mkfile = nullptr;
|
|
if(Option::qmake_mode == Option::QMAKE_GENERATE_PROJECT) {
|
|
mkfile = new ProjectGenerator;
|
|
mkfile->setProjectFile(proj);
|
|
return mkfile;
|
|
}
|
|
|
|
ProString gen = proj->first("MAKEFILE_GENERATOR");
|
|
if(gen.isEmpty()) {
|
|
fprintf(stderr, "MAKEFILE_GENERATOR variable not set as a result of parsing : %s. Possibly qmake was not able to find files included using \"include(..)\" - enable qmake debugging to investigate more.\n",
|
|
proj->projectFile().toLatin1().constData());
|
|
} else if(gen == "UNIX") {
|
|
mkfile = new UnixMakefileGenerator;
|
|
} else if(gen == "MINGW") {
|
|
mkfile = new MingwMakefileGenerator;
|
|
} else if(gen == "PROJECTBUILDER" || gen == "XCODE") {
|
|
#ifdef Q_CC_MSVC
|
|
fprintf(stderr, "Generating Xcode projects is not supported with an MSVC build of Qt.\n");
|
|
#else
|
|
mkfile = new ProjectBuilderMakefileGenerator;
|
|
#endif
|
|
} else if(gen == "MSVC.NET") {
|
|
if (proj->first("TEMPLATE").startsWith("vc"))
|
|
mkfile = new VcprojGenerator;
|
|
else
|
|
mkfile = new NmakeMakefileGenerator;
|
|
} else if(gen == "MSBUILD") {
|
|
// Visual Studio >= v11.0
|
|
if (proj->first("TEMPLATE").startsWith("vc"))
|
|
mkfile = new VcxprojGenerator;
|
|
else
|
|
mkfile = new NmakeMakefileGenerator;
|
|
} else {
|
|
fprintf(stderr, "Unknown generator specified: %s\n", gen.toLatin1().constData());
|
|
}
|
|
if (mkfile) {
|
|
mkfile->setNoIO(noIO);
|
|
mkfile->setProjectFile(proj);
|
|
}
|
|
return mkfile;
|
|
}
|
|
|
|
MetaMakefileGenerator *
|
|
MetaMakefileGenerator::createMetaGenerator(QMakeProject *proj, const QString &name, bool op, bool *success)
|
|
{
|
|
Option::postProcessProject(proj);
|
|
|
|
MetaMakefileGenerator *ret = nullptr;
|
|
if ((Option::qmake_mode == Option::QMAKE_GENERATE_MAKEFILE ||
|
|
Option::qmake_mode == Option::QMAKE_GENERATE_PRL)) {
|
|
if (proj->first("TEMPLATE").endsWith("subdirs"))
|
|
ret = new SubdirsMetaMakefileGenerator(proj, name, op);
|
|
}
|
|
if (!ret)
|
|
ret = new BuildsMetaMakefileGenerator(proj, name, op);
|
|
bool res = ret->init();
|
|
if (success)
|
|
*success = res;
|
|
return ret;
|
|
}
|
|
|
|
#endif // QT_QMAKE_PARSER_ONLY
|
|
|
|
QT_END_NAMESPACE
|