Adding upstream version 1.0.1.upstream/1.0.1upstream

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

1 files changed, 331 insertions, 0 deletions

diff --git a/mesonbuild/mconf.py b/mesonbuild/mconf.py
new file mode 100644
index 0000000..46d0463
--- /dev/null
+++ b/mesonbuild/mconf.py
@@ -0,0 +1,331 @@
+# Copyright 2014-2016 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
+
+import itertools
+import shutil
+import os
+import textwrap
+import typing as T
+import collections
+
+from . import build
+from . import coredata
+from . import environment
+from . import mesonlib
+from . import mintro
+from . import mlog
+from .ast import AstIDGenerator
+from .mesonlib import MachineChoice, OptionKey
+
+if T.TYPE_CHECKING:
+    import argparse
+
+def add_arguments(parser: 'argparse.ArgumentParser') -> None:
+    coredata.register_builtin_arguments(parser)
+    parser.add_argument('builddir', nargs='?', default='.')
+    parser.add_argument('--clearcache', action='store_true', default=False,
+                        help='Clear cached state (e.g. found dependencies)')
+    parser.add_argument('--no-pager', action='store_false', dest='pager',
+                        help='Do not redirect output to a pager')
+
+def stringify(val: T.Any) -> T.Union[str, T.List[T.Any]]:  # T.Any because of recursion...
+    if isinstance(val, bool):
+        return str(val).lower()
+    elif isinstance(val, list):
+        s = ', '.join(stringify(i) for i in val)
+        return f'[{s}]'
+    elif val is None:
+        return ''
+    else:
+        return str(val)
+
+
+class ConfException(mesonlib.MesonException):
+    pass
+
+
+class Conf:
+    def __init__(self, build_dir):
+        self.build_dir = os.path.abspath(os.path.realpath(build_dir))
+        if 'meson.build' in [os.path.basename(self.build_dir), self.build_dir]:
+            self.build_dir = os.path.dirname(self.build_dir)
+        self.build = None
+        self.max_choices_line_length = 60
+        self.name_col = []
+        self.value_col = []
+        self.choices_col = []
+        self.descr_col = []
+        self.all_subprojects: T.Set[str] = set()
+
+        if os.path.isdir(os.path.join(self.build_dir, 'meson-private')):
+            self.build = build.load(self.build_dir)
+            self.source_dir = self.build.environment.get_source_dir()
+            self.coredata = coredata.load(self.build_dir)
+            self.default_values_only = False
+        elif os.path.isfile(os.path.join(self.build_dir, environment.build_filename)):
+            # Make sure that log entries in other parts of meson don't interfere with the JSON output
+            mlog.disable()
+            self.source_dir = os.path.abspath(os.path.realpath(self.build_dir))
+            intr = mintro.IntrospectionInterpreter(self.source_dir, '', 'ninja', visitors = [AstIDGenerator()])
+            intr.analyze()
+            # Re-enable logging just in case
+            mlog.enable()
+            self.coredata = intr.coredata
+            self.default_values_only = True
+        else:
+            raise ConfException(f'Directory {build_dir} is neither a Meson build directory nor a project source directory.')
+
+    def clear_cache(self):
+        self.coredata.clear_deps_cache()
+
+    def set_options(self, options):
+        self.coredata.set_options(options)
+
+    def save(self):
+        # Do nothing when using introspection
+        if self.default_values_only:
+            return
+        coredata.save(self.coredata, self.build_dir)
+        # We don't write the build file because any changes to it
+        # are erased when Meson is executed the next time, i.e. when
+        # Ninja is run.
+
+    def print_aligned(self) -> None:
+        """Do the actual printing.
+
+        This prints the generated output in an aligned, pretty form. it aims
+        for a total width of 160 characters, but will use whatever the tty
+        reports it's value to be. Though this is much wider than the standard
+        80 characters of terminals, and even than the newer 120, compressing
+        it to those lengths makes the output hard to read.
+
+        Each column will have a specific width, and will be line wrapped.
+        """
+        total_width = shutil.get_terminal_size(fallback=(160, 0))[0]
+        _col = max(total_width // 5, 20)
+        last_column = total_width - (3 * _col) - 3
+        four_column = (_col, _col, _col, last_column if last_column > 1 else _col)
+
+        for line in zip(self.name_col, self.value_col, self.choices_col, self.descr_col):
+            if not any(line):
+                mlog.log('')
+                continue
+
+            # This is a header, like `Subproject foo:`,
+            # We just want to print that and get on with it
+            if line[0] and not any(line[1:]):
+                mlog.log(line[0])
+                continue
+
+            def wrap_text(text, width):
+                raw = text.text if isinstance(text, mlog.AnsiDecorator) else text
+                indent = ' ' if raw.startswith('[') else ''
+                wrapped = textwrap.wrap(raw, width, subsequent_indent=indent)
+                if isinstance(text, mlog.AnsiDecorator):
+                    wrapped = [mlog.AnsiDecorator(i, text.code) for i in wrapped]
+                # Add padding here to get even rows, as `textwrap.wrap()` will
+                # only shorten, not lengthen each item
+                return [str(i) + ' ' * (width - len(i)) for i in wrapped]
+
+            # wrap will take a long string, and create a list of strings no
+            # longer than the size given. Then that list can be zipped into, to
+            # print each line of the output, such the that columns are printed
+            # to the right width, row by row.
+            name = wrap_text(line[0], four_column[0])
+            val = wrap_text(line[1], four_column[1])
+            choice = wrap_text(line[2], four_column[2])
+            desc = wrap_text(line[3], four_column[3])
+            for l in itertools.zip_longest(name, val, choice, desc, fillvalue=''):
+                items = [l[i] if l[i] else ' ' * four_column[i] for i in range(4)]
+                mlog.log(*items)
+
+    def split_options_per_subproject(self, options: 'coredata.KeyedOptionDictType') -> T.Dict[str, 'coredata.KeyedOptionDictType']:
+        result: T.Dict[str, 'coredata.KeyedOptionDictType'] = {}
+        for k, o in options.items():
+            if k.subproject:
+                self.all_subprojects.add(k.subproject)
+            result.setdefault(k.subproject, {})[k] = o
+        return result
+
+    def _add_line(self, name, value, choices, descr) -> None:
+        if isinstance(name, mlog.AnsiDecorator):
+            name.text = ' ' * self.print_margin + name.text
+        else:
+            name = ' ' * self.print_margin + name
+        self.name_col.append(name)
+        self.value_col.append(value)
+        self.choices_col.append(choices)
+        self.descr_col.append(descr)
+
+    def add_option(self, name, descr, value, choices):
+        value = stringify(value)
+        choices = stringify(choices)
+        self._add_line(mlog.green(name), mlog.yellow(value), mlog.blue(choices), descr)
+
+    def add_title(self, title):
+        title = mlog.cyan(title)
+        descr = mlog.cyan('Description')
+        value = mlog.cyan('Default Value' if self.default_values_only else 'Current Value')
+        choices = mlog.cyan('Possible Values')
+        self._add_line('', '', '', '')
+        self._add_line(title, value, choices, descr)
+        self._add_line('-' * len(title), '-' * len(value), '-' * len(choices), '-' * len(descr))
+
+    def add_section(self, section):
+        self.print_margin = 0
+        self._add_line('', '', '', '')
+        self._add_line(mlog.normal_yellow(section + ':'), '', '', '')
+        self.print_margin = 2
+
+    def print_options(self, title: str, options: 'coredata.KeyedOptionDictType') -> None:
+        if not options:
+            return
+        if title:
+            self.add_title(title)
+        auto = T.cast('coredata.UserFeatureOption', self.coredata.options[OptionKey('auto_features')])
+        for k, o in sorted(options.items()):
+            printable_value = o.printable_value()
+            root = k.as_root()
+            if o.yielding and k.subproject and root in self.coredata.options:
+                printable_value = '<inherited from main project>'
+            if isinstance(o, coredata.UserFeatureOption) and o.is_auto():
+                printable_value = auto.printable_value()
+            self.add_option(str(root), o.description, printable_value, o.choices)
+
+    def print_conf(self, pager: bool):
+        if pager:
+            mlog.start_pager()
+
+        def print_default_values_warning():
+            mlog.warning('The source directory instead of the build directory was specified.')
+            mlog.warning('Only the default values for the project are printed, and all command line parameters are ignored.')
+
+        if self.default_values_only:
+            print_default_values_warning()
+            mlog.log('')
+
+        mlog.log('Core properties:')
+        mlog.log('  Source dir', self.source_dir)
+        if not self.default_values_only:
+            mlog.log('  Build dir ', self.build_dir)
+
+        dir_option_names = set(coredata.BUILTIN_DIR_OPTIONS)
+        test_option_names = {OptionKey('errorlogs'),
+                             OptionKey('stdsplit')}
+
+        dir_options: 'coredata.KeyedOptionDictType' = {}
+        test_options: 'coredata.KeyedOptionDictType' = {}
+        core_options: 'coredata.KeyedOptionDictType' = {}
+        module_options: T.Dict[str, 'coredata.KeyedOptionDictType'] = collections.defaultdict(dict)
+        for k, v in self.coredata.options.items():
+            if k in dir_option_names:
+                dir_options[k] = v
+            elif k in test_option_names:
+                test_options[k] = v
+            elif k.module:
+                # Ignore module options if we did not use that module during
+                # configuration.
+                if self.build and k.module not in self.build.modules:
+                    continue
+                module_options[k.module][k] = v
+            elif k.is_builtin():
+                core_options[k] = v
+
+        host_core_options = self.split_options_per_subproject({k: v for k, v in core_options.items() if k.machine is MachineChoice.HOST})
+        build_core_options = self.split_options_per_subproject({k: v for k, v in core_options.items() if k.machine is MachineChoice.BUILD})
+        host_compiler_options = self.split_options_per_subproject({k: v for k, v in self.coredata.options.items() if k.is_compiler() and k.machine is MachineChoice.HOST})
+        build_compiler_options = self.split_options_per_subproject({k: v for k, v in self.coredata.options.items() if k.is_compiler() and k.machine is MachineChoice.BUILD})
+        project_options = self.split_options_per_subproject({k: v for k, v in self.coredata.options.items() if k.is_project()})
+        show_build_options = self.default_values_only or self.build.environment.is_cross_build()
+
+        self.add_section('Main project options')
+        self.print_options('Core options', host_core_options[''])
+        if show_build_options:
+            self.print_options('', build_core_options[''])
+        self.print_options('Backend options', {k: v for k, v in self.coredata.options.items() if k.is_backend()})
+        self.print_options('Base options', {k: v for k, v in self.coredata.options.items() if k.is_base()})
+        self.print_options('Compiler options', host_compiler_options.get('', {}))
+        if show_build_options:
+            self.print_options('', build_compiler_options.get('', {}))
+        for mod, mod_options in module_options.items():
+            self.print_options(f'{mod} module options', mod_options)
+        self.print_options('Directories', dir_options)
+        self.print_options('Testing options', test_options)
+        self.print_options('Project options', project_options.get('', {}))
+        for subproject in sorted(self.all_subprojects):
+            if subproject == '':
+                continue
+            self.add_section('Subproject ' + subproject)
+            if subproject in host_core_options:
+                self.print_options('Core options', host_core_options[subproject])
+            if subproject in build_core_options and show_build_options:
+                self.print_options('', build_core_options[subproject])
+            if subproject in host_compiler_options:
+                self.print_options('Compiler options', host_compiler_options[subproject])
+            if subproject in build_compiler_options and show_build_options:
+                self.print_options('', build_compiler_options[subproject])
+            if subproject in project_options:
+                self.print_options('Project options', project_options[subproject])
+        self.print_aligned()
+
+        # Print the warning twice so that the user shouldn't be able to miss it
+        if self.default_values_only:
+            mlog.log('')
+            print_default_values_warning()
+
+        self.print_nondefault_buildtype_options()
+
+    def print_nondefault_buildtype_options(self):
+        mismatching = self.coredata.get_nondefault_buildtype_args()
+        if not mismatching:
+            return
+        mlog.log("\nThe following option(s) have a different value than the build type default\n")
+        mlog.log('               current   default')
+        for m in mismatching:
+            mlog.log(f'{m[0]:21}{m[1]:10}{m[2]:10}')
+
+def run(options):
+    coredata.parse_cmd_line_options(options)
+    builddir = os.path.abspath(os.path.realpath(options.builddir))
+    c = None
+    try:
+        c = Conf(builddir)
+        if c.default_values_only:
+            c.print_conf(options.pager)
+            return 0
+
+        save = False
+        if options.cmd_line_options:
+            c.set_options(options.cmd_line_options)
+            coredata.update_cmd_line_file(builddir, options)
+            save = True
+        elif options.clearcache:
+            c.clear_cache()
+            save = True
+        else:
+            c.print_conf(options.pager)
+        if save:
+            c.save()
+            mintro.update_build_options(c.coredata, c.build.environment.info_dir)
+            mintro.write_meson_info_file(c.build, [])
+    except ConfException as e:
+        mlog.log('Meson configurator encountered an error:')
+        if c is not None and c.build is not None:
+            mintro.write_meson_info_file(c.build, [e])
+        raise e
+    except BrokenPipeError:
+        # Pager quit before we wrote everything.
+        pass
+    return 0