summaryrefslogtreecommitdiffstats
path: root/mesonbuild/optinterpreter.py
diff options
context:
space:
mode:
Diffstat (limited to 'mesonbuild/optinterpreter.py')
-rw-r--r--mesonbuild/optinterpreter.py225
1 files changed, 225 insertions, 0 deletions
diff --git a/mesonbuild/optinterpreter.py b/mesonbuild/optinterpreter.py
new file mode 100644
index 0000000..549d564
--- /dev/null
+++ b/mesonbuild/optinterpreter.py
@@ -0,0 +1,225 @@
+# 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 re
+import typing as T
+
+from . import coredata
+from . import mesonlib
+from . import mparser
+from . import mlog
+from .interpreterbase import FeatureNew, typed_pos_args, typed_kwargs, ContainerTypeInfo, KwargInfo, permittedKwargs
+if T.TYPE_CHECKING:
+ from .interpreterbase import TYPE_var, TYPE_kwargs
+ from .interpreterbase import SubProject
+ from typing_extensions import TypedDict
+ FuncOptionArgs = TypedDict('FuncOptionArgs', {
+ 'type': str,
+ 'description': str,
+ 'yield': bool,
+ 'choices': T.Optional[T.List[str]],
+ 'value': object,
+ 'min': T.Optional[int],
+ 'max': T.Optional[int],
+ 'deprecated': T.Union[bool, str, T.Dict[str, str], T.List[str]],
+ })
+ ParserArgs = TypedDict('ParserArgs', {
+ 'yield': bool,
+ 'choices': T.Optional[T.List[str]],
+ 'value': object,
+ 'min': T.Optional[int],
+ 'max': T.Optional[int],
+ })
+
+
+class OptionException(mesonlib.MesonException):
+ pass
+
+
+optname_regex = re.compile('[^a-zA-Z0-9_-]')
+
+
+class OptionInterpreter:
+ def __init__(self, subproject: 'SubProject') -> None:
+ self.options: 'coredata.MutableKeyedOptionDictType' = {}
+ self.subproject = subproject
+ self.option_types = {'string': self.string_parser,
+ 'boolean': self.boolean_parser,
+ 'combo': self.combo_parser,
+ 'integer': self.integer_parser,
+ 'array': self.string_array_parser,
+ 'feature': self.feature_parser,
+ }
+
+ def process(self, option_file: str) -> None:
+ try:
+ with open(option_file, encoding='utf-8') as f:
+ ast = mparser.Parser(f.read(), option_file).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()
+ e.file = option_file
+ raise e
+ for cur in ast.lines:
+ try:
+ self.current_node = cur
+ self.evaluate_statement(cur)
+ except mesonlib.MesonException as e:
+ e.lineno = cur.lineno
+ e.colno = cur.colno
+ e.file = option_file
+ raise e
+ except Exception as e:
+ raise mesonlib.MesonException(
+ str(e), lineno=cur.lineno, colno=cur.colno, file=option_file)
+
+ def reduce_single(self, arg: T.Union[str, mparser.BaseNode]) -> 'TYPE_var':
+ 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]
+ elif isinstance(arg, mparser.DictNode):
+ d = {}
+ for k, v in arg.args.kwargs.items():
+ if not isinstance(k, mparser.StringNode):
+ raise OptionException('Dictionary keys must be a string literal')
+ d[k.value] = self.reduce_single(v)
+ return d
+ elif isinstance(arg, mparser.UMinusNode):
+ res = self.reduce_single(arg.value)
+ if not isinstance(res, (int, float)):
+ raise OptionException('Token after "-" is not a number')
+ FeatureNew.single_use('negative numbers in meson_options.txt', '0.54.1', self.subproject)
+ return -res
+ elif isinstance(arg, mparser.NotNode):
+ res = self.reduce_single(arg.value)
+ if not isinstance(res, bool):
+ raise OptionException('Token after "not" is not a a boolean')
+ FeatureNew.single_use('negation ("not") in meson_options.txt', '0.54.1', self.subproject)
+ return not res
+ elif isinstance(arg, mparser.ArithmeticNode):
+ l = self.reduce_single(arg.left)
+ r = self.reduce_single(arg.right)
+ if not (arg.operation == 'add' and isinstance(l, str) and isinstance(r, str)):
+ raise OptionException('Only string concatenation with the "+" operator is allowed')
+ FeatureNew.single_use('string concatenation in meson_options.txt', '0.55.0', self.subproject)
+ return l + r
+ else:
+ raise OptionException('Arguments may only be string, int, bool, or array of those.')
+
+ def reduce_arguments(self, args: mparser.ArgumentNode) -> T.Tuple['TYPE_var', 'TYPE_kwargs']:
+ 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, mparser.IdNode):
+ raise OptionException('Keyword argument name is not a string.')
+ a = args.kwargs[key]
+ reduced_kw[key.value] = self.reduce_single(a)
+ return reduced_pos, reduced_kw
+
+ def evaluate_statement(self, node: mparser.BaseNode) -> None:
+ 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)
+ self.func_option(posargs, kwargs)
+
+ @typed_kwargs('option',
+ KwargInfo('type', str, required=True),
+ KwargInfo('description', str, default=''),
+ KwargInfo('yield', bool, default=coredata.default_yielding, since='0.45.0'),
+ KwargInfo('choices', (ContainerTypeInfo(list, str), type(None))),
+ KwargInfo('value', object),
+ KwargInfo('min', (int, type(None))),
+ KwargInfo('max', (int, type(None))),
+ KwargInfo('deprecated', (bool, str, ContainerTypeInfo(dict, str), ContainerTypeInfo(list, str)),
+ default=False, since='0.60.0')
+ )
+ @typed_pos_args('option', str)
+ def func_option(self, args: T.Tuple[str], kwargs: 'FuncOptionArgs') -> None:
+ opt_name = args[0]
+ if optname_regex.search(opt_name) is not None:
+ raise OptionException('Option names can only contain letters, numbers or dashes.')
+ key = mesonlib.OptionKey.from_string(opt_name).evolve(subproject=self.subproject)
+ if not key.is_project():
+ raise OptionException('Option name %s is reserved.' % opt_name)
+
+ opt_type = kwargs['type']
+ parser = self.option_types.get(opt_type)
+ if not parser:
+ raise OptionException(f'Unknown type {opt_type}.')
+ description = kwargs['description'] or opt_name
+
+ # Only keep in kwargs arguments that are used by option type's parser
+ # because they use @permittedKwargs().
+ known_parser_kwargs = {'value', 'choices', 'yield', 'min', 'max'}
+ parser_kwargs = {k: v for k, v in kwargs.items() if k in known_parser_kwargs and v is not None}
+ opt = parser(description, T.cast('ParserArgs', parser_kwargs))
+ opt.deprecated = kwargs['deprecated']
+ if isinstance(opt.deprecated, str):
+ FeatureNew.single_use('String value to "deprecated" keyword argument', '0.63.0', self.subproject)
+ if key in self.options:
+ mlog.deprecation(f'Option {opt_name} already exists.')
+ self.options[key] = opt
+
+ @permittedKwargs({'value', 'yield'})
+ def string_parser(self, description: str, kwargs: 'ParserArgs') -> coredata.UserOption:
+ value = kwargs.get('value', '')
+ return coredata.UserStringOption(description, value, kwargs['yield'])
+
+ @permittedKwargs({'value', 'yield'})
+ def boolean_parser(self, description: str, kwargs: 'ParserArgs') -> coredata.UserOption:
+ value = kwargs.get('value', True)
+ return coredata.UserBooleanOption(description, value, kwargs['yield'])
+
+ @permittedKwargs({'value', 'yield', 'choices'})
+ def combo_parser(self, description: str, kwargs: 'ParserArgs') -> coredata.UserOption:
+ choices = kwargs.get('choices')
+ if not choices:
+ raise OptionException('Combo option missing "choices" keyword.')
+ value = kwargs.get('value', choices[0])
+ return coredata.UserComboOption(description, choices, value, kwargs['yield'])
+
+ @permittedKwargs({'value', 'min', 'max', 'yield'})
+ def integer_parser(self, description: str, kwargs: 'ParserArgs') -> coredata.UserOption:
+ value = kwargs.get('value')
+ if value is None:
+ raise OptionException('Integer option must contain value argument.')
+ inttuple = (kwargs.get('min'), kwargs.get('max'), value)
+ return coredata.UserIntegerOption(description, inttuple, kwargs['yield'])
+
+ @permittedKwargs({'value', 'yield', 'choices'})
+ def string_array_parser(self, description: str, kwargs: 'ParserArgs') -> coredata.UserOption:
+ choices = kwargs.get('choices', [])
+ value = kwargs.get('value', choices)
+ if not isinstance(value, list):
+ raise OptionException('Array choices must be passed as an array.')
+ return coredata.UserArrayOption(description, value,
+ choices=choices,
+ yielding=kwargs['yield'])
+
+ @permittedKwargs({'value', 'yield'})
+ def feature_parser(self, description: str, kwargs: 'ParserArgs') -> coredata.UserOption:
+ value = kwargs.get('value', 'auto')
+ return coredata.UserFeatureOption(description, value, kwargs['yield'])
generated by cgit v1.2.3 (git 2.39.1) at 2025-02-19 15:45:51 +0000