frida 16.2.1 → 16.2.2

package/releng/meson/mesonbuild/templates/samplefactory.py

@@ -0,0 +1,41 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2019 The Meson development team
+
+from __future__ import annotations
+
+import typing as T
+
+from mesonbuild.templates.valatemplates import ValaProject
+from mesonbuild.templates.fortrantemplates import FortranProject
+from mesonbuild.templates.objcpptemplates import ObjCppProject
+from mesonbuild.templates.dlangtemplates import DlangProject
+from mesonbuild.templates.rusttemplates import RustProject
+from mesonbuild.templates.javatemplates import JavaProject
+from mesonbuild.templates.cudatemplates import CudaProject
+from mesonbuild.templates.objctemplates import ObjCProject
+from mesonbuild.templates.cpptemplates import CppProject
+from mesonbuild.templates.cstemplates import CSharpProject
+from mesonbuild.templates.ctemplates import CProject
+
+if T.TYPE_CHECKING:
+    from ..minit import Arguments
+    from .sampleimpl import ClassImpl, FileHeaderImpl, FileImpl, SampleImpl
+
+
+_IMPL: T.Mapping[str, T.Union[T.Type[ClassImpl], T.Type[FileHeaderImpl], T.Type[FileImpl]]] = {
+    'c': CProject,
+    'cpp': CppProject,
+    'cs': CSharpProject,
+    'cuda': CudaProject,
+    'objc': ObjCProject,
+    'objcpp': ObjCppProject,
+    'java': JavaProject,
+    'd': DlangProject,
+    'rust': RustProject,
+    'fortran': FortranProject,
+    'vala': ValaProject,
+}
+
+
+def sample_generator(options: Arguments) -> SampleImpl:
+    return _IMPL[options.language](options)

package/releng/meson/mesonbuild/templates/sampleimpl.py

@@ -0,0 +1,160 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2019 The Meson development team
+
+from __future__ import annotations
+
+import abc
+import re
+import typing as T
+
+if T.TYPE_CHECKING:
+    from ..minit import Arguments
+
+
+class SampleImpl(metaclass=abc.ABCMeta):
+
+    def __init__(self, args: Arguments):
+        self.name = args.name
+        self.version = args.version
+        self.lowercase_token = re.sub(r'[^a-z0-9]', '_', self.name.lower())
+        self.uppercase_token = self.lowercase_token.upper()
+        self.capitalized_token = self.lowercase_token.capitalize()
+
+    @abc.abstractmethod
+    def create_executable(self) -> None:
+        pass
+
+    @abc.abstractmethod
+    def create_library(self) -> None:
+        pass
+
+    @abc.abstractproperty
+    def exe_template(self) -> str:
+        pass
+
+    @abc.abstractproperty
+    def exe_meson_template(self) -> str:
+        pass
+
+    @abc.abstractproperty
+    def lib_template(self) -> str:
+        pass
+
+    @abc.abstractproperty
+    def lib_test_template(self) -> str:
+        pass
+
+    @abc.abstractproperty
+    def lib_meson_template(self) -> str:
+        pass
+
+    @abc.abstractproperty
+    def source_ext(self) -> str:
+        pass
+
+
+class ClassImpl(SampleImpl):
+
+    """For Class based languages, like Java and C#"""
+
+    def create_executable(self) -> None:
+        source_name = f'{self.capitalized_token}.{self.source_ext}'
+        with open(source_name, 'w', encoding='utf-8') as f:
+            f.write(self.exe_template.format(project_name=self.name,
+                                             class_name=self.capitalized_token))
+        with open('meson.build', 'w', encoding='utf-8') as f:
+            f.write(self.exe_meson_template.format(project_name=self.name,
+                                                   exe_name=self.name,
+                                                   source_name=source_name,
+                                                   version=self.version))
+
+    def create_library(self) -> None:
+        lib_name = f'{self.capitalized_token}.{self.source_ext}'
+        test_name = f'{self.capitalized_token}_test.{self.source_ext}'
+        kwargs = {'utoken': self.uppercase_token,
+                  'ltoken': self.lowercase_token,
+                  'class_test': f'{self.capitalized_token}_test',
+                  'class_name': self.capitalized_token,
+                  'source_file': lib_name,
+                  'test_source_file': test_name,
+                  'test_exe_name': f'{self.lowercase_token}_test',
+                  'project_name': self.name,
+                  'lib_name': self.lowercase_token,
+                  'test_name': self.lowercase_token,
+                  'version': self.version,
+                  }
+        with open(lib_name, 'w', encoding='utf-8') as f:
+            f.write(self.lib_template.format(**kwargs))
+        with open(test_name, 'w', encoding='utf-8') as f:
+            f.write(self.lib_test_template.format(**kwargs))
+        with open('meson.build', 'w', encoding='utf-8') as f:
+            f.write(self.lib_meson_template.format(**kwargs))
+
+
+class FileImpl(SampleImpl):
+
+    """File based languages without headers"""
+
+    def create_executable(self) -> None:
+        source_name = f'{self.lowercase_token}.{self.source_ext}'
+        with open(source_name, 'w', encoding='utf-8') as f:
+            f.write(self.exe_template.format(project_name=self.name))
+        with open('meson.build', 'w', encoding='utf-8') as f:
+            f.write(self.exe_meson_template.format(project_name=self.name,
+                                                   exe_name=self.name,
+                                                   source_name=source_name,
+                                                   version=self.version))
+
+    def lib_kwargs(self) -> T.Dict[str, str]:
+        """Get Language specific keyword arguments
+
+        :return: A dictionary of key: values to fill in the templates
+        """
+        return {
+            'utoken': self.uppercase_token,
+            'ltoken': self.lowercase_token,
+            'header_dir': self.lowercase_token,
+            'class_name': self.capitalized_token,
+            'function_name': f'{self.lowercase_token[0:3]}_func',
+            'namespace': self.lowercase_token,
+            'source_file': f'{self.lowercase_token}.{self.source_ext}',
+            'test_source_file': f'{self.lowercase_token}_test.{self.source_ext}',
+            'test_exe_name': f'{self.lowercase_token}_test',
+            'project_name': self.name,
+            'lib_name': self.lowercase_token,
+            'test_name': self.lowercase_token,
+            'version': self.version,
+        }
+
+    def create_library(self) -> None:
+        lib_name = f'{self.lowercase_token}.{self.source_ext}'
+        test_name = f'{self.lowercase_token}_test.{self.source_ext}'
+        kwargs = self.lib_kwargs()
+        with open(lib_name, 'w', encoding='utf-8') as f:
+            f.write(self.lib_template.format(**kwargs))
+        with open(test_name, 'w', encoding='utf-8') as f:
+            f.write(self.lib_test_template.format(**kwargs))
+        with open('meson.build', 'w', encoding='utf-8') as f:
+            f.write(self.lib_meson_template.format(**kwargs))
+
+
+class FileHeaderImpl(FileImpl):
+
+    @abc.abstractproperty
+    def header_ext(self) -> str:
+        pass
+
+    @abc.abstractproperty
+    def lib_header_template(self) -> str:
+        pass
+
+    def lib_kwargs(self) -> T.Dict[str, str]:
+        kwargs = super().lib_kwargs()
+        kwargs['header_file'] = f'{self.lowercase_token}.{self.header_ext}'
+        return kwargs
+
+    def create_library(self) -> None:
+        super().create_library()
+        kwargs = self.lib_kwargs()
+        with open(kwargs['header_file'], 'w', encoding='utf-8') as f:
+            f.write(self.lib_header_template.format_map(kwargs))

package/releng/meson/mesonbuild/templates/valatemplates.py

@@ -0,0 +1,82 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2019 The Meson development team
+
+from __future__ import annotations
+
+from mesonbuild.templates.sampleimpl import FileImpl
+
+
+hello_vala_template = '''void main (string[] args) {{
+    stdout.printf ("Hello {project_name}!\\n");
+}}
+'''
+
+hello_vala_meson_template = '''project('{project_name}', ['c', 'vala'],
+  version : '{version}')
+
+dependencies = [
+    dependency('glib-2.0'),
+    dependency('gobject-2.0'),
+]
+
+exe = executable('{exe_name}', '{source_name}', dependencies : dependencies,
+  install : true)
+
+test('basic', exe)
+'''
+
+
+lib_vala_template = '''namespace {namespace} {{
+    public int sum(int a, int b) {{
+        return(a + b);
+    }}
+
+    public int square(int a) {{
+        return(a * a);
+    }}
+}}
+'''
+
+lib_vala_test_template = '''using {namespace};
+
+public void main() {{
+    stdout.printf("\nTesting shlib");
+    stdout.printf("\n\t2 + 3 is %d", sum(2, 3));
+    stdout.printf("\n\t8 squared is %d\\n", square(8));
+}}
+'''
+
+lib_vala_meson_template = '''project('{project_name}', ['c', 'vala'],
+  version : '{version}')
+
+dependencies = [
+    dependency('glib-2.0'),
+    dependency('gobject-2.0'),
+]
+
+# These arguments are only used to build the shared library
+# not the executables that use the library.
+shlib = shared_library('foo', '{source_file}',
+               dependencies: dependencies,
+               install: true,
+               install_dir: [true, true, true])
+
+test_exe = executable('{test_exe_name}', '{test_source_file}', dependencies : dependencies,
+  link_with : shlib)
+test('{test_name}', test_exe)
+
+# Make this library usable as a Meson subproject.
+{ltoken}_dep = declare_dependency(
+  include_directories: include_directories('.'),
+  link_with : shlib)
+'''
+
+
+class ValaProject(FileImpl):
+
+    source_ext = 'vala'
+    exe_template = hello_vala_template
+    exe_meson_template = hello_vala_meson_template
+    lib_template = lib_vala_template
+    lib_test_template = lib_vala_test_template
+    lib_meson_template = lib_vala_meson_template

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

@@ -0,0 +1,166 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2012-2022 The Meson development team
+
+"""
+Contains the strict minimum to run scripts.
+
+When the backend needs to call back into Meson during compilation for running
+scripts or wrapping commands, it is important to load as little python modules
+as possible for performance reasons.
+"""
+
+from __future__ import annotations
+from dataclasses import dataclass
+import os
+import abc
+import typing as T
+
+if T.TYPE_CHECKING:
+    from hashlib import _Hash
+    from typing_extensions import Literal
+    from ..mparser import BaseNode
+    from ..interpreterbase import SubProject
+    from .. import programs
+
+    EnvironOrDict = T.Union[T.Dict[str, str], os._Environ[str]]
+
+    EnvInitValueType = T.Dict[str, T.Union[str, T.List[str]]]
+
+
+class MesonException(Exception):
+    '''Exceptions thrown by Meson'''
+
+    def __init__(self, *args: object, file: T.Optional[str] = None,
+                 lineno: T.Optional[int] = None, colno: T.Optional[int] = None):
+        super().__init__(*args)
+        self.file = file
+        self.lineno = lineno
+        self.colno = colno
+
+    @classmethod
+    def from_node(cls, *args: object, node: BaseNode) -> MesonException:
+        """Create a MesonException with location data from a BaseNode
+
+        :param node: A BaseNode to set location data from
+        :return: A Meson Exception instance
+        """
+        return cls(*args, file=node.filename, lineno=node.lineno, colno=node.colno)
+
+class MesonBugException(MesonException):
+    '''Exceptions thrown when there is a clear Meson bug that should be reported'''
+
+    def __init__(self, msg: str, file: T.Optional[str] = None,
+                 lineno: T.Optional[int] = None, colno: T.Optional[int] = None):
+        super().__init__(msg + '\n\n    This is a Meson bug and should be reported!',
+                         file=file, lineno=lineno, colno=colno)
+
+class HoldableObject(metaclass=abc.ABCMeta):
+    ''' Dummy base class for all objects that can be
+        held by an interpreter.baseobjects.ObjectHolder '''
+
+class EnvironmentVariables(HoldableObject):
+    def __init__(self, values: T.Optional[EnvInitValueType] = None,
+                 init_method: Literal['set', 'prepend', 'append'] = 'set', separator: str = os.pathsep) -> None:
+        self.envvars: T.List[T.Tuple[T.Callable[[T.Dict[str, str], str, T.List[str], str, T.Optional[str]], str], str, T.List[str], str]] = []
+        # The set of all env vars we have operations for. Only used for self.has_name()
+        self.varnames: T.Set[str] = set()
+        self.unset_vars: T.Set[str] = set()
+
+        if values:
+            init_func = getattr(self, init_method)
+            for name, value in values.items():
+                v = value if isinstance(value, list) else [value]
+                init_func(name, v, separator)
+
+    def __repr__(self) -> str:
+        repr_str = "<{0}: {1}>"
+        return repr_str.format(self.__class__.__name__, self.envvars)
+
+    def hash(self, hasher: _Hash) -> None:
+        myenv = self.get_env({})
+        for key in sorted(myenv.keys()):
+            hasher.update(bytes(key, encoding='utf-8'))
+            hasher.update(b',')
+            hasher.update(bytes(myenv[key], encoding='utf-8'))
+            hasher.update(b';')
+
+    def has_name(self, name: str) -> bool:
+        return name in self.varnames
+
+    def get_names(self) -> T.Set[str]:
+        return self.varnames
+
+    def merge(self, other: EnvironmentVariables) -> None:
+        for method, name, values, separator in other.envvars:
+            self.varnames.add(name)
+            self.envvars.append((method, name, values, separator))
+            if name in self.unset_vars:
+                self.unset_vars.remove(name)
+        self.unset_vars.update(other.unset_vars)
+
+    def set(self, name: str, values: T.List[str], separator: str = os.pathsep) -> None:
+        if name in self.unset_vars:
+            raise MesonException(f'You cannot set the already unset variable {name!r}')
+        self.varnames.add(name)
+        self.envvars.append((self._set, name, values, separator))
+
+    def unset(self, name: str) -> None:
+        if name in self.varnames:
+            raise MesonException(f'You cannot unset the {name!r} variable because it is already set')
+        self.unset_vars.add(name)
+
+    def append(self, name: str, values: T.List[str], separator: str = os.pathsep) -> None:
+        if name in self.unset_vars:
+            raise MesonException(f'You cannot append to unset variable {name!r}')
+        self.varnames.add(name)
+        self.envvars.append((self._append, name, values, separator))
+
+    def prepend(self, name: str, values: T.List[str], separator: str = os.pathsep) -> None:
+        if name in self.unset_vars:
+            raise MesonException(f'You cannot prepend to unset variable {name!r}')
+        self.varnames.add(name)
+        self.envvars.append((self._prepend, name, values, separator))
+
+    @staticmethod
+    def _set(env: T.Dict[str, str], name: str, values: T.List[str], separator: str, default_value: T.Optional[str]) -> str:
+        return separator.join(values)
+
+    @staticmethod
+    def _append(env: T.Dict[str, str], name: str, values: T.List[str], separator: str, default_value: T.Optional[str]) -> str:
+        curr = env.get(name, default_value)
+        return separator.join(values if curr is None else [curr] + values)
+
+    @staticmethod
+    def _prepend(env: T.Dict[str, str], name: str, values: T.List[str], separator: str, default_value: T.Optional[str]) -> str:
+        curr = env.get(name, default_value)
+        return separator.join(values if curr is None else values + [curr])
+
+    def get_env(self, full_env: EnvironOrDict, default_fmt: T.Optional[str] = None) -> T.Dict[str, str]:
+        env = full_env.copy()
+        for method, name, values, separator in self.envvars:
+            default_value = default_fmt.format(name) if default_fmt else None
+            env[name] = method(env, name, values, separator, default_value)
+        for name in self.unset_vars:
+            env.pop(name, None)
+        return env
+
+
+@dataclass(eq=False)
+class ExecutableSerialisation:
+
+    cmd_args: T.List[str]
+    env: T.Optional[EnvironmentVariables] = None
+    exe_wrapper: T.Optional['programs.ExternalProgram'] = None
+    workdir: T.Optional[str] = None
+    extra_paths: T.Optional[T.List] = None
+    capture: T.Optional[str] = None
+    feed: T.Optional[str] = None
+    tag: T.Optional[str] = None
+    verbose: bool = False
+    installdir_map: T.Optional[T.Dict[str, str]] = None
+
+    def __post_init__(self) -> None:
+        self.pickled = False
+        self.skip_if_destdir = False
+        self.subproject = T.cast('SubProject', '')  # avoid circular import
+        self.dry_run = False

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

@@ -0,0 +1,27 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2012-2021 The Meson development team
+# Copyright © 2021-2023 Intel Corporation
+
+from __future__ import annotations
+
+"""base classes providing no-op functionality.."""
+
+import os
+import typing as T
+
+from .. import mlog
+
+__all__ = ['BuildDirLock']
+
+# This needs to be inherited by the specific implementations to make type
+# checking happy
+class BuildDirLock:
+
+    def __init__(self, builddir: str) -> None:
+        self.lockfilename = os.path.join(builddir, 'meson-private/meson.lock')
+
+    def __enter__(self) -> None:
+        mlog.debug('Calling the no-op version of BuildDirLock')
+
+    def __exit__(self, *args: T.Any) -> None:
+        pass

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

@@ -0,0 +1,32 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2012-2021 The Meson development team
+# Copyright © 2021-2023 Intel Corporation
+
+from __future__ import annotations
+
+"""Posix specific implementations of mesonlib functionality."""
+
+import fcntl
+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:
+            fcntl.flock(self.lockfile, fcntl.LOCK_EX | fcntl.LOCK_NB)
+        except (BlockingIOError, PermissionError):
+            self.lockfile.close()
+            raise MesonException('Some other Meson process is already using this build directory. Exiting.')
+        except OSError as e:
+            self.lockfile.close()
+            raise MesonException(f'Failed to lock the build directory: {e.strerror}')
+
+    def __exit__(self, *args: T.Any) -> None:
+        fcntl.flock(self.lockfile, fcntl.LOCK_UN)
+        self.lockfile.close()