diff --git a/qmake/CMakeLists.txt b/qmake/CMakeLists.txt index 0a49c9db79..b89cf25f10 100644 --- a/qmake/CMakeLists.txt +++ b/qmake/CMakeLists.txt @@ -9,6 +9,7 @@ add_library(QtLibraryInfo OBJECT library/proitems.cpp library/proitems.h library/qmake_global.h property.cpp property.h + propertyprinter.cpp propertyprinter.h qmakelibraryinfo.cpp qmakelibraryinfo.h ) set_target_properties(QtLibraryInfo PROPERTIES diff --git a/qmake/main.cpp b/qmake/main.cpp index 3180d5c826..b00d110827 100644 --- a/qmake/main.cpp +++ b/qmake/main.cpp @@ -508,10 +508,18 @@ int runQMake(int argc, char **argv) } QMakeProperty prop; - if(Option::qmake_mode == Option::QMAKE_QUERY_PROPERTY || - Option::qmake_mode == Option::QMAKE_SET_PROPERTY || - Option::qmake_mode == Option::QMAKE_UNSET_PROPERTY) - return prop.exec() ? 0 : 101; + switch (Option::qmake_mode) { + case Option::QMAKE_QUERY_PROPERTY: + return prop.queryProperty(Option::prop::properties); + case Option::QMAKE_SET_PROPERTY: + return prop.setProperty(Option::prop::properties); + case Option::QMAKE_UNSET_PROPERTY: + prop.unsetProperty(Option::prop::properties); + return 0; + default: + break; + } + globals.setQMakeProperty(&prop); ProFileCache proFileCache; diff --git a/qmake/property.cpp b/qmake/property.cpp index 0ef9813eee..2a1c4170b9 100644 --- a/qmake/property.cpp +++ b/qmake/property.cpp @@ -27,7 +27,6 @@ ****************************************************************************/ #include "property.h" -#include "option.h" #include #include @@ -35,6 +34,11 @@ #include #include +namespace { +constexpr int PropSuccessRetCode = 0; +constexpr int PropFailRetCode = 101; +} + QT_BEGIN_NAMESPACE static const struct { @@ -146,76 +150,79 @@ QMakeProperty::remove(const QString &var) settings->remove(var); } -bool -QMakeProperty::exec() +int QMakeProperty::queryProperty(const QStringList &optionProperties, + const PropertyPrinter &printer) { - bool ret = true; - if (Option::qmake_mode == Option::QMAKE_QUERY_PROPERTY) { - if (Option::prop::properties.isEmpty()) { - initSettings(); - const auto keys = settings->childKeys(); - for (const QString &key : keys) { - QString val = settings->value(key).toString(); - fprintf(stdout, "%s:%s\n", qPrintable(key), qPrintable(val)); - } - QStringList specialProps; - for (unsigned i = 0; i < sizeof(propList)/sizeof(propList[0]); i++) - specialProps.append(QString::fromLatin1(propList[i].name)); - specialProps.append("QMAKE_VERSION"); -#ifdef QT_VERSION_STR - specialProps.append("QT_VERSION"); + QList> output; + int ret = PropSuccessRetCode; + if (optionProperties.isEmpty()) { + initSettings(); + const auto keys = settings->childKeys(); + for (const QString &key : keys) { + QString val = settings->value(key).toString(); + output.append({ key, val }); + } + QStringList specialProps; + for (unsigned i = 0; i < sizeof(propList) / sizeof(propList[0]); i++) + specialProps.append(QString::fromLatin1(propList[i].name)); +#ifdef QMAKE_VERSION_STR + specialProps.append("QMAKE_VERSION"); #endif - for (const QString &prop : qAsConst(specialProps)) { - ProString val = value(ProKey(prop)); - ProString pval = value(ProKey(prop + "/raw")); - ProString gval = value(ProKey(prop + "/get")); - ProString sval = value(ProKey(prop + "/src")); - ProString dval = value(ProKey(prop + "/dev")); - 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()); - if (!sval.isEmpty() && sval != gval) - fprintf(stdout, "%s/src:%s\n", prop.toLatin1().constData(), sval.toLatin1().constData()); - if (!dval.isEmpty() && dval != pval) - fprintf(stdout, "%s/dev:%s\n", prop.toLatin1().constData(), dval.toLatin1().constData()); - } - return true; +#ifdef QT_VERSION_STR + specialProps.append("QT_VERSION"); +#endif + for (const QString &prop : qAsConst(specialProps)) { + ProString val = value(ProKey(prop)); + ProString pval = value(ProKey(prop + "/raw")); + ProString gval = value(ProKey(prop + "/get")); + ProString sval = value(ProKey(prop + "/src")); + ProString dval = value(ProKey(prop + "/dev")); + output.append({ prop, val.toQString() }); + if (!pval.isEmpty() && pval != val) + output.append({ prop + "/raw", pval.toQString() }); + if (!gval.isEmpty() && gval != (pval.isEmpty() ? val : pval)) + output.append({ prop + "/get", gval.toQString() }); + if (!sval.isEmpty() && sval != gval) + output.append({ prop + "/src", sval.toQString() }); + if (!dval.isEmpty() && dval != pval) + output.append({ prop + "/dev", dval.toQString() }); } - for (QStringList::ConstIterator it = Option::prop::properties.cbegin(); - it != Option::prop::properties.cend(); it++) { - if (Option::prop::properties.count() > 1) - fprintf(stdout, "%s:", (*it).toLatin1().constData()); - const ProKey pkey(*it); + } else { + for (const auto &prop : optionProperties) { + const ProKey pkey(prop); if (!hasValue(pkey)) { - ret = false; - fprintf(stdout, "**Unknown**\n"); + ret = PropFailRetCode; + output.append({ prop, QString("**Unknown**") }); } else { - fprintf(stdout, "%s\n", value(pkey).toLatin1().constData()); + output.append({ prop, value(pkey).toQString() }); } } - } else if(Option::qmake_mode == Option::QMAKE_SET_PROPERTY) { - for (QStringList::ConstIterator it = Option::prop::properties.cbegin(); - it != Option::prop::properties.cend(); it++) { - QString var = (*it); - it++; - if (it == Option::prop::properties.cend()) { - ret = false; - break; - } - if(!var.startsWith(".")) - setValue(var, (*it)); - } - } else if(Option::qmake_mode == Option::QMAKE_UNSET_PROPERTY) { - for (QStringList::ConstIterator it = Option::prop::properties.cbegin(); - it != Option::prop::properties.cend(); it++) { - QString var = (*it); - if(!var.startsWith(".")) - remove(var); - } } + printer(output); return ret; } +int QMakeProperty::setProperty(const QStringList &optionProperties) +{ + for (auto it = optionProperties.cbegin(); it != optionProperties.cend(); ++it) { + QString var = (*it); + ++it; + if (it == optionProperties.cend()) { + return PropFailRetCode; + } + if (!var.startsWith(".")) + setValue(var, (*it)); + } + return PropSuccessRetCode; +} + +void QMakeProperty::unsetProperty(const QStringList &optionProperties) +{ + for (auto it = optionProperties.cbegin(); it != optionProperties.cend(); ++it) { + QString var = (*it); + if (!var.startsWith(".")) + remove(var); + } +} + QT_END_NAMESPACE diff --git a/qmake/property.h b/qmake/property.h index b0129196eb..7b41a7ad83 100644 --- a/qmake/property.h +++ b/qmake/property.h @@ -30,6 +30,7 @@ #define PROPERTY_H #include "library/proitems.h" +#include "propertyprinter.h" #include #include @@ -39,7 +40,7 @@ QT_BEGIN_NAMESPACE class QSettings; -class QMakeProperty +class QMakeProperty final { QSettings *settings; void initSettings(); @@ -58,7 +59,10 @@ public: void setValue(QString, const QString &); void remove(const QString &); - bool exec(); + int queryProperty(const QStringList &optionProperties = QStringList(), + const PropertyPrinter &printer = qmakePropertyPrinter); + int setProperty(const QStringList &optionProperties); + void unsetProperty(const QStringList &optionProperties); }; QT_END_NAMESPACE diff --git a/qmake/propertyprinter.cpp b/qmake/propertyprinter.cpp new file mode 100644 index 0000000000..d59e99f824 --- /dev/null +++ b/qmake/propertyprinter.cpp @@ -0,0 +1,68 @@ +/**************************************************************************** +** +** Copyright (C) 2021 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the QtCore module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** 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 Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** 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-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "propertyprinter.h" + +#include + +QT_BEGIN_NAMESPACE + +void qmakePropertyPrinter(const QList> &values) +{ + // Assume single property request + if (values.count() == 1) { + std::cout << qPrintable(values.at(0).second) << std::endl; + return; + } + + for (const auto &val : values) { + std::cout << qPrintable(val.first) << ":" << qPrintable(val.second) << std::endl; + } +} + +void jsonPropertyPrinter(const QList> &values) +{ + std::cout << "{\n"; + for (const auto &val : values) { + std::cout << "\"" << qPrintable(val.first) << "\":\"" << qPrintable(val.second) << "\",\n"; + } + std::cout << "}\n"; +} + +QT_END_NAMESPACE diff --git a/qmake/propertyprinter.h b/qmake/propertyprinter.h new file mode 100644 index 0000000000..c885d5b055 --- /dev/null +++ b/qmake/propertyprinter.h @@ -0,0 +1,58 @@ +/**************************************************************************** +** +** Copyright (C) 2021 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the QtCore module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** 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 Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** 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-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef PROPERTYPRINTER_H +#define PROPERTYPRINTER_H + +#include +#include +#include +#include + +#include + +QT_BEGIN_NAMESPACE + +using PropertyPrinter = std::function> &)>; +void qmakePropertyPrinter(const QList> &values); +void jsonPropertyPrinter(const QList> &values); + +QT_END_NAMESPACE + +#endif // PROPERTYPRINTER_H diff --git a/src/tools/CMakeLists.txt b/src/tools/CMakeLists.txt index 463f8bcc5b..b73c050e5b 100644 --- a/src/tools/CMakeLists.txt +++ b/src/tools/CMakeLists.txt @@ -5,6 +5,9 @@ if (QT_FEATURE_dbus) endif() add_subdirectory(qlalr) add_subdirectory(qvkgen) +if (QT_FEATURE_commandlineparser) + add_subdirectory(qtpaths) +endif() # Only include the following tools when performing a host build if(NOT CMAKE_CROSSCOMPILING) diff --git a/src/tools/qtpaths/CMakeLists.txt b/src/tools/qtpaths/CMakeLists.txt new file mode 100644 index 0000000000..a866000eaa --- /dev/null +++ b/src/tools/qtpaths/CMakeLists.txt @@ -0,0 +1,24 @@ +# Generated from qtpaths.pro. + +##################################################################### +## qtpaths App: +##################################################################### + +qt_get_tool_target_name(target_name qtpaths) +qt_internal_add_tool(${target_name} + TARGET_DESCRIPTION "Qt tool that provides the standard paths of the Qt framework" + TOOLS_TARGET Core + SOURCES + qtpaths.cpp + DEFINES + QT_NO_FOREACH +) + +## Scopes: +##################################################################### + +if(WIN32) + set_target_properties(qtpaths PROPERTIES + WIN32_EXECUTABLE FALSE + ) +endif() diff --git a/src/tools/qtpaths/qtpaths.cpp b/src/tools/qtpaths/qtpaths.cpp new file mode 100644 index 0000000000..93e2e42a5f --- /dev/null +++ b/src/tools/qtpaths/qtpaths.cpp @@ -0,0 +1,325 @@ +/**************************************************************************** + * * + ** Copyright (C) 2016 Sune Vuorela + ** Contact: http://www.qt-project.org/ + ** + ** This file is part of the tools applications of the Qt Toolkit. + ** + ** $QT_BEGIN_LICENSE:BSD$ + ** 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. + ** + ** BSD License Usage + ** Alternatively, you may use this file under the terms of the BSD license + ** as follows: + ** + ** "Redistribution and use in source and binary forms, with or without + ** modification, are permitted provided that the following conditions are + ** met: + ** * Redistributions of source code must retain the above copyright + ** notice, this list of conditions and the following disclaimer. + ** * Redistributions in binary form must reproduce the above copyright + ** notice, this list of conditions and the following disclaimer in + ** the documentation and/or other materials provided with the + ** distribution. + ** * Neither the name of The Qt Company Ltd nor the names of its + ** contributors may be used to endorse or promote products derived + ** from this software without specific prior written permission. + ** + ** + ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + ** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + ** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + ** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + ** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + ** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + ** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + ** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + ** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + ** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE." + ** + ** $QT_END_LICENSE$ + ** + ****************************************************************************/ + +#include +#include +#include +#include +#include + +#include + +#include + +QT_USE_NAMESPACE + +/** + * Prints the string on stdout and appends a newline + * \param string printable string + */ +static void message(const QString &string) +{ + fprintf(stdout, "%s\n", qPrintable(string)); +} + +/** + * Writes error message and exits 1 + * \param message to write + */ +Q_NORETURN static void error(const QString &message) +{ + fprintf(stderr, "%s\n", qPrintable(message)); + ::exit(EXIT_FAILURE); +} + +class StringEnum { +public: + const char *stringvalue; + QStandardPaths::StandardLocation enumvalue; + bool hasappname; + + /** + * Replace application name by generic name if requested + */ + QString mapName(const QString &s) const + { + return hasappname ? QString(s).replace("qtpaths", "") : s; + } +}; + +static const StringEnum lookupTableData[] = { + { "AppConfigLocation", QStandardPaths::AppConfigLocation, true }, + { "AppDataLocation", QStandardPaths::AppDataLocation, true }, + { "AppLocalDataLocation", QStandardPaths::AppLocalDataLocation, true }, + { "ApplicationsLocation", QStandardPaths::ApplicationsLocation, false }, + { "CacheLocation", QStandardPaths::CacheLocation, true }, + { "ConfigLocation", QStandardPaths::ConfigLocation, false }, +#if QT_VERSION < QT_VERSION_CHECK(6,0,0) + { "DataLocation", QStandardPaths::DataLocation, true }, +#endif + { "DesktopLocation", QStandardPaths::DesktopLocation, false }, + { "DocumentsLocation", QStandardPaths::DocumentsLocation, false }, + { "DownloadLocation", QStandardPaths::DownloadLocation, false }, + { "FontsLocation", QStandardPaths::FontsLocation, false }, + { "GenericCacheLocation", QStandardPaths::GenericCacheLocation, false }, + { "GenericConfigLocation", QStandardPaths::GenericConfigLocation, false }, + { "GenericDataLocation", QStandardPaths::GenericDataLocation, false }, + { "HomeLocation", QStandardPaths::HomeLocation, false }, + { "MoviesLocation", QStandardPaths::MoviesLocation, false }, + { "MusicLocation", QStandardPaths::MusicLocation, false }, + { "PicturesLocation", QStandardPaths::PicturesLocation, false }, + { "RuntimeLocation", QStandardPaths::RuntimeLocation, false }, + { "TempLocation", QStandardPaths::TempLocation, false } +}; + +/** + * \return available types as a QStringList. + */ +static QStringList types() +{ + QStringList typelist; + for (const StringEnum &se : lookupTableData) + typelist << QString::fromLatin1(se.stringvalue); + std::sort(typelist.begin(), typelist.end()); + return typelist; +} + +/** + * Tries to parse the location string into a reference to a StringEnum entry or alternatively + * calls \ref error with a error message + */ +static const StringEnum &parseLocationOrError(const QString &locationString) +{ + for (const StringEnum &se : lookupTableData) + if (locationString == QLatin1String(se.stringvalue)) + return se; + + QString message = QCoreApplication::translate("qtpaths", "Unknown location: %1"); + error(message.arg(locationString)); +} + +/** + * searches for exactly one remaining argument and returns it. + * If not found, \ref error is called with a error message. + * \param parser to ask for remaining arguments + * \return one extra argument + */ +static QString searchStringOrError(QCommandLineParser *parser) +{ + int positionalArgumentCount = parser->positionalArguments().size(); + if (positionalArgumentCount != 1) + error(QCoreApplication::translate("qtpaths", "Exactly one argument needed as searchitem")); + return parser->positionalArguments().constFirst(); +} + +int main(int argc, char **argv) +{ + QCoreApplication app(argc, argv); + app.setApplicationVersion("1.0"); + +#ifdef Q_OS_WIN + const QLatin1Char pathsep(';'); +#else + const QLatin1Char pathsep(':'); +#endif + + QCommandLineParser parser; + parser.setApplicationDescription(QCoreApplication::translate("qtpaths", "Command line client to QStandardPaths")); + parser.addPositionalArgument(QCoreApplication::translate("qtpaths", "[name]"), QCoreApplication::tr("Name of file or directory")); + parser.addHelpOption(); + parser.addVersionOption(); + + //setting up options + QCommandLineOption types(QStringLiteral("types"), QCoreApplication::translate("qtpaths", "Available location types.")); + parser.addOption(types); + + QCommandLineOption paths(QStringLiteral("paths"), QCoreApplication::translate("qtpaths", "Find paths for ."), QStringLiteral("type")); + parser.addOption(paths); + + QCommandLineOption writablePath(QStringLiteral("writable-path"), + QCoreApplication::translate("qtpaths", "Find writable path for ."), QStringLiteral("type")); + parser.addOption(writablePath); + + QCommandLineOption locateDir(QStringList() << QStringLiteral("locate-dir") << QStringLiteral("locate-directory"), + QCoreApplication::translate("qtpaths", "Locate directory [name] in ."), QStringLiteral("type")); + parser.addOption(locateDir); + + QCommandLineOption locateDirs(QStringList() << QStringLiteral("locate-dirs") << QStringLiteral("locate-directories"), + QCoreApplication::translate("qtpaths", "Locate directories [name] in all paths for ."), QStringLiteral("type")); + parser.addOption(locateDirs); + + QCommandLineOption locateFile(QStringLiteral("locate-file"), + QCoreApplication::translate("qtpaths", "Locate file [name] for ."), QStringLiteral("type")); + parser.addOption(locateFile); + + QCommandLineOption locateFiles(QStringLiteral("locate-files"), + QCoreApplication::translate("qtpaths", "Locate files [name] in all paths for ."), QStringLiteral("type")); + parser.addOption(locateFiles); + + QCommandLineOption findExe(QStringList() << QStringLiteral("find-exe") << QStringLiteral("find-executable"), + QCoreApplication::translate("qtpaths", "Find executable with [name].")); + parser.addOption(findExe); + + QCommandLineOption display(QStringList() << QStringLiteral("display"), + QCoreApplication::translate("qtpaths", "Prints user readable name for ."), QStringLiteral("type")); + parser.addOption(display); + + QCommandLineOption testmode(QStringList() << QStringLiteral("testmode") << QStringLiteral("test-mode"), + QCoreApplication::translate("qtpaths", "Use paths specific for unit testing.")); + parser.addOption(testmode); + + QCommandLineOption qtversion(QStringLiteral("qt-version"), QCoreApplication::translate("qtpaths", "Qt version.")); + parser.addOption(qtversion); + + QCommandLineOption installprefix(QStringLiteral("install-prefix"), QCoreApplication::translate("qtpaths", "Installation prefix for Qt.")); + parser.addOption(installprefix); + + QCommandLineOption bindir(QStringList() << QStringLiteral("binaries-dir") << QStringLiteral("binaries-directory"), + QCoreApplication::translate("qtpaths", "Location of Qt executables.")); + parser.addOption(bindir); + + QCommandLineOption plugindir(QStringList() << QStringLiteral("plugin-dir") << QStringLiteral("plugin-directory"), + QCoreApplication::translate("qtpaths", "Location of Qt plugins.")); + parser.addOption(plugindir); + + parser.process(app); + + QStandardPaths::setTestModeEnabled(parser.isSet(testmode)); + + QStringList results; + if (parser.isSet(qtversion)) { + QString qtversionstring = QString::fromLatin1(qVersion()); + results << qtversionstring; + } + + if (parser.isSet(installprefix)) { + QString path = QLibraryInfo::path(QLibraryInfo::PrefixPath); + results << path; + } + + if (parser.isSet(bindir)) { + QString path = QLibraryInfo::path(QLibraryInfo::BinariesPath); + results << path; + } + + if (parser.isSet(plugindir)) { + QString path = QLibraryInfo::path(QLibraryInfo::PluginsPath); + results << path; + } + + if (parser.isSet(types)) { + QStringList typesList = ::types(); + results << typesList.join('\n'); + } + + if (parser.isSet(display)) { + const StringEnum &location = parseLocationOrError(parser.value(display)); + QString text = QStandardPaths::displayName(location.enumvalue); + results << location.mapName(text); + } + + if (parser.isSet(paths)) { + const StringEnum &location = parseLocationOrError(parser.value(paths)); + QStringList paths = QStandardPaths::standardLocations(location.enumvalue); + results << location.mapName(paths.join(pathsep)); + } + + if (parser.isSet(writablePath)) { + const StringEnum &location = parseLocationOrError(parser.value(writablePath)); + QString path = QStandardPaths::writableLocation(location.enumvalue); + results << location.mapName(path); + } + + if (parser.isSet(findExe)) { + QString searchitem = searchStringOrError(&parser); + QString path = QStandardPaths::findExecutable(searchitem); + results << path; + } + + if (parser.isSet(locateDir)) { + const StringEnum &location = parseLocationOrError(parser.value(locateDir)); + QString searchitem = searchStringOrError(&parser); + QString path = QStandardPaths::locate(location.enumvalue, searchitem, QStandardPaths::LocateDirectory); + results << location.mapName(path); + } + + if (parser.isSet(locateFile)) { + const StringEnum &location = parseLocationOrError(parser.value(locateFile)); + QString searchitem = searchStringOrError(&parser); + QString path = QStandardPaths::locate(location.enumvalue, searchitem, QStandardPaths::LocateFile); + results << location.mapName(path); + } + + if (parser.isSet(locateDirs)) { + const StringEnum &location = parseLocationOrError(parser.value(locateDirs)); + QString searchitem = searchStringOrError(&parser); + QStringList paths = QStandardPaths::locateAll(location.enumvalue, searchitem, QStandardPaths::LocateDirectory); + results << location.mapName(paths.join(pathsep)); + } + + if (parser.isSet(locateFiles)) { + const StringEnum &location = parseLocationOrError(parser.value(locateFiles)); + QString searchitem = searchStringOrError(&parser); + QStringList paths = QStandardPaths::locateAll(location.enumvalue, searchitem, QStandardPaths::LocateFile); + results << location.mapName(paths.join(pathsep)); + } + if (results.isEmpty()) { + parser.showHelp(); + } else if (results.size() == 1) { + const QString &item = results.first(); + message(item); + if (item.isEmpty()) + return EXIT_FAILURE; + } else { + QString errorMessage = QCoreApplication::translate("qtpaths", "Several options given, only one is supported at a time."); + error(errorMessage); + } + return EXIT_SUCCESS; +}