The Meson Build System
http://mesonbuild.com/
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
331 lines
14 KiB
331 lines
14 KiB
# 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. |
|
|
|
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_true', default=False, |
|
help='Do not redirect output to a pager') |
|
|
|
def make_lower_case(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): |
|
return [make_lower_case(i) for i in val] |
|
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): |
|
if isinstance(value, list): |
|
value = '[{}]'.format(', '.join(make_lower_case(value))) |
|
else: |
|
value = make_lower_case(value) |
|
|
|
if isinstance(choices, list): |
|
choices = '[{}]'.format(', '.join(make_lower_case(choices))) |
|
else: |
|
choices = make_lower_case(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) |
|
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>' |
|
self.add_option(str(root), o.description, printable_value, o.choices) |
|
|
|
def print_conf(self): |
|
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)) |
|
if not options.no_pager: |
|
mlog.start_pager() |
|
c = None |
|
try: |
|
c = Conf(builddir) |
|
if c.default_values_only: |
|
c.print_conf() |
|
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() |
|
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
|
|
|