diff options
Diffstat (limited to 'mesonbuild')
| -rw-r--r-- | mesonbuild/backend/backends.py | 17 | ||||
| -rw-r--r-- | mesonbuild/backend/ninjabackend.py | 9 | ||||
| -rw-r--r-- | mesonbuild/backend/vs2010backend.py | 18 | ||||
| -rw-r--r-- | mesonbuild/build.py | 20 | ||||
| -rw-r--r-- | mesonbuild/compilers/c.py | 129 | ||||
| -rw-r--r-- | mesonbuild/compilers/compilers.py | 13 | ||||
| -rw-r--r-- | mesonbuild/compilers/cpp.py | 233 | ||||
| -rw-r--r-- | mesonbuild/compilers/fortran.py | 36 | ||||
| -rw-r--r-- | mesonbuild/coredata.py | 85 | ||||
| -rw-r--r-- | mesonbuild/environment.py | 4 | ||||
| -rw-r--r-- | mesonbuild/interpreter.py | 14 | ||||
| -rw-r--r-- | mesonbuild/mconf.py | 17 | ||||
| -rw-r--r-- | mesonbuild/mintro.py | 11 | ||||
| -rw-r--r-- | mesonbuild/rewriter.py | 4 |
14 files changed, 389 insertions, 221 deletions
diff --git a/mesonbuild/backend/backends.py b/mesonbuild/backend/backends.py index 138708d..31ddfb4 100644 --- a/mesonbuild/backend/backends.py +++ b/mesonbuild/backend/backends.py @@ -166,18 +166,21 @@ class Backend: return os.path.join(self.environment.get_build_dir(), self.get_target_filename(target)) def get_base_options_for_target(self, target): - return OptionOverrideProxy(target.option_overrides, + return OptionOverrideProxy(target.option_overrides_base, self.environment.coredata.builtins, self.environment.coredata.base_options) def get_compiler_options_for_target(self, target): - return OptionOverrideProxy( - target.option_overrides, - self.environment.coredata.compiler_options[target.for_machine]) + comp_reg = self.environment.coredata.compiler_options[target.for_machine] + comp_override = target.option_overrides_compiler + return { + lang: OptionOverrideProxy(comp_override[lang], comp_reg[lang]) + for lang in set(comp_reg.keys()) | set(comp_override.keys()) + } def get_option_for_target(self, option_name, target): - if option_name in target.option_overrides: - override = target.option_overrides[option_name] + if option_name in target.option_overrides_base: + override = target.option_overrides_base[option_name] return self.environment.coredata.validate_option_value(option_name, override) return self.environment.coredata.get_builtin_option(option_name, target.subproject) @@ -581,7 +584,7 @@ class Backend: # starting from hard-coded defaults followed by build options and so on. commands = CompilerArgs(compiler) - copt_proxy = self.get_compiler_options_for_target(target) + copt_proxy = self.get_compiler_options_for_target(target)[compiler.language] # First, the trivial ones that are impossible to override. # # Add -nostdinc/-nostdinc++ if needed; can't be overridden diff --git a/mesonbuild/backend/ninjabackend.py b/mesonbuild/backend/ninjabackend.py index 3f0cfca..e765466 100644 --- a/mesonbuild/backend/ninjabackend.py +++ b/mesonbuild/backend/ninjabackend.py @@ -2560,7 +2560,14 @@ https://gcc.gnu.org/bugzilla/show_bug.cgi?id=47485''')) # to be after all internal and external libraries so that unresolved # symbols from those can be found here. This is needed when the # *_winlibs that we want to link to are static mingw64 libraries. - commands += linker.get_option_link_args(self.environment.coredata.compiler_options[target.for_machine]) + if hasattr(linker, 'get_language'): + # The static linker doesn't know what language it is building, so we + # don't know what option. Fortunately, it doesn't care to see the + # language-specific options either. + # + # We shouldn't check whether we are making a static library, because + # in the LTO case we do use a real compiler here. + commands += linker.get_option_link_args(self.environment.coredata.compiler_options[target.for_machine][linker.get_language()]) dep_targets = [] dep_targets.extend(self.guess_external_link_dependencies(linker, target, commands, internal)) diff --git a/mesonbuild/backend/vs2010backend.py b/mesonbuild/backend/vs2010backend.py index 9a7ebf2..ef849e1 100644 --- a/mesonbuild/backend/vs2010backend.py +++ b/mesonbuild/backend/vs2010backend.py @@ -891,8 +891,10 @@ class Vs2010Backend(backends.Backend): # generate_single_compile() and generate_basic_compiler_args() for l, comp in target.compilers.items(): if l in file_args: - file_args[l] += compilers.get_base_compile_args(self.get_base_options_for_target(target), comp) - file_args[l] += comp.get_option_compile_args(self.environment.coredata.compiler_options[target.for_machine]) + file_args[l] += compilers.get_base_compile_args( + self.get_base_options_for_target(target), comp) + file_args[l] += comp.get_option_compile_args( + self.environment.coredata.compiler_options[target.for_machine][comp.language]) # Add compile args added using add_project_arguments() for l, args in self.build.projects_args[target.for_machine].get(target.subproject, {}).items(): @@ -905,10 +907,11 @@ class Vs2010Backend(backends.Backend): file_args[l] += args # Compile args added from the env or cross file: CFLAGS/CXXFLAGS, etc. We want these # to override all the defaults, but not the per-target compile args. - for key, opt in self.environment.coredata.compiler_options[target.for_machine].items(): - l, suffix = key.split('_', 1) - if suffix == 'args' and l in file_args: - file_args[l] += opt.value + for l in file_args.keys(): + opts = self.environment.coredata.compiler_options[target.for_machine][l] + k = 'args' + if k in opts: + file_args[l] += opts[k].value for args in file_args.values(): # This is where Visual Studio will insert target_args, target_defines, # etc, which are added later from external deps (see below). @@ -1115,7 +1118,8 @@ class Vs2010Backend(backends.Backend): # to be after all internal and external libraries so that unresolved # symbols from those can be found here. This is needed when the # *_winlibs that we want to link to are static mingw64 libraries. - extra_link_args += compiler.get_option_link_args(self.environment.coredata.compiler_options[compiler.for_machine]) + extra_link_args += compiler.get_option_link_args( + self.environment.coredata.compiler_options[compiler.for_machine][comp.language]) (additional_libpaths, additional_links, extra_link_args) = self.split_link_args(extra_link_args.to_native()) # Add more libraries to be linked if needed diff --git a/mesonbuild/build.py b/mesonbuild/build.py index b1bf9d4..c200261 100644 --- a/mesonbuild/build.py +++ b/mesonbuild/build.py @@ -13,7 +13,7 @@ # limitations under the License. import copy, os, re -from collections import OrderedDict +from collections import OrderedDict, defaultdict import itertools, pathlib import hashlib import pickle @@ -28,7 +28,10 @@ from .mesonlib import ( extract_as_list, typeslistify, stringlistify, classify_unity_sources, get_filenames_templates_dict, substitute_values, has_path_sep, unholder ) -from .compilers import Compiler, is_object, clink_langs, sort_clink, lang_suffixes, is_known_suffix +from .compilers import ( + Compiler, all_languages, is_object, clink_langs, sort_clink, lang_suffixes, + is_known_suffix +) from .linkers import StaticLinker from .interpreterbase import FeatureNew @@ -358,7 +361,8 @@ a hard error in the future.'''.format(name)) self.for_machine = for_machine self.install = False self.build_always_stale = False - self.option_overrides = {} + self.option_overrides_base = {} + self.option_overrides_compiler = defaultdict(dict) if not hasattr(self, 'typename'): raise RuntimeError('Target type is not set for target class "{}". This is a bug'.format(type(self).__name__)) @@ -448,7 +452,15 @@ a hard error in the future.'''.format(name)) # set, use the value of 'install' if it's enabled. self.build_by_default = True - self.option_overrides = self.parse_overrides(kwargs) + option_overrides = self.parse_overrides(kwargs) + + for k, v in option_overrides.items(): + if '_' in k: + lang, k2 = k.split('_', 1) + if lang in all_languages: + self.option_overrides_compiler[lang][k2] = v + continue + self.option_overrides_base[k] = v def parse_overrides(self, kwargs) -> dict: result = {} diff --git a/mesonbuild/compilers/c.py b/mesonbuild/compilers/c.py index eba7131..1bc9e84 100644 --- a/mesonbuild/compilers/c.py +++ b/mesonbuild/compilers/c.py @@ -107,25 +107,32 @@ class ClangCCompiler(ClangCompiler, CCompiler): if version_compare(self.version, self._C18_VERSION): c_stds += ['c18'] g_stds += ['gnu18'] - opts.update({'c_std': coredata.UserComboOption('C language standard to use', - ['none'] + c_stds + g_stds, - 'none')}) + opts.update({ + 'std': coredata.UserComboOption( + 'C language standard to use', + ['none'] + c_stds + g_stds, + 'none', + ), + }) if self.info.is_windows() or self.info.is_cygwin(): opts.update({ - 'c_winlibs': coredata.UserArrayOption('Standard Win libraries to link against', - gnu_winlibs), }) + 'winlibs': coredata.UserArrayOption( + 'Standard Win libraries to link against', + gnu_winlibs, + ), + }) return opts def get_option_compile_args(self, options): args = [] - std = options['c_std'] + std = options['std'] if std.value != 'none': args.append('-std=' + std.value) return args def get_option_link_args(self, options): if self.info.is_windows() or self.info.is_cygwin(): - return options['c_winlibs'].value[:] + return options['winlibs'].value[:] return [] @@ -166,15 +173,18 @@ class ArmclangCCompiler(ArmclangCompiler, CCompiler): def get_options(self): opts = CCompiler.get_options(self) - opts.update({'c_std': coredata.UserComboOption('C language standard to use', - ['none', 'c90', 'c99', 'c11', - 'gnu90', 'gnu99', 'gnu11'], - 'none')}) + opts.update({ + 'std': coredata.UserComboOption( + 'C language standard to use', + ['none', 'c90', 'c99', 'c11', 'gnu90', 'gnu99', 'gnu11'], + 'none', + ), + }) return opts def get_option_compile_args(self, options): args = [] - std = options['c_std'] + std = options['std'] if std.value != 'none': args.append('-std=' + std.value) return args @@ -204,25 +214,32 @@ class GnuCCompiler(GnuCompiler, CCompiler): if version_compare(self.version, v): c_stds += ['c17', 'c18'] g_stds += ['gnu17', 'gnu18'] - opts.update({'c_std': coredata.UserComboOption('C language standard to use', - ['none'] + c_stds + g_stds, - 'none')}) + opts.update({ + 'std': coredata.UserComboOption( + 'C language standard to use', + ['none'] + c_stds + g_stds, + 'none', + ), + }) if self.info.is_windows() or self.info.is_cygwin(): opts.update({ - 'c_winlibs': coredata.UserArrayOption('Standard Win libraries to link against', - gnu_winlibs), }) + 'winlibs': coredata.UserArrayOption( + 'Standard Win libraries to link against', + gnu_winlibs, + ), + }) return opts def get_option_compile_args(self, options): args = [] - std = options['c_std'] + std = options['std'] if std.value != 'none': args.append('-std=' + std.value) return args def get_option_link_args(self, options): if self.info.is_windows() or self.info.is_cygwin(): - return options['c_winlibs'].value[:] + return options['winlibs'].value[:] return [] def get_pch_use_args(self, pch_dir, header): @@ -248,11 +265,17 @@ class ElbrusCCompiler(GnuCCompiler, ElbrusCompiler): # It does support some various ISO standards and c/gnu 90, 9x, 1x in addition to those which GNU CC supports. def get_options(self): opts = CCompiler.get_options(self) - opts.update({'c_std': coredata.UserComboOption('C language standard to use', - ['none', 'c89', 'c90', 'c9x', 'c99', 'c1x', 'c11', - 'gnu89', 'gnu90', 'gnu9x', 'gnu99', 'gnu1x', 'gnu11', - 'iso9899:2011', 'iso9899:1990', 'iso9899:199409', 'iso9899:1999'], - 'none')}) + opts.update({ + 'std': coredata.UserComboOption( + 'C language standard to use', + [ + 'none', 'c89', 'c90', 'c9x', 'c99', 'c1x', 'c11', + 'gnu89', 'gnu90', 'gnu9x', 'gnu99', 'gnu1x', 'gnu11', + 'iso9899:2011', 'iso9899:1990', 'iso9899:199409', 'iso9899:1999', + ], + 'none', + ), + }) return opts # Elbrus C compiler does not have lchmod, but there is only linker warning, not compiler error. @@ -285,14 +308,18 @@ class IntelCCompiler(IntelGnuLikeCompiler, CCompiler): g_stds = ['gnu89', 'gnu99'] if version_compare(self.version, '>=16.0.0'): c_stds += ['c11'] - opts.update({'c_std': coredata.UserComboOption('C language standard to use', - ['none'] + c_stds + g_stds, - 'none')}) + opts.update({ + 'std': coredata.UserComboOption( + 'C language standard to use', + ['none'] + c_stds + g_stds, + 'none', + ), + }) return opts def get_option_compile_args(self, options): args = [] - std = options['c_std'] + std = options['std'] if std.value != 'none': args.append('-std=' + std.value) return args @@ -304,12 +331,16 @@ class VisualStudioLikeCCompilerMixin: def get_options(self): opts = super().get_options() - opts.update({'c_winlibs': coredata.UserArrayOption('Windows libs to link against.', - msvc_winlibs)}) + opts.update({ + 'winlibs': coredata.UserArrayOption( + 'Windows libs to link against.', + msvc_winlibs, + ), + }) return opts def get_option_link_args(self, options): - return options['c_winlibs'].value[:] + return options['winlibs'].value[:] class VisualStudioCCompiler(MSVCCompiler, VisualStudioLikeCCompilerMixin, CCompiler): @@ -343,14 +374,18 @@ class IntelClCCompiler(IntelVisualStudioLikeCompiler, VisualStudioLikeCCompilerM def get_options(self): opts = super().get_options() c_stds = ['none', 'c89', 'c99', 'c11'] - opts.update({'c_std': coredata.UserComboOption('C language standard to use', - c_stds, - 'none')}) + opts.update({ + 'std': coredata.UserComboOption( + 'C language standard to use', + c_stds, + 'none', + ), + }) return opts def get_option_compile_args(self, options): args = [] - std = options['c_std'] + std = options['std'] if std.value == 'c89': mlog.warning("ICL doesn't explicitly implement c89, setting the standard to 'none', which is close.", once=True) elif std.value != 'none': @@ -367,14 +402,18 @@ class ArmCCompiler(ArmCompiler, CCompiler): def get_options(self): opts = CCompiler.get_options(self) - opts.update({'c_std': coredata.UserComboOption('C language standard to use', - ['none', 'c90', 'c99'], - 'none')}) + opts.update({ + 'std': coredata.UserComboOption( + 'C language standard to use', + ['none', 'c90', 'c99'], + 'none', + ), + }) return opts def get_option_compile_args(self, options): args = [] - std = options['c_std'] + std = options['std'] if std.value != 'none': args.append('--' + std.value) return args @@ -393,9 +432,13 @@ class CcrxCCompiler(CcrxCompiler, CCompiler): def get_options(self): opts = CCompiler.get_options(self) - opts.update({'c_std': coredata.UserComboOption('C language standard to use', - ['none', 'c89', 'c99'], - 'none')}) + opts.update({ + 'std': coredata.UserComboOption( + 'C language standard to use', + ['none', 'c89', 'c99'], + 'none', + ), + }) return opts def get_no_stdinc_args(self): @@ -403,7 +446,7 @@ class CcrxCCompiler(CcrxCompiler, CCompiler): def get_option_compile_args(self, options): args = [] - std = options['c_std'] + std = options['std'] if std.value == 'c89': args.append('-lang=c') elif std.value == 'c99': diff --git a/mesonbuild/compilers/compilers.py b/mesonbuild/compilers/compilers.py index 52b9592..3d3a503 100644 --- a/mesonbuild/compilers/compilers.py +++ b/mesonbuild/compilers/compilers.py @@ -1272,10 +1272,10 @@ def get_global_options(lang: str, """Retreive options that apply to all compilers for a given language.""" description = 'Extra arguments passed to the {}'.format(lang) opts = { - lang + '_args': coredata.UserArrayOption( + 'args': coredata.UserArrayOption( description + ' compiler', [], split_args=True, user_input=True, allow_dups=True), - lang + '_link_args': coredata.UserArrayOption( + 'link_args': coredata.UserArrayOption( description + ' linker', [], split_args=True, user_input=True, allow_dups=True), } @@ -1288,12 +1288,13 @@ def get_global_options(lang: str, comp.INVOKES_LINKER) for k, o in opts.items(): - if k in properties: + user_k = lang + '_' + k + if user_k in properties: # Get from configuration files. - o.set_value(properties[k]) - elif k == lang + '_args': + o.set_value(properties[user_k]) + elif k == 'args': o.set_value(compile_args) - elif k == lang + '_link_args': + elif k == 'link_args': o.set_value(link_args) return opts diff --git a/mesonbuild/compilers/cpp.py b/mesonbuild/compilers/cpp.py index 9894cd3..d30017f 100644 --- a/mesonbuild/compilers/cpp.py +++ b/mesonbuild/compilers/cpp.py @@ -167,36 +167,45 @@ class ClangCPPCompiler(ClangCompiler, CPPCompiler): def get_options(self): opts = CPPCompiler.get_options(self) - opts.update({'cpp_eh': coredata.UserComboOption('C++ exception handling type.', - ['none', 'default', 'a', 's', 'sc'], - 'default'), - 'cpp_rtti': coredata.UserBooleanOption('Enable RTTI', True), - 'cpp_std': coredata.UserComboOption('C++ language standard to use', - ['none', 'c++98', 'c++03', 'c++11', 'c++14', 'c++17', 'c++1z', 'c++2a', - 'gnu++11', 'gnu++14', 'gnu++17', 'gnu++1z', 'gnu++2a'], - 'none')}) + opts.update({ + 'eh': coredata.UserComboOption( + 'C++ exception handling type.', + ['none', 'default', 'a', 's', 'sc'], + 'default', + ), + 'rtti': coredata.UserBooleanOption('Enable RTTI', True), + 'std': coredata.UserComboOption( + 'C++ language standard to use', + ['none', 'c++98', 'c++03', 'c++11', 'c++14', 'c++17', 'c++1z', 'c++2a', + 'gnu++11', 'gnu++14', 'gnu++17', 'gnu++1z', 'gnu++2a'], + 'none', + ), + }) if self.info.is_windows() or self.info.is_cygwin(): opts.update({ - 'cpp_winlibs': coredata.UserArrayOption('Standard Win libraries to link against', - gnu_winlibs), }) + 'winlibs': coredata.UserArrayOption( + 'Standard Win libraries to link against', + gnu_winlibs, + ), + }) return opts def get_option_compile_args(self, options): args = [] - std = options['cpp_std'] + std = options['std'] if std.value != 'none': args.append(self._find_best_cpp_std(std.value)) - non_msvc_eh_options(options['cpp_eh'].value, args) + non_msvc_eh_options(options['eh'].value, args) - if not options['cpp_rtti'].value: + if not options['rtti'].value: args.append('-fno-rtti') return args def get_option_link_args(self, options): if self.info.is_windows() or self.info.is_cygwin(): - return options['cpp_winlibs'].value[:] + return options['winlibs'].value[:] return [] def language_stdlib_only_link_flags(self): @@ -220,7 +229,7 @@ class EmscriptenCPPCompiler(EmscriptenMixin, LinkerEnvVarsMixin, ClangCPPCompile def get_option_compile_args(self, options): args = [] - std = options['cpp_std'] + std = options['std'] if std.value != 'none': args.append(self._find_best_cpp_std(std.value)) return args @@ -239,22 +248,30 @@ class ArmclangCPPCompiler(ArmclangCompiler, CPPCompiler): def get_options(self): opts = CPPCompiler.get_options(self) - opts.update({'cpp_eh': coredata.UserComboOption('C++ exception handling type.', - ['none', 'default', 'a', 's', 'sc'], - 'default'), - 'cpp_std': coredata.UserComboOption('C++ language standard to use', - ['none', 'c++98', 'c++03', 'c++11', 'c++14', 'c++17', - 'gnu++98', 'gnu++03', 'gnu++11', 'gnu++14', 'gnu++17'], - 'none')}) + opts.update({ + 'eh': coredata.UserComboOption( + 'C++ exception handling type.', + ['none', 'default', 'a', 's', 'sc'], + 'default', + ), + 'std': coredata.UserComboOption( + 'C++ language standard to use', + [ + 'none', 'c++98', 'c++03', 'c++11', 'c++14', 'c++17', + 'gnu++98', 'gnu++03', 'gnu++11', 'gnu++14', 'gnu++17', + ], + 'none', + ), + }) return opts def get_option_compile_args(self, options): args = [] - std = options['cpp_std'] + std = options['std'] if std.value != 'none': args.append('-std=' + std.value) - non_msvc_eh_options(options['cpp_eh'].value, args) + non_msvc_eh_options(options['eh'].value, args) return args @@ -275,40 +292,51 @@ class GnuCPPCompiler(GnuCompiler, CPPCompiler): def get_options(self): opts = CPPCompiler.get_options(self) - opts.update({'cpp_eh': coredata.UserComboOption('C++ exception handling type.', - ['none', 'default', 'a', 's', 'sc'], - 'default'), - 'cpp_rtti': coredata.UserBooleanOption('Enable RTTI', True), - 'cpp_std': coredata.UserComboOption('C++ language standard to use', - ['none', 'c++98', 'c++03', 'c++11', 'c++14', 'c++17', 'c++1z', 'c++2a', - 'gnu++03', 'gnu++11', 'gnu++14', 'gnu++17', 'gnu++1z', 'gnu++2a'], - 'none'), - 'cpp_debugstl': coredata.UserBooleanOption('STL debug mode', - False)}) + opts.update({ + 'eh': coredata.UserComboOption( + 'C++ exception handling type.', + ['none', 'default', 'a', 's', 'sc'], + 'default', + ), + 'rtti': coredata.UserBooleanOption('Enable RTTI', True), + 'std': coredata.UserComboOption( + 'C++ language standard to use', + ['none', 'c++98', 'c++03', 'c++11', 'c++14', 'c++17', 'c++1z', 'c++2a', + 'gnu++03', 'gnu++11', 'gnu++14', 'gnu++17', 'gnu++1z', 'gnu++2a'], + 'none', + ), + 'debugstl': coredata.UserBooleanOption( + 'STL debug mode', + False, + ) + }) if self.info.is_windows() or self.info.is_cygwin(): opts.update({ - 'cpp_winlibs': coredata.UserArrayOption('Standard Win libraries to link against', - gnu_winlibs), }) + 'winlibs': coredata.UserArrayOption( + 'Standard Win libraries to link against', + gnu_winlibs, + ), + }) return opts def get_option_compile_args(self, options): args = [] - std = options['cpp_std'] + std = options['std'] if std.value != 'none': args.append(self._find_best_cpp_std(std.value)) - non_msvc_eh_options(options['cpp_eh'].value, args) + non_msvc_eh_options(options['eh'].value, args) - if not options['cpp_rtti'].value: + if not options['rtti'].value: args.append('-fno-rtti') - if options['cpp_debugstl'].value: + if options['debugstl'].value: args.append('-D_GLIBCXX_DEBUG=1') return args def get_option_link_args(self, options): if self.info.is_windows() or self.info.is_cygwin(): - return options['cpp_winlibs'].value[:] + return options['winlibs'].value[:] return [] def get_pch_use_args(self, pch_dir, header): @@ -337,15 +365,25 @@ class ElbrusCPPCompiler(GnuCPPCompiler, ElbrusCompiler): # It does not support c++/gnu++ 17 and 1z, but still does support 0x, 1y, and gnu++98. def get_options(self): opts = CPPCompiler.get_options(self) - opts.update({'cpp_eh': coredata.UserComboOption('C++ exception handling type.', - ['none', 'default', 'a', 's', 'sc'], - 'default'), - 'cpp_std': coredata.UserComboOption('C++ language standard to use', - ['none', 'c++98', 'c++03', 'c++0x', 'c++11', 'c++14', 'c++1y', - 'gnu++98', 'gnu++03', 'gnu++0x', 'gnu++11', 'gnu++14', 'gnu++1y'], - 'none'), - 'cpp_debugstl': coredata.UserBooleanOption('STL debug mode', - False)}) + opts.update({ + 'eh': coredata.UserComboOption( + 'C++ exception handling type.', + ['none', 'default', 'a', 's', 'sc'], + 'default', + ), + 'std': coredata.UserComboOption( + 'C++ language standard to use', + [ + 'none', 'c++98', 'c++03', 'c++0x', 'c++11', 'c++14', 'c++1y', + 'gnu++98', 'gnu++03', 'gnu++0x', 'gnu++11', 'gnu++14', 'gnu++1y', + ], + 'none', + ), + 'debugstl': coredata.UserBooleanOption( + 'STL debug mode', + False, + ), + }) return opts # Elbrus C++ compiler does not have lchmod, but there is only linker warning, not compiler error. @@ -361,13 +399,13 @@ class ElbrusCPPCompiler(GnuCPPCompiler, ElbrusCompiler): # Elbrus C++ compiler does not support RTTI, so don't check for it. def get_option_compile_args(self, options): args = [] - std = options['cpp_std'] + std = options['std'] if std.value != 'none': args.append(self._find_best_cpp_std(std.value)) - non_msvc_eh_options(options['cpp_eh'].value, args) + non_msvc_eh_options(options['eh'].value, args) - if options['cpp_debugstl'].value: + if options['debugstl'].value: args.append('-D_GLIBCXX_DEBUG=1') return args @@ -400,31 +438,36 @@ class IntelCPPCompiler(IntelGnuLikeCompiler, CPPCompiler): c_stds += ['c++17'] if version_compare(self.version, '>=17.0.0'): g_stds += ['gnu++14'] - opts.update({'cpp_eh': coredata.UserComboOption('C++ exception handling type.', - ['none', 'default', 'a', 's', 'sc'], - 'default'), - 'cpp_rtti': coredata.UserBooleanOption('Enable RTTI', True), - 'cpp_std': coredata.UserComboOption('C++ language standard to use', - ['none'] + c_stds + g_stds, - 'none'), - 'cpp_debugstl': coredata.UserBooleanOption('STL debug mode', - False)}) + opts.update({ + 'eh': coredata.UserComboOption( + 'C++ exception handling type.', + ['none', 'default', 'a', 's', 'sc'], + 'default', + ), + 'rtti': coredata.UserBooleanOption('Enable RTTI', True), + 'std': coredata.UserComboOption( + 'C++ language standard to use', + ['none'] + c_stds + g_stds, + 'none', + ), + 'debugstl': coredata.UserBooleanOption('STL debug mode', False), + }) return opts def get_option_compile_args(self, options): args = [] - std = options['cpp_std'] + std = options['std'] if std.value != 'none': remap_cpp03 = { 'c++03': 'c++98', 'gnu++03': 'gnu++98' } args.append('-std=' + remap_cpp03.get(std.value, std.value)) - if options['cpp_eh'].value == 'none': + if options['eh'].value == 'none': args.append('-fno-exceptions') - if not options['cpp_rtti'].value: + if not options['rtti'].value: args.append('-fno-rtti') - if options['cpp_debugstl'].value: + if options['debugstl'].value: args.append('-D_GLIBCXX_DEBUG=1') return args @@ -449,24 +492,32 @@ class VisualStudioLikeCPPCompilerMixin: } def get_option_link_args(self, options): - return options['cpp_winlibs'].value[:] + return options['winlibs'].value[:] def _get_options_impl(self, opts, cpp_stds: T.List[str]): - opts.update({'cpp_eh': coredata.UserComboOption('C++ exception handling type.', - ['none', 'default', 'a', 's', 'sc'], - 'default'), - 'cpp_rtti': coredata.UserBooleanOption('Enable RTTI', True), - 'cpp_std': coredata.UserComboOption('C++ language standard to use', - cpp_stds, - 'none'), - 'cpp_winlibs': coredata.UserArrayOption('Windows libs to link against.', - msvc_winlibs)}) + opts.update({ + 'eh': coredata.UserComboOption( + 'C++ exception handling type.', + ['none', 'default', 'a', 's', 'sc'], + 'default', + ), + 'rtti': coredata.UserBooleanOption('Enable RTTI', True), + 'std': coredata.UserComboOption( + 'C++ language standard to use', + cpp_stds, + 'none', + ), + 'winlibs': coredata.UserArrayOption( + 'Windows libs to link against.', + msvc_winlibs, + ), + }) return opts def get_option_compile_args(self, options): args = [] - eh = options['cpp_eh'] + eh = options['eh'] if eh.value == 'default': args.append('/EHsc') elif eh.value == 'none': @@ -474,10 +525,10 @@ class VisualStudioLikeCPPCompilerMixin: else: args.append('/EH' + eh.value) - if not options['cpp_rtti'].value: + if not options['rtti'].value: args.append('/GR-') - permissive, ver = self.VC_VERSION_MAP[options['cpp_std'].value] + permissive, ver = self.VC_VERSION_MAP[options['std'].value] if ver is not None: args.append('/std:c++{}'.format(ver)) @@ -504,17 +555,17 @@ class CPP11AsCPP14Mixin: # which means setting the C++ standard version to C++14, in compilers that support it # (i.e., after VS2015U3) # if one is using anything before that point, one cannot set the standard. - if options['cpp_std'].value in {'vc++11', 'c++11'}: + if options['std'].value in {'vc++11', 'c++11'}: mlog.warning(self.id, 'does not support C++11;', 'attempting best effort; setting the standard to C++14', once=True) # Don't mutate anything we're going to change, we need to use # deepcopy since we're messing with members, and we can't simply # copy the members because the option proxy doesn't support it. options = copy.deepcopy(options) - if options['cpp_std'].value == 'vc++11': - options['cpp_std'].value = 'vc++14' + if options['std'].value == 'vc++11': + options['std'].value = 'vc++14' else: - options['cpp_std'].value = 'c++14' + options['std'].value = 'c++14' return super().get_option_compile_args(options) @@ -537,10 +588,10 @@ class VisualStudioCPPCompiler(CPP11AsCPP14Mixin, VisualStudioLikeCPPCompilerMixi return self._get_options_impl(super().get_options(), cpp_stds) def get_option_compile_args(self, options): - if options['cpp_std'].value != 'none' and version_compare(self.version, '<19.00.24210'): + if options['std'].value != 'none' and version_compare(self.version, '<19.00.24210'): mlog.warning('This version of MSVC does not support cpp_std arguments') options = copy.copy(options) - options['cpp_std'].value = 'none' + options['std'].value = 'none' args = super().get_option_compile_args(options) @@ -588,14 +639,18 @@ class ArmCPPCompiler(ArmCompiler, CPPCompiler): def get_options(self): opts = CPPCompiler.get_options(self) - opts.update({'cpp_std': coredata.UserComboOption('C++ language standard to use', - ['none', 'c++03', 'c++11'], - 'none')}) + opts.update({ + 'std': coredata.UserComboOption( + 'C++ language standard to use', + ['none', 'c++03', 'c++11'], + 'none', + ), + }) return opts def get_option_compile_args(self, options): args = [] - std = options['cpp_std'] + std = options['std'] if std.value == 'c++11': args.append('--cpp11') elif std.value == 'c++03': diff --git a/mesonbuild/compilers/fortran.py b/mesonbuild/compilers/fortran.py index 16a93f5..01283a1 100644 --- a/mesonbuild/compilers/fortran.py +++ b/mesonbuild/compilers/fortran.py @@ -186,14 +186,18 @@ class GnuFortranCompiler(GnuCompiler, FortranCompiler): fortran_stds += ['f2008'] if version_compare(self.version, '>=8.0.0'): fortran_stds += ['f2018'] - opts.update({'fortran_std': coredata.UserComboOption('Fortran language standard to use', - ['none'] + fortran_stds, - 'none')}) + opts.update({ + 'std': coredata.UserComboOption( + 'Fortran language standard to use', + ['none'] + fortran_stds, + 'none', + ), + }) return opts def get_option_compile_args(self, options) -> T.List[str]: args = [] - std = options['fortran_std'] + std = options['std'] if std.value != 'none': args.append('-std=' + std.value) return args @@ -292,14 +296,18 @@ class IntelFortranCompiler(IntelGnuLikeCompiler, FortranCompiler): def get_options(self): opts = FortranCompiler.get_options(self) fortran_stds = ['legacy', 'f95', 'f2003', 'f2008', 'f2018'] - opts.update({'fortran_std': coredata.UserComboOption('Fortran language standard to use', - ['none'] + fortran_stds, - 'none')}) + opts.update({ + 'std': coredata.UserComboOption( + 'Fortran language standard to use', + ['none'] + fortran_stds, + 'none', + ), + }) return opts def get_option_compile_args(self, options) -> T.List[str]: args = [] - std = options['fortran_std'] + std = options['std'] stds = {'legacy': 'none', 'f95': 'f95', 'f2003': 'f03', 'f2008': 'f08', 'f2018': 'f18'} if std.value != 'none': args.append('-stand=' + stds[std.value]) @@ -342,14 +350,18 @@ class IntelClFortranCompiler(IntelVisualStudioLikeCompiler, FortranCompiler): def get_options(self): opts = FortranCompiler.get_options(self) fortran_stds = ['legacy', 'f95', 'f2003', 'f2008', 'f2018'] - opts.update({'fortran_std': coredata.UserComboOption('Fortran language standard to use', - ['none'] + fortran_stds, - 'none')}) + opts.update({ + 'std': coredata.UserComboOption( + 'Fortran language standard to use', + ['none'] + fortran_stds, + 'none', + ), + }) return opts def get_option_compile_args(self, options) -> T.List[str]: args = [] - std = options['fortran_std'] + std = options['std'] stds = {'legacy': 'none', 'f95': 'f95', 'f2003': 'f03', 'f2008': 'f08', 'f2018': 'f18'} if std.value != 'none': args.append('/stand:' + stds[std.value]) diff --git a/mesonbuild/coredata.py b/mesonbuild/coredata.py index e71d674..0b79084 100644 --- a/mesonbuild/coredata.py +++ b/mesonbuild/coredata.py @@ -17,7 +17,7 @@ import pickle, os, uuid import sys from itertools import chain from pathlib import PurePath -from collections import OrderedDict +from collections import OrderedDict, defaultdict from .mesonlib import ( MesonException, MachineChoice, PerMachine, OrderedSet, default_libdir, default_libexecdir, default_prefix, split_args @@ -370,7 +370,10 @@ class CoreData: self.builtins_per_machine = PerMachine({}, {}) self.backend_options = {} # : OptionDictType self.user_options = {} # : OptionDictType - self.compiler_options = PerMachine({}, {}) + self.compiler_options = PerMachine( + defaultdict(dict), + defaultdict(dict), + ) # : PerMachine[T.defaultdict[str, OptionDictType]] self.base_options = {} # : OptionDictType self.cross_files = self.__load_config_files(options, scratch_dir, 'cross') self.compilers = PerMachine(OrderedDict(), OrderedDict()) @@ -614,28 +617,42 @@ class CoreData: mode = 'custom' self.builtins['buildtype'].set_value(mode) - @staticmethod + @classmethod def get_prefixed_options_per_machine( + cls, options_per_machine # : PerMachine[T.Dict[str, _V]]] - ) -> T.Iterable[T.Dict[str, _V]]: - for for_machine in iter(MachineChoice): - prefix = for_machine.get_prefix() - yield { - prefix + k: v - for k, v in options_per_machine[for_machine].items() - } + ) -> T.Iterable[T.Tuple[str, _V]]: + return cls._flatten_pair_iterator( + (for_machine.get_prefix(), options_per_machine[for_machine]) + for for_machine in iter(MachineChoice) + ) + + @classmethod + def flatten_lang_iterator( + cls, + outer # : T.Iterable[T.Tuple[str, T.Dict[str, _V]]] + ) -> T.Iterable[T.Tuple[str, _V]]: + return cls._flatten_pair_iterator((lang + '_', opts) for lang, opts in outer) + + @staticmethod + def _flatten_pair_iterator( + outer # : T.Iterable[T.Tuple[str, T.Dict[str, _V]]] + ) -> T.Iterable[T.Tuple[str, _V]]: + for k0, v0 in outer: + for k1, v1 in v0.items(): + yield (k0 + k1, v1) def _get_all_nonbuiltin_options(self) -> T.Iterable[T.Dict[str, UserOption]]: yield self.backend_options yield self.user_options - yield from self.get_prefixed_options_per_machine(self.compiler_options) + yield dict(self.flatten_lang_iterator(self.get_prefixed_options_per_machine(self.compiler_options))) yield self.base_options - def _get_all_builtin_options(self) -> T.Dict[str, UserOption]: - yield from self.get_prefixed_options_per_machine(self.builtins_per_machine) + def _get_all_builtin_options(self) -> T.Iterable[T.Dict[str, UserOption]]: + yield dict(self.get_prefixed_options_per_machine(self.builtins_per_machine)) yield self.builtins - def get_all_options(self) -> T.Dict[str, UserOption]: + def get_all_options(self) -> T.Iterable[T.Dict[str, UserOption]]: yield from self._get_all_nonbuiltin_options() yield from self._get_all_builtin_options() @@ -651,10 +668,10 @@ class CoreData: raise MesonException('Tried to validate unknown option %s.' % option_name) def get_external_args(self, for_machine: MachineChoice, lang): - return self.compiler_options[for_machine][lang + '_args'].value + return self.compiler_options[for_machine][lang]['args'].value def get_external_link_args(self, for_machine: MachineChoice, lang): - return self.compiler_options[for_machine][lang + '_link_args'].value + return self.compiler_options[for_machine][lang]['link_args'].value def merge_user_options(self, options): for (name, value) in options.items(): @@ -680,9 +697,11 @@ class CoreData: assert(not self.is_cross_build()) for k, o in self.builtins_per_machine.host.items(): self.builtins_per_machine.build[k].set_value(o.value) - for k, o in self.compiler_options.host.items(): - if k in self.compiler_options.build: - self.compiler_options.build[k].set_value(o.value) + for lang, host_opts in self.compiler_options.host.items(): + build_opts = self.compiler_options.build[lang] + for k, o in host_opts.items(): + if k in build_opts: + build_opts[k].set_value(o.value) def set_options(self, options, *, subproject='', warn_unknown=True): if not self.is_cross_build(): @@ -783,13 +802,17 @@ class CoreData: 'path instead.' ) + def remove_prefix(text, prefix): + if text.startswith(prefix): + return text[len(prefix):] + return text + for k, v in env.cmd_line_options.items(): if subproject: if not k.startswith(subproject + ':'): continue elif k not in builtin_options.keys() \ - and 'build.' + k not in builtin_options_per_machine.keys() \ - and k not in builtin_options_per_machine.keys(): + and remove_prefix(k, 'build.') not in builtin_options_per_machine.keys(): if ':' in k: continue if optinterpreter.is_invalid_name(k, log=False): @@ -803,20 +826,18 @@ class CoreData: """Add global language arguments that are needed before compiler/linker detection.""" from .compilers import compilers - optprefix = lang + '_' for k, o in compilers.get_global_options( lang, comp, for_machine, env.is_cross_build(), env.properties[for_machine]).items(): - if not k.startswith(optprefix): - raise MesonException('Internal error, %s has incorrect prefix.' % k) # prefixed compiler options affect just this machine opt_prefix = for_machine.get_prefix() - if opt_prefix + k in env.cmd_line_options: - o.set_value(env.cmd_line_options[opt_prefix + k]) - self.compiler_options[for_machine].setdefault(k, o) + user_k = opt_prefix + lang + '_' + k + if user_k in env.cmd_line_options: + o.set_value(env.cmd_line_options[user_k]) + self.compiler_options[for_machine][lang].setdefault(k, o) def process_new_compiler(self, lang: str, comp: T.Type['Compiler'], env: 'Environment') -> None: from . import compilers @@ -824,15 +845,13 @@ class CoreData: self.compilers[comp.for_machine][lang] = comp enabled_opts = [] - optprefix = lang + '_' for k, o in comp.get_options().items(): - if not k.startswith(optprefix): - raise MesonException('Internal error, %s has incorrect prefix.' % k) # prefixed compiler options affect just this machine opt_prefix = comp.for_machine.get_prefix() - if opt_prefix + k in env.cmd_line_options: - o.set_value(env.cmd_line_options[opt_prefix + k]) - self.compiler_options[comp.for_machine].setdefault(k, o) + user_k = opt_prefix + lang + '_' + k + if user_k in env.cmd_line_options: + o.set_value(env.cmd_line_options[user_k]) + self.compiler_options[comp.for_machine][lang].setdefault(k, o) enabled_opts = [] for optname in comp.base_options: diff --git a/mesonbuild/environment.py b/mesonbuild/environment.py index 11bc76c..c571141 100644 --- a/mesonbuild/environment.py +++ b/mesonbuild/environment.py @@ -771,7 +771,7 @@ class Environment: elif isinstance(comp_class.LINKER_PREFIX, list): check_args = comp_class.LINKER_PREFIX + ['/logo'] + comp_class.LINKER_PREFIX + ['--version'] - check_args += self.coredata.compiler_options[for_machine][comp_class.language + '_args'].value + check_args += self.coredata.compiler_options[for_machine][comp_class.language]['args'].value override = [] # type: T.List[str] value = self.lookup_binary_entry(for_machine, comp_class.language + '_ld') @@ -833,7 +833,7 @@ class Environment: """ self.coredata.add_lang_args(comp_class.language, comp_class, for_machine, self) extra_args = T.cast(T.List[str], extra_args or []) - extra_args += self.coredata.compiler_options[for_machine][comp_class.language + '_args'].value + extra_args += self.coredata.compiler_options[for_machine][comp_class.language]['args'].value if isinstance(comp_class.LINKER_PREFIX, str): check_args = [comp_class.LINKER_PREFIX + '--version'] + extra_args diff --git a/mesonbuild/interpreter.py b/mesonbuild/interpreter.py index 214b1eb..48b6bd6 100644 --- a/mesonbuild/interpreter.py +++ b/mesonbuild/interpreter.py @@ -42,7 +42,6 @@ import re import shlex import subprocess import collections -from itertools import chain import functools import typing as T @@ -1112,7 +1111,7 @@ class CompilerHolder(InterpreterObject): args += self.compiler.get_include_args(idir, False) if not nobuiltins: for_machine = Interpreter.machine_from_native_kwarg(kwargs) - opts = self.environment.coredata.compiler_options[for_machine] + opts = self.environment.coredata.compiler_options[for_machine][self.compiler.language] args += self.compiler.get_option_compile_args(opts) if mode == 'link': args += self.compiler.get_option_link_args(opts) @@ -2800,11 +2799,12 @@ external dependencies (including libraries) must go to "dependencies".''') if self.is_subproject(): optname = self.subproject + ':' + optname - for opts in chain( - [self.coredata.base_options, compilers.base_options, self.coredata.builtins], - self.coredata.get_prefixed_options_per_machine(self.coredata.builtins_per_machine), - self.coredata.get_prefixed_options_per_machine(self.coredata.compiler_options), - ): + for opts in [ + self.coredata.base_options, compilers.base_options, self.coredata.builtins, + dict(self.coredata.get_prefixed_options_per_machine(self.coredata.builtins_per_machine)), + dict(self.coredata.flatten_lang_iterator( + self.coredata.get_prefixed_options_per_machine(self.coredata.compiler_options))), + ]: v = opts.get(optname) if v is None or v.yielding: v = opts.get(raw_optname) diff --git a/mesonbuild/mconf.py b/mesonbuild/mconf.py index cadc1f5..05e9518 100644 --- a/mesonbuild/mconf.py +++ b/mesonbuild/mconf.py @@ -97,9 +97,9 @@ class Conf: else: print('{0:{width[0]}} {1:{width[1]}} {3}'.format(*line, width=col_widths)) - def split_options_per_subproject(self, options): + def split_options_per_subproject(self, options_iter): result = {} - for k, o in options.items(): + for k, o in options_iter: subproject = '' if ':' in k: subproject, optname = k.split(':') @@ -211,10 +211,15 @@ class Conf: return 'build.' + k return k[:idx + 1] + 'build.' + k[idx + 1:] - core_options = self.split_options_per_subproject(core_options) - host_compiler_options = self.split_options_per_subproject(self.coredata.compiler_options.host) - build_compiler_options = self.split_options_per_subproject({insert_build_prefix(k): o for k, o in self.coredata.compiler_options.build.items()}) - project_options = self.split_options_per_subproject(self.coredata.user_options) + core_options = self.split_options_per_subproject(core_options.items()) + host_compiler_options = self.split_options_per_subproject( + self.coredata.flatten_lang_iterator( + self.coredata.compiler_options.host.items())) + build_compiler_options = self.split_options_per_subproject( + self.coredata.flatten_lang_iterator( + (insert_build_prefix(k), o) + for k, o in self.coredata.compiler_options.build.items())) + project_options = self.split_options_per_subproject(self.coredata.user_options.items()) show_build_options = self.default_values_only or self.build.environment.is_cross_build() self.add_section('Main project options') diff --git a/mesonbuild/mintro.py b/mesonbuild/mintro.py index 9278584..d5516d4 100644 --- a/mesonbuild/mintro.py +++ b/mesonbuild/mintro.py @@ -253,9 +253,16 @@ def list_buildoptions(coredata: cdata.CoreData, subprojects: T.Optional[T.List[s ) add_keys(coredata.backend_options, 'backend') add_keys(coredata.base_options, 'base') - add_keys(coredata.compiler_options.host, 'compiler', machine='host') add_keys( - {'build.' + k: o for k, o in coredata.compiler_options.build.items()}, + dict(coredata.flatten_lang_iterator(coredata.compiler_options.host.items())), + 'compiler', + machine='host', + ) + add_keys( + { + 'build.' + k: o for k, o in + coredata.flatten_lang_iterator(coredata.compiler_options.build.items()) + }, 'compiler', machine='build', ) diff --git a/mesonbuild/rewriter.py b/mesonbuild/rewriter.py index 785451f..7730ab6 100644 --- a/mesonbuild/rewriter.py +++ b/mesonbuild/rewriter.py @@ -469,8 +469,8 @@ class Rewriter: **{'build.' + k: o for k, o in cdata.builtins_per_machine.build.items()}, **cdata.backend_options, **cdata.base_options, - **cdata.compiler_options.host, - **{'build.' + k: o for k, o in cdata.compiler_options.build.items()}, + **(dict(cdata.flatten_lang_iterator(cdata.compiler_options.host.items()))), + **{'build.' + k: o for k, o in cdata.flatten_lang_iterator(cdata.compiler_options.build.items())}, **cdata.user_options, } |