qstandardpaths.cpp

Go to the documentation of this file.

// Copyright (C) 2020 The Qt Company Ltd.
// Copyright (C) 2016 Intel Corporation.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qstandardpaths.h"
 
#include <qdir.h>
#include <qfileinfo.h>
 
#ifndef QT_BOOTSTRAPPED
#include <qobject.h>
#include <qcoreapplication.h>
#endif
 
#if __has_include(<paths.h>)
#include <paths.h>
#endif
 
#ifdef Q_OS_UNIX
#include <unistd.h>
#endif
 
#ifndef QT_NO_STANDARDPATHS
 
QT_BEGIN_NAMESPACE
 
using namespace Qt::StringLiterals;
static bool existsAsSpecified(const QString &path, QStandardPaths::LocateOptions options)
{
    if (options & QStandardPaths::LocateDirectory)
        return QDir(path).exists();
    return QFileInfo(path).isFile();
}
 
QString QStandardPaths::locate(StandardLocation type, const QString &fileName, LocateOptions options)
{
    const QStringList &dirs = standardLocations(type);
    for (QStringList::const_iterator dir = dirs.constBegin(); dir != dirs.constEnd(); ++dir) {
        const QString path = *dir + u'/' + fileName;
        if (existsAsSpecified(path, options))
            return path;
    }
    return QString();
}
 
QStringList QStandardPaths::locateAll(StandardLocation type, const QString &fileName, LocateOptions options)
{
    const QStringList &dirs = standardLocations(type);
    QStringList result;
    for (QStringList::const_iterator dir = dirs.constBegin(); dir != dirs.constEnd(); ++dir) {
        const QString path = *dir + u'/' + fileName;
        if (existsAsSpecified(path, options))
            result.append(path);
    }
    return result;
}
 
#ifdef Q_OS_WIN
static QStringList executableExtensions()
{
    // If %PATHEXT% does not contain .exe, it is either empty, malformed, or distorted in ways that we cannot support, anyway.
    const QStringList pathExt = QString::fromLocal8Bit(qgetenv("PATHEXT")).toLower().split(u';');
    return pathExt.contains(".exe"_L1, Qt::CaseInsensitive) ?
           pathExt : QStringList{".exe"_L1, ".com"_L1, ".bat"_L1, ".cmd"_L1};
}
#endif
 
static QString checkExecutable(const QString &path)
{
    const QFileInfo info(path);
    if (info.isBundle())
        return info.bundleName();
    if (info.isFile() && info.isExecutable())
        return QDir::cleanPath(path);
    return QString();
}
 
static inline QString searchExecutable(const QStringList &searchPaths,
                                       const QString &executableName)
{
    const QDir currentDir = QDir::current();
    for (const QString &searchPath : searchPaths) {
        const QString candidate = currentDir.absoluteFilePath(searchPath + u'/' + executableName);
        const QString absPath = checkExecutable(candidate);
        if (!absPath.isEmpty())
            return absPath;
    }
    return QString();
}
 
#ifdef Q_OS_WIN
 
// Find executable appending candidate suffixes, used for suffix-less executables
// on Windows.
static inline QString
    searchExecutableAppendSuffix(const QStringList &searchPaths,
                                 const QString &executableName,
                                 const QStringList &suffixes)
{
    const QDir currentDir = QDir::current();
    for (const QString &searchPath : searchPaths) {
        const QString candidateRoot = currentDir.absoluteFilePath(searchPath + u'/' + executableName);
        for (const QString &suffix : suffixes) {
            const QString absPath = checkExecutable(candidateRoot + suffix);
            if (!absPath.isEmpty())
                return absPath;
        }
    }
    return QString();
}
 
#endif // Q_OS_WIN
 
QString QStandardPaths::findExecutable(const QString &executableName, const QStringList &paths)
{
    if (QFileInfo(executableName).isAbsolute())
        return checkExecutable(executableName);
 
    QStringList searchPaths = paths;
    if (paths.isEmpty()) {
        QByteArray pEnv = qgetenv("PATH");
        if (Q_UNLIKELY(pEnv.isNull())) {
            // Get a default path. POSIX.1 does not actually require this, but
            // most Unix libc fall back to confstr(_CS_PATH) if the PATH
            // environment variable isn't set. Let's try to do the same.
#if defined(_PATH_DEFPATH)
            // BSD API.
            pEnv = _PATH_DEFPATH;
#elif defined(_CS_PATH)
            // POSIX API.
            size_t n = confstr(_CS_PATH, nullptr, 0);
            if (n) {
                pEnv.resize(n);
                // size()+1 is ok because QByteArray always has an extra NUL-terminator
                confstr(_CS_PATH, pEnv.data(), pEnv.size() + 1);
            }
#else
            // Windows SDK's execvpe() does not have a fallback, so we won't
            // apply one either.
#endif
        }
 
        // Remove trailing slashes, which occur on Windows.
        const QStringList rawPaths = QString::fromLocal8Bit(pEnv.constData()).split(
            QDir::listSeparator(), Qt::SkipEmptyParts);
        searchPaths.reserve(rawPaths.size());
        for (const QString &rawPath : rawPaths) {
            QString cleanPath = QDir::cleanPath(rawPath);
            if (cleanPath.size() > 1 && cleanPath.endsWith(u'/'))
                cleanPath.truncate(cleanPath.size() - 1);
            searchPaths.push_back(cleanPath);
        }
    }
 
#ifdef Q_OS_WIN
    // On Windows, if the name does not have a suffix or a suffix not
    // in PATHEXT ("xx.foo"), append suffixes from PATHEXT.
    static const QStringList executable_extensions = executableExtensions();
    if (executableName.contains(u'.')) {
        const QString suffix = QFileInfo(executableName).suffix();
        if (suffix.isEmpty() || !executable_extensions.contains(u'.' + suffix, Qt::CaseInsensitive))
            return searchExecutableAppendSuffix(searchPaths, executableName, executable_extensions);
    } else {
        return searchExecutableAppendSuffix(searchPaths, executableName, executable_extensions);
    }
#endif
    return searchExecutable(searchPaths, executableName);
}
 
#if !defined(Q_OS_DARWIN) && !defined(QT_BOOTSTRAPPED)
QString QStandardPaths::displayName(StandardLocation type)
{
    switch (type) {
    case DesktopLocation:
        return QCoreApplication::translate("QStandardPaths", "Desktop");
    case DocumentsLocation:
        return QCoreApplication::translate("QStandardPaths", "Documents");
    case FontsLocation:
        return QCoreApplication::translate("QStandardPaths", "Fonts");
    case ApplicationsLocation:
        return QCoreApplication::translate("QStandardPaths", "Applications");
    case MusicLocation:
        return QCoreApplication::translate("QStandardPaths", "Music");
    case MoviesLocation:
        return QCoreApplication::translate("QStandardPaths", "Movies");
    case PicturesLocation:
        return QCoreApplication::translate("QStandardPaths", "Pictures");
    case TempLocation:
        return QCoreApplication::translate("QStandardPaths", "Temporary Directory");
    case HomeLocation:
        return QCoreApplication::translate("QStandardPaths", "Home");
    case AppLocalDataLocation:
        return QCoreApplication::translate("QStandardPaths", "Application Data");
    case CacheLocation:
        return QCoreApplication::translate("QStandardPaths", "Cache");
    case GenericDataLocation:
        return QCoreApplication::translate("QStandardPaths", "Shared Data");
    case RuntimeLocation:
        return QCoreApplication::translate("QStandardPaths", "Runtime");
    case ConfigLocation:
        return QCoreApplication::translate("QStandardPaths", "Configuration");
    case GenericConfigLocation:
        return QCoreApplication::translate("QStandardPaths", "Shared Configuration");
    case GenericCacheLocation:
        return QCoreApplication::translate("QStandardPaths", "Shared Cache");
    case DownloadLocation:
        return QCoreApplication::translate("QStandardPaths", "Download");
    case AppDataLocation:
    case AppConfigLocation:
        return QCoreApplication::translate("QStandardPaths", "Application Configuration");
    case PublicShareLocation:
        return QCoreApplication::translate("QStandardPaths", "Public");
    case TemplatesLocation:
        return QCoreApplication::translate("QStandardPaths", "Templates");
    }
    // not reached
    return QString();
}
#endif
 
Q_CONSTINIT static bool qsp_testMode = false;
 
void QStandardPaths::setTestModeEnabled(bool testMode)
{
    qsp_testMode = testMode;
}
 
bool QStandardPaths::isTestModeEnabled()
{
    return qsp_testMode;
}
 
 
QT_END_NAMESPACE
 
#ifndef QT_NO_QOBJECT
#include "moc_qstandardpaths.cpp"
#endif
 
#endif // QT_NO_STANDARDPATHS