qt6windows7/qmake/library/qmakebuiltins.cpp
2023-10-29 23:33:08 +01:00

1896 lines
72 KiB
C++

// Copyright (C) 2021 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
#include "qmakeevaluator.h"
#include "qmakeevaluator_p.h"
#include "qmakeglobals.h"
#include "qmakeparser.h"
#include "qmakevfs.h"
#include "ioutils.h"
#include <qbytearray.h>
#include <qdir.h>
#include <qfile.h>
#include <qfileinfo.h>
#include <qjsonarray.h>
#include <qjsondocument.h>
#include <qjsonobject.h>
#include <qlist.h>
#include <qregularexpression.h>
#include <qset.h>
#include <qstringlist.h>
#include <qtextstream.h>
#ifdef PROEVALUATOR_THREAD_SAFE
# include <qthreadpool.h>
#endif
#include <qversionnumber.h>
#ifdef Q_OS_WIN
# include <registry_p.h>
#endif
#include <algorithm>
#ifdef Q_OS_UNIX
#include <time.h>
#include <errno.h>
#include <unistd.h>
#include <signal.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <sys/utsname.h>
#else
#include <qt_windows.h>
#endif
#include <stdio.h>
#include <stdlib.h>
#ifdef Q_OS_WIN32
#define QT_POPEN _popen
#define QT_POPEN_READ "rb"
#define QT_PCLOSE _pclose
#else
#define QT_POPEN popen
#define QT_POPEN_READ "r"
#define QT_PCLOSE pclose
#endif
using namespace QMakeInternal;
QT_BEGIN_NAMESPACE
#define fL1S(s) QString::fromLatin1(s)
enum ExpandFunc {
E_INVALID = 0, E_MEMBER, E_STR_MEMBER, E_FIRST, E_TAKE_FIRST, E_LAST, E_TAKE_LAST,
E_SIZE, E_STR_SIZE, E_CAT, E_FROMFILE, E_EVAL, E_LIST, E_SPRINTF, E_FORMAT_NUMBER,
E_NUM_ADD, E_JOIN, E_SPLIT, E_BASENAME, E_DIRNAME, E_SECTION,
E_FIND, E_SYSTEM, E_UNIQUE, E_SORTED, E_REVERSE, E_QUOTE, E_ESCAPE_EXPAND,
E_UPPER, E_LOWER, E_TITLE, E_FILES, E_PROMPT, E_RE_ESCAPE, E_VAL_ESCAPE,
E_REPLACE, E_SORT_DEPENDS, E_RESOLVE_DEPENDS, E_ENUMERATE_VARS,
E_SHADOWED, E_ABSOLUTE_PATH, E_RELATIVE_PATH, E_CLEAN_PATH,
E_SYSTEM_PATH, E_SHELL_PATH, E_SYSTEM_QUOTE, E_SHELL_QUOTE, E_GETENV, E_READ_REGISTRY
};
enum TestFunc {
T_INVALID = 0, T_REQUIRES, T_GREATERTHAN, T_LESSTHAN, T_EQUALS,
T_VERSION_AT_LEAST, T_VERSION_AT_MOST,
T_EXISTS, T_EXPORT, T_CLEAR, T_UNSET, T_EVAL, T_CONFIG, T_SYSTEM,
T_DEFINED, T_DISCARD_FROM, T_CONTAINS, T_INFILE,
T_COUNT, T_ISEMPTY, T_PARSE_JSON, T_INCLUDE, T_LOAD, T_DEBUG, T_LOG, T_MESSAGE, T_WARNING, T_ERROR, T_IF,
T_MKPATH, T_WRITE_FILE, T_TOUCH, T_CACHE, T_RELOAD_PROPERTIES
};
QMakeBuiltin::QMakeBuiltin(const QMakeBuiltinInit &d)
: index(d.func), minArgs(qMax(0, d.min_args)), maxArgs(d.max_args)
{
static const char * const nstr[6] = { "no", "one", "two", "three", "four", "five" };
// For legacy reasons, there is actually no such thing as "no arguments"
// - there is only "empty first argument", which needs to be mapped back.
// -1 means "one, which may be empty", which is effectively zero, except
// for the error message if there are too many arguments.
int dmin = qAbs(d.min_args);
int dmax = d.max_args;
if (dmax == QMakeBuiltinInit::VarArgs) {
Q_ASSERT_X(dmin < 2, "init", d.name);
if (dmin == 1) {
Q_ASSERT_X(d.args != nullptr, "init", d.name);
usage = fL1S("%1(%2) requires at least one argument.")
.arg(fL1S(d.name), fL1S(d.args));
}
return;
}
int arange = dmax - dmin;
Q_ASSERT_X(arange >= 0, "init", d.name);
Q_ASSERT_X(d.args != nullptr, "init", d.name);
usage = arange > 1
? fL1S("%1(%2) requires %3 to %4 arguments.")
.arg(fL1S(d.name), fL1S(d.args), fL1S(nstr[dmin]), fL1S(nstr[dmax]))
: arange > 0
? fL1S("%1(%2) requires %3 or %4 arguments.")
.arg(fL1S(d.name), fL1S(d.args), fL1S(nstr[dmin]), fL1S(nstr[dmax]))
: dmax != 1
? fL1S("%1(%2) requires %3 arguments.")
.arg(fL1S(d.name), fL1S(d.args), fL1S(nstr[dmax]))
: fL1S("%1(%2) requires one argument.")
.arg(fL1S(d.name), fL1S(d.args));
}
void QMakeEvaluator::initFunctionStatics()
{
static const QMakeBuiltinInit expandInits[] = {
{ "member", E_MEMBER, 1, 3, "var, [start, [end]]" },
{ "str_member", E_STR_MEMBER, -1, 3, "str, [start, [end]]" },
{ "first", E_FIRST, 1, 1, "var" },
{ "take_first", E_TAKE_FIRST, 1, 1, "var" },
{ "last", E_LAST, 1, 1, "var" },
{ "take_last", E_TAKE_LAST, 1, 1, "var" },
{ "size", E_SIZE, 1, 1, "var" },
{ "str_size", E_STR_SIZE, -1, 1, "str" },
{ "cat", E_CAT, 1, 2, "file, [mode=true|blob|lines]" },
{ "fromfile", E_FROMFILE, 2, 2, "file, var" },
{ "eval", E_EVAL, 1, 1, "var" },
{ "list", E_LIST, 0, QMakeBuiltinInit::VarArgs, nullptr },
{ "sprintf", E_SPRINTF, 1, QMakeBuiltinInit::VarArgs, "format, ..." },
{ "format_number", E_FORMAT_NUMBER, 1, 2, "number, [options...]" },
{ "num_add", E_NUM_ADD, 1, QMakeBuiltinInit::VarArgs, "num, ..." },
{ "join", E_JOIN, 1, 4, "var, [glue, [before, [after]]]" },
{ "split", E_SPLIT, 1, 2, "var, sep" },
{ "basename", E_BASENAME, 1, 1, "var" },
{ "dirname", E_DIRNAME, 1, 1, "var" },
{ "section", E_SECTION, 3, 4, "var, sep, begin, [end]" },
{ "find", E_FIND, 2, 2, "var, str" },
{ "system", E_SYSTEM, 1, 3, "command, [mode], [stsvar]" },
{ "unique", E_UNIQUE, 1, 1, "var" },
{ "sorted", E_SORTED, 1, 1, "var" },
{ "reverse", E_REVERSE, 1, 1, "var" },
{ "quote", E_QUOTE, 0, QMakeBuiltinInit::VarArgs, nullptr },
{ "escape_expand", E_ESCAPE_EXPAND, 0, QMakeBuiltinInit::VarArgs, nullptr },
{ "upper", E_UPPER, 0, QMakeBuiltinInit::VarArgs, nullptr },
{ "lower", E_LOWER, 0, QMakeBuiltinInit::VarArgs, nullptr },
{ "title", E_TITLE, 0, QMakeBuiltinInit::VarArgs, nullptr },
{ "re_escape", E_RE_ESCAPE, 0, QMakeBuiltinInit::VarArgs, nullptr },
{ "val_escape", E_VAL_ESCAPE, 1, 1, "var" },
{ "files", E_FILES, 1, 2, "pattern, [recursive=false]" },
{ "prompt", E_PROMPT, 1, 2, "question, [decorate=true]" },
{ "replace", E_REPLACE, 3, 3, "var, before, after" },
{ "sort_depends", E_SORT_DEPENDS, 1, 4, "var, [prefix, [suffixes, [prio-suffix]]]" },
{ "resolve_depends", E_RESOLVE_DEPENDS, 1, 4, "var, [prefix, [suffixes, [prio-suffix]]]" },
{ "enumerate_vars", E_ENUMERATE_VARS, 0, 0, "" },
{ "shadowed", E_SHADOWED, 1, 1, "path" },
{ "absolute_path", E_ABSOLUTE_PATH, -1, 2, "path, [base]" },
{ "relative_path", E_RELATIVE_PATH, -1, 2, "path, [base]" },
{ "clean_path", E_CLEAN_PATH, -1, 1, "path" },
{ "system_path", E_SYSTEM_PATH, -1, 1, "path" },
{ "shell_path", E_SHELL_PATH, -1, 1, "path" },
{ "system_quote", E_SYSTEM_QUOTE, -1, 1, "arg" },
{ "shell_quote", E_SHELL_QUOTE, -1, 1, "arg" },
{ "getenv", E_GETENV, 1, 1, "arg" },
{ "read_registry", E_READ_REGISTRY, 2, 3, "tree, key, [wow64]" },
};
statics.expands.reserve((int)(sizeof(expandInits)/sizeof(expandInits[0])));
for (unsigned i = 0; i < sizeof(expandInits)/sizeof(expandInits[0]); ++i)
statics.expands.insert(ProKey(expandInits[i].name), QMakeBuiltin(expandInits[i]));
static const QMakeBuiltinInit testInits[] = {
{ "requires", T_REQUIRES, 0, QMakeBuiltinInit::VarArgs, nullptr },
{ "greaterThan", T_GREATERTHAN, 2, 2, "var, val" },
{ "lessThan", T_LESSTHAN, 2, 2, "var, val" },
{ "equals", T_EQUALS, 2, 2, "var, val" },
{ "isEqual", T_EQUALS, 2, 2, "var, val" },
{ "versionAtLeast", T_VERSION_AT_LEAST, 2, 2, "var, version" },
{ "versionAtMost", T_VERSION_AT_MOST, 2, 2, "var, version" },
{ "exists", T_EXISTS, 1, 1, "file" },
{ "export", T_EXPORT, 1, 1, "var" },
{ "clear", T_CLEAR, 1, 1, "var" },
{ "unset", T_UNSET, 1, 1, "var" },
{ "eval", T_EVAL, 0, QMakeBuiltinInit::VarArgs, nullptr },
{ "CONFIG", T_CONFIG, 1, 2, "config, [mutuals]" },
{ "if", T_IF, 1, 1, "condition" },
{ "isActiveConfig", T_CONFIG, 1, 2, "config, [mutuals]" },
{ "system", T_SYSTEM, 1, 1, "exec" },
{ "discard_from", T_DISCARD_FROM, 1, 1, "file" },
{ "defined", T_DEFINED, 1, 2, "object, [\"test\"|\"replace\"|\"var\"]" },
{ "contains", T_CONTAINS, 2, 3, "var, val, [mutuals]" },
{ "infile", T_INFILE, 2, 3, "file, var, [values]" },
{ "count", T_COUNT, 2, 3, "var, count, [op=operator]" },
{ "isEmpty", T_ISEMPTY, 1, 1, "var" },
{ "parseJson", T_PARSE_JSON, 2, 2, "var, into" },
{ "load", T_LOAD, 1, 2, "feature, [ignore_errors=false]" },
{ "include", T_INCLUDE, 1, 3, "file, [into, [silent]]" },
{ "debug", T_DEBUG, 2, 2, "level, message" },
{ "log", T_LOG, 1, 1, "message" },
{ "message", T_MESSAGE, 1, 1, "message" },
{ "warning", T_WARNING, 1, 1, "message" },
{ "error", T_ERROR, 0, 1, "message" },
{ "mkpath", T_MKPATH, 1, 1, "path" },
{ "write_file", T_WRITE_FILE, 1, 3, "name, [content var, [append] [exe]]" },
{ "touch", T_TOUCH, 2, 2, "file, reffile" },
{ "cache", T_CACHE, 0, 3, "[var], [set|add|sub] [transient] [super|stash], [srcvar]" },
{ "reload_properties", T_RELOAD_PROPERTIES, 0, 0, "" },
};
statics.functions.reserve((int)(sizeof(testInits)/sizeof(testInits[0])));
for (unsigned i = 0; i < sizeof(testInits)/sizeof(testInits[0]); ++i)
statics.functions.insert(ProKey(testInits[i].name), QMakeBuiltin(testInits[i]));
}
static bool isTrue(const ProString &str)
{
return !str.compare(statics.strtrue, Qt::CaseInsensitive) || str.toInt();
}
bool
QMakeEvaluator::getMemberArgs(const ProKey &func, int srclen, const ProStringList &args,
int *start, int *end)
{
*start = 0, *end = 0;
if (args.size() >= 2) {
bool ok = true;
const ProString &start_str = args.at(1);
*start = start_str.toInt(&ok);
if (!ok) {
if (args.size() == 2) {
int dotdot = start_str.indexOf(statics.strDotDot);
if (dotdot != -1) {
*start = start_str.left(dotdot).toInt(&ok);
if (ok)
*end = start_str.mid(dotdot+2).toInt(&ok);
}
}
if (!ok) {
ProStringRoUser u1(func, m_tmp1);
ProStringRoUser u2(start_str, m_tmp2);
evalError(fL1S("%1() argument 2 (start) '%2' invalid.").arg(u1.str(), u2.str()));
return false;
}
} else {
*end = *start;
if (args.size() == 3)
*end = args.at(2).toInt(&ok);
if (!ok) {
ProStringRoUser u1(func, m_tmp1);
ProStringRoUser u2(args.at(2), m_tmp2);
evalError(fL1S("%1() argument 3 (end) '%2' invalid.").arg(u1.str(), u2.str()));
return false;
}
}
}
if (*start < 0)
*start += srclen;
if (*end < 0)
*end += srclen;
if (*start < 0 || *start >= srclen || *end < 0 || *end >= srclen)
return false;
return true;
}
QString
QMakeEvaluator::quoteValue(const ProString &val)
{
QString ret;
ret.reserve(val.size());
const QChar *chars = val.constData();
bool quote = val.isEmpty();
bool escaping = false;
for (int i = 0, l = val.size(); i < l; i++) {
QChar c = chars[i];
ushort uc = c.unicode();
if (uc < 32) {
if (!escaping) {
escaping = true;
ret += QLatin1String("$$escape_expand(");
}
switch (uc) {
case '\r':
ret += QLatin1String("\\\\r");
break;
case '\n':
ret += QLatin1String("\\\\n");
break;
case '\t':
ret += QLatin1String("\\\\t");
break;
default:
ret += QString::fromLatin1("\\\\x%1").arg(uc, 2, 16, QLatin1Char('0'));
break;
}
} else {
if (escaping) {
escaping = false;
ret += QLatin1Char(')');
}
switch (uc) {
case '\\':
ret += QLatin1String("\\\\");
break;
case '"':
ret += QLatin1String("\\\"");
break;
case '\'':
ret += QLatin1String("\\'");
break;
case '$':
ret += QLatin1String("\\$");
break;
case '#':
ret += QLatin1String("$${LITERAL_HASH}");
break;
case 32:
quote = true;
Q_FALLTHROUGH();
default:
ret += c;
break;
}
}
}
if (escaping)
ret += QLatin1Char(')');
if (quote) {
ret.prepend(QLatin1Char('"'));
ret.append(QLatin1Char('"'));
}
return ret;
}
static void addJsonValue(const QJsonValue &value, const QString &keyPrefix, ProValueMap *map);
static void insertJsonKeyValue(const QString &key, const QStringList &values, ProValueMap *map)
{
map->insert(ProKey(key), ProStringList(values));
}
static void addJsonArray(const QJsonArray &array, const QString &keyPrefix, ProValueMap *map)
{
QStringList keys;
const int size = array.count();
keys.reserve(size);
for (int i = 0; i < size; ++i) {
const QString number = QString::number(i);
keys.append(number);
addJsonValue(array.at(i), keyPrefix + number, map);
}
insertJsonKeyValue(keyPrefix + QLatin1String("_KEYS_"), keys, map);
}
static void addJsonObject(const QJsonObject &object, const QString &keyPrefix, ProValueMap *map)
{
QStringList keys;
keys.reserve(object.size());
for (auto it = object.begin(), end = object.end(); it != end; ++it) {
const QString key = it.key();
keys.append(key);
addJsonValue(it.value(), keyPrefix + key, map);
}
insertJsonKeyValue(keyPrefix + QLatin1String("_KEYS_"), keys, map);
}
static void addJsonValue(const QJsonValue &value, const QString &keyPrefix, ProValueMap *map)
{
switch (value.type()) {
case QJsonValue::Bool:
insertJsonKeyValue(keyPrefix, QStringList() << (value.toBool() ? QLatin1String("true") : QLatin1String("false")), map);
break;
case QJsonValue::Double:
insertJsonKeyValue(keyPrefix, QStringList() << QString::number(value.toDouble()), map);
break;
case QJsonValue::String:
insertJsonKeyValue(keyPrefix, QStringList() << value.toString(), map);
break;
case QJsonValue::Array:
addJsonArray(value.toArray(), keyPrefix + QLatin1Char('.'), map);
break;
case QJsonValue::Object:
addJsonObject(value.toObject(), keyPrefix + QLatin1Char('.'), map);
break;
default:
break;
}
}
struct ErrorPosition {
int line;
int column;
};
static ErrorPosition calculateErrorPosition(const QByteArray &json, int offset)
{
ErrorPosition pos = { 0, 0 };
offset--; // offset is 1-based, switching to 0-based
for (int i = 0; i < offset; ++i) {
switch (json.at(i)) {
case '\n':
pos.line++;
pos.column = 0;
break;
case '\r':
break;
case '\t':
pos.column = (pos.column + 8) & ~7;
break;
default:
pos.column++;
break;
}
}
// Lines and columns in text editors are 1-based:
pos.line++;
pos.column++;
return pos;
}
QMakeEvaluator::VisitReturn QMakeEvaluator::parseJsonInto(const QByteArray &json, const QString &into, ProValueMap *value)
{
QJsonParseError error;
QJsonDocument document = QJsonDocument::fromJson(json, &error);
if (document.isNull()) {
if (error.error != QJsonParseError::NoError) {
ErrorPosition errorPos = calculateErrorPosition(json, error.offset);
evalError(fL1S("Error parsing JSON at %1:%2: %3")
.arg(errorPos.line).arg(errorPos.column).arg(error.errorString()));
}
return QMakeEvaluator::ReturnFalse;
}
QString currentKey = into + QLatin1Char('.');
// top-level item is either an array or object
if (document.isArray())
addJsonArray(document.array(), currentKey, value);
else if (document.isObject())
addJsonObject(document.object(), currentKey, value);
else
return QMakeEvaluator::ReturnFalse;
return QMakeEvaluator::ReturnTrue;
}
QMakeEvaluator::VisitReturn
QMakeEvaluator::writeFile(const QString &ctx, const QString &fn, QIODevice::OpenMode mode,
QMakeVfs::VfsFlags flags, const QString &contents)
{
int oldId = m_vfs->idForFileName(fn, flags | QMakeVfs::VfsAccessedOnly);
int id = m_vfs->idForFileName(fn, flags | QMakeVfs::VfsCreate);
QString errStr;
if (!m_vfs->writeFile(id, mode, flags, contents, &errStr)) {
evalError(fL1S("Cannot write %1file %2: %3")
.arg(ctx, QDir::toNativeSeparators(fn), errStr));
return ReturnFalse;
}
if (oldId)
m_parser->discardFileFromCache(oldId);
return ReturnTrue;
}
#if QT_CONFIG(process)
void QMakeEvaluator::runProcess(QProcess *proc, const QString &command) const
{
proc->setWorkingDirectory(currentDirectory());
# ifdef PROEVALUATOR_SETENV
if (!m_option->environment.isEmpty())
proc->setProcessEnvironment(m_option->environment);
# endif
# ifdef Q_OS_WIN
proc->setNativeArguments(QLatin1String("/v:off /s /c \"") + command + QLatin1Char('"'));
proc->start(m_option->getEnv(QLatin1String("COMSPEC")), QStringList());
# else
proc->start(QLatin1String("/bin/sh"), QStringList() << QLatin1String("-c") << command);
# endif
proc->waitForFinished(-1);
}
#endif
QByteArray QMakeEvaluator::getCommandOutput(const QString &args, int *exitCode) const
{
QByteArray out;
#if QT_CONFIG(process)
QProcess proc;
runProcess(&proc, args);
*exitCode = (proc.exitStatus() == QProcess::NormalExit) ? proc.exitCode() : -1;
QByteArray errout = proc.readAllStandardError();
# ifdef PROEVALUATOR_FULL
// FIXME: Qt really should have the option to set forwarding per channel
fputs(errout.constData(), stderr);
# else
if (!errout.isEmpty()) {
if (errout.endsWith('\n'))
errout.chop(1);
m_handler->message(
QMakeHandler::EvalError | (m_cumulative ? QMakeHandler::CumulativeEvalMessage : 0),
QString::fromLocal8Bit(errout));
}
# endif
out = proc.readAllStandardOutput();
# ifdef Q_OS_WIN
// FIXME: Qt's line end conversion on sequential files should really be fixed
out.replace("\r\n", "\n");
# endif
#else
if (FILE *proc = QT_POPEN(QString(QLatin1String("cd ")
+ IoUtils::shellQuote(QDir::toNativeSeparators(currentDirectory()))
+ QLatin1String(" && ") + args).toLocal8Bit().constData(), QT_POPEN_READ)) {
while (!feof(proc)) {
char buff[10 * 1024];
int read_in = int(fread(buff, 1, sizeof(buff), proc));
if (!read_in)
break;
out += QByteArray(buff, read_in);
}
int ec = QT_PCLOSE(proc);
# ifdef Q_OS_WIN
*exitCode = ec >= 0 ? ec : -1;
# else
*exitCode = WIFEXITED(ec) ? WEXITSTATUS(ec) : -1;
# endif
}
# ifdef Q_OS_WIN
out.replace("\r\n", "\n");
# endif
#endif
return out;
}
void QMakeEvaluator::populateDeps(
const ProStringList &deps, const ProString &prefix, const ProStringList &suffixes,
const ProString &priosfx,
QHash<ProKey, QSet<ProKey> > &dependencies, ProValueMap &dependees,
QMultiMap<int, ProString> &rootSet) const
{
for (const ProString &item : deps)
if (!dependencies.contains(item.toKey())) {
QSet<ProKey> &dset = dependencies[item.toKey()]; // Always create entry
ProStringList depends;
for (const ProString &suffix : suffixes)
depends += values(ProKey(prefix + item + suffix));
if (depends.isEmpty()) {
rootSet.insert(first(ProKey(prefix + item + priosfx)).toInt(), item);
} else {
for (const ProString &dep : std::as_const(depends)) {
dset.insert(dep.toKey());
dependees[dep.toKey()] << item;
}
populateDeps(depends, prefix, suffixes, priosfx, dependencies, dependees, rootSet);
}
}
}
QString QMakeEvaluator::filePathArg0(const ProStringList &args)
{
ProStringRoUser u1(args.at(0), m_tmp1);
QString fn = resolvePath(u1.str());
fn.detach();
return fn;
}
QString QMakeEvaluator::filePathEnvArg0(const ProStringList &args)
{
ProStringRoUser u1(args.at(0), m_tmp1);
QString fn = resolvePath(m_option->expandEnvVars(u1.str()));
fn.detach();
return fn;
}
QMakeEvaluator::VisitReturn QMakeEvaluator::evaluateBuiltinExpand(
const QMakeBuiltin &adef, const ProKey &func, const ProStringList &args, ProStringList &ret)
{
traceMsg("calling built-in $$%s(%s)", dbgKey(func), dbgSepStrList(args));
int asz = args.size() > 1 ? args.size() : args.at(0).isEmpty() ? 0 : 1;
if (asz < adef.minArgs || asz > adef.maxArgs) {
evalError(adef.usage);
return ReturnTrue;
}
int func_t = adef.index;
switch (func_t) {
case E_BASENAME:
case E_DIRNAME:
case E_SECTION: {
bool regexp = false;
QString sep;
ProString var;
int beg = 0;
int end = -1;
if (func_t == E_SECTION) {
var = args[0];
sep = args.at(1).toQString();
beg = args.at(2).toInt();
if (args.size() == 4)
end = args.at(3).toInt();
} else {
var = args[0];
regexp = true;
sep = QLatin1String("[\\\\/]");
if (func_t == E_DIRNAME)
end = -2;
else
beg = -1;
}
if (!var.isEmpty()) {
const auto strings = values(map(var));
if (regexp) {
QRegularExpression sepRx(sep, QRegularExpression::DotMatchesEverythingOption);
if (!sepRx.isValid()) {
evalError(fL1S("section(): Encountered invalid regular expression '%1'.").arg(sep));
goto allfail;
}
for (const ProString &str : strings) {
ProStringRwUser u1(str, m_tmp[m_toggle ^= 1]);
ret << u1.extract(u1.str().section(sepRx, beg, end));
}
} else {
for (const ProString &str : strings) {
ProStringRwUser u1(str, m_tmp1);
ret << u1.extract(u1.str().section(sep, beg, end));
}
}
}
break;
}
case E_SPRINTF: {
ProStringRwUser u1(args.at(0), m_tmp1);
QString tmp = u1.str();
for (int i = 1; i < args.size(); ++i)
tmp = tmp.arg(args.at(i).toQStringView());
ret << u1.extract(tmp);
break;
}
case E_FORMAT_NUMBER: {
int ibase = 10;
int obase = 10;
int width = 0;
bool zeropad = false;
bool leftalign = false;
enum { DefaultSign, PadSign, AlwaysSign } sign = DefaultSign;
if (args.size() >= 2) {
const auto opts = split_value_list(args.at(1).toQStringView());
for (const ProString &opt : opts) {
if (opt.startsWith(QLatin1String("ibase="))) {
ibase = opt.mid(6).toInt();
} else if (opt.startsWith(QLatin1String("obase="))) {
obase = opt.mid(6).toInt();
} else if (opt.startsWith(QLatin1String("width="))) {
width = opt.mid(6).toInt();
} else if (opt == QLatin1String("zeropad")) {
zeropad = true;
} else if (opt == QLatin1String("padsign")) {
sign = PadSign;
} else if (opt == QLatin1String("alwayssign")) {
sign = AlwaysSign;
} else if (opt == QLatin1String("leftalign")) {
leftalign = true;
} else {
evalError(fL1S("format_number(): invalid format option %1.")
.arg(opt.toQStringView()));
goto allfail;
}
}
}
if (args.at(0).contains(QLatin1Char('.'))) {
evalError(fL1S("format_number(): floats are currently not supported."));
break;
}
bool ok;
qlonglong num = args.at(0).toLongLong(&ok, ibase);
if (!ok) {
evalError(fL1S("format_number(): malformed number %2 for base %1.")
.arg(ibase).arg(args.at(0).toQStringView()));
break;
}
QString outstr;
if (num < 0) {
num = -num;
outstr = QLatin1Char('-');
} else if (sign == AlwaysSign) {
outstr = QLatin1Char('+');
} else if (sign == PadSign) {
outstr = QLatin1Char(' ');
}
QString numstr = QString::number(num, obase);
int space = width - outstr.size() - numstr.size();
if (space <= 0) {
outstr += numstr;
} else if (leftalign) {
outstr += numstr + QString(space, QLatin1Char(' '));
} else if (zeropad) {
outstr += QString(space, QLatin1Char('0')) + numstr;
} else {
outstr.prepend(QString(space, QLatin1Char(' ')));
outstr += numstr;
}
ret += ProString(outstr);
break;
}
case E_NUM_ADD: {
qlonglong sum = 0;
for (const ProString &arg : std::as_const(args)) {
if (arg.contains(QLatin1Char('.'))) {
evalError(fL1S("num_add(): floats are currently not supported."));
goto allfail;
}
bool ok;
qlonglong num = arg.toLongLong(&ok);
if (!ok) {
evalError(fL1S("num_add(): malformed number %1.")
.arg(arg.toQStringView()));
goto allfail;
}
sum += num;
}
ret += ProString(QString::number(sum));
break;
}
case E_JOIN: {
ProString glue, before, after;
if (args.size() >= 2)
glue = args.at(1);
if (args.size() >= 3)
before = args[2];
if (args.size() == 4)
after = args[3];
const ProStringList &var = values(map(args.at(0)));
if (!var.isEmpty()) {
int src = currentFileId();
for (const ProString &v : var)
if (int s = v.sourceFile()) {
src = s;
break;
}
ret << ProString(before + var.join(glue) + after).setSource(src);
}
break;
}
case E_SPLIT: {
ProStringRoUser u1(m_tmp1);
const QString &sep = (args.size() == 2) ? u1.set(args.at(1)) : statics.field_sep;
const auto vars = values(map(args.at(0)));
for (const ProString &var : vars) {
// FIXME: this is inconsistent with the "there are no empty strings" dogma.
const auto splits = var.toQStringView().split(sep, Qt::KeepEmptyParts);
for (const auto &splt : splits)
ret << ProString(splt).setSource(var);
}
break;
}
case E_MEMBER: {
const ProStringList &src = values(map(args.at(0)));
int start, end;
if (getMemberArgs(func, src.size(), args, &start, &end)) {
ret.reserve(qAbs(end - start) + 1);
if (start < end) {
for (int i = start; i <= end && src.size() >= i; i++)
ret += src.at(i);
} else {
for (int i = start; i >= end && src.size() >= i && i >= 0; i--)
ret += src.at(i);
}
}
break;
}
case E_STR_MEMBER: {
const ProString &src = args.at(0);
int start, end;
if (getMemberArgs(func, src.size(), args, &start, &end)) {
QString res;
res.reserve(qAbs(end - start) + 1);
if (start < end) {
for (int i = start; i <= end && src.size() >= i; i++)
res += src.at(i);
} else {
for (int i = start; i >= end && src.size() >= i && i >= 0; i--)
res += src.at(i);
}
ret += ProString(res);
}
break;
}
case E_FIRST:
case E_LAST: {
const ProStringList &var = values(map(args.at(0)));
if (!var.isEmpty()) {
if (func_t == E_FIRST)
ret.append(var[0]);
else
ret.append(var.last());
}
break;
}
case E_TAKE_FIRST:
case E_TAKE_LAST: {
ProStringList &var = valuesRef(map(args.at(0)));
if (!var.isEmpty()) {
if (func_t == E_TAKE_FIRST)
ret.append(var.takeFirst());
else
ret.append(var.takeLast());
}
break;
}
case E_SIZE:
ret.append(ProString(QString::number(values(map(args.at(0))).size())));
break;
case E_STR_SIZE:
ret.append(ProString(QString::number(args.at(0).size())));
break;
case E_CAT: {
bool blob = false;
bool lines = false;
bool singleLine = true;
if (args.size() > 1) {
if (!args.at(1).compare(QLatin1String("false"), Qt::CaseInsensitive))
singleLine = false;
else if (!args.at(1).compare(QLatin1String("blob"), Qt::CaseInsensitive))
blob = true;
else if (!args.at(1).compare(QLatin1String("lines"), Qt::CaseInsensitive))
lines = true;
}
QString fn = filePathEnvArg0(args);
QFile qfile(fn);
if (qfile.open(QIODevice::ReadOnly)) {
QTextStream stream(&qfile);
if (blob) {
ret += ProString(stream.readAll());
} else {
while (!stream.atEnd()) {
if (lines) {
ret += ProString(stream.readLine());
} else {
const QString &line = stream.readLine();
ret += split_value_list(QStringView(line).trimmed());
if (!singleLine)
ret += ProString("\n");
}
}
}
}
break;
}
case E_FROMFILE: {
ProValueMap vars;
QString fn = filePathEnvArg0(args);
if (evaluateFileInto(fn, &vars, LoadProOnly) == ReturnTrue)
ret = vars.value(map(args.at(1)));
break;
}
case E_EVAL:
ret += values(map(args.at(0)));
break;
case E_LIST: {
QString tmp(QString::asprintf(".QMAKE_INTERNAL_TMP_variableName_%d", m_listCount++));
ret = ProStringList(ProString(tmp));
ProStringList lst;
for (const ProString &arg : args)
lst += split_value_list(arg.toQStringView(), arg.sourceFile()); // Relies on deep copy
m_valuemapStack.top()[ret.at(0).toKey()] = lst;
break; }
case E_FIND: {
QRegularExpression regx(args.at(1).toQString(), QRegularExpression::DotMatchesEverythingOption);
if (!regx.isValid()) {
evalError(fL1S("find(): Encountered invalid regular expression '%1'.").arg(regx.pattern()));
goto allfail;
}
const auto vals = values(map(args.at(0)));
for (const ProString &val : vals) {
ProStringRoUser u1(val, m_tmp[m_toggle ^= 1]);
if (u1.str().contains(regx))
ret += val;
}
break;
}
case E_SYSTEM: {
if (m_skipLevel)
break;
bool blob = false;
bool lines = false;
bool singleLine = true;
if (args.size() > 1) {
if (!args.at(1).compare(QLatin1String("false"), Qt::CaseInsensitive))
singleLine = false;
else if (!args.at(1).compare(QLatin1String("blob"), Qt::CaseInsensitive))
blob = true;
else if (!args.at(1).compare(QLatin1String("lines"), Qt::CaseInsensitive))
lines = true;
}
int exitCode;
QByteArray bytes = getCommandOutput(args.at(0).toQString(), &exitCode);
if (args.size() > 2 && !args.at(2).isEmpty()) {
m_valuemapStack.top()[args.at(2).toKey()] =
ProStringList(ProString(QString::number(exitCode)));
}
if (lines) {
QTextStream stream(bytes);
while (!stream.atEnd())
ret += ProString(stream.readLine());
} else {
QString output = QString::fromLocal8Bit(bytes);
if (blob) {
ret += ProString(output);
} else {
output.replace(QLatin1Char('\t'), QLatin1Char(' '));
if (singleLine)
output.replace(QLatin1Char('\n'), QLatin1Char(' '));
ret += split_value_list(QStringView(output));
}
}
break;
}
case E_UNIQUE:
ret = values(map(args.at(0)));
ret.removeDuplicates();
break;
case E_SORTED:
ret = values(map(args.at(0)));
std::sort(ret.begin(), ret.end());
break;
case E_REVERSE: {
ProStringList var = values(args.at(0).toKey());
for (int i = 0; i < var.size() / 2; i++)
qSwap(var[i], var[var.size() - i - 1]);
ret += var;
break;
}
case E_QUOTE:
ret += args;
break;
case E_ESCAPE_EXPAND:
for (int i = 0; i < args.size(); ++i) {
QString str = args.at(i).toQString();
QChar *i_data = str.data();
int i_len = str.size();
for (int x = 0; x < i_len; ++x) {
if (*(i_data+x) == QLatin1Char('\\') && x < i_len-1) {
if (*(i_data+x+1) == QLatin1Char('\\')) {
++x;
} else {
struct {
char in, out;
} mapped_quotes[] = {
{ 'n', '\n' },
{ 't', '\t' },
{ 'r', '\r' },
{ 0, 0 }
};
for (int i = 0; mapped_quotes[i].in; ++i) {
if (*(i_data+x+1) == QLatin1Char(mapped_quotes[i].in)) {
*(i_data+x) = QLatin1Char(mapped_quotes[i].out);
if (x < i_len-2)
memmove(i_data+x+1, i_data+x+2, (i_len-x-2)*sizeof(QChar));
--i_len;
break;
}
}
}
}
}
ret.append(ProString(QString(i_data, i_len)).setSource(args.at(i)));
}
break;
case E_RE_ESCAPE:
for (int i = 0; i < args.size(); ++i) {
ProStringRwUser u1(args.at(i), m_tmp1);
ret << u1.extract(QRegularExpression::escape(u1.str()));
}
break;
case E_VAL_ESCAPE: {
const ProStringList &vals = values(args.at(0).toKey());
ret.reserve(vals.size());
for (const ProString &str : vals)
ret += ProString(quoteValue(str));
break;
}
case E_UPPER:
case E_LOWER:
case E_TITLE:
for (int i = 0; i < args.size(); ++i) {
ProStringRwUser u1(args.at(i), m_tmp1);
QString rstr = u1.str();
if (func_t == E_UPPER) {
rstr = rstr.toUpper();
} else {
rstr = rstr.toLower();
if (func_t == E_TITLE && rstr.size() > 0)
rstr[0] = rstr.at(0).toTitleCase();
}
ret << u1.extract(rstr);
}
break;
case E_FILES: {
bool recursive = false;
if (args.size() == 2)
recursive = isTrue(args.at(1));
QStringList dirs;
ProStringRoUser u1(args.at(0), m_tmp1);
QString r = m_option->expandEnvVars(u1.str())
.replace(QLatin1Char('\\'), QLatin1Char('/'));
QString pfx;
if (IoUtils::isRelativePath(r)) {
pfx = currentDirectory();
if (!pfx.endsWith(QLatin1Char('/')))
pfx += QLatin1Char('/');
}
int slash = r.lastIndexOf(QLatin1Char('/'));
if (slash != -1) {
dirs.append(r.left(slash+1));
r = r.mid(slash+1);
} else {
dirs.append(QString());
}
QString pattern = QRegularExpression::wildcardToRegularExpression(r);
QRegularExpression regex(pattern, QRegularExpression::DotMatchesEverythingOption);
if (!regex.isValid()) {
evalError(fL1S("section(): Encountered invalid wildcard expression '%1'.").arg(pattern));
goto allfail;
}
for (int d = 0; d < dirs.size(); d++) {
QString dir = dirs[d];
QDir qdir(pfx + dir);
for (int i = 0, count = int(qdir.count()); i < count; ++i) {
if (qdir[i] == statics.strDot || qdir[i] == statics.strDotDot)
continue;
QString fname = dir + qdir[i];
if (IoUtils::fileType(pfx + fname) == IoUtils::FileIsDir) {
if (recursive)
dirs.append(fname + QLatin1Char('/'));
}
if (regex.match(qdir[i]).hasMatch())
ret += ProString(fname).setSource(currentFileId());
}
}
break;
}
#ifdef PROEVALUATOR_FULL
case E_PROMPT: {
ProStringRoUser u1(args.at(0), m_tmp1);
QString msg = m_option->expandEnvVars(u1.str());
bool decorate = true;
if (args.size() == 2)
decorate = isTrue(args.at(1));
if (decorate) {
if (!msg.endsWith(QLatin1Char('?')))
msg += QLatin1Char('?');
fprintf(stderr, "Project PROMPT: %s ", qPrintable(msg));
} else {
fputs(qPrintable(msg), stderr);
}
QFile qfile;
if (qfile.open(stdin, QIODevice::ReadOnly)) {
QTextStream t(&qfile);
const QString &line = t.readLine();
if (t.atEnd()) {
fputs("\n", stderr);
evalError(fL1S("Unexpected EOF."));
return ReturnError;
}
ret = split_value_list(QStringView(line));
}
break;
}
#endif
case E_REPLACE: {
const QRegularExpression before(args.at(1).toQString(), QRegularExpression::DotMatchesEverythingOption);
if (!before.isValid()) {
evalError(fL1S("replace(): Encountered invalid regular expression '%1'.").arg(before.pattern()));
goto allfail;
}
ProStringRwUser u2(args.at(2), m_tmp2);
const QString &after = u2.str();
const auto vals = values(map(args.at(0)));
for (const ProString &val : vals) {
ProStringRwUser u1(val, m_tmp1);
QString rstr = u1.str();
QString copy = rstr; // Force a detach on modify
rstr.replace(before, after);
ret << u1.extract(rstr, u2);
}
break;
}
case E_SORT_DEPENDS:
case E_RESOLVE_DEPENDS: {
QHash<ProKey, QSet<ProKey> > dependencies;
ProValueMap dependees;
QMultiMap<int, ProString> rootSet;
ProStringList orgList = values(args.at(0).toKey());
ProString prefix = args.size() < 2 ? ProString() : args.at(1);
ProString priosfx = args.size() < 4 ? ProString(".priority") : args.at(3);
populateDeps(orgList, prefix,
args.size() < 3 ? ProStringList(ProString(".depends"))
: split_value_list(args.at(2).toQStringView()),
priosfx, dependencies, dependees, rootSet);
while (!rootSet.isEmpty()) {
QMultiMap<int, ProString>::iterator it = rootSet.begin();
const ProString item = *it;
rootSet.erase(it);
if ((func_t == E_RESOLVE_DEPENDS) || orgList.contains(item))
ret.prepend(item);
for (const ProString &dep : std::as_const(dependees[item.toKey()])) {
QSet<ProKey> &dset = dependencies[dep.toKey()];
dset.remove(item.toKey());
if (dset.isEmpty())
rootSet.insert(first(ProKey(prefix + dep + priosfx)).toInt(), dep);
}
}
break;
}
case E_ENUMERATE_VARS: {
QSet<ProString> keys;
for (const ProValueMap &vmap : std::as_const(m_valuemapStack))
for (ProValueMap::ConstIterator it = vmap.constBegin(); it != vmap.constEnd(); ++it)
keys.insert(it.key());
ret.reserve(keys.size());
for (const ProString &key : std::as_const(keys))
ret << key;
break; }
case E_SHADOWED: {
ProStringRwUser u1(args.at(0), m_tmp1);
QString rstr = m_option->shadowedPath(resolvePath(u1.str()));
if (!rstr.isEmpty())
ret << u1.extract(rstr);
break;
}
case E_ABSOLUTE_PATH: {
ProStringRwUser u1(args.at(0), m_tmp1);
ProStringRwUser u2(m_tmp2);
QString baseDir = args.size() > 1
? IoUtils::resolvePath(currentDirectory(), u2.set(args.at(1)))
: currentDirectory();
QString rstr = u1.str().isEmpty() ? baseDir : IoUtils::resolvePath(baseDir, u1.str());
ret << u1.extract(rstr, u2);
break;
}
case E_RELATIVE_PATH: {
ProStringRwUser u1(args.at(0), m_tmp1);
ProStringRoUser u2(m_tmp2);
QString baseDir = args.size() > 1
? IoUtils::resolvePath(currentDirectory(), u2.set(args.at(1)))
: currentDirectory();
QString absArg = u1.str().isEmpty() ? baseDir : IoUtils::resolvePath(baseDir, u1.str());
QString rstr = QDir(baseDir).relativeFilePath(absArg);
ret << u1.extract(rstr);
break;
}
case E_CLEAN_PATH: {
ProStringRwUser u1(args.at(0), m_tmp1);
ret << u1.extract(QDir::cleanPath(u1.str()));
break;
}
case E_SYSTEM_PATH: {
ProStringRwUser u1(args.at(0), m_tmp1);
QString rstr = u1.str();
#ifdef Q_OS_WIN
rstr.replace(QLatin1Char('/'), QLatin1Char('\\'));
#else
rstr.replace(QLatin1Char('\\'), QLatin1Char('/'));
#endif
ret << u1.extract(rstr);
break;
}
case E_SHELL_PATH: {
ProStringRwUser u1(args.at(0), m_tmp1);
QString rstr = u1.str();
if (m_dirSep.startsWith(QLatin1Char('\\'))) {
rstr.replace(QLatin1Char('/'), QLatin1Char('\\'));
} else {
rstr.replace(QLatin1Char('\\'), QLatin1Char('/'));
#ifdef Q_OS_WIN
// Convert d:/foo/bar to msys-style /d/foo/bar.
if (rstr.length() > 2 && rstr.at(1) == QLatin1Char(':') && rstr.at(2) == QLatin1Char('/')) {
rstr[1] = rstr.at(0);
rstr[0] = QLatin1Char('/');
}
#endif
}
ret << u1.extract(rstr);
break;
}
case E_SYSTEM_QUOTE: {
ProStringRwUser u1(args.at(0), m_tmp1);
ret << u1.extract(IoUtils::shellQuote(u1.str()));
break;
}
case E_SHELL_QUOTE: {
ProStringRwUser u1(args.at(0), m_tmp1);
QString rstr = u1.str();
if (m_dirSep.startsWith(QLatin1Char('\\')))
rstr = IoUtils::shellQuoteWin(rstr);
else
rstr = IoUtils::shellQuoteUnix(rstr);
ret << u1.extract(rstr);
break;
}
case E_GETENV: {
ProStringRoUser u1(args.at(0), m_tmp1);
ret << ProString(m_option->getEnv(u1.str()));
break;
}
#ifdef Q_OS_WIN
case E_READ_REGISTRY: {
HKEY tree;
const auto par = args.at(0);
if (!par.compare(QLatin1String("HKCU"), Qt::CaseInsensitive)
|| !par.compare(QLatin1String("HKEY_CURRENT_USER"), Qt::CaseInsensitive)) {
tree = HKEY_CURRENT_USER;
} else if (!par.compare(QLatin1String("HKLM"), Qt::CaseInsensitive)
|| !par.compare(QLatin1String("HKEY_LOCAL_MACHINE"), Qt::CaseInsensitive)) {
tree = HKEY_LOCAL_MACHINE;
} else {
evalError(fL1S("read_registry(): invalid or unsupported registry tree %1.")
.arg(par.toQStringView()));
goto allfail;
}
int flags = 0;
if (args.count() > 2) {
const auto opt = args.at(2);
if (opt == "32"
|| !opt.compare(QLatin1String("wow64_32key"), Qt::CaseInsensitive)) {
flags = KEY_WOW64_32KEY;
} else if (opt == "64"
|| !opt.compare(QLatin1String("wow64_64key"), Qt::CaseInsensitive)) {
flags = KEY_WOW64_64KEY;
} else {
evalError(fL1S("read_registry(): invalid option %1.")
.arg(opt.toQStringView()));
goto allfail;
}
}
ret << ProString(qt_readRegistryKey(tree, args.at(1).toQString(m_tmp1), flags));
break;
}
#endif
default:
evalError(fL1S("Function '%1' is not implemented.").arg(func.toQStringView()));
break;
}
allfail:
return ReturnTrue;
}
QMakeEvaluator::VisitReturn QMakeEvaluator::testFunc_cache(const ProStringList &args)
{
bool persist = true;
enum { TargetStash, TargetCache, TargetSuper } target = TargetCache;
enum { CacheSet, CacheAdd, CacheSub } mode = CacheSet;
ProKey srcvar;
if (args.size() >= 2) {
const auto opts = split_value_list(args.at(1).toQStringView());
for (const ProString &opt : opts) {
if (opt == QLatin1String("transient")) {
persist = false;
} else if (opt == QLatin1String("super")) {
target = TargetSuper;
} else if (opt == QLatin1String("stash")) {
target = TargetStash;
} else if (opt == QLatin1String("set")) {
mode = CacheSet;
} else if (opt == QLatin1String("add")) {
mode = CacheAdd;
} else if (opt == QLatin1String("sub")) {
mode = CacheSub;
} else {
evalError(fL1S("cache(): invalid flag %1.").arg(opt.toQStringView()));
return ReturnFalse;
}
}
if (args.size() >= 3) {
srcvar = args.at(2).toKey();
} else if (mode != CacheSet) {
evalError(fL1S("cache(): modes other than 'set' require a source variable."));
return ReturnFalse;
}
}
QString varstr;
ProKey dstvar = args.at(0).toKey();
if (!dstvar.isEmpty()) {
if (srcvar.isEmpty())
srcvar = dstvar;
ProValueMap::Iterator srcvarIt;
if (!findValues(srcvar, &srcvarIt)) {
evalError(fL1S("Variable %1 is not defined.").arg(srcvar.toQStringView()));
return ReturnFalse;
}
// The caches for the host and target may differ (e.g., when we are manipulating
// CONFIG), so we cannot compute a common new value for both.
const ProStringList &diffval = *srcvarIt;
ProStringList newval;
bool changed = false;
for (bool hostBuild = false; ; hostBuild = true) {
#ifdef PROEVALUATOR_THREAD_SAFE
m_option->mutex.lock();
#endif
QMakeBaseEnv *baseEnv =
m_option->baseEnvs.value(QMakeBaseKey(m_buildRoot, m_stashfile, hostBuild));
#ifdef PROEVALUATOR_THREAD_SAFE
// It's ok to unlock this before locking baseEnv,
// as we have no intention to initialize the env.
m_option->mutex.unlock();
#endif
do {
if (!baseEnv)
break;
#ifdef PROEVALUATOR_THREAD_SAFE
QMutexLocker locker(&baseEnv->mutex);
if (baseEnv->inProgress && baseEnv->evaluator != this) {
// The env is still in the works, but it may be already past the cache
// loading. So we need to wait for completion and amend it as usual.
QThreadPool::globalInstance()->releaseThread();
baseEnv->cond.wait(&baseEnv->mutex);
QThreadPool::globalInstance()->reserveThread();
}
if (!baseEnv->isOk)
break;
#endif
QMakeEvaluator *baseEval = baseEnv->evaluator;
const ProStringList &oldval = baseEval->values(dstvar);
if (mode == CacheSet) {
newval = diffval;
} else {
newval = oldval;
if (mode == CacheAdd)
newval += diffval;
else
newval.removeEach(diffval);
}
if (oldval != newval) {
if (target != TargetStash || !m_stashfile.isEmpty()) {
baseEval->valuesRef(dstvar) = newval;
if (target == TargetSuper) {
do {
if (dstvar == QLatin1String("QMAKEPATH")) {
baseEval->m_qmakepath = newval.toQStringList();
baseEval->updateMkspecPaths();
} else if (dstvar == QLatin1String("QMAKEFEATURES")) {
baseEval->m_qmakefeatures = newval.toQStringList();
} else {
break;
}
baseEval->updateFeaturePaths();
if (hostBuild == m_hostBuild)
m_featureRoots = baseEval->m_featureRoots;
} while (false);
}
}
changed = true;
}
} while (false);
if (hostBuild)
break;
}
// We assume that whatever got the cached value to be what it is now will do so
// the next time as well, so we just skip the persisting if nothing changed.
if (!persist || !changed)
return ReturnTrue;
varstr = dstvar.toQString();
if (mode == CacheAdd)
varstr += QLatin1String(" +=");
else if (mode == CacheSub)
varstr += QLatin1String(" -=");
else
varstr += QLatin1String(" =");
if (diffval.size() == 1) {
varstr += QLatin1Char(' ');
varstr += quoteValue(diffval.at(0));
} else if (!diffval.isEmpty()) {
for (const ProString &vval : diffval) {
varstr += QLatin1String(" \\\n ");
varstr += quoteValue(vval);
}
}
varstr += QLatin1Char('\n');
}
QString fn;
QMakeVfs::VfsFlags flags = (m_cumulative ? QMakeVfs::VfsCumulative : QMakeVfs::VfsExact);
if (target == TargetSuper) {
if (m_superfile.isEmpty()) {
m_superfile = QDir::cleanPath(m_outputDir + QLatin1String("/.qmake.super"));
printf("Info: creating super cache file %s\n", qPrintable(QDir::toNativeSeparators(m_superfile)));
valuesRef(ProKey("_QMAKE_SUPER_CACHE_")) << ProString(m_superfile);
}
fn = m_superfile;
} else if (target == TargetCache) {
if (m_cachefile.isEmpty()) {
m_cachefile = QDir::cleanPath(m_outputDir + QLatin1String("/.qmake.cache"));
printf("Info: creating cache file %s\n", qPrintable(QDir::toNativeSeparators(m_cachefile)));
valuesRef(ProKey("_QMAKE_CACHE_")) << ProString(m_cachefile);
// We could update m_{source,build}Root and m_featureRoots here, or even
// "re-home" our rootEnv, but this doesn't sound too useful - if somebody
// wanted qmake to find something in the build directory, he could have
// done so "from the outside".
// The sub-projects will find the new cache all by themselves.
}
fn = m_cachefile;
} else {
fn = m_stashfile;
if (fn.isEmpty())
fn = QDir::cleanPath(m_outputDir + QLatin1String("/.qmake.stash"));
if (!m_vfs->exists(fn, flags)) {
printf("Info: creating stash file %s\n", qPrintable(QDir::toNativeSeparators(fn)));
valuesRef(ProKey("_QMAKE_STASH_")) << ProString(fn);
}
}
return writeFile(fL1S("cache "), fn, QIODevice::Append, flags, varstr);
}
QMakeEvaluator::VisitReturn QMakeEvaluator::evaluateBuiltinConditional(
const QMakeInternal::QMakeBuiltin &adef, const ProKey &function, const ProStringList &args)
{
traceMsg("calling built-in %s(%s)", dbgKey(function), dbgSepStrList(args));
int asz = args.size() > 1 ? args.size() : args.at(0).isEmpty() ? 0 : 1;
if (asz < adef.minArgs || asz > adef.maxArgs) {
evalError(adef.usage);
return ReturnFalse;
}
int func_t = adef.index;
switch (func_t) {
case T_DEFINED: {
const ProKey &var = args.at(0).toKey();
if (args.size() > 1) {
if (args[1] == QLatin1String("test")) {
return returnBool(m_functionDefs.testFunctions.contains(var));
} else if (args[1] == QLatin1String("replace")) {
return returnBool(m_functionDefs.replaceFunctions.contains(var));
} else if (args[1] == QLatin1String("var")) {
ProValueMap::Iterator it;
return returnBool(findValues(var, &it));
}
evalError(fL1S("defined(function, type): unexpected type [%1].")
.arg(args.at(1).toQStringView()));
return ReturnFalse;
}
return returnBool(m_functionDefs.replaceFunctions.contains(var)
|| m_functionDefs.testFunctions.contains(var));
}
case T_EXPORT: {
const ProKey &var = map(args.at(0));
for (ProValueMapStack::iterator vmi = m_valuemapStack.end();
--vmi != m_valuemapStack.begin(); ) {
ProValueMap::Iterator it = (*vmi).find(var);
if (it != (*vmi).end()) {
if (it->constBegin() == statics.fakeValue.constBegin()) {
// This is stupid, but qmake doesn't propagate deletions
m_valuemapStack.front()[var] = ProStringList();
} else {
m_valuemapStack.front()[var] = *it;
}
(*vmi).erase(it);
while (--vmi != m_valuemapStack.begin())
(*vmi).remove(var);
break;
}
}
return ReturnTrue;
}
case T_DISCARD_FROM: {
if (m_valuemapStack.size() != 1) {
evalError(fL1S("discard_from() cannot be called from functions."));
return ReturnFalse;
}
ProStringRoUser u1(args.at(0), m_tmp1);
QString fn = resolvePath(u1.str());
QMakeVfs::VfsFlags flags = (m_cumulative ? QMakeVfs::VfsCumulative : QMakeVfs::VfsExact);
int pro = m_vfs->idForFileName(fn, flags | QMakeVfs::VfsAccessedOnly);
if (!pro)
return ReturnFalse;
ProValueMap &vmap = m_valuemapStack.front();
for (auto vit = vmap.begin(); vit != vmap.end(); ) {
if (!vit->isEmpty()) {
auto isFrom = [pro](const ProString &s) {
return s.sourceFile() == pro;
};
vit->removeIf(isFrom);
if (vit->isEmpty()) {
// When an initially non-empty variable becomes entirely empty,
// undefine it altogether.
vit = vmap.erase(vit);
continue;
}
}
++vit;
}
for (auto fit = m_functionDefs.testFunctions.begin(); fit != m_functionDefs.testFunctions.end(); ) {
if (fit->pro()->id() == pro)
fit = m_functionDefs.testFunctions.erase(fit);
else
++fit;
}
for (auto fit = m_functionDefs.replaceFunctions.begin(); fit != m_functionDefs.replaceFunctions.end(); ) {
if (fit->pro()->id() == pro)
fit = m_functionDefs.replaceFunctions.erase(fit);
else
++fit;
}
ProStringList &iif = m_valuemapStack.front()[ProKey("QMAKE_INTERNAL_INCLUDED_FILES")];
int idx = iif.indexOf(ProString(fn));
if (idx >= 0)
iif.removeAt(idx);
return ReturnTrue;
}
case T_INFILE: {
ProValueMap vars;
QString fn = filePathEnvArg0(args);
VisitReturn ok = evaluateFileInto(fn, &vars, LoadProOnly);
if (ok != ReturnTrue)
return ok;
if (args.size() == 2)
return returnBool(vars.contains(map(args.at(1))));
QRegularExpression regx;
regx.setPatternOptions(QRegularExpression::DotMatchesEverythingOption);
ProStringRoUser u1(args.at(2), m_tmp1);
const QString &qry = u1.str();
if (qry != QRegularExpression::escape(qry)) {
regx.setPattern(QRegularExpression::anchoredPattern(qry));
if (!regx.isValid()) {
evalError(fL1S("infile(): Encountered invalid regular expression '%1'.").arg(qry));
return ReturnFalse;
}
}
const auto strings = vars.value(map(args.at(1)));
for (const ProString &s : strings) {
if (s == qry)
return ReturnTrue;
if (!regx.pattern().isEmpty()) {
ProStringRoUser u2(s, m_tmp[m_toggle ^= 1]);
if (regx.match(u2.str()).hasMatch())
return ReturnTrue;
}
}
return ReturnFalse;
}
case T_REQUIRES:
#ifdef PROEVALUATOR_FULL
if (checkRequirements(args) == ReturnError)
return ReturnError;
#endif
return ReturnFalse; // Another qmake breakage
case T_EVAL: {
VisitReturn ret = ReturnFalse;
QString contents = args.join(statics.field_sep);
ProFile *pro = m_parser->parsedProBlock(QStringView(contents),
0, m_current.pro->fileName(), m_current.line);
if (m_cumulative || pro->isOk()) {
m_locationStack.push(m_current);
visitProBlock(pro, pro->tokPtr());
ret = ReturnTrue; // This return value is not too useful, but that's qmake
m_current = m_locationStack.pop();
}
pro->deref();
return ret;
}
case T_IF: {
return evaluateConditional(args.at(0).toQStringView(),
m_current.pro->fileName(), m_current.line);
}
case T_CONFIG: {
if (args.size() == 1)
return returnBool(isActiveConfig(args.at(0).toQStringView()));
const auto mutuals = args.at(1).toQStringView().split(QLatin1Char('|'),
Qt::SkipEmptyParts);
const ProStringList &configs = values(statics.strCONFIG);
for (int i = configs.size() - 1; i >= 0; i--) {
for (int mut = 0; mut < mutuals.size(); mut++) {
if (configs[i].toQStringView() == mutuals[mut].trimmed())
return returnBool(configs[i] == args[0]);
}
}
return ReturnFalse;
}
case T_CONTAINS: {
ProStringRoUser u1(args.at(1), m_tmp1);
const QString &qry = u1.str();
QRegularExpression regx;
regx.setPatternOptions(QRegularExpression::DotMatchesEverythingOption);
if (qry != QRegularExpression::escape(qry)) {
regx.setPattern(QRegularExpression::anchoredPattern(qry));
if (!regx.isValid()) {
evalError(fL1S("contains(): Encountered invalid regular expression '%1'.").arg(qry));
return ReturnFalse;
}
}
const ProStringList &l = values(map(args.at(0)));
if (args.size() == 2) {
for (int i = 0; i < l.size(); ++i) {
const ProString &val = l[i];
if (val == qry)
return ReturnTrue;
if (!regx.pattern().isEmpty()) {
ProStringRoUser u2(val, m_tmp[m_toggle ^= 1]);
if (regx.match(u2.str()).hasMatch())
return ReturnTrue;
}
}
} else {
const auto mutuals = args.at(2).toQStringView().split(QLatin1Char('|'),
Qt::SkipEmptyParts);
for (int i = l.size() - 1; i >= 0; i--) {
const ProString &val = l[i];
for (int mut = 0; mut < mutuals.size(); mut++) {
if (val.toQStringView() == mutuals[mut].trimmed()) {
if (val == qry)
return ReturnTrue;
if (!regx.pattern().isEmpty()) {
ProStringRoUser u2(val, m_tmp[m_toggle ^= 1]);
if (regx.match(u2.str()).hasMatch())
return ReturnTrue;
}
return ReturnFalse;
}
}
}
}
return ReturnFalse;
}
case T_COUNT: {
int cnt = values(map(args.at(0))).size();
int val = args.at(1).toInt();
if (args.size() == 3) {
const ProString &comp = args.at(2);
if (comp == QLatin1String(">") || comp == QLatin1String("greaterThan")) {
return returnBool(cnt > val);
} else if (comp == QLatin1String(">=")) {
return returnBool(cnt >= val);
} else if (comp == QLatin1String("<") || comp == QLatin1String("lessThan")) {
return returnBool(cnt < val);
} else if (comp == QLatin1String("<=")) {
return returnBool(cnt <= val);
} else if (comp == QLatin1String("equals") || comp == QLatin1String("isEqual")
|| comp == QLatin1String("=") || comp == QLatin1String("==")) {
// fallthrough
} else {
evalError(fL1S("Unexpected modifier to count(%2).").arg(comp.toQStringView()));
return ReturnFalse;
}
}
return returnBool(cnt == val);
}
case T_GREATERTHAN:
case T_LESSTHAN: {
const ProString &rhs = args.at(1);
const QString &lhs = values(map(args.at(0))).join(statics.field_sep);
bool ok;
int rhs_int = rhs.toInt(&ok);
if (ok) { // do integer compare
int lhs_int = lhs.toInt(&ok);
if (ok) {
if (func_t == T_GREATERTHAN)
return returnBool(lhs_int > rhs_int);
return returnBool(lhs_int < rhs_int);
}
}
if (func_t == T_GREATERTHAN)
return returnBool(lhs > rhs.toQStringView());
return returnBool(lhs < rhs.toQStringView());
}
case T_EQUALS:
return returnBool(values(map(args.at(0))).join(statics.field_sep)
== args.at(1).toQStringView());
case T_VERSION_AT_LEAST:
case T_VERSION_AT_MOST: {
const QVersionNumber lvn = QVersionNumber::fromString(values(args.at(0).toKey()).join(QLatin1Char('.')));
const QVersionNumber rvn = QVersionNumber::fromString(args.at(1).toQStringView());
if (func_t == T_VERSION_AT_LEAST)
return returnBool(lvn >= rvn);
return returnBool(lvn <= rvn);
}
case T_CLEAR: {
ProValueMap *hsh;
ProValueMap::Iterator it;
const ProKey &var = map(args.at(0));
if (!(hsh = findValues(var, &it)))
return ReturnFalse;
if (hsh == &m_valuemapStack.top())
it->clear();
else
m_valuemapStack.top()[var].clear();
return ReturnTrue;
}
case T_UNSET: {
ProValueMap *hsh;
ProValueMap::Iterator it;
const ProKey &var = map(args.at(0));
if (!(hsh = findValues(var, &it)))
return ReturnFalse;
if (m_valuemapStack.size() == 1)
hsh->erase(it);
else if (hsh == &m_valuemapStack.top())
*it = statics.fakeValue;
else
m_valuemapStack.top()[var] = statics.fakeValue;
return ReturnTrue;
}
case T_PARSE_JSON: {
QByteArray json = values(args.at(0).toKey()).join(QLatin1Char(' ')).toUtf8();
ProStringRoUser u1(args.at(1), m_tmp2);
QString parseInto = u1.str();
return parseJsonInto(json, parseInto, &m_valuemapStack.top());
}
case T_INCLUDE: {
QString parseInto;
LoadFlags flags;
if (m_cumulative)
flags = LoadSilent;
if (args.size() >= 2) {
if (!args.at(1).isEmpty())
parseInto = args.at(1) + QLatin1Char('.');
if (args.size() >= 3 && isTrue(args.at(2)))
flags = LoadSilent;
}
QString fn = filePathEnvArg0(args);
VisitReturn ok;
if (parseInto.isEmpty()) {
ok = evaluateFileChecked(fn, QMakeHandler::EvalIncludeFile, LoadProOnly | flags);
} else {
ProValueMap symbols;
if ((ok = evaluateFileInto(fn, &symbols, LoadAll | flags)) == ReturnTrue) {
ProValueMap newMap;
for (ProValueMap::ConstIterator
it = m_valuemapStack.top().constBegin(),
end = m_valuemapStack.top().constEnd();
it != end; ++it) {
const ProString &ky = it.key();
if (!ky.startsWith(parseInto))
newMap[it.key()] = it.value();
}
for (ProValueMap::ConstIterator it = symbols.constBegin();
it != symbols.constEnd(); ++it) {
if (!it.key().startsWith(QLatin1Char('.')))
newMap.insert(ProKey(parseInto + it.key()), it.value());
}
m_valuemapStack.top() = newMap;
}
}
if (ok == ReturnFalse && (flags & LoadSilent))
ok = ReturnTrue;
return ok;
}
case T_LOAD: {
bool ignore_error = (args.size() == 2 && isTrue(args.at(1)));
VisitReturn ok = evaluateFeatureFile(m_option->expandEnvVars(args.at(0).toQString()),
ignore_error);
if (ok == ReturnFalse && ignore_error)
ok = ReturnTrue;
return ok;
}
case T_DEBUG: {
#ifdef PROEVALUATOR_DEBUG
int level = args.at(0).toInt();
if (level <= m_debugLevel) {
ProStringRoUser u1(args.at(1), m_tmp1);
const QString &msg = m_option->expandEnvVars(u1.str());
debugMsg(level, "Project DEBUG: %s", qPrintable(msg));
}
#endif
return ReturnTrue;
}
case T_LOG:
case T_ERROR:
case T_WARNING:
case T_MESSAGE: {
ProStringRoUser u1(args.at(0), m_tmp1);
const QString &msg = m_option->expandEnvVars(u1.str());
if (!m_skipLevel) {
if (func_t == T_LOG) {
#ifdef PROEVALUATOR_FULL
fputs(msg.toLatin1().constData(), stderr);
#endif
} else if (!msg.isEmpty() || func_t != T_ERROR) {
ProStringRoUser u2(function, m_tmp2);
m_handler->fileMessage(
(func_t == T_ERROR ? QMakeHandler::ErrorMessage :
func_t == T_WARNING ? QMakeHandler::WarningMessage :
QMakeHandler::InfoMessage)
| (m_cumulative ? QMakeHandler::CumulativeEvalMessage : 0),
fL1S("Project %1: %2").arg(u2.str().toUpper(), msg));
}
}
return (func_t == T_ERROR && !m_cumulative) ? ReturnError : ReturnTrue;
}
case T_SYSTEM: {
#ifdef PROEVALUATOR_FULL
if (m_cumulative) // Anything else would be insanity
return ReturnFalse;
#if QT_CONFIG(process)
QProcess proc;
proc.setProcessChannelMode(QProcess::ForwardedChannels);
runProcess(&proc, args.at(0).toQString());
return returnBool(proc.exitStatus() == QProcess::NormalExit && proc.exitCode() == 0);
#else
int ec = system((QLatin1String("cd ")
+ IoUtils::shellQuote(QDir::toNativeSeparators(currentDirectory()))
+ QLatin1String(" && ") + args.at(0)).toLocal8Bit().constData());
# ifdef Q_OS_UNIX
if (ec != -1 && WIFSIGNALED(ec) && (WTERMSIG(ec) == SIGQUIT || WTERMSIG(ec) == SIGINT))
raise(WTERMSIG(ec));
# endif
return returnBool(ec == 0);
#endif
#else
return ReturnTrue;
#endif
}
case T_ISEMPTY: {
return returnBool(values(map(args.at(0))).isEmpty());
}
case T_EXISTS: {
QString file = filePathEnvArg0(args);
// Don't use VFS here:
// - it supports neither listing nor even directories
// - it's unlikely that somebody would test for files they created themselves
if (IoUtils::exists(file))
return ReturnTrue;
int slsh = file.lastIndexOf(QLatin1Char('/'));
QString fn = file.mid(slsh+1);
if (fn.contains(QLatin1Char('*')) || fn.contains(QLatin1Char('?'))) {
QString dirstr = file.left(slsh+1);
dirstr.detach();
if (!QDir(dirstr).entryList(QStringList(fn)).isEmpty())
return ReturnTrue;
}
return ReturnFalse;
}
case T_MKPATH: {
#ifdef PROEVALUATOR_FULL
QString fn = filePathArg0(args);
if (!QDir::current().mkpath(fn)) {
evalError(fL1S("Cannot create directory %1.").arg(QDir::toNativeSeparators(fn)));
return ReturnFalse;
}
#endif
return ReturnTrue;
}
case T_WRITE_FILE: {
QIODevice::OpenMode mode = QIODevice::Truncate;
QMakeVfs::VfsFlags flags = (m_cumulative ? QMakeVfs::VfsCumulative : QMakeVfs::VfsExact);
QString contents;
if (args.size() >= 2) {
const ProStringList &vals = values(args.at(1).toKey());
if (!vals.isEmpty())
contents = vals.join(QLatin1Char('\n')) + QLatin1Char('\n');
if (args.size() >= 3) {
const auto opts = split_value_list(args.at(2).toQStringView());
for (const ProString &opt : opts) {
if (opt == QLatin1String("append")) {
mode = QIODevice::Append;
} else if (opt == QLatin1String("exe")) {
flags |= QMakeVfs::VfsExecutable;
} else {
evalError(fL1S("write_file(): invalid flag %1.").arg(opt.toQStringView()));
return ReturnFalse;
}
}
}
}
QString path = filePathArg0(args);
return writeFile(QString(), path, mode, flags, contents);
}
case T_TOUCH: {
#ifdef PROEVALUATOR_FULL
ProStringRoUser u1(args.at(0), m_tmp1);
ProStringRoUser u2(args.at(1), m_tmp2);
const QString &tfn = resolvePath(u1.str());
const QString &rfn = resolvePath(u2.str());
QString error;
if (!IoUtils::touchFile(tfn, rfn, &error)) {
evalError(error);
return ReturnFalse;
}
#endif
return ReturnTrue;
}
case T_CACHE:
return testFunc_cache(args);
case T_RELOAD_PROPERTIES:
#ifdef QT_BUILD_QMAKE
m_option->reloadProperties();
#endif
return ReturnTrue;
default:
evalError(fL1S("Function '%1' is not implemented.").arg(function.toQStringView()));
return ReturnFalse;
}
}
QT_END_NAMESPACE