}
for(QStringList::Iterator concat_it = concat.begin();
concat_it != concat.end(); ++concat_it)
- feature_roots << (QLibraryInfo::location(QLibraryInfo::HostDataPath) +
+ feature_roots << (QLibraryInfo::rawLocation(QLibraryInfo::HostDataPath,
+ QLibraryInfo::EffectivePaths) +
mkspecs_concat + (*concat_it));
feature_roots.removeDuplicates();
return feature_roots;
ret << project_build_root + concat;
if (!project_root.isEmpty())
ret << project_root + concat;
- ret << QLibraryInfo::location(QLibraryInfo::DataPath) + concat;
+ ret << QLibraryInfo::rawLocation(QLibraryInfo::HostDataPath, QLibraryInfo::EffectivePaths) + concat;
ret.removeDuplicates();
return ret;
place[var] = QStringList(Option::fixPathToTargetOS(
!Option::qmake_abslocation.isEmpty()
? Option::qmake_abslocation
- : QLibraryInfo::location(QLibraryInfo::HostBinariesPath) + "/qmake",
+ : QLibraryInfo::rawLocation(QLibraryInfo::HostBinariesPath,
+ QLibraryInfo::EffectivePaths) + "/qmake",
false));
}
#if defined(Q_OS_WIN32) && defined(Q_CC_MSVC)
{
for (int i = 0; i < sizeof(propList)/sizeof(propList[0]); i++) {
QString name = QString::fromLatin1(propList[i].name);
- QString val = QLibraryInfo::rawLocation(propList[i].loc);
+ m_values[name + "/get"] = QLibraryInfo::rawLocation(propList[i].loc, QLibraryInfo::EffectivePaths);
+ QString val = QLibraryInfo::rawLocation(propList[i].loc, QLibraryInfo::FinalPaths);
if (!propList[i].raw) {
m_values[name] = QLibraryInfo::location(propList[i].loc);
name += "/raw";
foreach (QString prop, specialProps) {
QString val = value(prop);
QString pval = value(prop + "/raw");
+ QString gval = value(prop + "/get");
fprintf(stdout, "%s:%s\n", prop.toLatin1().constData(), val.toLatin1().constData());
if (!pval.isEmpty() && pval != val)
fprintf(stdout, "%s/raw:%s\n", prop.toLatin1().constData(), pval.toLatin1().constData());
+ if (!gval.isEmpty() && gval != (pval.isEmpty() ? val : pval))
+ fprintf(stdout, "%s/get:%s\n", prop.toLatin1().constData(), gval.toLatin1().constData());
}
return true;
}
{
QLibrarySettings();
QScopedPointer<QSettings> settings;
+#ifdef QT_BUILD_QMAKE
+ bool haveEffectivePaths;
+ bool havePaths;
+#endif
};
Q_GLOBAL_STATIC(QLibrarySettings, qt_library_settings)
{
public:
static QSettings *findConfiguration();
+#ifndef QT_BUILD_QMAKE
static void cleanup()
{
QLibrarySettings *ls = qt_library_settings();
if (ls)
ls->settings.reset(0);
}
+#else
+ static bool haveGroup(QLibraryInfo::PathGroup group)
+ {
+ QLibrarySettings *ls = qt_library_settings();
+ return ls ? (group == QLibraryInfo::EffectivePaths
+ ? ls->haveEffectivePaths : ls->havePaths) : false;
+ }
+#endif
static QSettings *configuration()
{
QLibrarySettings *ls = qt_library_settings();
{
#ifndef QT_BUILD_QMAKE
qAddPostRoutine(QLibraryInfoPrivate::cleanup);
+ bool haveEffectivePaths;
+ bool havePaths;
#endif
+ if (settings) {
+ // This code needs to be in the regular library, as otherwise a qt.conf that
+ // works for qmake would break things for dynamically built Qt tools.
+ QStringList children = settings->childGroups();
+ haveEffectivePaths = children.contains(QLatin1String("EffectivePaths"));
+ // Backwards compat: an existing but empty file is claimed to contain the Paths section.
+ havePaths = !haveEffectivePaths || children.contains(QLatin1String("Paths"));
+#ifndef QT_BUILD_QMAKE
+ if (!havePaths)
+ settings.reset(0);
+#else
+ } else {
+ haveEffectivePaths = false;
+ havePaths = false;
+#endif
+ }
}
QSettings *QLibraryInfoPrivate::findConfiguration()
QLibraryInfo::location(LibraryLocation loc)
{
#ifdef QT_BUILD_QMAKE
- QString ret = rawLocation(loc);
+ QString ret = rawLocation(loc, FinalPaths);
// Automatically prepend the sysroot to target paths
if (loc < SysrootPath || loc > LastHostPath) {
- QString sysroot = rawLocation(SysrootPath);
+ QString sysroot = rawLocation(SysrootPath, FinalPaths);
if (!sysroot.isEmpty() && ret.length() > 2 && ret.at(1) == QLatin1Char(':')
&& (ret.at(2) == QLatin1Char('/') || ret.at(2) == QLatin1Char('\\')))
ret.replace(0, 2, sysroot); // Strip out the drive on Windows targets
}
QString
-QLibraryInfo::rawLocation(LibraryLocation loc)
+QLibraryInfo::rawLocation(LibraryLocation loc, PathGroup group)
{
#else
-# define rawLocation location
+# define rawLocation(loca, group) location(loca)
+# define group dummy
#endif
QString ret;
- if(!QLibraryInfoPrivate::configuration()) {
+#ifdef QT_BUILD_QMAKE
+ // Logic for choosing the right data source: if EffectivePaths are requested
+ // and qt.conf with that section is present, use it, otherwise fall back to
+ // FinalPaths. For FinalPaths, use qt.conf if present and contains not only
+ // [EffectivePaths], otherwise fall back to builtins.
+ if (!QLibraryInfoPrivate::haveGroup(group)
+ && (group == FinalPaths
+ || !(group = FinalPaths, QLibraryInfoPrivate::haveGroup(FinalPaths))))
+#else
+ if (!QLibraryInfoPrivate::configuration())
+#endif
+ {
const char *path = 0;
if (loc >= 0 && loc < sizeof(qt_configure_prefix_path_strs)/sizeof(qt_configure_prefix_path_strs[0]))
path = qt_configure_prefix_path_strs[loc] + 12;
if(!key.isNull()) {
QSettings *config = QLibraryInfoPrivate::configuration();
- config->beginGroup(QLatin1String("Paths"));
+ config->beginGroup(QLatin1String(
+#ifdef QT_BUILD_QMAKE
+ group == EffectivePaths ? "EffectivePaths" :
+#endif
+ "Paths"));
ret = config->value(key, defaultValue).toString();
baseDir = QFileInfo(qmake_libraryInfoFile()).absolutePath();
} else if (loc > SysrootPath && loc <= LastHostPath) {
// We make any other host path absolute to the host prefix directory.
- baseDir = rawLocation(HostPrefixPath);
+ baseDir = rawLocation(HostPrefixPath, group);
#else
if (loc == PrefixPath) {
if (QCoreApplication::instance()) {
#endif
} else {
// we make any other path absolute to the prefix directory
- baseDir = rawLocation(PrefixPath);
+ baseDir = rawLocation(PrefixPath, group);
}
ret = QDir::cleanPath(baseDir + QLatin1Char('/') + ret);
}