Adding upstream version 1.0.1.upstream/1.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 375 insertions, 0 deletions

diff --git a/mesonbuild/programs.py b/mesonbuild/programs.py
new file mode 100644
index 0000000..64f7c29
--- /dev/null
+++ b/mesonbuild/programs.py
@@ -0,0 +1,375 @@
+# Copyright 2013-2020 The Meson development team
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from __future__ import annotations
+
+"""Representations and logic for External and Internal Programs."""
+
+import functools
+import os
+import shutil
+import stat
+import sys
+import re
+import typing as T
+from pathlib import Path
+
+from . import mesonlib
+from . import mlog
+from .mesonlib import MachineChoice
+
+if T.TYPE_CHECKING:
+    from .environment import Environment
+    from .interpreter import Interpreter
+
+
+class ExternalProgram(mesonlib.HoldableObject):
+
+    """A program that is found on the system."""
+
+    windows_exts = ('exe', 'msc', 'com', 'bat', 'cmd')
+    for_machine = MachineChoice.BUILD
+
+    def __init__(self, name: str, command: T.Optional[T.List[str]] = None,
+                 silent: bool = False, search_dir: T.Optional[str] = None,
+                 extra_search_dirs: T.Optional[T.List[str]] = None):
+        self.name = name
+        self.path: T.Optional[str] = None
+        self.cached_version: T.Optional[str] = None
+        if command is not None:
+            self.command = mesonlib.listify(command)
+            if mesonlib.is_windows():
+                cmd = self.command[0]
+                args = self.command[1:]
+                # Check whether the specified cmd is a path to a script, in
+                # which case we need to insert the interpreter. If not, try to
+                # use it as-is.
+                ret = self._shebang_to_cmd(cmd)
+                if ret:
+                    self.command = ret + args
+                else:
+                    self.command = [cmd] + args
+        else:
+            all_search_dirs = [search_dir]
+            if extra_search_dirs:
+                all_search_dirs += extra_search_dirs
+            for d in all_search_dirs:
+                self.command = self._search(name, d)
+                if self.found():
+                    break
+
+        if self.found():
+            # Set path to be the last item that is actually a file (in order to
+            # skip options in something like ['python', '-u', 'file.py']. If we
+            # can't find any components, default to the last component of the path.
+            for arg in reversed(self.command):
+                if arg is not None and os.path.isfile(arg):
+                    self.path = arg
+                    break
+            else:
+                self.path = self.command[-1]
+
+        if not silent:
+            # ignore the warning because derived classes never call this __init__
+            # method, and thus only the found() method of this class is ever executed
+            if self.found():  # lgtm [py/init-calls-subclass]
+                mlog.log('Program', mlog.bold(name), 'found:', mlog.green('YES'),
+                         '(%s)' % ' '.join(self.command))
+            else:
+                mlog.log('Program', mlog.bold(name), 'found:', mlog.red('NO'))
+
+    def summary_value(self) -> T.Union[str, mlog.AnsiDecorator]:
+        if not self.found():
+            return mlog.red('NO')
+        return self.path
+
+    def __repr__(self) -> str:
+        r = '<{} {!r} -> {!r}>'
+        return r.format(self.__class__.__name__, self.name, self.command)
+
+    def description(self) -> str:
+        '''Human friendly description of the command'''
+        return ' '.join(self.command)
+
+    def get_version(self, interpreter: T.Optional['Interpreter'] = None) -> str:
+        if not self.cached_version:
+            from . import build
+            raw_cmd = self.get_command() + ['--version']
+            if interpreter:
+                res = interpreter.run_command_impl(interpreter.current_node, (self, ['--version']),
+                                                   {'capture': True,
+                                                    'check': True,
+                                                    'env': build.EnvironmentVariables()},
+                                                   True)
+                o, e = res.stdout, res.stderr
+            else:
+                p, o, e = mesonlib.Popen_safe(raw_cmd)
+                if p.returncode != 0:
+                    cmd_str = mesonlib.join_args(raw_cmd)
+                    raise mesonlib.MesonException(f'Command {cmd_str!r} failed with status {p.returncode}.')
+            output = o.strip()
+            if not output:
+                output = e.strip()
+            match = re.search(r'([0-9][0-9\.]+)', output)
+            if not match:
+                raise mesonlib.MesonException(f'Could not find a version number in output of {raw_cmd!r}')
+            self.cached_version = match.group(1)
+        return self.cached_version
+
+    @classmethod
+    def from_bin_list(cls, env: 'Environment', for_machine: MachineChoice, name: str) -> 'ExternalProgram':
+        # There is a static `for_machine` for this class because the binary
+        # always runs on the build platform. (It's host platform is our build
+        # platform.) But some external programs have a target platform, so this
+        # is what we are specifying here.
+        command = env.lookup_binary_entry(for_machine, name)
+        if command is None:
+            return NonExistingExternalProgram()
+        return cls.from_entry(name, command)
+
+    @staticmethod
+    @functools.lru_cache(maxsize=None)
+    def _windows_sanitize_path(path: str) -> str:
+        # Ensure that we use USERPROFILE even when inside MSYS, MSYS2, Cygwin, etc.
+        if 'USERPROFILE' not in os.environ:
+            return path
+        # The WindowsApps directory is a bit of a problem. It contains
+        # some zero-sized .exe files which have "reparse points", that
+        # might either launch an installed application, or might open
+        # a page in the Windows Store to download the application.
+        #
+        # To handle the case where the python interpreter we're
+        # running on came from the Windows Store, if we see the
+        # WindowsApps path in the search path, replace it with
+        # dirname(sys.executable).
+        appstore_dir = Path(os.environ['USERPROFILE']) / 'AppData' / 'Local' / 'Microsoft' / 'WindowsApps'
+        paths = []
+        for each in path.split(os.pathsep):
+            if Path(each) != appstore_dir:
+                paths.append(each)
+            elif 'WindowsApps' in sys.executable:
+                paths.append(os.path.dirname(sys.executable))
+        return os.pathsep.join(paths)
+
+    @staticmethod
+    def from_entry(name: str, command: T.Union[str, T.List[str]]) -> 'ExternalProgram':
+        if isinstance(command, list):
+            if len(command) == 1:
+                command = command[0]
+        # We cannot do any searching if the command is a list, and we don't
+        # need to search if the path is an absolute path.
+        if isinstance(command, list) or os.path.isabs(command):
+            if isinstance(command, str):
+                command = [command]
+            return ExternalProgram(name, command=command, silent=True)
+        assert isinstance(command, str)
+        # Search for the command using the specified string!
+        return ExternalProgram(command, silent=True)
+
+    @staticmethod
+    def _shebang_to_cmd(script: str) -> T.Optional[T.List[str]]:
+        """
+        Check if the file has a shebang and manually parse it to figure out
+        the interpreter to use. This is useful if the script is not executable
+        or if we're on Windows (which does not understand shebangs).
+        """
+        try:
+            with open(script, encoding='utf-8') as f:
+                first_line = f.readline().strip()
+            if first_line.startswith('#!'):
+                # In a shebang, everything before the first space is assumed to
+                # be the command to run and everything after the first space is
+                # the single argument to pass to that command. So we must split
+                # exactly once.
+                commands = first_line[2:].split('#')[0].strip().split(maxsplit=1)
+                if mesonlib.is_windows():
+                    # Windows does not have UNIX paths so remove them,
+                    # but don't remove Windows paths
+                    if commands[0].startswith('/'):
+                        commands[0] = commands[0].split('/')[-1]
+                    if len(commands) > 0 and commands[0] == 'env':
+                        commands = commands[1:]
+                    # Windows does not ship python3.exe, but we know the path to it
+                    if len(commands) > 0 and commands[0] == 'python3':
+                        commands = mesonlib.python_command + commands[1:]
+                elif mesonlib.is_haiku():
+                    # Haiku does not have /usr, but a lot of scripts assume that
+                    # /usr/bin/env always exists. Detect that case and run the
+                    # script with the interpreter after it.
+                    if commands[0] == '/usr/bin/env':
+                        commands = commands[1:]
+                    # We know what python3 is, we're running on it
+                    if len(commands) > 0 and commands[0] == 'python3':
+                        commands = mesonlib.python_command + commands[1:]
+                else:
+                    # Replace python3 with the actual python3 that we are using
+                    if commands[0] == '/usr/bin/env' and commands[1] == 'python3':
+                        commands = mesonlib.python_command + commands[2:]
+                    elif commands[0].split('/')[-1] == 'python3':
+                        commands = mesonlib.python_command + commands[1:]
+                return commands + [script]
+        except Exception as e:
+            mlog.debug(str(e))
+        mlog.debug(f'Unusable script {script!r}')
+        return None
+
+    def _is_executable(self, path: str) -> bool:
+        suffix = os.path.splitext(path)[-1].lower()[1:]
+        execmask = stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH
+        if mesonlib.is_windows():
+            if suffix in self.windows_exts:
+                return True
+        elif os.stat(path).st_mode & execmask:
+            return not os.path.isdir(path)
+        return False
+
+    def _search_dir(self, name: str, search_dir: T.Optional[str]) -> T.Optional[list]:
+        if search_dir is None:
+            return None
+        trial = os.path.join(search_dir, name)
+        if os.path.exists(trial):
+            if self._is_executable(trial):
+                return [trial]
+            # Now getting desperate. Maybe it is a script file that is
+            # a) not chmodded executable, or
+            # b) we are on windows so they can't be directly executed.
+            return self._shebang_to_cmd(trial)
+        else:
+            if mesonlib.is_windows():
+                for ext in self.windows_exts:
+                    trial_ext = f'{trial}.{ext}'
+                    if os.path.exists(trial_ext):
+                        return [trial_ext]
+        return None
+
+    def _search_windows_special_cases(self, name: str, command: str) -> T.List[T.Optional[str]]:
+        '''
+        Lots of weird Windows quirks:
+        1. PATH search for @name returns files with extensions from PATHEXT,
+           but only self.windows_exts are executable without an interpreter.
+        2. @name might be an absolute path to an executable, but without the
+           extension. This works inside MinGW so people use it a lot.
+        3. The script is specified without an extension, in which case we have
+           to manually search in PATH.
+        4. More special-casing for the shebang inside the script.
+        '''
+        if command:
+            # On Windows, even if the PATH search returned a full path, we can't be
+            # sure that it can be run directly if it's not a native executable.
+            # For instance, interpreted scripts sometimes need to be run explicitly
+            # with an interpreter if the file association is not done properly.
+            name_ext = os.path.splitext(command)[1]
+            if name_ext[1:].lower() in self.windows_exts:
+                # Good, it can be directly executed
+                return [command]
+            # Try to extract the interpreter from the shebang
+            commands = self._shebang_to_cmd(command)
+            if commands:
+                return commands
+            return [None]
+        # Maybe the name is an absolute path to a native Windows
+        # executable, but without the extension. This is technically wrong,
+        # but many people do it because it works in the MinGW shell.
+        if os.path.isabs(name):
+            for ext in self.windows_exts:
+                command = f'{name}.{ext}'
+                if os.path.exists(command):
+                    return [command]
+        # On Windows, interpreted scripts must have an extension otherwise they
+        # cannot be found by a standard PATH search. So we do a custom search
+        # where we manually search for a script with a shebang in PATH.
+        search_dirs = self._windows_sanitize_path(os.environ.get('PATH', '')).split(';')
+        for search_dir in search_dirs:
+            commands = self._search_dir(name, search_dir)
+            if commands:
+                return commands
+        return [None]
+
+    def _search(self, name: str, search_dir: T.Optional[str]) -> T.List[T.Optional[str]]:
+        '''
+        Search in the specified dir for the specified executable by name
+        and if not found search in PATH
+        '''
+        commands = self._search_dir(name, search_dir)
+        if commands:
+            return commands
+        # If there is a directory component, do not look in PATH
+        if os.path.dirname(name) and not os.path.isabs(name):
+            return [None]
+        # Do a standard search in PATH
+        path = os.environ.get('PATH', None)
+        if mesonlib.is_windows() and path:
+            path = self._windows_sanitize_path(path)
+        command = shutil.which(name, path=path)
+        if mesonlib.is_windows():
+            return self._search_windows_special_cases(name, command)
+        # On UNIX-like platforms, shutil.which() is enough to find
+        # all executables whether in PATH or with an absolute path
+        return [command]
+
+    def found(self) -> bool:
+        return self.command[0] is not None
+
+    def get_command(self) -> T.List[str]:
+        return self.command[:]
+
+    def get_path(self) -> T.Optional[str]:
+        return self.path
+
+    def get_name(self) -> str:
+        return self.name
+
+
+class NonExistingExternalProgram(ExternalProgram):  # lgtm [py/missing-call-to-init]
+    "A program that will never exist"
+
+    def __init__(self, name: str = 'nonexistingprogram') -> None:
+        self.name = name
+        self.command = [None]
+        self.path = None
+
+    def __repr__(self) -> str:
+        r = '<{} {!r} -> {!r}>'
+        return r.format(self.__class__.__name__, self.name, self.command)
+
+    def found(self) -> bool:
+        return False
+
+
+class OverrideProgram(ExternalProgram):
+
+    """A script overriding a program."""
+
+
+def find_external_program(env: 'Environment', for_machine: MachineChoice, name: str,
+                          display_name: str, default_names: T.List[str],
+                          allow_default_for_cross: bool = True) -> T.Generator['ExternalProgram', None, None]:
+    """Find an external program, chcking the cross file plus any default options."""
+    # Lookup in cross or machine file.
+    potential_cmd = env.lookup_binary_entry(for_machine, name)
+    if potential_cmd is not None:
+        mlog.debug(f'{display_name} binary for {for_machine} specified from cross file, native file, '
+                   f'or env var as {potential_cmd}')
+        yield ExternalProgram.from_entry(name, potential_cmd)
+        # We never fallback if the user-specified option is no good, so
+        # stop returning options.
+        return
+    mlog.debug(f'{display_name} binary missing from cross or native file, or env var undefined.')
+    # Fallback on hard-coded defaults, if a default binary is allowed for use
+    # with cross targets, or if this is not a cross target
+    if allow_default_for_cross or not (for_machine is MachineChoice.HOST and env.is_cross_build(for_machine)):
+        for potential_path in default_names:
+            mlog.debug(f'Trying a default {display_name} fallback at', potential_path)
+            yield ExternalProgram(potential_path, silent=True)
+    else:
+        mlog.debug('Default target is not allowed for cross use')