frida 16.2.0 → 16.2.2

package/releng/meson/mesonbuild/mesonmain.py

@@ -0,0 +1,289 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2012-2021 The Meson development team
+
+from __future__ import annotations
+
+# Work around some pathlib bugs...
+
+from . import _pathlib
+import sys
+sys.modules['pathlib'] = _pathlib
+
+# This file is an entry point for all commands, including scripts. Include the
+# strict minimum python modules for performance reasons.
+import os.path
+import platform
+import importlib
+import argparse
+import typing as T
+
+from .utils.core import MesonException, MesonBugException
+from . import mlog
+
+def errorhandler(e: Exception, command: str) -> int:
+    import traceback
+    if isinstance(e, MesonException):
+        mlog.exception(e)
+        logfile = mlog.shutdown()
+        if logfile is not None:
+            mlog.log("\nA full log can be found at", mlog.bold(logfile))
+        if os.environ.get('MESON_FORCE_BACKTRACE'):
+            raise e
+        return 1
+    else:
+        # We assume many types of traceback are Meson logic bugs, but most
+        # particularly anything coming from the interpreter during `setup`.
+        # Some things definitely aren't:
+        # - PermissionError is always a problem in the user environment
+        # - runpython doesn't run Meson's own code, even though it is
+        #   dispatched by our run()
+        if os.environ.get('MESON_FORCE_BACKTRACE'):
+            raise e
+        traceback.print_exc()
+
+        if command == 'runpython':
+            return 2
+        elif isinstance(e, OSError):
+            mlog.exception(Exception("Unhandled python OSError. This is probably not a Meson bug, "
+                           "but an issue with your build environment."))
+            return e.errno
+        else: # Exception
+            msg = 'Unhandled python exception'
+            if all(getattr(e, a, None) is not None for a in ['file', 'lineno', 'colno']):
+                e = MesonBugException(msg, e.file, e.lineno, e.colno) # type: ignore
+            else:
+                e = MesonBugException(msg)
+            mlog.exception(e)
+        return 2
+
+# Note: when adding arguments, please also add them to the completion
+# scripts in $MESONSRC/data/shell-completions/
+class CommandLineParser:
+    def __init__(self) -> None:
+        # only import these once we do full argparse processing
+        from . import mconf, mdist, minit, minstall, mintro, msetup, mtest, rewriter, msubprojects, munstable_coredata, mcompile, mdevenv
+        from .scripts import env2mfile
+        from .wrap import wraptool
+        import shutil
+
+        self.term_width = shutil.get_terminal_size().columns
+        self.formatter = lambda prog: argparse.HelpFormatter(prog, max_help_position=int(self.term_width / 2), width=self.term_width)
+
+        self.commands: T.Dict[str, argparse.ArgumentParser] = {}
+        self.hidden_commands: T.List[str] = []
+        self.parser = argparse.ArgumentParser(prog='meson', formatter_class=self.formatter)
+        self.subparsers = self.parser.add_subparsers(title='Commands', dest='command',
+                                                     description='If no command is specified it defaults to setup command.')
+        self.add_command('setup', msetup.add_arguments, msetup.run,
+                         help_msg='Configure the project')
+        self.add_command('configure', mconf.add_arguments, mconf.run,
+                         help_msg='Change project options',)
+        self.add_command('dist', mdist.add_arguments, mdist.run,
+                         help_msg='Generate release archive',)
+        self.add_command('install', minstall.add_arguments, minstall.run,
+                         help_msg='Install the project')
+        self.add_command('introspect', mintro.add_arguments, mintro.run,
+                         help_msg='Introspect project')
+        self.add_command('init', minit.add_arguments, minit.run,
+                         help_msg='Create a new project')
+        self.add_command('test', mtest.add_arguments, mtest.run,
+                         help_msg='Run tests')
+        self.add_command('wrap', wraptool.add_arguments, wraptool.run,
+                         help_msg='Wrap tools')
+        self.add_command('subprojects', msubprojects.add_arguments, msubprojects.run,
+                         help_msg='Manage subprojects')
+        self.add_command('rewrite', lambda parser: rewriter.add_arguments(parser, self.formatter), rewriter.run,
+                         help_msg='Modify the project definition')
+        self.add_command('compile', mcompile.add_arguments, mcompile.run,
+                         help_msg='Build the project')
+        self.add_command('devenv', mdevenv.add_arguments, mdevenv.run,
+                         help_msg='Run commands in developer environment')
+        self.add_command('env2mfile', env2mfile.add_arguments, env2mfile.run,
+                         help_msg='Convert current environment to a cross or native file')
+        # Add new commands above this line to list them in help command
+        self.add_command('help', self.add_help_arguments, self.run_help_command,
+                         help_msg='Print help of a subcommand')
+
+        # Hidden commands
+        self.add_command('runpython', self.add_runpython_arguments, self.run_runpython_command,
+                         help_msg=argparse.SUPPRESS)
+        self.add_command('unstable-coredata', munstable_coredata.add_arguments, munstable_coredata.run,
+                         help_msg=argparse.SUPPRESS)
+
+    def add_command(self, name: str, add_arguments_func: T.Callable[[argparse.ArgumentParser], None],
+                    run_func: T.Callable[[argparse.Namespace], int], help_msg: str, aliases: T.List[str] = None) -> None:
+        aliases = aliases or []
+        # FIXME: Cannot have hidden subparser:
+        # https://bugs.python.org/issue22848
+        if help_msg == argparse.SUPPRESS:
+            p = argparse.ArgumentParser(prog='meson ' + name, formatter_class=self.formatter)
+            self.hidden_commands.append(name)
+        else:
+            p = self.subparsers.add_parser(name, help=help_msg, aliases=aliases, formatter_class=self.formatter)
+        add_arguments_func(p)
+        p.set_defaults(run_func=run_func)
+        for i in [name] + aliases:
+            self.commands[i] = p
+
+    def add_runpython_arguments(self, parser: argparse.ArgumentParser) -> None:
+        parser.add_argument('-c', action='store_true', dest='eval_arg', default=False)
+        parser.add_argument('--version', action='version', version=platform.python_version())
+        parser.add_argument('script_file')
+        parser.add_argument('script_args', nargs=argparse.REMAINDER)
+
+    def run_runpython_command(self, options: argparse.Namespace) -> int:
+        sys.argv[1:] = options.script_args
+        if options.eval_arg:
+            exec(options.script_file)
+        else:
+            import runpy
+            sys.path.insert(0, os.path.dirname(options.script_file))
+            runpy.run_path(options.script_file, run_name='__main__')
+        return 0
+
+    def add_help_arguments(self, parser: argparse.ArgumentParser) -> None:
+        parser.add_argument('command', nargs='?', choices=list(self.commands.keys()))
+
+    def run_help_command(self, options: argparse.Namespace) -> int:
+        if options.command:
+            self.commands[options.command].print_help()
+        else:
+            self.parser.print_help()
+        return 0
+
+    def run(self, args: T.List[str]) -> int:
+        implicit_setup_command_notice = False
+        # If first arg is not a known command, assume user wants to run the setup
+        # command.
+        known_commands = list(self.commands.keys()) + ['-h', '--help']
+        if not args or args[0] not in known_commands:
+            implicit_setup_command_notice = True
+            args = ['setup'] + args
+
+        # Hidden commands have their own parser instead of using the global one
+        if args[0] in self.hidden_commands:
+            command = args[0]
+            parser = self.commands[command]
+            args = args[1:]
+        else:
+            parser = self.parser
+            command = None
+
+        from . import mesonlib
+        args = mesonlib.expand_arguments(args)
+        options = parser.parse_args(args)
+
+        if command is None:
+            command = options.command
+
+        # Bump the version here in order to add a pre-exit warning that we are phasing out
+        # support for old python. If this is already the oldest supported version, then
+        # this can never be true and does nothing.
+        pending_python_deprecation_notice = \
+            command in {'setup', 'compile', 'test', 'install'} and sys.version_info < (3, 7)
+
+        try:
+            return options.run_func(options)
+        except Exception as e:
+            return errorhandler(e, command)
+        finally:
+            if implicit_setup_command_notice:
+                mlog.warning('Running the setup command as `meson [options]` instead of '
+                             '`meson setup [options]` is ambiguous and deprecated.', fatal=False)
+            if pending_python_deprecation_notice:
+                mlog.notice('You are using Python 3.6 which is EOL. Starting with v0.62.0, '
+                            'Meson will require Python 3.7 or newer', fatal=False)
+            mlog.shutdown()
+
+def run_script_command(script_name: str, script_args: T.List[str]) -> int:
+    # Map script name to module name for those that doesn't match
+    script_map = {'exe': 'meson_exe',
+                  'install': 'meson_install',
+                  'delsuffix': 'delwithsuffix',
+                  'gtkdoc': 'gtkdochelper',
+                  'hotdoc': 'hotdochelper',
+                  'regencheck': 'regen_checker'}
+    module_name = script_map.get(script_name, script_name)
+
+    try:
+        module = importlib.import_module('mesonbuild.scripts.' + module_name)
+    except ModuleNotFoundError as e:
+        mlog.exception(e)
+        return 1
+
+    try:
+        return module.run(script_args)
+    except MesonException as e:
+        mlog.error(f'Error in {script_name} helper script:')
+        mlog.exception(e)
+        return 1
+
+def ensure_stdout_accepts_unicode() -> None:
+    if sys.stdout.encoding and not sys.stdout.encoding.upper().startswith('UTF-'):
+        sys.stdout.reconfigure(errors='surrogateescape') # type: ignore[attr-defined]
+
+def set_meson_command(mainfile: str) -> None:
+    # Set the meson command that will be used to run scripts and so on
+    from . import mesonlib
+    mesonlib.set_meson_command(mainfile)
+
+def run(original_args: T.List[str], mainfile: str) -> int:
+    if os.environ.get('MESON_SHOW_DEPRECATIONS'):
+        # workaround for https://bugs.python.org/issue34624
+        import warnings
+        for typ in [DeprecationWarning, SyntaxWarning, FutureWarning, PendingDeprecationWarning]:
+            warnings.filterwarnings('error', category=typ, module='mesonbuild')
+        warnings.filterwarnings('ignore', message=".*importlib-resources.*")
+
+    if sys.version_info >= (3, 10) and os.environ.get('MESON_RUNNING_IN_PROJECT_TESTS'):
+        # workaround for https://bugs.python.org/issue34624
+        import warnings
+        warnings.filterwarnings('error', category=EncodingWarning, module='mesonbuild')
+        # python 3.11 adds a warning that in 3.15, UTF-8 mode will be default.
+        # This is fantastic news, we'd love that. Less fantastic: this warning is silly,
+        # we *want* these checks to be affected. Plus, the recommended alternative API
+        # would (in addition to warning people when UTF-8 mode removed the problem) also
+        # require using a minimum python version of 3.11 (in which the warning was added)
+        # or add verbose if/else soup.
+        warnings.filterwarnings('ignore', message="UTF-8 Mode affects .*getpreferredencoding", category=EncodingWarning)
+
+    # Meson gets confused if stdout can't output Unicode, if the
+    # locale isn't Unicode, just force stdout to accept it. This tries
+    # to emulate enough of PEP 540 to work elsewhere.
+    ensure_stdout_accepts_unicode()
+
+    # https://github.com/mesonbuild/meson/issues/3653
+    if sys.platform == 'cygwin' and os.environ.get('MSYSTEM', '') not in ['MSYS', '']:
+        mlog.error('This python3 seems to be msys/python on MSYS2 Windows, but you are in a MinGW environment')
+        mlog.error('Please install and use mingw-w64-x86_64-python3 and/or mingw-w64-x86_64-meson with Pacman')
+        return 2
+
+    args = original_args[:]
+
+    # Special handling of internal commands called from backends, they don't
+    # need to go through argparse.
+    if len(args) >= 2 and args[0] == '--internal':
+        if args[1] == 'regenerate':
+            set_meson_command(mainfile)
+            from . import msetup
+            try:
+                return msetup.run(['--reconfigure'] + args[2:])
+            except Exception as e:
+                return errorhandler(e, 'setup')
+        else:
+            return run_script_command(args[1], args[2:])
+
+    set_meson_command(mainfile)
+    return CommandLineParser().run(args)
+
+def main() -> int:
+    # Always resolve the command path so Ninja can find it for regen, tests, etc.
+    if 'meson.exe' in sys.executable:
+        assert os.path.isabs(sys.executable)
+        launcher = sys.executable
+    else:
+        launcher = os.path.abspath(sys.argv[0])
+    return run(sys.argv[1:], launcher)
+
+if __name__ == '__main__':
+    sys.exit(main())

package/releng/meson/mesonbuild/minit.py

@@ -0,0 +1,204 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2017 The Meson development team
+
+"""Code that creates simple startup projects."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from enum import Enum
+import subprocess
+import shutil
+import sys
+import os
+import re
+from glob import glob
+import typing as T
+
+from mesonbuild import build, mesonlib, mlog
+from mesonbuild.coredata import FORBIDDEN_TARGET_NAMES
+from mesonbuild.environment import detect_ninja
+from mesonbuild.templates.mesontemplates import create_meson_build
+from mesonbuild.templates.samplefactory import sample_generator
+
+if T.TYPE_CHECKING:
+    import argparse
+
+    from typing_extensions import Protocol, Literal
+
+    class Arguments(Protocol):
+
+        srcfiles: T.List[Path]
+        wd: str
+        name: str
+        executable: str
+        deps: str
+        language: Literal['c', 'cpp', 'cs', 'cuda', 'd', 'fortran', 'java', 'rust', 'objc', 'objcpp', 'vala']
+        build: bool
+        builddir: str
+        force: bool
+        type: Literal['executable', 'library']
+        version: str
+
+
+FORTRAN_SUFFIXES = {'.f', '.for', '.F', '.f90', '.F90'}
+LANG_SUFFIXES = {'.c', '.cc', '.cpp', '.cs', '.cu', '.d', '.m', '.mm', '.rs', '.java', '.vala'} | FORTRAN_SUFFIXES
+LANG_SUPPORTED = {'c', 'cpp', 'cs', 'cuda', 'd', 'fortran', 'java', 'rust', 'objc', 'objcpp', 'vala'}
+
+DEFAULT_PROJECT = 'executable'
+DEFAULT_VERSION = '0.1'
+class DEFAULT_TYPES(Enum):
+    EXE = 'executable'
+    LIB = 'library'
+
+INFO_MESSAGE = '''Sample project created. To build it run the
+following commands:
+
+meson setup builddir
+meson compile -C builddir
+'''
+
+
+def create_sample(options: Arguments) -> None:
+    '''
+    Based on what arguments are passed we check for a match in language
+    then check for project type and create new Meson samples project.
+    '''
+    sample_gen = sample_generator(options)
+    if options.type == DEFAULT_TYPES['EXE'].value:
+        sample_gen.create_executable()
+    elif options.type == DEFAULT_TYPES['LIB'].value:
+        sample_gen.create_library()
+    else:
+        raise RuntimeError('Unreachable code')
+    print(INFO_MESSAGE)
+
+def autodetect_options(options: Arguments, sample: bool = False) -> None:
+    '''
+    Here we autodetect options for args not passed in so don't have to
+    think about it.
+    '''
+    if not options.name:
+        options.name = Path().resolve().stem
+        if not re.match('[a-zA-Z_][a-zA-Z0-9]*', options.name) and sample:
+            raise SystemExit(f'Name of current directory "{options.name}" is not usable as a sample project name.\n'
+                             'Specify a project name with --name.')
+        print(f'Using "{options.name}" (name of current directory) as project name.')
+    if not options.executable:
+        options.executable = options.name
+        print(f'Using "{options.executable}" (project name) as name of executable to build.')
+    if options.executable in FORBIDDEN_TARGET_NAMES:
+        raise mesonlib.MesonException(f'Executable name {options.executable!r} is reserved for Meson internal use. '
+                                      'Refusing to init an invalid project.')
+    if sample:
+        # The rest of the autodetection is not applicable to generating sample projects.
+        return
+    if not options.srcfiles:
+        srcfiles: T.List[Path] = []
+        for f in (f for f in Path().iterdir() if f.is_file()):
+            if f.suffix in LANG_SUFFIXES:
+                srcfiles.append(f)
+        if not srcfiles:
+            raise SystemExit('No recognizable source files found.\n'
+                             'Run meson init in an empty directory to create a sample project.')
+        options.srcfiles = srcfiles
+        print("Detected source files: " + ' '.join(str(s) for s in srcfiles))
+    if not options.language:
+        for f in options.srcfiles:
+            if f.suffix == '.c':
+                options.language = 'c'
+                break
+            if f.suffix in {'.cc', '.cpp'}:
+                options.language = 'cpp'
+                break
+            if f.suffix == '.cs':
+                options.language = 'cs'
+                break
+            if f.suffix == '.cu':
+                options.language = 'cuda'
+                break
+            if f.suffix == '.d':
+                options.language = 'd'
+                break
+            if f.suffix in FORTRAN_SUFFIXES:
+                options.language = 'fortran'
+                break
+            if f.suffix == '.rs':
+                options.language = 'rust'
+                break
+            if f.suffix == '.m':
+                options.language = 'objc'
+                break
+            if f.suffix == '.mm':
+                options.language = 'objcpp'
+                break
+            if f.suffix == '.java':
+                options.language = 'java'
+                break
+            if f.suffix == '.vala':
+                options.language = 'vala'
+                break
+        if not options.language:
+            raise SystemExit("Can't autodetect language, please specify it with -l.")
+        print("Detected language: " + options.language)
+
+# Note: when adding arguments, please also add them to the completion
+# scripts in $MESONSRC/data/shell-completions/
+def add_arguments(parser: 'argparse.ArgumentParser') -> None:
+    '''
+    Here we add args for that the user can passed when making a new
+    Meson project.
+    '''
+    parser.add_argument("srcfiles", metavar="sourcefile", nargs="*", type=Path, help="source files. default: all recognized files in current directory")
+    parser.add_argument('-C', dest='wd', action=mesonlib.RealPathAction,
+                        help='directory to cd into before running')
+    parser.add_argument("-n", "--name", help="project name. default: name of current directory")
+    parser.add_argument("-e", "--executable", help="executable name. default: project name")
+    parser.add_argument("-d", "--deps", help="dependencies, comma-separated")
+    parser.add_argument("-l", "--language", choices=sorted(LANG_SUPPORTED), help="project language. default: autodetected based on source files")
+    parser.add_argument("-b", "--build", action='store_true', help="build after generation")
+    parser.add_argument("--builddir", default='build', help="directory for build")
+    parser.add_argument("-f", "--force", action="store_true", help="force overwrite of existing files and directories.")
+    parser.add_argument('--type', default=DEFAULT_PROJECT, choices=('executable', 'library'), help=f"project type. default: {DEFAULT_PROJECT} based project")
+    parser.add_argument('--version', default=DEFAULT_VERSION, help=f"project version. default: {DEFAULT_VERSION}")
+
+def run(options: Arguments) -> int:
+    '''
+    Here we generate the new Meson sample project.
+    '''
+    if not Path(options.wd).exists():
+        sys.exit('Project source root directory not found. Run this command in source directory root.')
+    os.chdir(options.wd)
+
+    if not glob('*'):
+        autodetect_options(options, sample=True)
+        if not options.language:
+            print('Defaulting to generating a C language project.')
+            options.language = 'c'
+        create_sample(options)
+    else:
+        autodetect_options(options)
+        if Path('meson.build').is_file() and not options.force:
+            raise SystemExit('meson.build already exists. Use --force to overwrite.')
+        create_meson_build(options)
+    if options.build:
+        if Path(options.builddir).is_dir() and options.force:
+            print('Build directory already exists, deleting it.')
+            shutil.rmtree(options.builddir)
+        print('Building...')
+        cmd = mesonlib.get_meson_command() + ['setup', options.builddir]
+        ret = subprocess.run(cmd)
+        if ret.returncode:
+            raise SystemExit
+
+        b = build.load(options.builddir)
+        need_vsenv = T.cast('bool', b.environment.coredata.get_option(mesonlib.OptionKey('vsenv')))
+        vsenv_active = mesonlib.setup_vsenv(need_vsenv)
+        if vsenv_active:
+            mlog.log(mlog.green('INFO:'), 'automatically activated MSVC compiler environment')
+
+        cmd = detect_ninja() + ['-C', options.builddir]
+        ret = subprocess.run(cmd)
+        if ret.returncode:
+            raise SystemExit
+    return 0