frida 16.2.1 → 16.2.2

package/releng/meson/mesonbuild/mconf.py

@@ -0,0 +1,368 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2014-2016 The Meson development team
+# Copyright © 2023-2024 Intel Corporation
+
+from __future__ import annotations
+
+import itertools
+import hashlib
+import shutil
+import os
+import textwrap
+import typing as T
+import collections
+
+from . import build
+from . import coredata
+from . import environment
+from . import mesonlib
+from . import mintro
+from . import mlog
+from .ast import AstIDGenerator, IntrospectionInterpreter
+from .mesonlib import MachineChoice, OptionKey
+from .optinterpreter import OptionInterpreter
+
+if T.TYPE_CHECKING:
+    from typing_extensions import Protocol
+    import argparse
+
+    class CMDOptions(coredata.SharedCMDOptions, Protocol):
+
+        builddir: str
+        clearcache: bool
+        pager: bool
+
+    # cannot be TV_Loggable, because non-ansidecorators do direct string concat
+    LOGLINE = T.Union[str, mlog.AnsiDecorator]
+
+# Note: when adding arguments, please also add them to the completion
+# scripts in $MESONSRC/data/shell-completions/
+def add_arguments(parser: 'argparse.ArgumentParser') -> None:
+    coredata.register_builtin_arguments(parser)
+    parser.add_argument('builddir', nargs='?', default='.')
+    parser.add_argument('--clearcache', action='store_true', default=False,
+                        help='Clear cached state (e.g. found dependencies)')
+    parser.add_argument('--no-pager', action='store_false', dest='pager',
+                        help='Do not redirect output to a pager')
+
+def stringify(val: T.Any) -> str:
+    if isinstance(val, bool):
+        return str(val).lower()
+    elif isinstance(val, list):
+        s = ', '.join(stringify(i) for i in val)
+        return f'[{s}]'
+    elif val is None:
+        return ''
+    else:
+        return str(val)
+
+
+class ConfException(mesonlib.MesonException):
+    pass
+
+
+class Conf:
+    def __init__(self, build_dir: str):
+        self.build_dir = os.path.abspath(os.path.realpath(build_dir))
+        if 'meson.build' in [os.path.basename(self.build_dir), self.build_dir]:
+            self.build_dir = os.path.dirname(self.build_dir)
+        self.build = None
+        self.max_choices_line_length = 60
+        self.name_col: T.List[LOGLINE] = []
+        self.value_col: T.List[LOGLINE] = []
+        self.choices_col: T.List[LOGLINE] = []
+        self.descr_col: T.List[LOGLINE] = []
+        self.all_subprojects: T.Set[str] = set()
+
+        if os.path.isdir(os.path.join(self.build_dir, 'meson-private')):
+            self.build = build.load(self.build_dir)
+            self.source_dir = self.build.environment.get_source_dir()
+            self.coredata = self.build.environment.coredata
+            self.default_values_only = False
+
+            # if the option file has been updated, reload it
+            # This cannot handle options for a new subproject that has not yet
+            # been configured.
+            for sub, options in self.coredata.options_files.items():
+                if options is not None and os.path.exists(options[0]):
+                    opfile = options[0]
+                    with open(opfile, 'rb') as f:
+                        ophash = hashlib.sha1(f.read()).hexdigest()
+                        if ophash != options[1]:
+                            oi = OptionInterpreter(sub)
+                            oi.process(opfile)
+                            self.coredata.update_project_options(oi.options, sub)
+                            self.coredata.options_files[sub] = (opfile, ophash)
+                else:
+                    opfile = os.path.join(self.source_dir, 'meson.options')
+                    if not os.path.exists(opfile):
+                        opfile = os.path.join(self.source_dir, 'meson_options.txt')
+                    if os.path.exists(opfile):
+                        oi = OptionInterpreter(sub)
+                        oi.process(opfile)
+                        self.coredata.update_project_options(oi.options, sub)
+                        with open(opfile, 'rb') as f:
+                            ophash = hashlib.sha1(f.read()).hexdigest()
+                        self.coredata.options_files[sub] = (opfile, ophash)
+                    else:
+                        self.coredata.update_project_options({}, sub)
+        elif os.path.isfile(os.path.join(self.build_dir, environment.build_filename)):
+            # Make sure that log entries in other parts of meson don't interfere with the JSON output
+            with mlog.no_logging():
+                self.source_dir = os.path.abspath(os.path.realpath(self.build_dir))
+                intr = IntrospectionInterpreter(self.source_dir, '', 'ninja', visitors = [AstIDGenerator()])
+                intr.analyze()
+            self.coredata = intr.coredata
+            self.default_values_only = True
+        else:
+            raise ConfException(f'Directory {build_dir} is neither a Meson build directory nor a project source directory.')
+
+    def clear_cache(self) -> None:
+        self.coredata.clear_cache()
+
+    def set_options(self, options: T.Dict[OptionKey, str]) -> bool:
+        return self.coredata.set_options(options)
+
+    def save(self) -> None:
+        # Do nothing when using introspection
+        if self.default_values_only:
+            return
+        coredata.save(self.coredata, self.build_dir)
+        # We don't write the build file because any changes to it
+        # are erased when Meson is executed the next time, i.e. when
+        # Ninja is run.
+
+    def print_aligned(self) -> None:
+        """Do the actual printing.
+
+        This prints the generated output in an aligned, pretty form. it aims
+        for a total width of 160 characters, but will use whatever the tty
+        reports it's value to be. Though this is much wider than the standard
+        80 characters of terminals, and even than the newer 120, compressing
+        it to those lengths makes the output hard to read.
+
+        Each column will have a specific width, and will be line wrapped.
+        """
+        total_width = shutil.get_terminal_size(fallback=(160, 0))[0]
+        _col = max(total_width // 5, 20)
+        last_column = total_width - (3 * _col) - 3
+        four_column = (_col, _col, _col, last_column if last_column > 1 else _col)
+
+        for line in zip(self.name_col, self.value_col, self.choices_col, self.descr_col):
+            if not any(line):
+                mlog.log('')
+                continue
+
+            # This is a header, like `Subproject foo:`,
+            # We just want to print that and get on with it
+            if line[0] and not any(line[1:]):
+                mlog.log(line[0])
+                continue
+
+            def wrap_text(text: LOGLINE, width: int) -> mlog.TV_LoggableList:
+                raw = text.text if isinstance(text, mlog.AnsiDecorator) else text
+                indent = ' ' if raw.startswith('[') else ''
+                wrapped_ = textwrap.wrap(raw, width, subsequent_indent=indent)
+                # We cast this because https://github.com/python/mypy/issues/1965
+                # mlog.TV_LoggableList does not provide __len__ for stringprotocol
+                if isinstance(text, mlog.AnsiDecorator):
+                    wrapped = T.cast('T.List[LOGLINE]', [mlog.AnsiDecorator(i, text.code) for i in wrapped_])
+                else:
+                    wrapped = T.cast('T.List[LOGLINE]', wrapped_)
+                # Add padding here to get even rows, as `textwrap.wrap()` will
+                # only shorten, not lengthen each item
+                return [str(i) + ' ' * (width - len(i)) for i in wrapped]
+
+            # wrap will take a long string, and create a list of strings no
+            # longer than the size given. Then that list can be zipped into, to
+            # print each line of the output, such the that columns are printed
+            # to the right width, row by row.
+            name = wrap_text(line[0], four_column[0])
+            val = wrap_text(line[1], four_column[1])
+            choice = wrap_text(line[2], four_column[2])
+            desc = wrap_text(line[3], four_column[3])
+            for l in itertools.zip_longest(name, val, choice, desc, fillvalue=''):
+                items = [l[i] if l[i] else ' ' * four_column[i] for i in range(4)]
+                mlog.log(*items)
+
+    def split_options_per_subproject(self, options: 'coredata.KeyedOptionDictType') -> T.Dict[str, 'coredata.MutableKeyedOptionDictType']:
+        result: T.Dict[str, 'coredata.MutableKeyedOptionDictType'] = {}
+        for k, o in options.items():
+            if k.subproject:
+                self.all_subprojects.add(k.subproject)
+            result.setdefault(k.subproject, {})[k] = o
+        return result
+
+    def _add_line(self, name: LOGLINE, value: LOGLINE, choices: LOGLINE, descr: LOGLINE) -> None:
+        if isinstance(name, mlog.AnsiDecorator):
+            name.text = ' ' * self.print_margin + name.text
+        else:
+            name = ' ' * self.print_margin + name
+        self.name_col.append(name)
+        self.value_col.append(value)
+        self.choices_col.append(choices)
+        self.descr_col.append(descr)
+
+    def add_option(self, name: str, descr: str, value: T.Any, choices: T.Any) -> None:
+        value = stringify(value)
+        choices = stringify(choices)
+        self._add_line(mlog.green(name), mlog.yellow(value), mlog.blue(choices), descr)
+
+    def add_title(self, title: str) -> None:
+        newtitle = mlog.cyan(title)
+        descr = mlog.cyan('Description')
+        value = mlog.cyan('Default Value' if self.default_values_only else 'Current Value')
+        choices = mlog.cyan('Possible Values')
+        self._add_line('', '', '', '')
+        self._add_line(newtitle, value, choices, descr)
+        self._add_line('-' * len(newtitle), '-' * len(value), '-' * len(choices), '-' * len(descr))
+
+    def add_section(self, section: str) -> None:
+        self.print_margin = 0
+        self._add_line('', '', '', '')
+        self._add_line(mlog.normal_yellow(section + ':'), '', '', '')
+        self.print_margin = 2
+
+    def print_options(self, title: str, options: 'coredata.KeyedOptionDictType') -> None:
+        if not options:
+            return
+        if title:
+            self.add_title(title)
+        auto = T.cast('coredata.UserFeatureOption', self.coredata.options[OptionKey('auto_features')])
+        for k, o in sorted(options.items()):
+            printable_value = o.printable_value()
+            root = k.as_root()
+            if o.yielding and k.subproject and root in self.coredata.options:
+                printable_value = '<inherited from main project>'
+            if isinstance(o, coredata.UserFeatureOption) and o.is_auto():
+                printable_value = auto.printable_value()
+            self.add_option(str(root), o.description, printable_value, o.choices)
+
+    def print_conf(self, pager: bool) -> None:
+        if pager:
+            mlog.start_pager()
+
+        def print_default_values_warning() -> None:
+            mlog.warning('The source directory instead of the build directory was specified.')
+            mlog.warning('Only the default values for the project are printed.')
+
+        if self.default_values_only:
+            print_default_values_warning()
+            mlog.log('')
+
+        mlog.log('Core properties:')
+        mlog.log('  Source dir', self.source_dir)
+        if not self.default_values_only:
+            mlog.log('  Build dir ', self.build_dir)
+
+        dir_option_names = set(coredata.BUILTIN_DIR_OPTIONS)
+        test_option_names = {OptionKey('errorlogs'),
+                             OptionKey('stdsplit')}
+
+        dir_options: 'coredata.MutableKeyedOptionDictType' = {}
+        test_options: 'coredata.MutableKeyedOptionDictType' = {}
+        core_options: 'coredata.MutableKeyedOptionDictType' = {}
+        module_options: T.Dict[str, 'coredata.MutableKeyedOptionDictType'] = collections.defaultdict(dict)
+        for k, v in self.coredata.options.items():
+            if k in dir_option_names:
+                dir_options[k] = v
+            elif k in test_option_names:
+                test_options[k] = v
+            elif k.module:
+                # Ignore module options if we did not use that module during
+                # configuration.
+                if self.build and k.module not in self.build.modules:
+                    continue
+                module_options[k.module][k] = v
+            elif k.is_builtin():
+                core_options[k] = v
+
+        host_core_options = self.split_options_per_subproject({k: v for k, v in core_options.items() if k.machine is MachineChoice.HOST})
+        build_core_options = self.split_options_per_subproject({k: v for k, v in core_options.items() if k.machine is MachineChoice.BUILD})
+        host_compiler_options = self.split_options_per_subproject({k: v for k, v in self.coredata.options.items() if k.is_compiler() and k.machine is MachineChoice.HOST})
+        build_compiler_options = self.split_options_per_subproject({k: v for k, v in self.coredata.options.items() if k.is_compiler() and k.machine is MachineChoice.BUILD})
+        project_options = self.split_options_per_subproject({k: v for k, v in self.coredata.options.items() if k.is_project()})
+        show_build_options = self.default_values_only or self.build.environment.is_cross_build()
+
+        self.add_section('Main project options')
+        self.print_options('Core options', host_core_options[''])
+        if show_build_options:
+            self.print_options('', build_core_options[''])
+        self.print_options('Backend options', {k: v for k, v in self.coredata.options.items() if k.is_backend()})
+        self.print_options('Base options', {k: v for k, v in self.coredata.options.items() if k.is_base()})
+        self.print_options('Compiler options', host_compiler_options.get('', {}))
+        if show_build_options:
+            self.print_options('', build_compiler_options.get('', {}))
+        for mod, mod_options in module_options.items():
+            self.print_options(f'{mod} module options', mod_options)
+        self.print_options('Directories', dir_options)
+        self.print_options('Testing options', test_options)
+        self.print_options('Project options', project_options.get('', {}))
+        for subproject in sorted(self.all_subprojects):
+            if subproject == '':
+                continue
+            self.add_section('Subproject ' + subproject)
+            if subproject in host_core_options:
+                self.print_options('Core options', host_core_options[subproject])
+            if subproject in build_core_options and show_build_options:
+                self.print_options('', build_core_options[subproject])
+            if subproject in host_compiler_options:
+                self.print_options('Compiler options', host_compiler_options[subproject])
+            if subproject in build_compiler_options and show_build_options:
+                self.print_options('', build_compiler_options[subproject])
+            if subproject in project_options:
+                self.print_options('Project options', project_options[subproject])
+        self.print_aligned()
+
+        # Print the warning twice so that the user shouldn't be able to miss it
+        if self.default_values_only:
+            mlog.log('')
+            print_default_values_warning()
+
+        self.print_nondefault_buildtype_options()
+
+    def print_nondefault_buildtype_options(self) -> None:
+        mismatching = self.coredata.get_nondefault_buildtype_args()
+        if not mismatching:
+            return
+        mlog.log("\nThe following option(s) have a different value than the build type default\n")
+        mlog.log('               current   default')
+        for m in mismatching:
+            mlog.log(f'{m[0]:21}{m[1]:10}{m[2]:10}')
+
+def run_impl(options: CMDOptions, builddir: str) -> int:
+    print_only = not options.cmd_line_options and not options.clearcache
+    c = None
+    try:
+        c = Conf(builddir)
+        if c.default_values_only and not print_only:
+            raise mesonlib.MesonException('No valid build directory found, cannot modify options.')
+        if c.default_values_only or print_only:
+            c.print_conf(options.pager)
+            return 0
+
+        save = False
+        if options.cmd_line_options:
+            save = c.set_options(options.cmd_line_options)
+            coredata.update_cmd_line_file(builddir, options)
+        if options.clearcache:
+            c.clear_cache()
+            save = True
+        if save:
+            c.save()
+            mintro.update_build_options(c.coredata, c.build.environment.info_dir)
+            mintro.write_meson_info_file(c.build, [])
+    except ConfException as e:
+        mlog.log('Meson configurator encountered an error:')
+        if c is not None and c.build is not None:
+            mintro.write_meson_info_file(c.build, [e])
+        raise e
+    except BrokenPipeError:
+        # Pager quit before we wrote everything.
+        pass
+    return 0
+
+def run(options: CMDOptions) -> int:
+    coredata.parse_cmd_line_options(options)
+    builddir = os.path.abspath(os.path.realpath(options.builddir))
+    return run_impl(options, builddir)

package/releng/meson/mesonbuild/mdevenv.py

@@ -0,0 +1,234 @@
+from __future__ import annotations
+
+import os, subprocess
+import argparse
+import tempfile
+import shutil
+import itertools
+import typing as T
+
+from pathlib import Path
+from . import build, minstall
+from .mesonlib import (EnvironmentVariables, MesonException, is_windows, setup_vsenv, OptionKey,
+                       get_wine_shortpath, MachineChoice)
+from . import mlog
+
+
+if T.TYPE_CHECKING:
+    from .backend.backends import InstallData
+
+POWERSHELL_EXES = {'pwsh.exe', 'powershell.exe'}
+
+# Note: when adding arguments, please also add them to the completion
+# scripts in $MESONSRC/data/shell-completions/
+def add_arguments(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument('-C', dest='builddir', type=Path, default='.',
+                        help='Path to build directory')
+    parser.add_argument('--workdir', '-w', type=Path, default=None,
+                        help='Directory to cd into before running (default: builddir, Since 1.0.0)')
+    parser.add_argument('--dump', nargs='?', const=True,
+                        help='Only print required environment (Since 0.62.0) ' +
+                             'Takes an optional file path (Since 1.1.0)')
+    parser.add_argument('--dump-format', default='export',
+                        choices=['sh', 'export', 'vscode'],
+                        help='Format used with --dump (Since 1.1.0)')
+    parser.add_argument('devcmd', nargs=argparse.REMAINDER, metavar='command',
+                        help='Command to run in developer environment (default: interactive shell)')
+
+def get_windows_shell() -> T.Optional[str]:
+    mesonbuild = Path(__file__).parent
+    script = mesonbuild / 'scripts' / 'cmd_or_ps.ps1'
+    for shell in POWERSHELL_EXES:
+        try:
+            command = [shell, '-noprofile', '-executionpolicy', 'bypass', '-file', str(script)]
+            result = subprocess.check_output(command)
+            return result.decode().strip()
+        except (subprocess.CalledProcessError, OSError):
+            pass
+    return None
+
+def reduce_winepath(env: T.Dict[str, str]) -> None:
+    winepath = env.get('WINEPATH')
+    if not winepath:
+        return
+    winecmd = shutil.which('wine64') or shutil.which('wine')
+    if not winecmd:
+        return
+    env['WINEPATH'] = get_wine_shortpath([winecmd], winepath.split(';'))
+    mlog.log('Meson detected wine and has set WINEPATH accordingly')
+
+def get_env(b: build.Build, dump_fmt: T.Optional[str]) -> T.Tuple[T.Dict[str, str], T.Set[str]]:
+    extra_env = EnvironmentVariables()
+    extra_env.set('MESON_DEVENV', ['1'])
+    extra_env.set('MESON_PROJECT_NAME', [b.project_name])
+
+    sysroot = b.environment.properties[MachineChoice.HOST].get_sys_root()
+    if sysroot:
+        extra_env.set('QEMU_LD_PREFIX', [sysroot])
+
+    env = {} if dump_fmt else os.environ.copy()
+    default_fmt = '${0}' if dump_fmt in {'sh', 'export'} else None
+    varnames = set()
+    for i in itertools.chain(b.devenv, {extra_env}):
+        env = i.get_env(env, default_fmt)
+        varnames |= i.get_names()
+
+    reduce_winepath(env)
+
+    return env, varnames
+
+def bash_completion_files(b: build.Build, install_data: 'InstallData') -> T.List[str]:
+    from .dependencies.pkgconfig import PkgConfigDependency
+    result = []
+    dep = PkgConfigDependency('bash-completion', b.environment,
+                              {'required': False, 'silent': True, 'version': '>=2.10'})
+    if dep.found():
+        prefix = b.environment.coredata.get_option(OptionKey('prefix'))
+        assert isinstance(prefix, str), 'for mypy'
+        datadir = b.environment.coredata.get_option(OptionKey('datadir'))
+        assert isinstance(datadir, str), 'for mypy'
+        datadir_abs = os.path.join(prefix, datadir)
+        completionsdir = dep.get_variable(pkgconfig='completionsdir', pkgconfig_define=(('datadir', datadir_abs),))
+        assert isinstance(completionsdir, str), 'for mypy'
+        completionsdir_path = Path(completionsdir)
+        for f in install_data.data:
+            if completionsdir_path in Path(f.install_path).parents:
+                result.append(f.path)
+    return result
+
+def add_gdb_auto_load(autoload_path: Path, gdb_helper: str, fname: Path) -> None:
+    # Copy or symlink the GDB helper into our private directory tree
+    destdir = autoload_path / fname.parent
+    destdir.mkdir(parents=True, exist_ok=True)
+    try:
+        if is_windows():
+            shutil.copy(gdb_helper, str(destdir / os.path.basename(gdb_helper)))
+        else:
+            os.symlink(gdb_helper, str(destdir / os.path.basename(gdb_helper)))
+    except (FileExistsError, shutil.SameFileError):
+        pass
+
+def write_gdb_script(privatedir: Path, install_data: 'InstallData', workdir: Path) -> None:
+    if not shutil.which('gdb'):
+        return
+    bdir = privatedir.parent
+    autoload_basedir = privatedir / 'gdb-auto-load'
+    autoload_path = Path(autoload_basedir, *bdir.parts[1:])
+    have_gdb_helpers = False
+    for d in install_data.data:
+        if d.path.endswith('-gdb.py') or d.path.endswith('-gdb.gdb') or d.path.endswith('-gdb.scm'):
+            # This GDB helper is made for a specific shared library, search if
+            # we have it in our builddir.
+            libname = Path(d.path).name.rsplit('-', 1)[0]
+            for t in install_data.targets:
+                path = Path(t.fname)
+                if path.name == libname:
+                    add_gdb_auto_load(autoload_path, d.path, path)
+                    have_gdb_helpers = True
+    if have_gdb_helpers:
+        gdbinit_line = f'add-auto-load-scripts-directory {autoload_basedir}\n'
+        gdbinit_path = bdir / '.gdbinit'
+        first_time = False
+        try:
+            with gdbinit_path.open('r+', encoding='utf-8') as f:
+                if gdbinit_line not in f.readlines():
+                    f.write(gdbinit_line)
+                    first_time = True
+        except FileNotFoundError:
+            gdbinit_path.write_text(gdbinit_line, encoding='utf-8')
+            first_time = True
+        if first_time:
+            gdbinit_path = gdbinit_path.resolve()
+            workdir_path = workdir.resolve()
+            rel_path = gdbinit_path.relative_to(workdir_path)
+            mlog.log('Meson detected GDB helpers and added config in', mlog.bold(str(rel_path)))
+            mlog.log('To load it automatically you might need to:')
+            mlog.log(' - Add', mlog.bold(f'add-auto-load-safe-path {gdbinit_path.parent}'),
+                     'in', mlog.bold('~/.gdbinit'))
+            if gdbinit_path.parent != workdir_path:
+                mlog.log(' - Change current workdir to', mlog.bold(str(rel_path.parent)),
+                         'or use', mlog.bold(f'--init-command {rel_path}'))
+
+def dump(devenv: T.Dict[str, str], varnames: T.Set[str], dump_format: T.Optional[str], output: T.Optional[T.TextIO] = None) -> None:
+    for name in varnames:
+        print(f'{name}="{devenv[name]}"', file=output)
+        if dump_format == 'export':
+            print(f'export {name}', file=output)
+
+def run(options: argparse.Namespace) -> int:
+    privatedir = Path(options.builddir) / 'meson-private'
+    buildfile = privatedir / 'build.dat'
+    if not buildfile.is_file():
+        raise MesonException(f'Directory {options.builddir!r} does not seem to be a Meson build directory.')
+    b = build.load(options.builddir)
+    workdir = options.workdir or options.builddir
+
+    need_vsenv = T.cast('bool', b.environment.coredata.get_option(OptionKey('vsenv')))
+    setup_vsenv(need_vsenv) # Call it before get_env to get vsenv vars as well
+    dump_fmt = options.dump_format if options.dump else None
+    devenv, varnames = get_env(b, dump_fmt)
+    if options.dump:
+        if options.devcmd:
+            raise MesonException('--dump option does not allow running other command.')
+        if options.dump is True:
+            dump(devenv, varnames, dump_fmt)
+        else:
+            with open(options.dump, "w", encoding='utf-8') as output:
+                dump(devenv, varnames, dump_fmt, output)
+        return 0
+
+    if b.environment.need_exe_wrapper():
+        m = 'An executable wrapper could be required'
+        exe_wrapper = b.environment.get_exe_wrapper()
+        if exe_wrapper:
+            cmd = ' '.join(exe_wrapper.get_command())
+            m += f': {cmd}'
+        mlog.log(m)
+
+    install_data = minstall.load_install_data(str(privatedir / 'install.dat'))
+    write_gdb_script(privatedir, install_data, workdir)
+
+    args = options.devcmd
+    if not args:
+        prompt_prefix = f'[{b.project_name}]'
+        shell_env = os.environ.get("SHELL")
+        # Prefer $SHELL in a MSYS2 bash despite it being Windows
+        if shell_env and os.path.exists(shell_env):
+            args = [shell_env]
+        elif is_windows():
+            shell = get_windows_shell()
+            if not shell:
+                mlog.warning('Failed to determine Windows shell, fallback to cmd.exe')
+            if shell in POWERSHELL_EXES:
+                args = [shell, '-NoLogo', '-NoExit']
+                prompt = f'function global:prompt {{  "{prompt_prefix} PS " + $PWD + "> "}}'
+                args += ['-Command', prompt]
+            else:
+                args = [os.environ.get("COMSPEC", r"C:\WINDOWS\system32\cmd.exe")]
+                args += ['/k', f'prompt {prompt_prefix} $P$G']
+        else:
+            args = [os.environ.get("SHELL", os.path.realpath("/bin/sh"))]
+        if "bash" in args[0]:
+            # Let the GC remove the tmp file
+            tmprc = tempfile.NamedTemporaryFile(mode='w')
+            tmprc.write('[ -e ~/.bashrc ] && . ~/.bashrc\n')
+            if not os.environ.get("MESON_DISABLE_PS1_OVERRIDE"):
+                tmprc.write(f'export PS1="{prompt_prefix} $PS1"\n')
+            for f in bash_completion_files(b, install_data):
+                tmprc.write(f'. "{f}"\n')
+            tmprc.flush()
+            args.append("--rcfile")
+            args.append(tmprc.name)
+    else:
+        # Try to resolve executable using devenv's PATH
+        abs_path = shutil.which(args[0], path=devenv.get('PATH', None))
+        args[0] = abs_path or args[0]
+
+    try:
+        return subprocess.call(args, close_fds=False,
+                               env=devenv,
+                               cwd=workdir)
+    except subprocess.CalledProcessError as e:
+        return e.returncode
+    except FileNotFoundError:
+        raise MesonException(f'Command not found: {args[0]}')