10 files changed, 192 insertions, 314 deletions

diff --git a/src/lib/pkgconfig/CMakeLists.txt b/src/lib/pkgconfig/CMakeLists.txt
index e64d934c8..c82edac16 100644
--- a/src/lib/pkgconfig/CMakeLists.txt
+++ b/src/lib/pkgconfig/CMakeLists.txt
@@ -15,7 +15,7 @@ else()
 endif()
 
 set(QBS_PKGCONFIG_PUBLIC_DEPENDS "")
-if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 8.0)
+if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 9.0)
     set(QBS_PKGCONFIG_PUBLIC_DEPENDS "stdc++fs")
 endif()
 
diff --git a/src/lib/pkgconfig/pcpackage.cpp b/src/lib/pkgconfig/pcpackage.cpp
index cba783708..9aaefcfde 100644
--- a/src/lib/pkgconfig/pcpackage.cpp
+++ b/src/lib/pkgconfig/pcpackage.cpp
@@ -43,6 +43,8 @@
 
 namespace qbs {
 
+using Internal::startsWith;
+
 using ComparisonType = PcPackage::RequiredVersion::ComparisonType;
 
 std::string_view PcPackage::Flag::typeToString(Type t)
@@ -67,25 +69,25 @@ std::optional<PcPackage::Flag::Type> PcPackage::Flag::typeFromString(std::string
 {
     if (s == "LibraryName")
         return Type::LibraryName;
-    else if (s == "StaticLibraryName")
+    if (s == "StaticLibraryName")
         return Type::StaticLibraryName;
-    else if (s == "LibraryPath")
+    if (s == "LibraryPath")
         return Type::LibraryPath;
-    else if (s == "Framework")
+    if (s == "Framework")
         return Type::Framework;
-    else if (s == "FrameworkPath")
+    if (s == "FrameworkPath")
         return Type::FrameworkPath;
-    else if (s == "LinkerFlag")
+    if (s == "LinkerFlag")
         return Type::LinkerFlag;
-    else if (s == "IncludePath")
+    if (s == "IncludePath")
         return Type::IncludePath;
-    else if (s == "SystemIncludePath")
+    if (s == "SystemIncludePath")
         return Type::SystemIncludePath;
-    else if (s == "DirAfterIncludePath")
+    if (s == "DirAfterIncludePath")
         return Type::DirAfterIncludePath;
-    else if (s == "Define")
+    if (s == "Define")
         return Type::Define;
-    else if (s == "CompilerFlag")
+    if (s == "CompilerFlag")
         return Type::CompilerFlag;
     return std::nullopt;
 }
@@ -108,21 +110,41 @@ std::optional<ComparisonType> PcPackage::RequiredVersion::comparisonFromString(s
 {
     if (s == "LessThan")
         return ComparisonType::LessThan;
-    else if (s == "GreaterThan")
+    if (s == "GreaterThan")
         return ComparisonType::GreaterThan;
-    else if (s == "LessThanEqual")
+    if (s == "LessThanEqual")
         return ComparisonType::LessThanEqual;
-    else if (s == "GreaterThanEqual")
+    if (s == "GreaterThanEqual")
         return ComparisonType::GreaterThanEqual;
-    else if (s == "Equal")
+    if (s == "Equal")
         return ComparisonType::Equal;
-    else if (s == "NotEqual")
+    if (s == "NotEqual")
         return ComparisonType::NotEqual;
-    else if (s == "AlwaysMatch")
+    if (s == "AlwaysMatch")
         return ComparisonType::AlwaysMatch;
     return std::nullopt;
 }
 
+// see https://github.com/pkgconf/pkgconf/blob/pkgconf-2.1.0/libpkgconf/tuple.c#L194
+bool PcPackage::shouldRewriteSysroot(std::string_view sysroot, std::string_view value)
+{
+    if (sysroot.empty() || value.empty())
+        return false;
+
+    if (value.front() != '/')
+        return false;
+
+    if (sysroot == "/")
+        return false;
+
+    if (startsWith(value, sysroot))
+        return false;
+
+    return true;
+}
+
+// TODO: pkg-config only prepends sysroot to flags; while pkgconf does this as a part of the
+// variable substitution and thus this affects all variables, not only flags
 PcPackage PcPackage::prependSysroot(std::string_view sysroot) &&
 {
     PcPackage package(std::move(*this));
@@ -132,6 +154,8 @@ PcPackage PcPackage::prependSysroot(std::string_view sysroot) &&
         if (sysroot.empty())
             return flags;
         for (auto &flag : flags) {
+            if (!shouldRewriteSysroot(sysroot, flag.value))
+                continue;
             if (flag.type == Flag::Type::IncludePath
                     || flag.type == Flag::Type::SystemIncludePath
                     || flag.type == Flag::Type::DirAfterIncludePath
@@ -169,4 +193,51 @@ PcPackage PcPackage::removeSystemLibraryPaths(
     return package;
 }
 
+namespace Internal {
+
+std::string_view fileName(std::string_view filePath)
+{
+    const auto pos = filePath.rfind('/');
+    if (pos == std::string_view::npos) {
+#if defined(WIN32)
+        if (filePath.size() >= 2 && filePath[1] == ':')
+            return filePath.substr(2);
+#endif
+        return filePath;
+    }
+    return filePath.substr(pos + 1);
+}
+
+std::string_view completeBaseName(std::string_view filePath)
+{
+    filePath = fileName(filePath);
+    const auto pos = filePath.rfind('.');
+    return pos == std::string_view::npos
+            ? filePath
+            : filePath.substr(0, pos);
+}
+
+std::string_view parentPath(std::string_view path)
+{
+    if (path.empty())
+        return {};
+    auto pos = path.rfind('/');
+    if (pos == std::string_view::npos) {
+#if defined(WIN32)
+        if (path.size() >= 2 && path[1] == ':')
+            return path.substr(0, 2);
+#endif
+        return ".";
+    }
+    if (pos == 0)
+        return "/";
+#if defined(WIN32)
+    if (pos == 2 && path[1] == ':')
+        return path.substr(0, pos + 1);
+#endif
+    return path.substr(0, pos);
+};
+
+} // namespace Internal
+
 } // namespace qbs
diff --git a/src/lib/pkgconfig/pcpackage.h b/src/lib/pkgconfig/pcpackage.h
index 340a4698f..794e2fc40 100644
--- a/src/lib/pkgconfig/pcpackage.h
+++ b/src/lib/pkgconfig/pcpackage.h
@@ -112,12 +112,14 @@ public:
     std::vector<RequiredVersion> requiresPublic;
     std::vector<RequiredVersion> requiresPrivate;
     std::vector<RequiredVersion> conflicts;
+    std::optional<std::string> oldPrefix;
 
     using VariablesMap = std::map<std::string, std::string, std::less<>>;
-    VariablesMap vars;
+    VariablesMap variables;
 
     bool uninstalled{false};
 
+    static bool shouldRewriteSysroot(std::string_view sysroot, std::string_view value);
     PcPackage prependSysroot(std::string_view sysroot) &&;
     PcPackage removeSystemLibraryPaths(const std::unordered_set<std::string> &libraryPaths) &&;
 };
@@ -181,6 +183,26 @@ inline bool operator!=(const PcPackage::Flag &lhs, const PcPackage::Flag &rhs)
     return !(lhs == rhs);
 }
 
+namespace Internal {
+
+// fast versions (no allocations) of the QFileInfo methods
+std::string_view fileName(std::string_view filePath);
+std::string_view completeBaseName(std::string_view filePath);
+std::string_view parentPath(std::string_view path);
+
+inline bool startsWith(std::string_view haystack, std::string_view needle)
+{
+    return haystack.size() >= needle.size() && haystack.compare(0, needle.size(), needle) == 0;
+}
+
+inline bool endsWith(std::string_view haystack, std::string_view needle)
+{
+    return haystack.size() >= needle.size()
+            && haystack.compare(haystack.size() - needle.size(), needle.size(), needle) == 0;
+}
+
+} // Internal
+
 } // namespace qbs
 
 namespace std {
diff --git a/src/lib/pkgconfig/pcparser.cpp b/src/lib/pkgconfig/pcparser.cpp
index b3ba57c3d..eb07aa5ef 100644
--- a/src/lib/pkgconfig/pcparser.cpp
+++ b/src/lib/pkgconfig/pcparser.cpp
@@ -56,13 +56,28 @@ namespace std {
 #endif
 
 #include <algorithm>
+#include <cctype>
 #include <fstream>
 #include <stdexcept>
 
 namespace qbs {
 
+using Internal::completeBaseName;
+using Internal::parentPath;
+using Internal::startsWith;
+using Internal::endsWith;
+
 namespace {
 
+// workaround for a missing ctor before c++20
+template<typename It>
+std::string_view makeStringView(It begin, It end)
+{
+    if (begin == end)
+        return {};
+    return std::string_view(&*begin, std::distance(begin, end));
+}
+
 bool readOneLine(std::ifstream &file, std::string &line)
 {
     bool quoted = false;
@@ -81,9 +96,8 @@ bool readOneLine(std::ifstream &file, std::string &line)
                 line += '\\';
 
             return n_read > 0;
-        } else {
-            n_read++;
         }
+        n_read++;
 
         if (c == '\r') {
             n_read--;
@@ -133,7 +147,7 @@ std::string_view trimmed(std::string_view str)
     const auto right = std::find_if_not(str.rbegin(), str.rend(), predicate).base();
     if (right <= left)
         return {};
-    return std::string_view(&*left, std::distance(left, right));
+    return makeStringView(left, right);
 }
 
 // based on https://opensource.apple.com/source/distcc/distcc-31.0.81/popt/poptparse.c.auto.html
@@ -186,17 +200,6 @@ std::optional<std::vector<std::string>> splitCommand(std::string_view s)
     return result;
 }
 
-bool startsWith(std::string_view haystack, std::string_view needle)
-{
-    return haystack.size() >= needle.size() && haystack.compare(0, needle.size(), needle) == 0;
-}
-
-bool endsWith(std::string_view haystack, std::string_view needle)
-{
-    return haystack.size() >= needle.size()
-            && haystack.compare(haystack.size() - needle.size(), needle.size(), needle) == 0;
-}
-
 [[noreturn]] void raizeUnknownComparisonException(const PcPackage &pkg, std::string_view verName, std::string_view comp)
 {
     std::string message;
@@ -388,17 +391,6 @@ PcPackage::RequiredVersion::ComparisonType comparisonFromString(
     raizeUnknownComparisonException(pkg, verName, comp);
 }
 
-std::string baseName(const std::string_view &filePath)
-{
-    auto pos = filePath.rfind('/');
-    const auto fileName =
-            pos == std::string_view::npos ? std::string_view() : filePath.substr(pos + 1);
-    pos = fileName.rfind('.');
-    return std::string(pos == std::string_view::npos
-            ? std::string_view()
-            : fileName.substr(0, pos));
-}
-
 } // namespace
 
 PcParser::PcParser(const PkgConfig &pkgConfig)
@@ -420,15 +412,15 @@ try
     if (!file.is_open())
         throw PcException(std::string("Can't open file ") + path);
 
-    package.baseFileName = baseName(path);
+    package.baseFileName = std::string{completeBaseName(path)};
 #if HAS_STD_FILESYSTEM
     const auto fsPath = std::filesystem::path(path);
     package.filePath = fsPath.generic_string();
-    package.vars["pcfiledir"] = fsPath.parent_path().generic_string();
+    package.variables["pcfiledir"] = fsPath.parent_path().generic_string();
 #else
     QFileInfo fileInfo(QString::fromStdString(path));
     package.filePath = fileInfo.absoluteFilePath().toStdString();
-    package.vars["pcfiledir"] = fileInfo.absolutePath().toStdString();
+    package.variables["pcfiledir"] = fileInfo.absolutePath().toStdString();
 #endif
 
     std::string line;
@@ -436,7 +428,7 @@ try
         parseLine(package, line);
     return package;
 } catch(const PcException &ex) {
-    return PcBrokenPackage{path, baseName(path), ex.what()};
+    return PcBrokenPackage{path, std::string{completeBaseName(path)}, ex.what()};
 }
 
 std::string PcParser::trimAndSubstitute(const PcPackage &pkg, std::string_view str) const
@@ -466,10 +458,10 @@ std::string PcParser::trimAndSubstitute(const PcPackage &pkg, std::string_view s
 
             const auto varval = m_pkgConfig.packageGetVariable(pkg, varname);
 
-            if (varval.empty())
+            if (!varval)
                 raizeUndefinedVariableException(pkg, varname);
 
-            result += varval;
+            result += *varval;
         } else {
             result += str.front();
             str.remove_prefix(1);
@@ -479,6 +471,35 @@ std::string PcParser::trimAndSubstitute(const PcPackage &pkg, std::string_view s
     return result;
 }
 
+std::string PcParser::evaluateVariable(
+    PcPackage &pkg, std::string_view tag, std::string_view str) const
+{
+    static constexpr std::string_view prefixVariable = "prefix";
+    if (m_pkgConfig.options().definePrefix) {
+        if (tag == prefixVariable) {
+            std::string_view prefix = pkg.filePath;
+            prefix = parentPath(prefix);
+            if (completeBaseName(prefix) == "pkgconfig") {
+                prefix = parentPath(prefix);
+                prefix = parentPath(prefix);
+            }
+            pkg.oldPrefix = std::string(str);
+            if (!prefix.empty())
+                str = prefix;
+            return std::string(str);
+        } else if (pkg.oldPrefix
+                && str.size() > pkg.oldPrefix->size()
+                && str.substr(0, pkg.oldPrefix->size()) == *pkg.oldPrefix
+                && str[pkg.oldPrefix->size()] == '/') {
+            auto result = pkg.variables["prefix"];
+            result += str.substr(pkg.oldPrefix->size());
+            return trimAndSubstitute(pkg, result);
+        }
+    }
+
+    return trimAndSubstitute(pkg, str);
+}
+
 void PcParser::parseStringField(
         PcPackage &pkg,
         std::string &field,
@@ -503,9 +524,11 @@ void PcParser::parseLibs(
         raiseDuplicateFieldException(fieldName, pkg.filePath);
 
     const auto trimmed = trimAndSubstitute(pkg, str);
+    if (trimmed.empty())
+        return;
 
     const auto argv = splitCommand(trimmed);
-    if (!trimmed.empty() && !argv)
+    if (!argv)
         throw PcException("Couldn't parse Libs field into an argument vector");
 
     libs = doParseLibs(*argv);
@@ -572,9 +595,11 @@ void PcParser::parseCFlags(PcPackage &pkg, std::string_view str)
         raiseDuplicateFieldException("Cflags", pkg.filePath);
 
     const auto command = trimAndSubstitute(pkg, str);
+    if (command.empty())
+        return;
 
     const auto argv = splitCommand(command);
-    if (!command.empty() && !argv)
+    if (!argv)
         throw PcException("Couldn't parse Cflags field into an argument vector");
 
     std::vector<PcPackage::Flag> cflags;
@@ -633,10 +658,10 @@ std::vector<PcPackage::RequiredVersion> PcParser::parseModuleList(PcPackage &pkg
 
         auto start = p;
 
-        while (*p && !std::isspace(*p))
+        while (p != end && !std::isspace(*p))
             ++p;
 
-        const auto name = std::string_view(&*start, std::distance(start, p));
+        const auto name = makeStringView(start, p);
 
         if (name.empty())
             raizeEmptyPackageNameException(pkg);
@@ -651,7 +676,7 @@ std::vector<PcPackage::RequiredVersion> PcParser::parseModuleList(PcPackage &pkg
         while (p != end && !std::isspace(*p))
             ++p;
 
-        const auto comp = std::string_view(&*start, std::distance(start, p));
+        const auto comp = makeStringView(start, p);
         ver.comparison = comparisonFromString(pkg, ver.name, comp);
 
         while (p != end && std::isspace(*p))
@@ -662,7 +687,7 @@ std::vector<PcPackage::RequiredVersion> PcParser::parseModuleList(PcPackage &pkg
         while (p != end && !std::isspace(*p))
             ++p;
 
-        const auto version = std::string_view(&*start, std::distance(start, p));
+        const auto version = makeStringView(start, p);
 
         while (p != end && std::isspace(*p))
             ++p;
@@ -701,10 +726,8 @@ void PcParser::parseLine(PcPackage &pkg, std::string_view str)
         size_t pos = 0;
         for (; pos < s.size(); ++pos) {
             auto p = s.data() + pos;
-            if (!((*p >= 'A' && *p <= 'Z') ||
-                   (*p >= 'a' && *p <= 'z') ||
-                   (*p >= '0' && *p <= '9') ||
-                   *p == '_' || *p == '.')) {
+            if ((*p < 'A' || *p > 'Z') && (*p < 'a' || *p > 'z') && (*p < '0' || *p > '9')
+                && *p != '_' && *p != '.') {
                 break;
             }
         }
@@ -756,15 +779,8 @@ void PcParser::parseLine(PcPackage &pkg, std::string_view str)
         str.remove_prefix(1); // cut '='
         str = trimmed(str);
 
-        // TODO: support guesstimating of the prefix variable (pkg-config's --define-prefix option)
-        // from doc: "try to override the value of prefix for each .pc file found with a
-        // guesstimated value based on the location of the .pc file"
-        // https://gitlab.freedesktop.org/pkg-config/pkg-config/-/blob/pkg-config-0.29.2/parse.c#L998
-        // This option is disabled by default, and Qbs doesn't allow to override it yet, so we can
-        // ignore this feature for now
-
-        const auto value = trimAndSubstitute(pkg, str);
-        if (!pkg.vars.insert({std::string(tag), value}).second)
+        const auto value = evaluateVariable(pkg, tag, str);
+        if (!pkg.variables.insert({std::string(tag), value}).second)
             raizeDuplicateVariableException(pkg, tag);
     }
 }
diff --git a/src/lib/pkgconfig/pcparser.h b/src/lib/pkgconfig/pcparser.h
index ffdf86aaa..a8a5e5cd4 100644
--- a/src/lib/pkgconfig/pcparser.h
+++ b/src/lib/pkgconfig/pcparser.h
@@ -55,6 +55,7 @@ public:
 
 private:
     std::string trimAndSubstitute(const PcPackage &pkg, std::string_view str) const;
+    std::string evaluateVariable(PcPackage &pkg, std::string_view tag, std::string_view str) const;
     void parseStringField(
             PcPackage &pkg,
             std::string &field,
diff --git a/src/lib/pkgconfig/pkgconfig.cpp b/src/lib/pkgconfig/pkgconfig.cpp
index f017b365c..6b3bde46c 100644
--- a/src/lib/pkgconfig/pkgconfig.cpp
+++ b/src/lib/pkgconfig/pkgconfig.cpp
@@ -106,50 +106,6 @@ constexpr inline char listSeparator() noexcept
 #endif
 }
 
-// based on https://stackoverflow.com/a/33135699/295518
-int compareVersions(std::string_view v1, std::string_view v2)
-{
-    for (size_t i = 0, j = 0; i < v1.length() || j < v2.length(); ) {
-        size_t acc1 = 0;
-        size_t acc2 = 0;
-
-        while (i < v1.length() && v1[i] != '.') {
-            acc1 = acc1 * 10 + (v1[i] - '0');
-            i++;
-        }
-        while (j < v2.length() && v2[j] != '.') {
-            acc2 = acc2 * 10 + (v2[j] - '0');
-            j++;
-        }
-
-        if (acc1 < acc2)
-            return -1;
-        if (acc1 > acc2)
-            return +1;
-
-        ++i;
-        ++j;
-    }
-    return 0;
-}
-
-using ComparisonType = PcPackage::RequiredVersion::ComparisonType;
-
-bool versionTest(ComparisonType comparison, std::string_view a, std::string_view b)
-{
-    switch (comparison) {
-    case ComparisonType::LessThan: return compareVersions(a, b) < 0;
-    case ComparisonType::GreaterThan: return compareVersions(a, b) > 0;
-    case ComparisonType::LessThanEqual: return compareVersions(a, b) <= 0;
-    case ComparisonType::GreaterThanEqual: return compareVersions(a, b) >= 0;
-    case ComparisonType::Equal: return compareVersions(a, b) == 0;
-    case ComparisonType::NotEqual: return compareVersions(a, b) != 0;
-    case ComparisonType::AlwaysMatch: return true;
-    }
-
-    return false;
-}
-
 [[noreturn]] void raizeUnknownPackageException(std::string_view package)
 {
     std::string message;
@@ -217,16 +173,17 @@ const PcPackageVariant &PkgConfig::getPackage(std::string_view baseFileName) con
     return *it;
 }
 
-std::string_view PkgConfig::packageGetVariable(const PcPackage &pkg, std::string_view var) const
+std::optional<std::string_view> PkgConfig::packageGetVariable(
+    const PcPackage &pkg, std::string_view var) const
 {
-    std::string_view varval;
+    std::optional<std::string_view> result;
 
     if (var.empty())
-        return varval;
+        return result;
 
     const auto &globals = m_options.globalVariables;
     if (auto it = globals.find(var); it != globals.end())
-        varval = it->second;
+        result = it->second;
 
     // Allow overriding specific variables using an environment variable of the
     // form PKG_CONFIG_$PACKAGENAME_$VARIABLE
@@ -234,15 +191,15 @@ std::string_view PkgConfig::packageGetVariable(const PcPackage &pkg, std::string
         const std::string envVariable = varToEnvVar(pkg.baseFileName, var);
         const auto it = m_options.systemVariables.find(envVariable);
         if (it != m_options.systemVariables.end())
-            return it->second;
+            result = it->second;
     }
 
-    if (varval.empty()) {
-        const auto it = pkg.vars.find(var);
-        varval = (it != pkg.vars.end()) ? it->second : std::string_view();
+    if (!result) {
+        if (const auto it = pkg.variables.find(var); it != pkg.variables.end())
+            result = it->second;
     }
 
-    return varval;
+    return result;
 }
 
 #if HAS_STD_FILESYSTEM
@@ -333,115 +290,6 @@ PcBrokenPackage makeVersionMismatchDependency(
             package.filePath, package.baseFileName, std::move(message)};
 }
 
-PkgConfig::Packages PkgConfig::mergeDependencies(const PkgConfig::Packages &packages) const
-{
-    std::unordered_map<std::string_view, const PcPackageVariant *> packageHash;
-
-    struct MergedHashEntry
-    {
-        PcPackageVariant package; // merged package or broken package
-        std::vector<const PcPackage *> deps; // unmerged transitive deps, including Package itself
-    };
-    std::unordered_map<std::string, MergedHashEntry> mergedHash;
-
-    for (const auto &package: packages)
-        packageHash[package.getBaseFileName()] = &package;
-
-    auto func = [&](const PcPackageVariant &package, auto &f) -> const MergedHashEntry &
-    {
-        const auto it = mergedHash.find(package.getBaseFileName());
-        if (it != mergedHash.end())
-            return it->second;
-
-        auto &entry = mergedHash[package.getBaseFileName()];
-
-        auto visitor = [&](auto &&package) -> PcPackageVariant {
-
-            using T = std::decay_t<decltype(package)>;
-            if constexpr (std::is_same_v<T, PcPackage>) { // NOLINT
-
-                using Flags = std::vector<PcPackage::Flag>;
-
-                // returns true if multiple copies of the flag can present in the same package
-                // we can't properly merge flags that have multiple parameters except for
-                // -framework which we handle correctly.
-                auto canHaveDuplicates = [](const PcPackage::Flag::Type &type) {
-                    return type == PcPackage::Flag::Type::LinkerFlag
-                            || type == PcPackage::Flag::Type::CompilerFlag;
-                };
-
-                std::unordered_set<PcPackage::Flag> visitedFlags;
-                // appends only those flags to the target that were not seen before (except for
-                // ones that can have duplicates)
-                auto mergeFlags = [&](Flags &target, const Flags &source)
-                {
-                    for (const auto &flag: source) {
-                        if (canHaveDuplicates(flag.type) || visitedFlags.insert(flag).second)
-                            target.push_back(flag);
-                    }
-                };
-
-                std::unordered_set<const PcPackage *> visitedDeps;
-
-                PcPackage result;
-                // copy only meta info for now
-                result.filePath = package.filePath;
-                result.baseFileName = package.baseFileName;
-                result.name = package.name;
-                result.version = package.version;
-                result.description = package.description;
-                result.url = package.url;
-
-                auto allDependencies = package.requiresPublic;
-                if (m_options.staticMode)
-                    allDependencies << package.requiresPrivate;
-
-                for (const auto &dependency: allDependencies) {
-                    const auto it = packageHash.find(dependency.name);
-                    if (it == packageHash.end())
-                        return makeMissingDependency(result, dependency);
-
-                    const auto childEntry = f(*it->second, f);
-                    if (childEntry.package.isBroken())
-                        return makeBrokenDependency(result, dependency);
-
-                    const auto &mergedPackage = childEntry.package.asPackage();
-                    const bool versionOk = versionTest(
-                            dependency.comparison, mergedPackage.version, dependency.version);
-                    if (!versionOk)
-                        return makeVersionMismatchDependency(result, mergedPackage, dependency);
-
-                    for (const auto *dep: childEntry.deps) {
-                        if (visitedDeps.insert(dep).second)
-                            entry.deps.push_back(dep);
-                    }
-                }
-
-                entry.deps.push_back(&package);
-
-                for (const auto *dep: entry.deps) {
-                    mergeFlags(result.libs, dep->libs);
-                    mergeFlags(result.cflags, dep->cflags);
-                }
-
-                return result;
-            }
-            return package;
-        };
-        entry.package = package.visit(visitor);
-
-        return entry;
-    };
-
-    for (auto &package: packages)
-        func(package, func);
-
-    Packages result;
-    for (auto &[key, value]: mergedHash)
-        result.push_back(std::move(value.package));
-    return result;
-}
-
 PkgConfig::Packages PkgConfig::findPackages() const
 {
     Packages result;
@@ -478,9 +326,6 @@ PkgConfig::Packages PkgConfig::findPackages() const
         result.emplace_back(std::move(pkg));
     }
 
-    if (m_options.mergeDependencies)
-        result = mergeDependencies(result);
-
     const auto lessThanPackage = [](const PcPackageVariant &lhs, const PcPackageVariant &rhs)
     {
         return lhs.getBaseFileName() < rhs.getBaseFileName();
diff --git a/src/lib/pkgconfig/pkgconfig.h b/src/lib/pkgconfig/pkgconfig.h
index 6da1f053f..fd4cc3253 100644
--- a/src/lib/pkgconfig/pkgconfig.h
+++ b/src/lib/pkgconfig/pkgconfig.h
@@ -58,7 +58,7 @@ public:
         std::vector<std::string> systemLibraryPaths; // PKG_CONFIG_SYSTEM_LIBRARY_PATH
         bool disableUninstalled{true};               // PKG_CONFIG_DISABLE_UNINSTALLED
         bool staticMode{false};
-        bool mergeDependencies{true};
+        bool definePrefix{false};
         VariablesMap globalVariables;
         VariablesMap systemVariables;
     };
@@ -72,11 +72,11 @@ public:
     const Packages &packages() const { return m_packages; }
     const PcPackageVariant &getPackage(std::string_view baseFileName) const;
 
-    std::string_view packageGetVariable(const PcPackage &pkg, std::string_view var) const;
+    std::optional<std::string_view> packageGetVariable(
+        const PcPackage &pkg, std::string_view var) const;
 
 private:
     Packages findPackages() const;
-    Packages mergeDependencies(const Packages &packages) const;
 
 private:
     Options m_options;
diff --git a/src/lib/pkgconfig/pkgconfig.pro b/src/lib/pkgconfig/pkgconfig.pro
deleted file mode 100644
index dcabf0ba1..000000000
--- a/src/lib/pkgconfig/pkgconfig.pro
+++ /dev/null
@@ -1,25 +0,0 @@
-TARGET = qbspkgconfig
-include(../staticlibrary.pri)
-include(../../shared/variant/variant.pri)
-
-DEFINES += \
-    PKG_CONFIG_PC_PATH=\\\"/usr/lib/pkgconfig:/usr/share/pkgconfig\\\" \
-    PKG_CONFIG_SYSTEM_LIBRARY_PATH=\\\"/usr/$${QBS_LIBRARY_DIRNAME}/\\\" \
-    QBS_PC_WITH_QT_SUPPORT=1
-
-macos|win32-g++ {
-    DEFINES += HAS_STD_FILESYSTEM=0
-} else {
-    DEFINES += HAS_STD_FILESYSTEM=1
-}
-
-HEADERS += \
-    pcpackage.h \
-    pcparser.h \
-    pkgconfig.h
-
-SOURCES += \
-    pcpackage.cpp \
-    pcparser.cpp \
-    pkgconfig.cpp \
-
diff --git a/src/lib/pkgconfig/pkgconfig.qbs b/src/lib/pkgconfig/pkgconfig.qbs
index 0be5065f5..a32eb775b 100644
--- a/src/lib/pkgconfig/pkgconfig.qbs
+++ b/src/lib/pkgconfig/pkgconfig.qbs
@@ -60,7 +60,7 @@ QbsStaticLibrary {
         Depends { name: "qbsvariant" }
         cpp.defines: exportingProduct.publicDefines
         cpp.staticLibraries: {
-            if (qbs.toolchainType === "gcc" && cpp.compilerVersionMajor === 7)
+            if (qbs.toolchainType === "gcc" && cpp.compilerVersionMajor < 9)
                 return ["stdc++fs"];
             return [];
         }
diff --git a/src/lib/pkgconfig/use_pkgconfig.pri b/src/lib/pkgconfig/use_pkgconfig.pri
deleted file mode 100644
index e0e485e46..000000000
--- a/src/lib/pkgconfig/use_pkgconfig.pri
+++ /dev/null
@@ -1,52 +0,0 @@
-include(../../library_dirname.pri)
-include(../../shared/variant/variant.pri)
-
-isEmpty(QBSLIBDIR) {
-    QBSLIBDIR = $${OUT_PWD}/../../../$${QBS_LIBRARY_DIRNAME}
-}
-
-QBSPKGCONFIG_LIBNAME=qbspkgconfig
-
-unix {
-    LIBS += -L$${QBSLIBDIR} -l$${QBSPKGCONFIG_LIBNAME}
-}
-
-win32 {
-    CONFIG(debug, debug|release) {
-        QBSPKGCONFIG_LIB = $${QBSPKGCONFIG_LIBNAME}d
-    }
-    CONFIG(release, debug|release) {
-        QBSPKGCONFIG_LIB = $${QBSPKGCONFIG_LIBNAME}
-    }
-    msvc {
-        LIBS += /LIBPATH:$$QBSLIBDIR
-        QBSPKGCONFIG_LIB = $${QBSPKGCONFIG_LIB}.lib
-        LIBS += Shell32.lib
-    } else {
-        LIBS += -L$${QBSLIBDIR}
-        QBSPKGCONFIG_LIB = lib$${QBSPKGCONFIG_LIB}
-    }
-    LIBS += $${QBSPKGCONFIG_LIB}
-}
-
-gcc {
-    isEmpty(COMPILER_VERSION) {
-        COMPILER_VERSION = $$system($$QMAKE_CXX " -dumpversion")
-        COMPILER_MAJOR_VERSION = $$str_member($$COMPILER_VERSION)
-        equals(COMPILER_MAJOR_VERSION, 7) {
-            LIBS += -lstdc++fs
-        }
-    }
-}
-
-INCLUDEPATH += \
-    $$PWD
-
-CONFIG += depend_includepath
-
-CONFIG(static, static|shared) {
-    DEFINES += QBS_STATIC_LIB
-}
-
-DEFINES += \
-    QBS_PC_WITH_QT_SUPPORT=1