frida 16.2.1 → 16.2.2

package/releng/meson/mesonbuild/scripts/gtkdochelper.py

@@ -0,0 +1,286 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2015-2016 The Meson development team
+
+from __future__ import annotations
+
+import sys, os
+import subprocess
+import shutil
+import argparse
+from ..mesonlib import MesonException, Popen_safe, is_windows, is_cygwin, split_args
+from . import destdir_join
+import typing as T
+
+parser = argparse.ArgumentParser()
+
+parser.add_argument('--sourcedir', dest='sourcedir')
+parser.add_argument('--builddir', dest='builddir')
+parser.add_argument('--subdir', dest='subdir')
+parser.add_argument('--headerdirs', dest='headerdirs')
+parser.add_argument('--mainfile', dest='mainfile')
+parser.add_argument('--modulename', dest='modulename')
+parser.add_argument('--moduleversion', dest='moduleversion')
+parser.add_argument('--htmlargs', dest='htmlargs', default='')
+parser.add_argument('--scanargs', dest='scanargs', default='')
+parser.add_argument('--scanobjsargs', dest='scanobjsargs', default='')
+parser.add_argument('--gobjects-types-file', dest='gobject_typesfile', default='')
+parser.add_argument('--fixxrefargs', dest='fixxrefargs', default='')
+parser.add_argument('--mkdbargs', dest='mkdbargs', default='')
+parser.add_argument('--ld', dest='ld', default='')
+parser.add_argument('--cc', dest='cc', default='')
+parser.add_argument('--ldflags', dest='ldflags', default='')
+parser.add_argument('--cflags', dest='cflags', default='')
+parser.add_argument('--content-files', dest='content_files', default='')
+parser.add_argument('--expand-content-files', dest='expand_content_files', default='')
+parser.add_argument('--html-assets', dest='html_assets', default='')
+parser.add_argument('--ignore-headers', dest='ignore_headers', default='')
+parser.add_argument('--namespace', dest='namespace', default='')
+parser.add_argument('--mode', dest='mode', default='')
+parser.add_argument('--installdir', dest='install_dir')
+parser.add_argument('--run', dest='run', default='')
+for tool in ['scan', 'scangobj', 'mkdb', 'mkhtml', 'fixxref']:
+    program_name = 'gtkdoc-' + tool
+    parser.add_argument('--' + program_name, dest=program_name.replace('-', '_'))
+
+def gtkdoc_run_check(cmd: T.List[str], cwd: str, library_paths: T.Optional[T.List[str]] = None) -> None:
+    if library_paths is None:
+        library_paths = []
+
+    env = dict(os.environ)
+    if is_windows() or is_cygwin():
+        if 'PATH' in env:
+            library_paths.extend(env['PATH'].split(os.pathsep))
+        env['PATH'] = os.pathsep.join(library_paths)
+    else:
+        if 'LD_LIBRARY_PATH' in env:
+            library_paths.extend(env['LD_LIBRARY_PATH'].split(os.pathsep))
+        env['LD_LIBRARY_PATH'] = os.pathsep.join(library_paths)
+
+    if is_windows():
+        cmd.insert(0, sys.executable)
+
+    # Put stderr into stdout since we want to print it out anyway.
+    # This preserves the order of messages.
+    p, out = Popen_safe(cmd, cwd=cwd, env=env, stderr=subprocess.STDOUT)[0:2]
+    if p.returncode != 0:
+        err_msg = [f"{cmd!r} failed with status {p.returncode:d}"]
+        if out:
+            err_msg.append(out)
+        raise MesonException('\n'.join(err_msg))
+    elif out:
+        # Unfortunately Windows cmd.exe consoles may be using a codepage
+        # that might choke print() with a UnicodeEncodeError, so let's
+        # ignore such errors for now, as a compromise as we are outputting
+        # console output here...
+        try:
+            print(out)
+        except UnicodeEncodeError:
+            pass
+
+def build_gtkdoc(source_root: str, build_root: str, doc_subdir: str, src_subdirs: T.List[str],
+                 main_file: str, module: str, module_version: str,
+                 html_args: T.List[str], scan_args: T.List[str], fixxref_args: T.List[str], mkdb_args: T.List[str],
+                 gobject_typesfile: str, scanobjs_args: T.List[str], run: str, ld: str, cc: str, ldflags: str, cflags: str,
+                 html_assets: T.List[str], content_files: T.List[str], ignore_headers: T.List[str], namespace: str,
+                 expand_content_files: T.List[str], mode: str, options: argparse.Namespace) -> None:
+    print("Building documentation for %s" % module)
+
+    src_dir_args = []
+    for src_dir in src_subdirs:
+        if not os.path.isabs(src_dir):
+            dirs = [os.path.join(source_root, src_dir),
+                    os.path.join(build_root, src_dir)]
+        else:
+            dirs = [src_dir]
+        src_dir_args += ['--source-dir=' + d for d in dirs]
+
+    doc_src = os.path.join(source_root, doc_subdir)
+    abs_out = os.path.join(build_root, doc_subdir)
+    htmldir = os.path.join(abs_out, 'html')
+
+    content_files += [main_file]
+    sections = os.path.join(doc_src, module + "-sections.txt")
+    if os.path.exists(sections):
+        content_files.append(sections)
+
+    overrides = os.path.join(doc_src, module + "-overrides.txt")
+    if os.path.exists(overrides):
+        content_files.append(overrides)
+
+    # Copy files to build directory
+    for f in content_files:
+        # FIXME: Use mesonlib.File objects so we don't need to do this
+        if not os.path.isabs(f):
+            f = os.path.join(doc_src, f)
+        elif os.path.commonpath([f, build_root]) == build_root:
+            continue
+        shutil.copyfile(f, os.path.join(abs_out, os.path.basename(f)))
+
+    shutil.rmtree(htmldir, ignore_errors=True)
+    try:
+        os.mkdir(htmldir)
+    except Exception:
+        pass
+
+    for f in html_assets:
+        f_abs = os.path.join(doc_src, f)
+        shutil.copyfile(f_abs, os.path.join(htmldir, os.path.basename(f_abs)))
+
+    scan_cmd = [options.gtkdoc_scan, '--module=' + module] + src_dir_args
+    if ignore_headers:
+        scan_cmd.append('--ignore-headers=' + ' '.join(ignore_headers))
+    # Add user-specified arguments
+    scan_cmd += scan_args
+    gtkdoc_run_check(scan_cmd, abs_out)
+
+    # Use the generated types file when available, otherwise gobject_typesfile
+    # would often be a path to source dir instead of build dir.
+    if '--rebuild-types' in scan_args:
+        gobject_typesfile = os.path.join(abs_out, module + '.types')
+
+    if gobject_typesfile:
+        scanobjs_cmd = [options.gtkdoc_scangobj] + scanobjs_args
+        scanobjs_cmd += ['--types=' + gobject_typesfile,
+                         '--module=' + module,
+                         '--run=' + run,
+                         '--cflags=' + cflags,
+                         '--ldflags=' + ldflags,
+                         '--cc=' + cc,
+                         '--ld=' + ld,
+                         '--output-dir=' + abs_out]
+
+        library_paths = []
+        for ldflag in split_args(ldflags):
+            if ldflag.startswith('-Wl,-rpath,'):
+                library_paths.append(ldflag[11:])
+
+        gtkdoc_run_check(scanobjs_cmd, build_root, library_paths)
+
+    # Make docbook files
+    if mode == 'auto':
+        # Guessing is probably a poor idea but these keeps compat
+        # with previous behavior
+        if main_file.endswith('sgml'):
+            modeflag = '--sgml-mode'
+        else:
+            modeflag = '--xml-mode'
+    elif mode == 'xml':
+        modeflag = '--xml-mode'
+    elif mode == 'sgml':
+        modeflag = '--sgml-mode'
+    else: # none
+        modeflag = None
+
+    mkdb_cmd = [options.gtkdoc_mkdb,
+                '--module=' + module,
+                '--output-format=xml',
+                '--expand-content-files=' + ' '.join(expand_content_files),
+                ] + src_dir_args
+    if namespace:
+        mkdb_cmd.append('--name-space=' + namespace)
+    if modeflag:
+        mkdb_cmd.append(modeflag)
+    if main_file:
+        # Yes, this is the flag even if the file is in xml.
+        mkdb_cmd.append('--main-sgml-file=' + main_file)
+    # Add user-specified arguments
+    mkdb_cmd += mkdb_args
+    gtkdoc_run_check(mkdb_cmd, abs_out)
+
+    # Make HTML documentation
+    mkhtml_cmd = [options.gtkdoc_mkhtml,
+                  '--path=' + os.pathsep.join((doc_src, abs_out)),
+                  module,
+                  ] + html_args
+    if main_file:
+        mkhtml_cmd.append('../' + main_file)
+    else:
+        mkhtml_cmd.append('%s-docs.xml' % module)
+    # html gen must be run in the HTML dir
+    gtkdoc_run_check(mkhtml_cmd, htmldir)
+
+    # Fix cross-references in HTML files
+    fixref_cmd = [options.gtkdoc_fixxref,
+                  '--module=' + module,
+                  '--module-dir=html'] + fixxref_args
+    gtkdoc_run_check(fixref_cmd, abs_out)
+
+    if module_version:
+        shutil.move(os.path.join(htmldir, f'{module}.devhelp2'),
+                    os.path.join(htmldir, f'{module}-{module_version}.devhelp2'))
+
+def install_gtkdoc(build_root: str, doc_subdir: str, install_prefix: str, datadir: str, module: str) -> None:
+    source = os.path.join(build_root, doc_subdir, 'html')
+    final_destination = os.path.join(install_prefix, datadir, module)
+    shutil.rmtree(final_destination, ignore_errors=True)
+    shutil.copytree(source, final_destination)
+
+def run(args: T.List[str]) -> int:
+    options = parser.parse_args(args)
+    if options.htmlargs:
+        htmlargs = options.htmlargs.split('@@')
+    else:
+        htmlargs = []
+    if options.scanargs:
+        scanargs = options.scanargs.split('@@')
+    else:
+        scanargs = []
+    if options.scanobjsargs:
+        scanobjsargs = options.scanobjsargs.split('@@')
+    else:
+        scanobjsargs = []
+    if options.fixxrefargs:
+        fixxrefargs = options.fixxrefargs.split('@@')
+    else:
+        fixxrefargs = []
+    if options.mkdbargs:
+        mkdbargs = options.mkdbargs.split('@@')
+    else:
+        mkdbargs = []
+    build_gtkdoc(
+        options.sourcedir,
+        options.builddir,
+        options.subdir,
+        options.headerdirs.split('@@'),
+        options.mainfile,
+        options.modulename,
+        options.moduleversion,
+        htmlargs,
+        scanargs,
+        fixxrefargs,
+        mkdbargs,
+        options.gobject_typesfile,
+        scanobjsargs,
+        options.run,
+        options.ld,
+        options.cc,
+        options.ldflags,
+        options.cflags,
+        options.html_assets.split('@@') if options.html_assets else [],
+        options.content_files.split('@@') if options.content_files else [],
+        options.ignore_headers.split('@@') if options.ignore_headers else [],
+        options.namespace,
+        options.expand_content_files.split('@@') if options.expand_content_files else [],
+        options.mode,
+        options)
+
+    if 'MESON_INSTALL_PREFIX' in os.environ:
+        destdir = os.environ.get('DESTDIR', '')
+        install_prefix = destdir_join(destdir, os.environ['MESON_INSTALL_PREFIX'])
+        if options.install_dir:
+            install_dir = options.install_dir
+        else:
+            install_dir = options.modulename
+            if options.moduleversion:
+                install_dir += '-' + options.moduleversion
+        if os.path.isabs(install_dir):
+            install_dir = destdir_join(destdir, install_dir)
+        install_gtkdoc(options.builddir,
+                       options.subdir,
+                       install_prefix,
+                       'share/gtk-doc/html',
+                       install_dir)
+    return 0
+
+if __name__ == '__main__':
+    sys.exit(run(sys.argv[1:]))

package/releng/meson/mesonbuild/scripts/hotdochelper.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+
+from . import destdir_join
+
+import argparse
+import typing as T
+
+parser = argparse.ArgumentParser()
+parser.add_argument('--install')
+parser.add_argument('--extra-extension-path', action="append", default=[])
+parser.add_argument('--name')
+parser.add_argument('--builddir')
+parser.add_argument('--project-version')
+parser.add_argument('--docdir')
+
+
+def run(argv: T.List[str]) -> int:
+    options, args = parser.parse_known_args(argv)
+    subenv = os.environ.copy()
+
+    val = subenv.get('PYTHONPATH')
+    paths = [val] if val else []
+    subenv['PYTHONPATH'] = os.pathsep.join(paths + options.extra_extension_path)
+
+    res = subprocess.call(args, cwd=options.builddir, env=subenv)
+    if res != 0:
+        return res
+
+    if options.install:
+        source_dir = os.path.join(options.builddir, options.install)
+        destdir = os.environ.get('DESTDIR', '')
+        installdir = destdir_join(destdir, options.docdir)
+
+        shutil.rmtree(installdir, ignore_errors=True)
+        shutil.copytree(source_dir, installdir)
+    return 0

package/releng/meson/mesonbuild/scripts/itstool.py

@@ -0,0 +1,77 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2016 The Meson development team
+
+from __future__ import annotations
+
+import os
+import argparse
+import subprocess
+import tempfile
+import shlex
+import shutil
+import typing as T
+
+parser = argparse.ArgumentParser()
+parser.add_argument('command')
+parser.add_argument('--build-dir', default='')
+parser.add_argument('-i', '--input', default='')
+parser.add_argument('-o', '--output', default='')
+parser.add_argument('--itstool', default='itstool')
+parser.add_argument('--its', action='append', default=[])
+parser.add_argument('mo_files', nargs='+')
+
+
+def run_join(build_dir: str, itstool: str, its_files: T.List[str], mo_files: T.List[str],
+             in_fname: str, out_fname: str) -> int:
+    if not mo_files:
+        print('No mo files specified to use for translation.')
+        return 1
+
+    with tempfile.TemporaryDirectory(prefix=os.path.basename(in_fname), dir=build_dir) as tmp_dir:
+        # copy mo files to have the right names so itstool can infer their locale
+        locale_mo_files = []
+        for mo_file in mo_files:
+            if not os.path.exists(mo_file):
+                print(f'Could not find mo file {mo_file}')
+                return 1
+            if not mo_file.endswith('.mo'):
+                print(f'File is not a mo file: {mo_file}')
+                return 1
+            # determine locale of this mo file
+            parts = mo_file.partition('LC_MESSAGES')
+            if parts[0].endswith((os.sep, '/')):
+                locale = os.path.basename(parts[0][:-1])
+            else:
+                locale = os.path.basename(parts[0])
+            tmp_mo_fname = os.path.join(tmp_dir, locale + '.mo')
+            shutil.copy(mo_file, tmp_mo_fname)
+            locale_mo_files.append(tmp_mo_fname)
+
+        cmd = shlex.split(itstool)
+        if its_files:
+            for fname in its_files:
+                cmd.extend(['-i', fname])
+        cmd.extend(['-j', in_fname,
+                    '-o', out_fname])
+        cmd.extend(locale_mo_files)
+
+        return subprocess.call(cmd)
+
+
+def run(args: T.List[str]) -> int:
+    options = parser.parse_args(args)
+    command = options.command
+    build_dir = os.environ.get('MESON_BUILD_ROOT', os.getcwd())
+    if options.build_dir:
+        build_dir = options.build_dir
+
+    if command == 'join':
+        return run_join(build_dir,
+                        options.itstool,
+                        options.its,
+                        options.mo_files,
+                        options.input,
+                        options.output)
+    else:
+        print('Unknown subcommand.')
+        return 1

package/releng/meson/mesonbuild/scripts/meson_exe.py

@@ -0,0 +1,115 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2013-2016 The Meson development team
+
+from __future__ import annotations
+
+import os
+import sys
+import argparse
+import pickle
+import subprocess
+import typing as T
+import locale
+
+from ..utils.core import ExecutableSerialisation
+
+def buildparser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description='Custom executable wrapper for Meson. Do not run on your own, mmm\'kay?')
+    parser.add_argument('--unpickle')
+    parser.add_argument('--capture')
+    parser.add_argument('--feed')
+    return parser
+
+def run_exe(exe: ExecutableSerialisation, extra_env: T.Optional[T.Dict[str, str]] = None) -> int:
+    if exe.exe_wrapper:
+        if not exe.exe_wrapper.found():
+            raise AssertionError('BUG: Can\'t run cross-compiled exe {!r} with not-found '
+                                 'wrapper {!r}'.format(exe.cmd_args[0], exe.exe_wrapper.get_path()))
+        cmd_args = exe.exe_wrapper.get_command() + exe.cmd_args
+    else:
+        cmd_args = exe.cmd_args
+    child_env = os.environ.copy()
+    if extra_env:
+        child_env.update(extra_env)
+    if exe.env:
+        child_env = exe.env.get_env(child_env)
+    if exe.extra_paths:
+        child_env['PATH'] = (os.pathsep.join(exe.extra_paths + ['']) +
+                             child_env['PATH'])
+        if exe.exe_wrapper and any('wine' in i for i in exe.exe_wrapper.get_command()):
+            from .. import mesonlib
+            child_env['WINEPATH'] = mesonlib.get_wine_shortpath(
+                exe.exe_wrapper.get_command(),
+                ['Z:' + p for p in exe.extra_paths] + child_env.get('WINEPATH', '').split(';'),
+                exe.workdir
+            )
+
+    stdin = None
+    if exe.feed:
+        stdin = open(exe.feed, 'rb')
+
+    pipe = subprocess.PIPE
+    if exe.verbose:
+        assert not exe.capture, 'Cannot capture and print to console at the same time'
+        pipe = None
+
+    p = subprocess.Popen(cmd_args, env=child_env, cwd=exe.workdir,
+                         close_fds=False, stdin=stdin, stdout=pipe, stderr=pipe)
+    stdout, stderr = p.communicate()
+
+    if stdin is not None:
+        stdin.close()
+
+    if p.returncode == 0xc0000135:
+        # STATUS_DLL_NOT_FOUND on Windows indicating a common problem that is otherwise hard to diagnose
+        strerror = 'Failed to run due to missing DLLs, with path: ' + child_env['PATH']
+        raise FileNotFoundError(p.returncode, strerror, cmd_args)
+
+    if p.returncode != 0:
+        if exe.pickled:
+            print(f'while executing {cmd_args!r}')
+        if exe.verbose:
+            return p.returncode
+        encoding = locale.getpreferredencoding()
+        if not exe.capture:
+            print('--- stdout ---')
+            print(stdout.decode(encoding=encoding, errors='replace'))
+        print('--- stderr ---')
+        print(stderr.decode(encoding=encoding, errors='replace'))
+        return p.returncode
+
+    if exe.capture:
+        skip_write = False
+        try:
+            with open(exe.capture, 'rb') as cur:
+                skip_write = cur.read() == stdout
+        except OSError:
+            pass
+        if not skip_write:
+            with open(exe.capture, 'wb') as output:
+                output.write(stdout)
+
+    return 0
+
+def run(args: T.List[str]) -> int:
+    parser = buildparser()
+    options, cmd_args = parser.parse_known_args(args)
+    # argparse supports double dash to separate options and positional arguments,
+    # but the user has to remove it manually.
+    if cmd_args and cmd_args[0] == '--':
+        cmd_args = cmd_args[1:]
+    if not options.unpickle and not cmd_args:
+        parser.error('either --unpickle or executable and arguments are required')
+    if options.unpickle:
+        if cmd_args or options.capture or options.feed:
+            parser.error('no other arguments can be used with --unpickle')
+        with open(options.unpickle, 'rb') as f:
+            exe = pickle.load(f)
+            exe.pickled = True
+    else:
+        exe = ExecutableSerialisation(cmd_args, capture=options.capture, feed=options.feed)
+
+    return run_exe(exe)
+
+if __name__ == '__main__':
+    sys.exit(run(sys.argv[1:]))

package/releng/meson/mesonbuild/scripts/msgfmthelper.py

@@ -0,0 +1,29 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2016 The Meson development team
+
+from __future__ import annotations
+
+import argparse
+import subprocess
+import os
+import typing as T
+
+parser = argparse.ArgumentParser()
+parser.add_argument('input')
+parser.add_argument('output')
+parser.add_argument('type')
+parser.add_argument('podir')
+parser.add_argument('--msgfmt', default='msgfmt')
+parser.add_argument('--datadirs', default='')
+parser.add_argument('args', default=[], metavar='extra msgfmt argument', nargs='*')
+
+
+def run(args: T.List[str]) -> int:
+    options = parser.parse_args(args)
+    env = None
+    if options.datadirs:
+        env = os.environ.copy()
+        env.update({'GETTEXTDATADIRS': options.datadirs})
+    return subprocess.call([options.msgfmt, '--' + options.type, '-d', options.podir,
+                            '--template', options.input,  '-o', options.output] + options.args,
+                           env=env)

package/releng/meson/mesonbuild/scripts/pycompile.py

@@ -0,0 +1,54 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2016 The Meson development team
+
+# ignore all lints for this file, since it is run by python2 as well
+
+# type: ignore
+# pylint: disable=deprecated-module
+
+import json, os, subprocess, sys
+from compileall import compile_file
+
+quiet = int(os.environ.get('MESON_INSTALL_QUIET', 0))
+
+def compileall(files):
+    for f in files:
+        # f is prefixed by {py_xxxxlib}, both variants are 12 chars
+        # the key is the middle 10 chars of the prefix
+        key = f[1:11].upper()
+        f = f[12:]
+
+        ddir = None
+        fullpath = absf = os.environ['MESON_INSTALL_DESTDIR_'+key] + f
+        f = os.environ['MESON_INSTALL_'+key] + f
+
+        if absf != f:
+            ddir = os.path.dirname(f)
+
+        if os.path.isdir(absf):
+            for root, _, files in os.walk(absf):
+                if ddir is not None:
+                    ddir = root.replace(absf, f, 1)
+                for dirf in files:
+                    if dirf.endswith('.py'):
+                        fullpath = os.path.join(root, dirf)
+                        compile_file(fullpath, ddir, force=True, quiet=quiet)
+        else:
+            compile_file(fullpath, ddir, force=True, quiet=quiet)
+
+def run(manifest):
+    data_file = os.path.join(os.path.dirname(__file__), manifest)
+    with open(data_file, 'rb') as f:
+        dat = json.load(f)
+    compileall(dat)
+
+if __name__ == '__main__':
+    manifest = sys.argv[1]
+    run(manifest)
+    if len(sys.argv) > 2:
+        optlevel = int(sys.argv[2])
+        # python2 only needs one or the other
+        if optlevel == 1 or (sys.version_info >= (3,) and optlevel > 0):
+            subprocess.check_call([sys.executable, '-O'] + sys.argv[:2])
+        if optlevel == 2:
+            subprocess.check_call([sys.executable, '-OO'] + sys.argv[:2])