frida 16.2.1 → 16.2.3

package/releng/meson/mesonbuild/utils/vsenv.py

@@ -0,0 +1,126 @@
+from __future__ import annotations
+
+import os
+import subprocess
+import json
+import pathlib
+import shutil
+import tempfile
+import locale
+
+from .. import mlog
+from .core import MesonException
+from .universal import is_windows, windows_detect_native_arch
+
+
+__all__ = [
+    'setup_vsenv',
+]
+
+
+bat_template = '''@ECHO OFF
+
+call "{}"
+
+ECHO {}
+SET
+'''
+
+# If on Windows and VS is installed but not set up in the environment,
+# set it to be runnable. In this way Meson can be directly invoked
+# from any shell, VS Code etc.
+def _setup_vsenv(force: bool) -> bool:
+    if not is_windows():
+        return False
+    if os.environ.get('OSTYPE') == 'cygwin':
+        return False
+    if 'MESON_FORCE_VSENV_FOR_UNITTEST' not in os.environ:
+        # VSINSTALL is set when running setvars from a Visual Studio installation
+        # Tested with Visual Studio 2012 and 2017
+        if 'VSINSTALLDIR' in os.environ:
+            return False
+        # Check explicitly for cl when on Windows
+        if shutil.which('cl.exe'):
+            return False
+    if not force:
+        if shutil.which('cc'):
+            return False
+        if shutil.which('gcc'):
+            return False
+        if shutil.which('clang'):
+            return False
+        if shutil.which('clang-cl'):
+            return False
+
+    root = os.environ.get("ProgramFiles(x86)") or os.environ.get("ProgramFiles")
+    bat_locator_bin = pathlib.Path(root, 'Microsoft Visual Studio/Installer/vswhere.exe')
+    if not bat_locator_bin.exists():
+        raise MesonException(f'Could not find {bat_locator_bin}')
+    bat_json = subprocess.check_output(
+        [
+            str(bat_locator_bin),
+            '-latest',
+            '-prerelease',
+            '-requiresAny',
+            '-requires', 'Microsoft.VisualStudio.Component.VC.Tools.x86.x64',
+            '-requires', 'Microsoft.VisualStudio.Workload.WDExpress',
+            '-products', '*',
+            '-utf8',
+            '-format',
+            'json'
+        ]
+    )
+    bat_info = json.loads(bat_json)
+    if not bat_info:
+        # VS installer installed but not VS itself maybe?
+        raise MesonException('Could not parse vswhere.exe output')
+    bat_root = pathlib.Path(bat_info[0]['installationPath'])
+    if windows_detect_native_arch() == 'arm64':
+        bat_path = bat_root / 'VC/Auxiliary/Build/vcvarsarm64.bat'
+        if not bat_path.exists():
+            bat_path = bat_root / 'VC/Auxiliary/Build/vcvarsx86_arm64.bat'
+    else:
+        bat_path = bat_root / 'VC/Auxiliary/Build/vcvars64.bat'
+        # if VS is not found try VS Express
+        if not bat_path.exists():
+            bat_path = bat_root / 'VC/Auxiliary/Build/vcvarsx86_amd64.bat'
+    if not bat_path.exists():
+        raise MesonException(f'Could not find {bat_path}')
+
+    mlog.log('Activating VS', bat_info[0]['catalog']['productDisplayVersion'])
+    bat_separator = '---SPLIT---'
+    bat_contents = bat_template.format(bat_path, bat_separator)
+    bat_file = tempfile.NamedTemporaryFile('w', suffix='.bat', encoding='utf-8', delete=False)
+    bat_file.write(bat_contents)
+    bat_file.flush()
+    bat_file.close()
+    bat_output = subprocess.check_output(bat_file.name, universal_newlines=True,
+                                         encoding=locale.getpreferredencoding(False))
+    os.unlink(bat_file.name)
+    bat_lines = bat_output.split('\n')
+    bat_separator_seen = False
+    for bat_line in bat_lines:
+        if bat_line == bat_separator:
+            bat_separator_seen = True
+            continue
+        if not bat_separator_seen:
+            continue
+        if not bat_line:
+            continue
+        try:
+            k, v = bat_line.split('=', 1)
+        except ValueError:
+            # there is no "=", ignore junk data
+            pass
+        else:
+            os.environ[k] = v
+    return True
+
+def setup_vsenv(force: bool = False) -> bool:
+    try:
+        return _setup_vsenv(force)
+    except MesonException as e:
+        if force:
+            raise
+        mlog.warning('Failed to activate VS environment:', str(e))
+        return False

package/releng/meson/mesonbuild/utils/win32.py

@@ -0,0 +1,29 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2012-2021 The Meson development team
+# Copyright © 2021-2023 Intel Corporation
+
+from __future__ import annotations
+
+"""Windows specific implementations of mesonlib functionality."""
+
+import msvcrt
+import typing as T
+
+from .core import MesonException
+from .platform import BuildDirLock as BuildDirLockBase
+
+__all__ = ['BuildDirLock']
+
+class BuildDirLock(BuildDirLockBase):
+
+    def __enter__(self) -> None:
+        self.lockfile = open(self.lockfilename, 'w', encoding='utf-8')
+        try:
+            msvcrt.locking(self.lockfile.fileno(), msvcrt.LK_NBLCK, 1)
+        except (BlockingIOError, PermissionError):
+            self.lockfile.close()
+            raise MesonException('Some other Meson process is already using this build directory. Exiting.')
+
+    def __exit__(self, *args: T.Any) -> None:
+        msvcrt.locking(self.lockfile.fileno(), msvcrt.LK_UNLCK, 1)
+        self.lockfile.close()

package/releng/meson/mesonbuild/wrap/__init__.py

@@ -0,0 +1,59 @@
+from enum import Enum
+
+# Used for the --wrap-mode command-line argument
+#
+# Special wrap modes:
+#   nofallback: Don't download wraps for dependency() fallbacks
+#   nodownload: Don't download wraps for all subproject() calls
+#
+# subprojects are used for two purposes:
+# 1. To download and build dependencies by using .wrap
+#    files if they are not provided by the system. This is
+#    usually expressed via dependency(..., fallback: ...).
+# 2. To download and build 'copylibs' which are meant to be
+#    used by copying into your project. This is always done
+#    with an explicit subproject() call.
+#
+# --wrap-mode=nofallback will never do (1)
+# --wrap-mode=nodownload will do neither (1) nor (2)
+#
+# If you are building from a release tarball, you should be
+# able to safely use 'nodownload' since upstream is
+# expected to ship all required sources with the tarball.
+#
+# If you are building from a git repository, you will want
+# to use 'nofallback' so that any 'copylib' wraps will be
+# download as subprojects.
+#
+# --wrap-mode=forcefallback will ignore external dependencies,
+# even if they match the version requirements, and automatically
+# use the fallback if one was provided. This is useful for example
+# to make sure a project builds when using the fallbacks.
+#
+# Note that these options do not affect subprojects that
+# are git submodules since those are only usable in git
+# repositories, and you almost always want to download them.
+
+# This did _not_ work when inside the WrapMode class.
+# I don't know why. If you can fix this, patches welcome.
+string_to_value = {'default': 1,
+                   'nofallback': 2,
+                   'nodownload': 3,
+                   'forcefallback': 4,
+                   'nopromote': 5,
+                   }
+
+class WrapMode(Enum):
+    default = 1
+    nofallback = 2
+    nodownload = 3
+    forcefallback = 4
+    nopromote = 5
+
+    def __str__(self) -> str:
+        return self.name
+
+    @staticmethod
+    def from_string(mode_name: str) -> 'WrapMode':
+        g = string_to_value[mode_name]
+        return WrapMode(g)