# Copyright 2013-2014 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 os, re import functools from . import mlog from . import mparser from . import coredata from . import mesonlib forbidden_option_names = coredata.get_builtin_options() forbidden_prefixes = {'c_', 'cpp_', 'd_', 'rust_', 'fortran_', 'objc_', 'objcpp_', 'vala_', 'csharp_', 'swift_', 'b_', 'backend_', } def is_invalid_name(name): if name in forbidden_option_names: return True pref = name.split('_')[0] + '_' if pref in forbidden_prefixes: return True return False class OptionException(mesonlib.MesonException): pass def permitted_kwargs(permitted): """Function that validates kwargs for options.""" def _wraps(func): @functools.wraps(func) def _inner(name, description, kwargs): bad = [a for a in kwargs.keys() if a not in permitted] if bad: raise OptionException('Invalid kwargs for option "{}": "{}"'.format( name, ' '.join(bad))) return func(name, description, kwargs) return _inner return _wraps optname_regex = re.compile('[^a-zA-Z0-9_-]') @permitted_kwargs({'value'}) def StringParser(name, description, kwargs): return coredata.UserStringOption(name, description, kwargs.get('value', ''), kwargs.get('choices', [])) @permitted_kwargs({'value'}) def BooleanParser(name, description, kwargs): return coredata.UserBooleanOption(name, description, kwargs.get('value', True)) @permitted_kwargs({'value', 'choices'}) def ComboParser(name, description, kwargs): if 'choices' not in kwargs: raise OptionException('Combo option missing "choices" keyword.') choices = kwargs['choices'] if not isinstance(choices, list): raise OptionException('Combo choices must be an array.') for i in choices: if not isinstance(i, str): raise OptionException('Combo choice elements must be strings.') return coredata.UserComboOption(name, description, choices, kwargs.get('value', choices[0])) @permitted_kwargs({'value', 'choices'}) def string_array_parser(name, description, kwargs): if 'choices' in kwargs: choices = kwargs['choices'] if not isinstance(choices, list): raise OptionException('Array choices must be an array.') for i in choices: if not isinstance(i, str): raise OptionException('Array choice elements must be strings.') value = kwargs.get('value', choices) else: choices = None value = kwargs.get('value', []) if not isinstance(value, list): raise OptionException('Array choices must be passed as an array.') return coredata.UserArrayOption(name, description, value, choices=choices) option_types = {'string': StringParser, 'boolean': BooleanParser, 'combo': ComboParser, 'array': string_array_parser, } class OptionInterpreter: def __init__(self, subproject, command_line_options): self.options = {} self.subproject = subproject self.sbprefix = subproject + ':' self.cmd_line_options = {} for o in command_line_options: if self.subproject != '': # Strip the beginning. # Ignore options that aren't for this subproject if not o.startswith(self.sbprefix): continue try: (key, value) = o.split('=', 1) except ValueError: raise OptionException('Option {!r} must have a value separated by equals sign.'.format(o)) # Ignore subproject options if not fetching subproject options if self.subproject == '' and ':' in key: continue self.cmd_line_options[key] = value def process(self, option_file): try: with open(option_file, 'r', encoding='utf8') as f: ast = mparser.Parser(f.read(), '').parse() except mesonlib.MesonException as me: me.file = option_file raise me if not isinstance(ast, mparser.CodeBlockNode): e = OptionException('Option file is malformed.') e.lineno = ast.lineno() raise e for cur in ast.lines: try: self.evaluate_statement(cur) except Exception as e: e.lineno = cur.lineno e.colno = cur.colno e.file = os.path.join('meson_options.txt') raise e bad = [o for o in sorted(self.cmd_line_options) if not (o in list(self.options) + forbidden_option_names or any(o.startswith(p) for p in forbidden_prefixes))] if bad: sub = 'In subproject {}: '.format(self.subproject) if self.subproject else '' mlog.warning( '{}Unknown command line options: "{}"\n' 'This will become a hard error in a future Meson release.'.format(sub, ', '.join(bad))) def reduce_single(self, arg): if isinstance(arg, str): return arg elif isinstance(arg, (mparser.StringNode, mparser.BooleanNode, mparser.NumberNode)): return arg.value elif isinstance(arg, mparser.ArrayNode): return [self.reduce_single(curarg) for curarg in arg.args.arguments] else: raise OptionException('Arguments may only be string, int, bool, or array of those.') def reduce_arguments(self, args): assert(isinstance(args, mparser.ArgumentNode)) if args.incorrect_order(): raise OptionException('All keyword arguments must be after positional arguments.') reduced_pos = [self.reduce_single(arg) for arg in args.arguments] reduced_kw = {} for key in args.kwargs.keys(): if not isinstance(key, str): raise OptionException('Keyword argument name is not a string.') a = args.kwargs[key] reduced_kw[key] = self.reduce_single(a) return reduced_pos, reduced_kw def evaluate_statement(self, node): if not isinstance(node, mparser.FunctionNode): raise OptionException('Option file may only contain option definitions') func_name = node.func_name if func_name != 'option': raise OptionException('Only calls to option() are allowed in option files.') (posargs, kwargs) = self.reduce_arguments(node.args) if 'type' not in kwargs: raise OptionException('Option call missing mandatory "type" keyword argument') opt_type = kwargs.pop('type') if opt_type not in option_types: raise OptionException('Unknown type %s.' % opt_type) if len(posargs) != 1: raise OptionException('Option() must have one (and only one) positional argument') opt_name = posargs[0] if not isinstance(opt_name, str): raise OptionException('Positional argument must be a string.') if optname_regex.search(opt_name) is not None: raise OptionException('Option names can only contain letters, numbers or dashes.') if is_invalid_name(opt_name): raise OptionException('Option name %s is reserved.' % opt_name) if self.subproject != '': opt_name = self.subproject + ':' + opt_name opt = option_types[opt_type](opt_name, kwargs.pop('description', ''), kwargs) if opt.description == '': opt.description = opt_name if opt_name in self.cmd_line_options: opt.set_value(self.cmd_line_options[opt_name]) self.options[opt_name] = opt