aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--docs/markdown/snippets/qt_factory.md6
-rw-r--r--mesonbuild/dependencies/__init__.py8
-rw-r--r--mesonbuild/dependencies/base.py11
-rw-r--r--mesonbuild/dependencies/qt.py297
-rw-r--r--mesonbuild/modules/qt.py22
-rwxr-xr-xrun_unittests.py8
-rw-r--r--test cases/frameworks/4 qt/test.json11
7 files changed, 202 insertions, 161 deletions
diff --git a/docs/markdown/snippets/qt_factory.md b/docs/markdown/snippets/qt_factory.md
new file mode 100644
index 0000000..11cc783
--- /dev/null
+++ b/docs/markdown/snippets/qt_factory.md
@@ -0,0 +1,6 @@
+## Qt Dependency uses a Factory
+
+This separates the Pkg-config and QMake based discovery methods into two
+distinct classes in the backend. This allows using
+`dependency.get_variable()` and `dependency.get_pkg_config_variable()`, as
+well as being a cleaner implementation.
diff --git a/mesonbuild/dependencies/__init__.py b/mesonbuild/dependencies/__init__.py
index 416325d..afd4adc 100644
--- a/mesonbuild/dependencies/__init__.py
+++ b/mesonbuild/dependencies/__init__.py
@@ -31,7 +31,7 @@ from .misc import (
shaderc_factory, threads_factory,
)
from .platform import AppleFrameworks
-from .qt import Qt4Dependency, Qt5Dependency, Qt6Dependency
+from .qt import qt4_factory, qt5_factory, qt6_factory
from .ui import GnuStepDependency, WxDependency, gl_factory, sdl2_factory, vulkan_factory
"""Dependency representations and discovery logic.
@@ -226,9 +226,9 @@ packages.update({
# From ui:
'gl': gl_factory,
'gnustep': GnuStepDependency,
- 'qt4': Qt4Dependency,
- 'qt5': Qt5Dependency,
- 'qt6': Qt6Dependency,
+ 'qt4': qt4_factory,
+ 'qt5': qt5_factory,
+ 'qt6': qt6_factory,
'sdl2': sdl2_factory,
'wxwidgets': WxDependency,
'vulkan': vulkan_factory,
diff --git a/mesonbuild/dependencies/base.py b/mesonbuild/dependencies/base.py
index 6ec74ce..8944780 100644
--- a/mesonbuild/dependencies/base.py
+++ b/mesonbuild/dependencies/base.py
@@ -18,6 +18,7 @@ import copy
import functools
import os
import re
+import itertools
import json
import shlex
import shutil
@@ -136,11 +137,21 @@ class Dependency:
return converted
return self.compile_args
+ def get_all_compile_args(self) -> T.List[str]:
+ """Get the compile arguments from this dependency and it's sub dependencies."""
+ return list(itertools.chain(self.get_compile_args(),
+ *[d.get_all_compile_args() for d in self.ext_deps]))
+
def get_link_args(self, raw: bool = False) -> T.List[str]:
if raw and self.raw_link_args is not None:
return self.raw_link_args
return self.link_args
+ def get_all_link_args(self) -> T.List[str]:
+ """Get the link arguments from this dependency and it's sub dependencies."""
+ return list(itertools.chain(self.get_link_args(),
+ *[d.get_all_link_args() for d in self.ext_deps]))
+
def found(self) -> bool:
return self.is_found
diff --git a/mesonbuild/dependencies/qt.py b/mesonbuild/dependencies/qt.py
index 97a8a7f..1059871 100644
--- a/mesonbuild/dependencies/qt.py
+++ b/mesonbuild/dependencies/qt.py
@@ -17,25 +17,22 @@
"""Dependency finders for the Qt framework."""
import abc
-import collections
import re
import os
import typing as T
from . import (
- ExtraFrameworkDependency, ExternalDependency, DependencyException, DependencyMethods,
- PkgConfigDependency
+ ExtraFrameworkDependency, DependencyException, DependencyMethods,
+ PkgConfigDependency,
)
-from .base import ConfigToolDependency
+from .base import ConfigToolDependency, DependencyFactory
from .. import mlog
from .. import mesonlib
-from ..programs import find_external_program
if T.TYPE_CHECKING:
from ..compilers import Compiler
from ..envconfig import MachineInfo
from ..environment import Environment
- from ..programs import ExternalProgram
def _qt_get_private_includes(mod_inc_dir: str, module: str, mod_version: str) -> T.List[str]:
@@ -114,70 +111,78 @@ class QtExtraFrameworkDependency(ExtraFrameworkDependency):
return []
-class QtBaseDependency(ExternalDependency, metaclass=abc.ABCMeta):
+class _QtBase:
- version: T.Optional[str]
+ """Mixin class for shared componenets between PkgConfig and Qmake."""
- def __init__(self, name: str, env: 'Environment', kwargs: T.Dict[str, T.Any]):
- super().__init__(name, env, kwargs, language='cpp')
+ link_args: T.List[str]
+ clib_compiler: 'Compiler'
+ env: 'Environment'
+
+ def __init__(self, name: str, kwargs: T.Dict[str, T.Any]):
self.qtname = name.capitalize()
self.qtver = name[-1]
if self.qtver == "4":
self.qtpkgname = 'Qt'
else:
self.qtpkgname = self.qtname
- self.root = '/usr'
- self.bindir: T.Optional[str] = None
+
self.private_headers = T.cast(bool, kwargs.get('private_headers', False))
- mods = mesonlib.stringlistify(mesonlib.extract_as_list(kwargs, 'modules'))
- self.requested_modules = mods
- if not mods:
+
+ self.requested_modules = mesonlib.stringlistify(mesonlib.extract_as_list(kwargs, 'modules'))
+ if not self.requested_modules:
raise DependencyException('No ' + self.qtname + ' modules specified.')
- self.from_text = 'pkg-config'
self.qtmain = T.cast(bool, kwargs.get('main', False))
if not isinstance(self.qtmain, bool):
raise DependencyException('"main" argument must be a boolean')
- # Keep track of the detection methods used, for logging purposes.
- methods: T.List[str] = []
- # Prefer pkg-config, then fallback to `qmake -query`
- if DependencyMethods.PKGCONFIG in self.methods:
- mlog.debug('Trying to find qt with pkg-config')
- self._pkgconfig_detect(mods, kwargs)
- methods.append('pkgconfig')
- if not self.is_found and DependencyMethods.QMAKE in self.methods:
- mlog.debug('Trying to find qt with qmake')
- self.from_text = self._qmake_detect(mods, kwargs)
- methods.append('qmake-' + self.name)
- methods.append('qmake')
- if not self.is_found:
- # Reset compile args and link args
+ def _link_with_qtmain(self, is_debug: bool, libdir: T.Union[str, T.List[str]]) -> bool:
+ libdir = mesonlib.listify(libdir) # TODO: shouldn't be necessary
+ base_name = 'qtmaind' if is_debug else 'qtmain'
+ qtmain = self.clib_compiler.find_library(base_name, self.env, libdir)
+ if qtmain:
+ self.link_args.append(qtmain[0])
+ return True
+ return False
+
+ def get_exe_args(self, compiler: 'Compiler') -> T.List[str]:
+ # Originally this was -fPIE but nowadays the default
+ # for upstream and distros seems to be -reduce-relocations
+ # which requires -fPIC. This may cause a performance
+ # penalty when using self-built Qt or on platforms
+ # where -fPIC is not required. If this is an issue
+ # for you, patches are welcome.
+ return compiler.get_pic_args()
+
+ def log_details(self) -> str:
+ return f'modules: {", ".join(sorted(self.requested_modules))}'
+
+
+class QtPkgConfigDependency(_QtBase, PkgConfigDependency, metaclass=abc.ABCMeta):
+
+ """Specialization of the PkgConfigDependency for Qt."""
+
+ def __init__(self, name: str, env: 'Environment', kwargs: T.Dict[str, T.Any]):
+ _QtBase.__init__(self, name, kwargs)
+
+ # Always use QtCore as the "main" dependency, since it has the extra
+ # pkg-config variables that a user would expect to get. If "Core" is
+ # not a requested module, delete the compile and link arguments to
+ # avoid linking with something they didn't ask for
+ PkgConfigDependency.__init__(self, self.qtpkgname + 'Core', env, kwargs)
+ if 'Core' not in self.requested_modules:
self.compile_args = []
self.link_args = []
- self.from_text = mlog.format_list(methods)
- self.version = None
-
- @abc.abstractmethod
- def get_pkgconfig_host_bins(self, core: PkgConfigDependency) -> T.Optional[str]:
- pass
- def _pkgconfig_detect(self, mods: T.List[str], kwargs: T.Dict[str, T.Any]) -> None:
- # We set the value of required to False so that we can try the
- # qmake-based fallback if pkg-config fails.
- kwargs['required'] = False
- modules: T.MutableMapping[str, PkgConfigDependency] = collections.OrderedDict()
- for module in mods:
- modules[module] = PkgConfigDependency(self.qtpkgname + module, self.env,
- kwargs, language=self.language)
- for m_name, m in modules.items():
- if not m.found():
+ for m in self.requested_modules:
+ mod = PkgConfigDependency(self.qtpkgname + m, self.env, kwargs, language=self.language)
+ if not mod.found():
self.is_found = False
return
- self.compile_args += m.get_compile_args()
if self.private_headers:
- qt_inc_dir = m.get_pkgconfig_variable('includedir', dict())
- mod_private_dir = os.path.join(qt_inc_dir, 'Qt' + m_name)
+ qt_inc_dir = mod.get_pkgconfig_variable('includedir', {})
+ mod_private_dir = os.path.join(qt_inc_dir, 'Qt' + m)
if not os.path.isdir(mod_private_dir):
# At least some versions of homebrew don't seem to set this
# up correctly. /usr/local/opt/qt/include/Qt + m_name is a
@@ -185,94 +190,93 @@ class QtBaseDependency(ExternalDependency, metaclass=abc.ABCMeta):
# file points to /usr/local/Cellar/qt/x.y.z/Headers/, and
# the Qt + m_name there is not a symlink, it's a file
mod_private_dir = qt_inc_dir
- mod_private_inc = _qt_get_private_includes(mod_private_dir, m_name, m.version)
+ mod_private_inc = _qt_get_private_includes(mod_private_dir, m, mod.version)
for directory in mod_private_inc:
- self.compile_args.append('-I' + directory)
- self.link_args += m.get_link_args()
-
- if 'Core' in modules:
- core = modules['Core']
- else:
- corekwargs = {'required': 'false', 'silent': 'true'}
- core = PkgConfigDependency(self.qtpkgname + 'Core', self.env, corekwargs,
- language=self.language)
- modules['Core'] = core
+ mod.compile_args.append('-I' + directory)
+ self._add_sub_dependency([lambda: mod])
if self.env.machines[self.for_machine].is_windows() and self.qtmain:
# Check if we link with debug binaries
debug_lib_name = self.qtpkgname + 'Core' + _get_modules_lib_suffix(self.version, self.env.machines[self.for_machine], True)
is_debug = False
- for arg in core.get_link_args():
- if arg == '-l%s' % debug_lib_name or arg.endswith('%s.lib' % debug_lib_name) or arg.endswith('%s.a' % debug_lib_name):
+ for arg in self.get_link_args():
+ if arg == f'-l{debug_lib_name}' or arg.endswith(f'{debug_lib_name}.lib') or arg.endswith(f'{debug_lib_name}.a'):
is_debug = True
break
- libdir = core.get_pkgconfig_variable('libdir', {})
+ libdir = self.get_pkgconfig_variable('libdir', {})
if not self._link_with_qtmain(is_debug, libdir):
self.is_found = False
return
- self.is_found = True
- self.version = m.version
- self.pcdep = list(modules.values())
- # Try to detect moc, uic, rcc
- # Used by self.compilers_detect()
- self.bindir = self.get_pkgconfig_host_bins(core)
+ self.bindir = self.get_pkgconfig_host_bins(self)
if not self.bindir:
# If exec_prefix is not defined, the pkg-config file is broken
- prefix = core.get_pkgconfig_variable('exec_prefix', {})
+ prefix = self.get_pkgconfig_variable('exec_prefix', {})
if prefix:
self.bindir = os.path.join(prefix, 'bin')
- def search_qmake(self) -> T.Generator['ExternalProgram', None, None]:
- for qmake in ('qmake-' + self.name, 'qmake'):
- yield from find_external_program(self.env, self.for_machine, qmake, 'QMake', [qmake])
+ @staticmethod
+ @abc.abstractmethod
+ def get_pkgconfig_host_bins(core: PkgConfigDependency) -> T.Optional[str]:
+ pass
+
+ @abc.abstractmethod
+ def get_private_includes(self, mod_inc_dir: str, module: str) -> T.List[str]:
+ pass
+
+ def log_info(self) -> str:
+ return 'pkg-config'
+
+
+class QmakeQtDependency(_QtBase, ConfigToolDependency, metaclass=abc.ABCMeta):
+
+ """Find Qt using Qmake as a config-tool."""
+
+ tool_name = 'qmake'
+ version_arg = '-v'
+
+ def __init__(self, name: str, env: 'Environment', kwargs: T.Dict[str, T.Any]):
+ _QtBase.__init__(self, name, kwargs)
+ self.tools = [f'qmake-{self.qtname}', 'qmake']
+
+ # Add additional constraits that the Qt version is met, but preserve
+ # any version requrements the user has set as well. For exmaple, if Qt5
+ # is requested, add "">= 5, < 6", but if the user has ">= 5.6", don't
+ # lose that.
+ kwargs = kwargs.copy()
+ _vers = mesonlib.listify(kwargs.get('version', []))
+ _vers.extend([f'>= {self.qtver}', f'< {int(self.qtver) + 1}'])
+ kwargs['version'] = _vers
+
+ ConfigToolDependency.__init__(self, name, env, kwargs)
+ if not self.found():
+ return
- def _qmake_detect(self, mods: T.List[str], kwargs: T.Dict[str, T.Any]) -> T.Optional[str]:
- for qmake in self.search_qmake():
- if not qmake.found():
- continue
- # Check that the qmake is for qt5
- pc, stdo = mesonlib.Popen_safe(qmake.get_command() + ['-v'])[0:2]
- if pc.returncode != 0:
- continue
- if not 'Qt version ' + self.qtver in stdo:
- mlog.log('QMake is not for ' + self.qtname)
- continue
- # Found qmake for Qt5!
- self.qmake = qmake
- break
- else:
- # Didn't find qmake :(
- self.is_found = False
- return None
- self.version = re.search(self.qtver + r'(\.\d+)+', stdo).group(0)
# Query library path, header path, and binary path
- mlog.log("Found qmake:", mlog.bold(self.qmake.get_path()), '(%s)' % self.version)
- stdo = mesonlib.Popen_safe(self.qmake.get_command() + ['-query'])[1]
- qvars = {}
- for line in stdo.split('\n'):
+ stdo = self.get_config_value(['-query'], 'args')
+ qvars: T.Dict[str, str] = {}
+ for line in stdo:
line = line.strip()
if line == '':
continue
- (k, v) = tuple(line.split(':', 1))
+ k, v = line.split(':', 1)
qvars[k] = v
# Qt on macOS uses a framework, but Qt for iOS/tvOS does not
xspec = qvars.get('QMAKE_XSPEC', '')
if self.env.machines.host.is_darwin() and not any(s in xspec for s in ['ios', 'tvos']):
mlog.debug("Building for macOS, looking for framework")
- self._framework_detect(qvars, mods, kwargs)
+ self._framework_detect(qvars, self.requested_modules, kwargs)
# Sometimes Qt is built not as a framework (for instance, when using conan pkg manager)
# skip and fall back to normal procedure then
if self.is_found:
- return self.qmake.name
+ return
else:
mlog.debug("Building for macOS, couldn't find framework, falling back to library search")
incdir = qvars['QT_INSTALL_HEADERS']
self.compile_args.append('-I' + incdir)
libdir = qvars['QT_INSTALL_LIBS']
- # Used by self.compilers_detect()
+ # Used by qt.compilers_detect()
self.bindir = get_qmake_host_bins(qvars)
- self.is_found = True
# Use the buildtype by default, but look at the b_vscrt option if the
# compiler supports it.
@@ -282,7 +286,7 @@ class QtBaseDependency(ExternalDependency, metaclass=abc.ABCMeta):
is_debug = True
modules_lib_suffix = _get_modules_lib_suffix(self.version, self.env.machines[self.for_machine], is_debug)
- for module in mods:
+ for module in self.requested_modules:
mincdir = os.path.join(incdir, 'Qt' + module)
self.compile_args.append('-I' + mincdir)
@@ -292,7 +296,7 @@ class QtBaseDependency(ExternalDependency, metaclass=abc.ABCMeta):
define_base = 'TESTLIB'
else:
define_base = module.upper()
- self.compile_args.append('-DQT_%s_LIB' % define_base)
+ self.compile_args.append(f'-DQT_{define_base}_LIB')
if self.private_headers:
priv_inc = self.get_private_includes(mincdir, module)
@@ -315,16 +319,15 @@ class QtBaseDependency(ExternalDependency, metaclass=abc.ABCMeta):
if not self._link_with_qtmain(is_debug, libdir):
self.is_found = False
- return self.qmake.name
+ def _sanitize_version(self, version: str) -> str:
+ m = re.search(rf'({self.qtver}(\.\d+)+)', version)
+ if m:
+ return m.group(0).rstrip('.')
+ return version
- def _link_with_qtmain(self, is_debug: bool, libdir: T.Union[str, T.List[str]]) -> bool:
- libdir = mesonlib.listify(libdir) # TODO: shouldn't be necessary
- base_name = 'qtmaind' if is_debug else 'qtmain'
- qtmain = self.clib_compiler.find_library(base_name, self.env, libdir)
- if qtmain:
- self.link_args.append(qtmain[0])
- return True
- return False
+ @abc.abstractmethod
+ def get_private_includes(self, mod_inc_dir: str, module: str) -> T.List[str]:
+ pass
def _framework_detect(self, qvars: T.Dict[str, str], modules: T.List[str], kwargs: T.Dict[str, T.Any]) -> None:
libdir = qvars['QT_INSTALL_LIBS']
@@ -344,43 +347,36 @@ class QtBaseDependency(ExternalDependency, metaclass=abc.ABCMeta):
qt_version=self.version)
self.link_args += fwdep.get_link_args()
else:
+ self.is_found = False
break
else:
self.is_found = True
# Used by self.compilers_detect()
self.bindir = get_qmake_host_bins(qvars)
- @staticmethod
- def get_methods() -> T.List[DependencyMethods]:
- return [DependencyMethods.PKGCONFIG, DependencyMethods.QMAKE]
+ def log_info(self) -> str:
+ return 'qmake'
- @staticmethod
- def get_exe_args(compiler: 'Compiler') -> T.List[str]:
- # Originally this was -fPIE but nowadays the default
- # for upstream and distros seems to be -reduce-relocations
- # which requires -fPIC. This may cause a performance
- # penalty when using self-built Qt or on platforms
- # where -fPIC is not required. If this is an issue
- # for you, patches are welcome.
- return compiler.get_pic_args()
+
+class Qt4ConfigToolDependency(QmakeQtDependency):
def get_private_includes(self, mod_inc_dir: str, module: str) -> T.List[str]:
return []
- def log_details(self) -> str:
- module_str = ', '.join(self.requested_modules)
- return 'modules: ' + module_str
- def log_info(self) -> str:
- return f'{self.from_text}'
+class Qt5ConfigToolDependency(QmakeQtDependency):
+
+ def get_private_includes(self, mod_inc_dir: str, module: str) -> T.List[str]:
+ return _qt_get_private_includes(mod_inc_dir, module, self.version)
+
+
+class Qt6ConfigToolDependency(QmakeQtDependency):
- def log_tried(self) -> str:
- return self.from_text
+ def get_private_includes(self, mod_inc_dir: str, module: str) -> T.List[str]:
+ return _qt_get_private_includes(mod_inc_dir, module, self.version)
-class Qt4Dependency(QtBaseDependency):
- def __init__(self, env: 'Environment', kwargs: T.Dict[str, T.Any]):
- QtBaseDependency.__init__(self, 'qt4', env, kwargs)
+class Qt4PkgConfigDependency(QtPkgConfigDependency):
@staticmethod
def get_pkgconfig_host_bins(core: PkgConfigDependency) -> T.Optional[str]:
@@ -396,10 +392,11 @@ class Qt4Dependency(QtBaseDependency):
pass
return None
+ def get_private_includes(self, mod_inc_dir: str, module: str) -> T.List[str]:
+ return []
+
-class Qt5Dependency(QtBaseDependency):
- def __init__(self, env: 'Environment', kwargs: T.Dict[str, T.Any]):
- QtBaseDependency.__init__(self, 'qt5', env, kwargs)
+class Qt5PkgConfigDependency(QtPkgConfigDependency):
@staticmethod
def get_pkgconfig_host_bins(core: PkgConfigDependency) -> str:
@@ -409,9 +406,7 @@ class Qt5Dependency(QtBaseDependency):
return _qt_get_private_includes(mod_inc_dir, module, self.version)
-class Qt6Dependency(QtBaseDependency):
- def __init__(self, env: 'Environment', kwargs: T.Dict[str, T.Any]):
- QtBaseDependency.__init__(self, 'qt6', env, kwargs)
+class Qt6PkgConfigDependency(QtPkgConfigDependency):
@staticmethod
def get_pkgconfig_host_bins(core: PkgConfigDependency) -> str:
@@ -419,3 +414,25 @@ class Qt6Dependency(QtBaseDependency):
def get_private_includes(self, mod_inc_dir: str, module: str) -> T.List[str]:
return _qt_get_private_includes(mod_inc_dir, module, self.version)
+
+
+qt4_factory = DependencyFactory(
+ 'qt4',
+ [DependencyMethods.PKGCONFIG, DependencyMethods.CONFIG_TOOL],
+ pkgconfig_class=Qt4PkgConfigDependency,
+ configtool_class=Qt4ConfigToolDependency,
+)
+
+qt5_factory = DependencyFactory(
+ 'qt5',
+ [DependencyMethods.PKGCONFIG, DependencyMethods.CONFIG_TOOL],
+ pkgconfig_class=Qt5PkgConfigDependency,
+ configtool_class=Qt5ConfigToolDependency,
+)
+
+qt6_factory = DependencyFactory(
+ 'qt6',
+ [DependencyMethods.PKGCONFIG, DependencyMethods.CONFIG_TOOL],
+ pkgconfig_class=Qt6PkgConfigDependency,
+ configtool_class=Qt6ConfigToolDependency,
+)
diff --git a/mesonbuild/modules/qt.py b/mesonbuild/modules/qt.py
index addc571..645696d 100644
--- a/mesonbuild/modules/qt.py
+++ b/mesonbuild/modules/qt.py
@@ -12,6 +12,7 @@
# See the License for the specific language governing permissions and
# limitations under the License.
+from mesonbuild.dependencies.base import find_external_dependency
import os
import shutil
import typing as T
@@ -20,7 +21,7 @@ from .. import mlog
from .. import build
from .. import mesonlib
from ..mesonlib import MesonException, extract_as_list, File, unholder, version_compare
-from ..dependencies import Dependency, Qt4Dependency, Qt5Dependency, Qt6Dependency
+from ..dependencies import Dependency
import xml.etree.ElementTree as ET
from . import ModuleReturnValue, get_include_args, ExtensionModule
from ..interpreterbase import noPosargs, permittedKwargs, FeatureNew, FeatureNewKwargs
@@ -28,16 +29,11 @@ from ..interpreter import extract_required_kwarg
from ..programs import NonExistingExternalProgram
if T.TYPE_CHECKING:
- from .. import Interpreter
+ from ..interpreter import Interpreter
from ..dependencies.qt import QtBaseDependency
+ from ..environment import Environment
from ..programs import ExternalProgram
-_QT_DEPS_LUT = {
- 4: Qt4Dependency,
- 5: Qt5Dependency,
- 6: Qt6Dependency,
-}
-
class QtBaseModule(ExtensionModule):
tools_detected = False
@@ -57,7 +53,7 @@ class QtBaseModule(ExtensionModule):
# It is important that this list does not change order as the order of
# the returned ExternalPrograms will change as well
bins = ['moc', 'uic', 'rcc', 'lrelease']
- found = {b: NonExistingExternalProgram(name=f'{b}-{qt_dep.name}')
+ found = {b: NonExistingExternalProgram(name=f'{b}-qt{qt_dep.qtver}')
for b in bins}
wanted = f'== {qt_dep.version}'
@@ -67,7 +63,7 @@ class QtBaseModule(ExtensionModule):
yield os.path.join(qt_dep.bindir, b), b
# prefer the <tool>-qt<version> of the tool to the plain one, as we
# don't know what the unsuffixed one points to without calling it.
- yield f'{b}-{qt_dep.name}', b
+ yield f'{b}-qt{qt_dep.qtver}', b
yield b, b
for b, name in gen_bins():
@@ -97,13 +93,13 @@ class QtBaseModule(ExtensionModule):
if p.found():
setattr(self, name, p)
- def _detect_tools(self, env, method, required=True):
+ def _detect_tools(self, env: 'Environment', method, required=True):
if self.tools_detected:
return
self.tools_detected = True
mlog.log(f'Detecting Qt{self.qt_version} tools')
kwargs = {'required': required, 'modules': 'Core', 'method': method}
- qt = _QT_DEPS_LUT[self.qt_version](env, kwargs)
+ qt = find_external_dependency(f'qt{self.qt_version}', env, kwargs)
if qt.found():
# Get all tools and then make sure that they are the right version
self.compilers_detect(qt)
@@ -247,7 +243,7 @@ class QtBaseModule(ExtensionModule):
compile_args = []
for dep in unholder(dependencies):
if isinstance(dep, Dependency):
- for arg in dep.get_compile_args():
+ for arg in dep.get_all_compile_args():
if arg.startswith('-I') or arg.startswith('-D'):
compile_args.append(arg)
else:
diff --git a/run_unittests.py b/run_unittests.py
index c22f884..8ef907e 100755
--- a/run_unittests.py
+++ b/run_unittests.py
@@ -6604,10 +6604,10 @@ class LinuxlikeTests(BasePlatformTests):
mesonlog = self.get_meson_log()
if qt4 == 0:
self.assertRegex('\n'.join(mesonlog),
- r'Run-time dependency qt4 \(modules: Core\) found: YES 4.* \(pkg-config\)\n')
+ r'Run-time dependency qt4 \(modules: Core\) found: YES 4.* \(pkg-config\)')
if qt5 == 0:
self.assertRegex('\n'.join(mesonlog),
- r'Run-time dependency qt5 \(modules: Core\) found: YES 5.* \(pkg-config\)\n')
+ r'Run-time dependency qt5 \(modules: Core\) found: YES 5.* \(pkg-config\)')
@skip_if_not_base_option('b_sanitize')
def test_generate_gir_with_address_sanitizer(self):
@@ -6638,7 +6638,7 @@ class LinuxlikeTests(BasePlatformTests):
# Confirm that the dependency was found with qmake
mesonlog = self.get_meson_log()
self.assertRegex('\n'.join(mesonlog),
- r'Run-time dependency qt5 \(modules: Core\) found: YES .* \((qmake|qmake-qt5)\)\n')
+ r'Run-time dependency qt5 \(modules: Core\) found: YES .* \(qmake\)\n')
def test_qt6dependency_qmake_detection(self):
'''
@@ -6658,7 +6658,7 @@ class LinuxlikeTests(BasePlatformTests):
# Confirm that the dependency was found with qmake
mesonlog = self.get_meson_log()
self.assertRegex('\n'.join(mesonlog),
- r'Run-time dependency qt6 \(modules: Core\) found: YES .* \((qmake|qmake-qt6)\)\n')
+ r'Run-time dependency qt6 \(modules: Core\) found: YES .* \(qmake\)\n')
def glob_sofiles_without_privdir(self, g):
files = glob(g)
diff --git a/test cases/frameworks/4 qt/test.json b/test cases/frameworks/4 qt/test.json
new file mode 100644
index 0000000..4c70060
--- /dev/null
+++ b/test cases/frameworks/4 qt/test.json
@@ -0,0 +1,11 @@
+{
+ "matrix": {
+ "options": {
+ "method": [
+ { "val": "config-tool" },
+ { "val": "qmake" },
+ { "val": "pkg-config" }
+ ]
+ }
+ }
+}
generated by cgit v1.1 at 2024-10-13 03:04:39 +0000