Chiebot-Mirror
/
meson
mirror of https://github.com/mesonbuild/meson.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

Use enum instead of `int` for compiler variants

Browse Source 
* Enums are strongly typed and make the whole
  `gcc_type`/`clang_type`/`icc_type` distinction
  redundant.
* Enums also allow extending via member functions,
  which makes the code more generalisable.
pull/4181/merge
David Seifert 6 years ago committed by Jussi Pakkanen
parent 73b47e0025
commit 69ec001b06
10 changed files with 165 additions and 189 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 22
      mesonbuild/compilers/__init__.py
  2. 39
      mesonbuild/compilers/c.py
  3. 127
      mesonbuild/compilers/compilers.py
  4. 24
      mesonbuild/compilers/cpp.py
  5. 7
      mesonbuild/compilers/d.py
  6. 14
      mesonbuild/compilers/fortran.py
  7. 16
      mesonbuild/compilers/objc.py
  8. 16
      mesonbuild/compilers/objcpp.py
  9. 53
      mesonbuild/environment.py
  10. 26
      run_unittests.py

22
mesonbuild/compilers/__init__.py
Unescape View File

@ -14,16 +14,7 @@
# Public symbols for compilers sub-package when using 'from . import compilers' # Public symbols for compilers sub-package when using 'from . import compilers'
__all__ = [ __all__ = [
'CLANG_OSX', 'CompilerType',
'CLANG_STANDARD',
'CLANG_WIN',
'GCC_CYGWIN',
'GCC_MINGW',
'GCC_OSX',
'GCC_STANDARD',
'ICC_OSX',
'ICC_STANDARD',
'ICC_WIN',
'all_languages', 'all_languages',
'base_options', 'base_options',
@ -94,16 +85,7 @@ __all__ = [
# Bring symbols from each module into compilers sub-package namespace # Bring symbols from each module into compilers sub-package namespace
from .compilers import ( from .compilers import (
GCC_OSX, CompilerType,
GCC_MINGW,
GCC_CYGWIN,
GCC_STANDARD,
CLANG_OSX,
CLANG_WIN,
CLANG_STANDARD,
ICC_OSX,
ICC_WIN,
ICC_STANDARD,
all_languages, all_languages,
base_options, base_options,
clib_langs, clib_langs,

39
mesonbuild/compilers/c.py
Unescape View File

@ -30,7 +30,7 @@ from ..mesonlib import (
from .c_function_attributes import C_FUNC_ATTRIBUTES from .c_function_attributes import C_FUNC_ATTRIBUTES
from .compilers import ( from .compilers import (
GCC_MINGW, CompilerType,
get_largefile_args, get_largefile_args,
gnu_winlibs, gnu_winlibs,
msvc_winlibs, msvc_winlibs,
@ -121,7 +121,7 @@ class CCompiler(Compiler):
# The default behavior is this, override in MSVC # The default behavior is this, override in MSVC
@functools.lru_cache(maxsize=None) @functools.lru_cache(maxsize=None)
def build_rpath_args(self, build_dir, from_dir, rpath_paths, build_rpath, install_rpath): def build_rpath_args(self, build_dir, from_dir, rpath_paths, build_rpath, install_rpath):
if self.id == 'clang' and self.clang_type == compilers.CLANG_OSX: if self.id == 'clang' and self.compiler_type == CompilerType.CLANG_OSX:
return self.build_osx_rpath_args(build_dir, rpath_paths, build_rpath) return self.build_osx_rpath_args(build_dir, rpath_paths, build_rpath)
return self.build_unix_rpath_args(build_dir, from_dir, rpath_paths, build_rpath, install_rpath) return self.build_unix_rpath_args(build_dir, from_dir, rpath_paths, build_rpath, install_rpath)
@ -160,15 +160,8 @@ class CCompiler(Compiler):
''' '''
Get args for allowing undefined symbols when linking to a shared library Get args for allowing undefined symbols when linking to a shared library
''' '''
if self.id == 'clang': if self.id in ('clang', 'gcc'):
if self.clang_type == compilers.CLANG_OSX: if self.compiler_type.is_osx_compiler:
# Apple ld
return ['-Wl,-undefined,dynamic_lookup']
else:
# GNU ld and LLVM lld
return ['-Wl,--allow-shlib-undefined']
elif self.id == 'gcc':
if self.gcc_type == compilers.GCC_OSX:
# Apple ld # Apple ld
return ['-Wl,-undefined,dynamic_lookup'] return ['-Wl,-undefined,dynamic_lookup']
else: else:
@ -1064,9 +1057,9 @@ class CCompiler(Compiler):
class ClangCCompiler(ClangCompiler, CCompiler): class ClangCCompiler(ClangCompiler, CCompiler):
def __init__(self, exelist, version, clang_type, is_cross, exe_wrapper=None, **kwargs): def __init__(self, exelist, version, compiler_type, is_cross, exe_wrapper=None, **kwargs):
CCompiler.__init__(self, exelist, version, is_cross, exe_wrapper, **kwargs) CCompiler.__init__(self, exelist, version, is_cross, exe_wrapper, **kwargs)
ClangCompiler.__init__(self, clang_type) ClangCompiler.__init__(self, compiler_type)
default_warn_args = ['-Wall', '-Winvalid-pch'] default_warn_args = ['-Wall', '-Winvalid-pch']
self.warn_args = {'1': default_warn_args, self.warn_args = {'1': default_warn_args,
'2': default_warn_args + ['-Wextra'], '2': default_warn_args + ['-Wextra'],
@ -1092,7 +1085,7 @@ class ClangCCompiler(ClangCompiler, CCompiler):
def get_linker_always_args(self): def get_linker_always_args(self):
basic = super().get_linker_always_args() basic = super().get_linker_always_args()
if self.clang_type == compilers.CLANG_OSX: if self.compiler_type.is_osx_compiler:
return basic + ['-Wl,-headerpad_max_install_names'] return basic + ['-Wl,-headerpad_max_install_names']
return basic return basic
@ -1126,9 +1119,9 @@ class ArmclangCCompiler(ArmclangCompiler, CCompiler):
class GnuCCompiler(GnuCompiler, CCompiler): class GnuCCompiler(GnuCompiler, CCompiler):
def __init__(self, exelist, version, gcc_type, is_cross, exe_wrapper=None, defines=None, **kwargs): def __init__(self, exelist, version, compiler_type, is_cross, exe_wrapper=None, defines=None, **kwargs):
CCompiler.__init__(self, exelist, version, is_cross, exe_wrapper, **kwargs) CCompiler.__init__(self, exelist, version, is_cross, exe_wrapper, **kwargs)
GnuCompiler.__init__(self, gcc_type, defines) GnuCompiler.__init__(self, compiler_type, defines)
default_warn_args = ['-Wall', '-Winvalid-pch'] default_warn_args = ['-Wall', '-Winvalid-pch']
self.warn_args = {'1': default_warn_args, self.warn_args = {'1': default_warn_args,
'2': default_warn_args + ['-Wextra'], '2': default_warn_args + ['-Wextra'],
@ -1140,7 +1133,7 @@ class GnuCCompiler(GnuCompiler, CCompiler):
['none', 'c89', 'c99', 'c11', ['none', 'c89', 'c99', 'c11',
'gnu89', 'gnu99', 'gnu11'], 'gnu89', 'gnu99', 'gnu11'],
'none')}) 'none')})
if self.gcc_type == GCC_MINGW: if self.compiler_type == CompilerType.GCC_MINGW:
opts.update({ opts.update({
'c_winlibs': coredata.UserArrayOption('c_winlibs', 'Standard Win libraries to link against', 'c_winlibs': coredata.UserArrayOption('c_winlibs', 'Standard Win libraries to link against',
gnu_winlibs), }) gnu_winlibs), })
@ -1154,7 +1147,7 @@ class GnuCCompiler(GnuCompiler, CCompiler):
return args return args
def get_option_link_args(self, options): def get_option_link_args(self, options):
if self.gcc_type == GCC_MINGW: if self.compiler_type == CompilerType.GCC_MINGW:
return options['c_winlibs'].value[:] return options['c_winlibs'].value[:]
return [] return []
@ -1166,9 +1159,9 @@ class GnuCCompiler(GnuCompiler, CCompiler):
class ElbrusCCompiler(GnuCCompiler, ElbrusCompiler): class ElbrusCCompiler(GnuCCompiler, ElbrusCompiler):
def __init__(self, exelist, version, gcc_type, is_cross, exe_wrapper=None, defines=None, **kwargs): def __init__(self, exelist, version, compiler_type, is_cross, exe_wrapper=None, defines=None, **kwargs):
GnuCCompiler.__init__(self, exelist, version, gcc_type, is_cross, exe_wrapper, defines, **kwargs) GnuCCompiler.__init__(self, exelist, version, compiler_type, is_cross, exe_wrapper, defines, **kwargs)
ElbrusCompiler.__init__(self, gcc_type, defines) ElbrusCompiler.__init__(self, compiler_type, defines)
# It does support some various ISO standards and c/gnu 90, 9x, 1x in addition to those which GNU CC supports. # 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): def get_options(self):
@ -1190,9 +1183,9 @@ class ElbrusCCompiler(GnuCCompiler, ElbrusCompiler):
class IntelCCompiler(IntelCompiler, CCompiler): class IntelCCompiler(IntelCompiler, CCompiler):
def __init__(self, exelist, version, icc_type, is_cross, exe_wrapper=None, **kwargs): def __init__(self, exelist, version, compiler_type, is_cross, exe_wrapper=None, **kwargs):
CCompiler.__init__(self, exelist, version, is_cross, exe_wrapper, **kwargs) CCompiler.__init__(self, exelist, version, is_cross, exe_wrapper, **kwargs)
IntelCompiler.__init__(self, icc_type) IntelCompiler.__init__(self, compiler_type)
self.lang_header = 'c-header' self.lang_header = 'c-header'
default_warn_args = ['-Wall', '-w3', '-diag-disable:remark', '-Wpch-messages'] default_warn_args = ['-Wall', '-w3', '-diag-disable:remark', '-Wpch-messages']
self.warn_args = {'1': default_warn_args, self.warn_args = {'1': default_warn_args,

127
mesonbuild/compilers/compilers.py
Unescape View File

@ -12,7 +12,7 @@
# See the License for the specific language governing permissions and # See the License for the specific language governing permissions and
# limitations under the License. # limitations under the License.
import contextlib, os.path, re, tempfile, shlex import contextlib, enum, os.path, re, tempfile, shlex
import subprocess import subprocess
from ..linkers import StaticLinker from ..linkers import StaticLinker
@ -1141,19 +1141,35 @@ class Compiler:
raise EnvironmentException( raise EnvironmentException(
'Language {} does not support function attributes.'.format(self.get_display_language())) 'Language {} does not support function attributes.'.format(self.get_display_language()))
@enum.unique
class CompilerType(enum.Enum):
GCC_STANDARD = 0 GCC_STANDARD = 0
GCC_OSX = 1 GCC_OSX = 1
GCC_MINGW = 2 GCC_MINGW = 2
GCC_CYGWIN = 3 GCC_CYGWIN = 3
CLANG_STANDARD = 0 CLANG_STANDARD = 10
CLANG_OSX = 1 CLANG_OSX = 11
CLANG_WIN = 2 CLANG_MINGW = 12
# Possibly clang-cl? # Possibly clang-cl?
ICC_STANDARD = 0 ICC_STANDARD = 20
ICC_OSX = 1 ICC_OSX = 21
ICC_WIN = 2 ICC_WIN = 22
@property
def is_standard_compiler(self):
return self.name in ('GCC_STANDARD', 'CLANG_STANDARD', 'ICC_STANDARD')
@property
def is_osx_compiler(self):
return self.name in ('GCC_OSX', 'CLANG_OSX', 'ICC_OSX')
@property
def is_windows_compiler(self):
return self.name in ('GCC_MINGW', 'GCC_CYGWIN', 'CLANG_MINGW', 'ICC_WIN')
# GNU ld cannot be installed on macOS # GNU ld cannot be installed on macOS
# https://github.com/Homebrew/homebrew-core/issues/17794#issuecomment-328174395 # https://github.com/Homebrew/homebrew-core/issues/17794#issuecomment-328174395
@ -1169,14 +1185,14 @@ def get_macos_dylib_install_name(prefix, shlib_name, suffix, soversion):
install_name += '.dylib' install_name += '.dylib'
return '@rpath/' + install_name return '@rpath/' + install_name
def get_gcc_soname_args(gcc_type, prefix, shlib_name, suffix, soversion, darwin_versions, is_shared_module): def get_gcc_soname_args(compiler_type, prefix, shlib_name, suffix, soversion, darwin_versions, is_shared_module):
if gcc_type == GCC_STANDARD: if compiler_type.is_standard_compiler:
sostr = '' if soversion is None else '.' + soversion sostr = '' if soversion is None else '.' + soversion
return ['-Wl,-soname,%s%s.%s%s' % (prefix, shlib_name, suffix, sostr)] return ['-Wl,-soname,%s%s.%s%s' % (prefix, shlib_name, suffix, sostr)]
elif gcc_type in (GCC_MINGW, GCC_CYGWIN): elif compiler_type.is_windows_compiler:
# For PE/COFF the soname argument has no effect with GNU LD # For PE/COFF the soname argument has no effect with GNU LD
return [] return []
elif gcc_type == GCC_OSX: elif compiler_type.is_osx_compiler:
if is_shared_module: if is_shared_module:
return [] return []
name = get_macos_dylib_install_name(prefix, shlib_name, suffix, soversion) name = get_macos_dylib_install_name(prefix, shlib_name, suffix, soversion)
@ -1188,20 +1204,21 @@ def get_gcc_soname_args(gcc_type, prefix, shlib_name, suffix, soversion, darwin_
raise RuntimeError('Not implemented yet.') raise RuntimeError('Not implemented yet.')
def get_compiler_is_linuxlike(compiler): def get_compiler_is_linuxlike(compiler):
if (getattr(compiler, 'gcc_type', None) == GCC_STANDARD) or \ compiler_type = getattr(compiler, 'compiler_type', None)
(getattr(compiler, 'clang_type', None) == CLANG_STANDARD) or \ return compiler_type and compiler_type.is_standard_compiler
(getattr(compiler, 'icc_type', None) == ICC_STANDARD):
return True
return False
def get_compiler_uses_gnuld(c): def get_compiler_uses_gnuld(c):
# FIXME: Perhaps we should detect the linker in the environment? # FIXME: Perhaps we should detect the linker in the environment?
# FIXME: Assumes that *BSD use GNU ld, but they might start using lld soon # FIXME: Assumes that *BSD use GNU ld, but they might start using lld soon
if (getattr(c, 'gcc_type', None) in (GCC_STANDARD, GCC_MINGW, GCC_CYGWIN)) or \ compiler_type = getattr(c, 'compiler_type', None)
(getattr(c, 'clang_type', None) in (CLANG_STANDARD, CLANG_WIN)) or \ return compiler_type in (
(getattr(c, 'icc_type', None) in (ICC_STANDARD, ICC_WIN)): CompilerType.GCC_STANDARD,
return True CompilerType.GCC_MINGW,
return False CompilerType.GCC_CYGWIN,
CompilerType.CLANG_STANDARD,
CompilerType.CLANG_MINGW,
CompilerType.ICC_STANDARD,
CompilerType.ICC_WIN)
def get_largefile_args(compiler): def get_largefile_args(compiler):
''' '''
@ -1262,13 +1279,13 @@ def gnulike_default_include_dirs(compiler, lang):
class GnuCompiler: class GnuCompiler:
# Functionality that is common to all GNU family compilers. # Functionality that is common to all GNU family compilers.
def __init__(self, gcc_type, defines): def __init__(self, compiler_type, defines):
self.id = 'gcc' self.id = 'gcc'
self.gcc_type = gcc_type self.compiler_type = compiler_type
self.defines = defines or {} self.defines = defines or {}
self.base_options = ['b_pch', 'b_lto', 'b_pgo', 'b_sanitize', 'b_coverage', self.base_options = ['b_pch', 'b_lto', 'b_pgo', 'b_sanitize', 'b_coverage',
'b_colorout', 'b_ndebug', 'b_staticpic'] 'b_colorout', 'b_ndebug', 'b_staticpic']
if self.gcc_type == GCC_OSX: if self.compiler_type.is_osx_compiler:
self.base_options.append('b_bitcode') self.base_options.append('b_bitcode')
else: else:
self.base_options.append('b_lundef') self.base_options.append('b_lundef')
@ -1279,7 +1296,7 @@ class GnuCompiler:
# TODO: centralise this policy more globally, instead # TODO: centralise this policy more globally, instead
# of fragmenting it into GnuCompiler and ClangCompiler # of fragmenting it into GnuCompiler and ClangCompiler
def get_asneeded_args(self): def get_asneeded_args(self):
if self.gcc_type == GCC_OSX: if self.compiler_type.is_osx_compiler:
return APPLE_LD_AS_NEEDED return APPLE_LD_AS_NEEDED
else: else:
return GNU_LD_AS_NEEDED return GNU_LD_AS_NEEDED
@ -1305,7 +1322,7 @@ class GnuCompiler:
return self.defines[define] return self.defines[define]
def get_pic_args(self): def get_pic_args(self):
if self.gcc_type in (GCC_CYGWIN, GCC_MINGW, GCC_OSX): if self.compiler_type in (CompilerType.GCC_CYGWIN, CompilerType.GCC_MINGW, CompilerType.GCC_OSX):
return [] # On Window and OS X, pic is always on. return [] # On Window and OS X, pic is always on.
return ['-fPIC'] return ['-fPIC']
@ -1319,7 +1336,7 @@ class GnuCompiler:
return clike_debug_args[is_debug] return clike_debug_args[is_debug]
def get_buildtype_linker_args(self, buildtype): def get_buildtype_linker_args(self, buildtype):
if self.gcc_type == GCC_OSX: if self.compiler_type.is_osx_compiler:
return apple_buildtype_linker_args[buildtype] return apple_buildtype_linker_args[buildtype]
return gnulike_buildtype_linker_args[buildtype] return gnulike_buildtype_linker_args[buildtype]
@ -1330,7 +1347,7 @@ class GnuCompiler:
return os.path.dirname(fname), fname return os.path.dirname(fname), fname
def get_soname_args(self, *args): def get_soname_args(self, *args):
return get_gcc_soname_args(self.gcc_type, *args) return get_gcc_soname_args(self.compiler_type, *args)
def get_std_shared_lib_link_args(self): def get_std_shared_lib_link_args(self):
return ['-shared'] return ['-shared']
@ -1343,13 +1360,13 @@ class GnuCompiler:
raise RuntimeError('Module definitions file should be str') raise RuntimeError('Module definitions file should be str')
# On Windows targets, .def files may be specified on the linker command # On Windows targets, .def files may be specified on the linker command
# line like an object file. # line like an object file.
if self.gcc_type in (GCC_CYGWIN, GCC_MINGW): if self.compiler_type in (CompilerType.GCC_CYGWIN, CompilerType.GCC_MINGW):
return [defsfile] return [defsfile]
# For other targets, discard the .def file. # For other targets, discard the .def file.
return [] return []
def get_gui_app_args(self, value): def get_gui_app_args(self, value):
if self.gcc_type in (GCC_CYGWIN, GCC_MINGW) and value: if self.compiler_type in (CompilerType.GCC_CYGWIN, CompilerType.GCC_MINGW) and value:
return ['-mwindows'] return ['-mwindows']
return [] return []
@ -1368,8 +1385,8 @@ class GnuCompiler:
class ElbrusCompiler(GnuCompiler): class ElbrusCompiler(GnuCompiler):
# Elbrus compiler is nearly like GCC, but does not support # Elbrus compiler is nearly like GCC, but does not support
# PCH, LTO, sanitizers and color output as of version 1.21.x. # PCH, LTO, sanitizers and color output as of version 1.21.x.
def __init__(self, gcc_type, defines): def __init__(self, compiler_type, defines):
GnuCompiler.__init__(self, gcc_type, defines) GnuCompiler.__init__(self, compiler_type, defines)
self.id = 'lcc' self.id = 'lcc'
self.base_options = ['b_pgo', 'b_coverage', self.base_options = ['b_pgo', 'b_coverage',
'b_ndebug', 'b_staticpic', 'b_ndebug', 'b_staticpic',
@ -1404,12 +1421,12 @@ class ElbrusCompiler(GnuCompiler):
return paths return paths
class ClangCompiler: class ClangCompiler:
def __init__(self, clang_type): def __init__(self, compiler_type):
self.id = 'clang' self.id = 'clang'
self.clang_type = clang_type self.compiler_type = compiler_type
self.base_options = ['b_pch', 'b_lto', 'b_pgo', 'b_sanitize', 'b_coverage', self.base_options = ['b_pch', 'b_lto', 'b_pgo', 'b_sanitize', 'b_coverage',
'b_ndebug', 'b_staticpic', 'b_colorout'] 'b_ndebug', 'b_staticpic', 'b_colorout']
if self.clang_type == CLANG_OSX: if self.compiler_type.is_osx_compiler:
self.base_options.append('b_bitcode') self.base_options.append('b_bitcode')
else: else:
self.base_options.append('b_lundef') self.base_options.append('b_lundef')
@ -1420,13 +1437,13 @@ class ClangCompiler:
# TODO: centralise this policy more globally, instead # TODO: centralise this policy more globally, instead
# of fragmenting it into GnuCompiler and ClangCompiler # of fragmenting it into GnuCompiler and ClangCompiler
def get_asneeded_args(self): def get_asneeded_args(self):
if self.clang_type == CLANG_OSX: if self.compiler_type.is_osx_compiler:
return APPLE_LD_AS_NEEDED return APPLE_LD_AS_NEEDED
else: else:
return GNU_LD_AS_NEEDED return GNU_LD_AS_NEEDED
def get_pic_args(self): def get_pic_args(self):
if self.clang_type in (CLANG_WIN, CLANG_OSX): if self.compiler_type in (CompilerType.CLANG_MINGW, CompilerType.CLANG_OSX):
return [] # On Window and OS X, pic is always on. return [] # On Window and OS X, pic is always on.
return ['-fPIC'] return ['-fPIC']
@ -1437,7 +1454,7 @@ class ClangCompiler:
return gnulike_buildtype_args[buildtype] return gnulike_buildtype_args[buildtype]
def get_buildtype_linker_args(self, buildtype): def get_buildtype_linker_args(self, buildtype):
if self.clang_type == CLANG_OSX: if self.compiler_type.is_osx_compiler:
return apple_buildtype_linker_args[buildtype] return apple_buildtype_linker_args[buildtype]
return gnulike_buildtype_linker_args[buildtype] return gnulike_buildtype_linker_args[buildtype]
@ -1457,15 +1474,7 @@ class ClangCompiler:
return ['-include-pch', os.path.join(pch_dir, self.get_pch_name(header))] return ['-include-pch', os.path.join(pch_dir, self.get_pch_name(header))]
def get_soname_args(self, *args): def get_soname_args(self, *args):
if self.clang_type == CLANG_STANDARD: return get_gcc_soname_args(self.compiler_type, *args)
gcc_type = GCC_STANDARD
elif self.clang_type == CLANG_OSX:
gcc_type = GCC_OSX
elif self.clang_type == CLANG_WIN:
gcc_type = GCC_MINGW
else:
raise MesonException('Unreachable code when converting clang type to gcc type.')
return get_gcc_soname_args(gcc_type, *args)
def has_multi_arguments(self, args, env): def has_multi_arguments(self, args, env):
myargs = ['-Werror=unknown-warning-option', '-Werror=unused-command-line-argument'] myargs = ['-Werror=unknown-warning-option', '-Werror=unused-command-line-argument']
@ -1482,17 +1491,17 @@ class ClangCompiler:
# visibility to obey OS X and iOS minimum version targets with # visibility to obey OS X and iOS minimum version targets with
# -mmacosx-version-min, -miphoneos-version-min, etc. # -mmacosx-version-min, -miphoneos-version-min, etc.
# https://github.com/Homebrew/homebrew-core/issues/3727 # https://github.com/Homebrew/homebrew-core/issues/3727
if self.clang_type == CLANG_OSX and version_compare(self.version, '>=8.0'): if self.compiler_type.is_osx_compiler and version_compare(self.version, '>=8.0'):
extra_args.append('-Wl,-no_weak_imports') extra_args.append('-Wl,-no_weak_imports')
return super().has_function(funcname, prefix, env, extra_args, dependencies) return super().has_function(funcname, prefix, env, extra_args, dependencies)
def get_std_shared_module_link_args(self, options): def get_std_shared_module_link_args(self, options):
if self.clang_type == CLANG_OSX: if self.compiler_type.is_osx_compiler:
return ['-bundle', '-Wl,-undefined,dynamic_lookup'] return ['-bundle', '-Wl,-undefined,dynamic_lookup']
return ['-shared'] return ['-shared']
def get_link_whole_for(self, args): def get_link_whole_for(self, args):
if self.clang_type == CLANG_OSX: if self.compiler_type.is_osx_compiler:
result = [] result = []
for a in args: for a in args:
result += ['-Wl,-force_load', a] result += ['-Wl,-force_load', a]
@ -1593,9 +1602,9 @@ class ArmclangCompiler:
# Tested on linux for ICC 14.0.3, 15.0.6, 16.0.4, 17.0.1 # Tested on linux for ICC 14.0.3, 15.0.6, 16.0.4, 17.0.1
class IntelCompiler: class IntelCompiler:
def __init__(self, icc_type): def __init__(self, compiler_type):
self.id = 'intel' self.id = 'intel'
self.icc_type = icc_type self.compiler_type = compiler_type
self.lang_header = 'none' self.lang_header = 'none'
self.base_options = ['b_pch', 'b_lto', 'b_pgo', 'b_sanitize', 'b_coverage', self.base_options = ['b_pch', 'b_lto', 'b_pgo', 'b_sanitize', 'b_coverage',
'b_colorout', 'b_ndebug', 'b_staticpic', 'b_lundef', 'b_asneeded'] 'b_colorout', 'b_ndebug', 'b_staticpic', 'b_lundef', 'b_asneeded']
@ -1625,27 +1634,19 @@ class IntelCompiler:
return os.path.dirname(fname), fname return os.path.dirname(fname), fname
def get_soname_args(self, *args): def get_soname_args(self, *args):
if self.icc_type == ICC_STANDARD: return get_gcc_soname_args(self.compiler_type, *args)
gcc_type = GCC_STANDARD
elif self.icc_type == ICC_OSX:
gcc_type = GCC_OSX
elif self.icc_type == ICC_WIN:
gcc_type = GCC_MINGW
else:
raise MesonException('Unreachable code when converting icc type to gcc type.')
return get_gcc_soname_args(gcc_type, *args)
# TODO: centralise this policy more globally, instead # TODO: centralise this policy more globally, instead
# of fragmenting it into GnuCompiler and ClangCompiler # of fragmenting it into GnuCompiler and ClangCompiler
def get_asneeded_args(self): def get_asneeded_args(self):
if self.icc_type == CLANG_OSX: if self.compiler_type.is_osx_compiler:
return APPLE_LD_AS_NEEDED return APPLE_LD_AS_NEEDED
else: else:
return GNU_LD_AS_NEEDED return GNU_LD_AS_NEEDED
def get_std_shared_lib_link_args(self): def get_std_shared_lib_link_args(self):
# FIXME: Don't know how icc works on OSX # FIXME: Don't know how icc works on OSX
# if self.icc_type == ICC_OSX: # if self.compiler_type.is_osx_compiler:
# return ['-bundle'] # return ['-bundle']
return ['-shared'] return ['-shared']

24
mesonbuild/compilers/cpp.py
Unescape View File

@ -21,7 +21,7 @@ from ..mesonlib import MesonException, version_compare
from .c import CCompiler, VisualStudioCCompiler from .c import CCompiler, VisualStudioCCompiler
from .compilers import ( from .compilers import (
GCC_MINGW, CompilerType,
gnu_winlibs, gnu_winlibs,
msvc_winlibs, msvc_winlibs,
ClangCompiler, ClangCompiler,
@ -126,9 +126,9 @@ class CPPCompiler(CCompiler):
class ClangCPPCompiler(ClangCompiler, CPPCompiler): class ClangCPPCompiler(ClangCompiler, CPPCompiler):
def __init__(self, exelist, version, cltype, is_cross, exe_wrapper=None, **kwargs): def __init__(self, exelist, version, compiler_type, is_cross, exe_wrapper=None, **kwargs):
CPPCompiler.__init__(self, exelist, version, is_cross, exe_wrapper, **kwargs) CPPCompiler.__init__(self, exelist, version, is_cross, exe_wrapper, **kwargs)
ClangCompiler.__init__(self, cltype) ClangCompiler.__init__(self, compiler_type)
default_warn_args = ['-Wall', '-Winvalid-pch', '-Wnon-virtual-dtor'] default_warn_args = ['-Wall', '-Winvalid-pch', '-Wnon-virtual-dtor']
self.warn_args = {'1': default_warn_args, self.warn_args = {'1': default_warn_args,
'2': default_warn_args + ['-Wextra'], '2': default_warn_args + ['-Wextra'],
@ -185,9 +185,9 @@ class ArmclangCPPCompiler(ArmclangCompiler, CPPCompiler):
class GnuCPPCompiler(GnuCompiler, CPPCompiler): class GnuCPPCompiler(GnuCompiler, CPPCompiler):
def __init__(self, exelist, version, gcc_type, is_cross, exe_wrap, defines, **kwargs): def __init__(self, exelist, version, compiler_type, is_cross, exe_wrap, defines, **kwargs):
CPPCompiler.__init__(self, exelist, version, is_cross, exe_wrap, **kwargs) CPPCompiler.__init__(self, exelist, version, is_cross, exe_wrap, **kwargs)
GnuCompiler.__init__(self, gcc_type, defines) GnuCompiler.__init__(self, compiler_type, defines)
default_warn_args = ['-Wall', '-Winvalid-pch', '-Wnon-virtual-dtor'] default_warn_args = ['-Wall', '-Winvalid-pch', '-Wnon-virtual-dtor']
self.warn_args = {'1': default_warn_args, self.warn_args = {'1': default_warn_args,
'2': default_warn_args + ['-Wextra'], '2': default_warn_args + ['-Wextra'],
@ -202,7 +202,7 @@ class GnuCPPCompiler(GnuCompiler, CPPCompiler):
'cpp_debugstl': coredata.UserBooleanOption('cpp_debugstl', 'cpp_debugstl': coredata.UserBooleanOption('cpp_debugstl',
'STL debug mode', 'STL debug mode',
False)}) False)})
if self.gcc_type == GCC_MINGW: if self.compiler_type == CompilerType.GCC_MINGW:
opts.update({ opts.update({
'cpp_winlibs': coredata.UserArrayOption('cpp_winlibs', 'Standard Win libraries to link against', 'cpp_winlibs': coredata.UserArrayOption('cpp_winlibs', 'Standard Win libraries to link against',
gnu_winlibs), }) gnu_winlibs), })
@ -218,7 +218,7 @@ class GnuCPPCompiler(GnuCompiler, CPPCompiler):
return args return args
def get_option_link_args(self, options): def get_option_link_args(self, options):
if self.gcc_type == GCC_MINGW: if self.compiler_type == CompilerType.GCC_MINGW:
return options['cpp_winlibs'].value[:] return options['cpp_winlibs'].value[:]
return [] return []
@ -230,9 +230,9 @@ class GnuCPPCompiler(GnuCompiler, CPPCompiler):
class ElbrusCPPCompiler(GnuCPPCompiler, ElbrusCompiler): class ElbrusCPPCompiler(GnuCPPCompiler, ElbrusCompiler):
def __init__(self, exelist, version, gcc_type, is_cross, exe_wrapper=None, defines=None, **kwargs): def __init__(self, exelist, version, compiler_type, is_cross, exe_wrapper=None, defines=None, **kwargs):
GnuCPPCompiler.__init__(self, exelist, version, gcc_type, is_cross, exe_wrapper, defines, **kwargs) GnuCPPCompiler.__init__(self, exelist, version, compiler_type, is_cross, exe_wrapper, defines, **kwargs)
ElbrusCompiler.__init__(self, gcc_type, defines) ElbrusCompiler.__init__(self, compiler_type, defines)
# It does not support c++/gnu++ 17 and 1z, but still does support 0x, 1y, and gnu++98. # It does not support c++/gnu++ 17 and 1z, but still does support 0x, 1y, and gnu++98.
def get_options(self): def get_options(self):
@ -253,9 +253,9 @@ class ElbrusCPPCompiler(GnuCPPCompiler, ElbrusCompiler):
class IntelCPPCompiler(IntelCompiler, CPPCompiler): class IntelCPPCompiler(IntelCompiler, CPPCompiler):
def __init__(self, exelist, version, icc_type, is_cross, exe_wrap, **kwargs): def __init__(self, exelist, version, compiler_type, is_cross, exe_wrap, **kwargs):
CPPCompiler.__init__(self, exelist, version, is_cross, exe_wrap, **kwargs) CPPCompiler.__init__(self, exelist, version, is_cross, exe_wrap, **kwargs)
IntelCompiler.__init__(self, icc_type) IntelCompiler.__init__(self, compiler_type)
self.lang_header = 'c++-header' self.lang_header = 'c++-header'
default_warn_args = ['-Wall', '-w3', '-diag-disable:remark', default_warn_args = ['-Wall', '-w3', '-diag-disable:remark',
'-Wpch-messages', '-Wnon-virtual-dtor'] '-Wpch-messages', '-Wnon-virtual-dtor']

7
mesonbuild/compilers/d.py
Unescape View File

@ -17,8 +17,7 @@ import os.path, subprocess
from ..mesonlib import EnvironmentException, version_compare, is_windows, is_osx from ..mesonlib import EnvironmentException, version_compare, is_windows, is_osx
from .compilers import ( from .compilers import (
GCC_STANDARD, CompilerType,
GCC_OSX,
d_dmd_buildtype_args, d_dmd_buildtype_args,
d_gdc_buildtype_args, d_gdc_buildtype_args,
d_ldc_buildtype_args, d_ldc_buildtype_args,
@ -152,12 +151,12 @@ class DCompiler(Compiler):
if is_windows(): if is_windows():
return [] return []
elif is_osx(): elif is_osx():
soname_args = get_gcc_soname_args(GCC_OSX, *args) soname_args = get_gcc_soname_args(CompilerType.GCC_OSX, *args)
if soname_args: if soname_args:
return ['-Wl,' + ','.join(soname_args)] return ['-Wl,' + ','.join(soname_args)]
return [] return []
return get_gcc_soname_args(GCC_STANDARD, *args) return get_gcc_soname_args(CompilerType.GCC_STANDARD, *args)
def get_feature_args(self, kwargs, build_to_src): def get_feature_args(self, kwargs, build_to_src):
res = [] res = []

14
mesonbuild/compilers/fortran.py
Unescape View File

@ -14,7 +14,7 @@
from .c import CCompiler from .c import CCompiler
from .compilers import ( from .compilers import (
ICC_STANDARD, CompilerType,
apple_buildtype_linker_args, apple_buildtype_linker_args,
gnulike_buildtype_args, gnulike_buildtype_args,
gnulike_buildtype_linker_args, gnulike_buildtype_linker_args,
@ -257,9 +257,9 @@ end program prog
class GnuFortranCompiler(GnuCompiler, FortranCompiler): class GnuFortranCompiler(GnuCompiler, FortranCompiler):
def __init__(self, exelist, version, gcc_type, is_cross, exe_wrapper=None, defines=None, **kwargs): def __init__(self, exelist, version, compiler_type, is_cross, exe_wrapper=None, defines=None, **kwargs):
FortranCompiler.__init__(self, exelist, version, is_cross, exe_wrapper, **kwargs) FortranCompiler.__init__(self, exelist, version, is_cross, exe_wrapper, **kwargs)
GnuCompiler.__init__(self, gcc_type, defines) GnuCompiler.__init__(self, compiler_type, defines)
default_warn_args = ['-Wall'] default_warn_args = ['-Wall']
self.warn_args = {'1': default_warn_args, self.warn_args = {'1': default_warn_args,
'2': default_warn_args + ['-Wextra'], '2': default_warn_args + ['-Wextra'],
@ -279,9 +279,9 @@ class GnuFortranCompiler(GnuCompiler, FortranCompiler):
class ElbrusFortranCompiler(GnuFortranCompiler, ElbrusCompiler): class ElbrusFortranCompiler(GnuFortranCompiler, ElbrusCompiler):
def __init__(self, exelist, version, gcc_type, is_cross, exe_wrapper=None, defines=None, **kwargs): def __init__(self, exelist, version, compiler_type, is_cross, exe_wrapper=None, defines=None, **kwargs):
GnuFortranCompiler.__init__(self, exelist, version, gcc_type, is_cross, exe_wrapper, defines, **kwargs) GnuFortranCompiler.__init__(self, exelist, version, compiler_type, is_cross, exe_wrapper, defines, **kwargs)
ElbrusCompiler.__init__(self, gcc_type, defines) ElbrusCompiler.__init__(self, compiler_type, defines)
class G95FortranCompiler(FortranCompiler): class G95FortranCompiler(FortranCompiler):
def __init__(self, exelist, version, is_cross, exe_wrapper=None, **kwags): def __init__(self, exelist, version, is_cross, exe_wrapper=None, **kwags):
@ -330,7 +330,7 @@ class IntelFortranCompiler(IntelCompiler, FortranCompiler):
FortranCompiler.__init__(self, exelist, version, is_cross, exe_wrapper, **kwags) FortranCompiler.__init__(self, exelist, version, is_cross, exe_wrapper, **kwags)
# FIXME: Add support for OS X and Windows in detect_fortran_compiler so # FIXME: Add support for OS X and Windows in detect_fortran_compiler so
# we are sent the type of compiler # we are sent the type of compiler
IntelCompiler.__init__(self, ICC_STANDARD) IntelCompiler.__init__(self, CompilerType.ICC_STANDARD)
self.id = 'intel' self.id = 'intel'
default_warn_args = ['-warn', 'general', '-warn', 'truncated_source'] default_warn_args = ['-warn', 'general', '-warn', 'truncated_source']
self.warn_args = {'1': default_warn_args, self.warn_args = {'1': default_warn_args,

16
mesonbuild/compilers/objc.py
Unescape View File

@ -51,17 +51,21 @@ class ObjCCompiler(CCompiler):
class GnuObjCCompiler(GnuCompiler, ObjCCompiler): class GnuObjCCompiler(GnuCompiler, ObjCCompiler):
def __init__(self, exelist, version, gcc_type, is_cross, exe_wrapper=None, defines=None): def __init__(self, exelist, version, compiler_type, is_cross, exe_wrapper=None, defines=None):
ObjCCompiler.__init__(self, exelist, version, is_cross, exe_wrapper) ObjCCompiler.__init__(self, exelist, version, is_cross, exe_wrapper)
GnuCompiler.__init__(self, gcc_type, defines) GnuCompiler.__init__(self, compiler_type, defines)
default_warn_args = ['-Wall', '-Winvalid-pch'] default_warn_args = ['-Wall', '-Winvalid-pch']
self.warn_args = {'1': default_warn_args, self.warn_args = {'1': default_warn_args,
'2': default_warn_args + ['-Wextra'], '2': default_warn_args + ['-Wextra'],
'3': default_warn_args + ['-Wextra', '-Wpedantic']} '3': default_warn_args + ['-Wextra', '-Wpedantic']}
class ClangObjCCompiler(ClangCompiler, GnuObjCCompiler): class ClangObjCCompiler(ClangCompiler, ObjCCompiler):
def __init__(self, exelist, version, cltype, is_cross, exe_wrapper=None): def __init__(self, exelist, version, compiler_type, is_cross, exe_wrapper=None):
GnuObjCCompiler.__init__(self, exelist, version, cltype, is_cross, exe_wrapper) ObjCCompiler.__init__(self, exelist, version, is_cross, exe_wrapper)
ClangCompiler.__init__(self, cltype) ClangCompiler.__init__(self, compiler_type)
default_warn_args = ['-Wall', '-Winvalid-pch']
self.warn_args = {'1': default_warn_args,
'2': default_warn_args + ['-Wextra'],
'3': default_warn_args + ['-Wextra', '-Wpedantic']}
self.base_options = ['b_pch', 'b_lto', 'b_pgo', 'b_sanitize', 'b_coverage'] self.base_options = ['b_pch', 'b_lto', 'b_pgo', 'b_sanitize', 'b_coverage']

16
mesonbuild/compilers/objcpp.py
Unescape View File

@ -52,17 +52,21 @@ class ObjCPPCompiler(CPPCompiler):
class GnuObjCPPCompiler(GnuCompiler, ObjCPPCompiler): class GnuObjCPPCompiler(GnuCompiler, ObjCPPCompiler):
def __init__(self, exelist, version, gcc_type, is_cross, exe_wrapper=None, defines=None): def __init__(self, exelist, version, compiler_type, is_cross, exe_wrapper=None, defines=None):
ObjCPPCompiler.__init__(self, exelist, version, is_cross, exe_wrapper) ObjCPPCompiler.__init__(self, exelist, version, is_cross, exe_wrapper)
GnuCompiler.__init__(self, gcc_type, defines) GnuCompiler.__init__(self, compiler_type, defines)
default_warn_args = ['-Wall', '-Winvalid-pch', '-Wnon-virtual-dtor'] default_warn_args = ['-Wall', '-Winvalid-pch', '-Wnon-virtual-dtor']
self.warn_args = {'1': default_warn_args, self.warn_args = {'1': default_warn_args,
'2': default_warn_args + ['-Wextra'], '2': default_warn_args + ['-Wextra'],
'3': default_warn_args + ['-Wextra', '-Wpedantic']} '3': default_warn_args + ['-Wextra', '-Wpedantic']}
class ClangObjCPPCompiler(ClangCompiler, GnuObjCPPCompiler): class ClangObjCPPCompiler(ClangCompiler, ObjCPPCompiler):
def __init__(self, exelist, version, cltype, is_cross, exe_wrapper=None): def __init__(self, exelist, version, compiler_type, is_cross, exe_wrapper=None):
GnuObjCPPCompiler.__init__(self, exelist, version, cltype, is_cross, exe_wrapper) ObjCPPCompiler.__init__(self, exelist, version, is_cross, exe_wrapper)
ClangCompiler.__init__(self, cltype) ClangCompiler.__init__(self, compiler_type)
default_warn_args = ['-Wall', '-Winvalid-pch', '-Wnon-virtual-dtor']
self.warn_args = {'1': default_warn_args,
'2': default_warn_args + ['-Wextra'],
'3': default_warn_args + ['-Wextra', '-Wpedantic']}
self.base_options = ['b_pch', 'b_lto', 'b_pgo', 'b_sanitize', 'b_coverage'] self.base_options = ['b_pch', 'b_lto', 'b_pgo', 'b_sanitize', 'b_coverage']

53
mesonbuild/environment.py
Unescape View File

@ -22,14 +22,7 @@ from . import mlog
from . import compilers from . import compilers
from .compilers import ( from .compilers import (
CLANG_OSX, CompilerType,
CLANG_STANDARD,
CLANG_WIN,
GCC_CYGWIN,
GCC_MINGW,
GCC_OSX,
GCC_STANDARD,
ICC_STANDARD,
is_assembly, is_assembly,
is_header, is_header,
is_library, is_library,
@ -451,12 +444,12 @@ class Environment:
def get_gnu_compiler_type(defines): def get_gnu_compiler_type(defines):
# Detect GCC type (Apple, MinGW, Cygwin, Unix) # Detect GCC type (Apple, MinGW, Cygwin, Unix)
if '__APPLE__' in defines: if '__APPLE__' in defines:
return GCC_OSX return CompilerType.GCC_OSX
elif '__MINGW32__' in defines or '__MINGW64__' in defines: elif '__MINGW32__' in defines or '__MINGW64__' in defines:
return GCC_MINGW return CompilerType.GCC_MINGW
elif '__CYGWIN__' in defines: elif '__CYGWIN__' in defines:
return GCC_CYGWIN return CompilerType.GCC_CYGWIN
return GCC_STANDARD return CompilerType.GCC_STANDARD
def warn_about_lang_pointing_to_cross(self, compiler_exe, evar): def warn_about_lang_pointing_to_cross(self, compiler_exe, evar):
evar_str = os.environ.get(evar, 'WHO_WOULD_CALL_THEIR_COMPILER_WITH_THIS_NAME') evar_str = os.environ.get(evar, 'WHO_WOULD_CALL_THEIR_COMPILER_WITH_THIS_NAME')
@ -560,14 +553,14 @@ This is probably wrong, it should always point to the native compiler.''' % evar
if not defines: if not defines:
popen_exceptions[' '.join(compiler)] = 'no pre-processor defines' popen_exceptions[' '.join(compiler)] = 'no pre-processor defines'
continue continue
gtype = self.get_gnu_compiler_type(defines) compiler_type = self.get_gnu_compiler_type(defines)
if guess_gcc_or_lcc == 'lcc': if guess_gcc_or_lcc == 'lcc':
version = self.get_lcc_version_from_defines(defines) version = self.get_lcc_version_from_defines(defines)
cls = ElbrusCCompiler if lang == 'c' else ElbrusCPPCompiler cls = ElbrusCCompiler if lang == 'c' else ElbrusCPPCompiler
else: else:
version = self.get_gnu_version_from_defines(defines) version = self.get_gnu_version_from_defines(defines)
cls = GnuCCompiler if lang == 'c' else GnuCPPCompiler cls = GnuCCompiler if lang == 'c' else GnuCPPCompiler
return cls(ccache + compiler, version, gtype, is_cross, exe_wrap, defines, full_version=full_version) return cls(ccache + compiler, version, compiler_type, is_cross, exe_wrap, defines, full_version=full_version)
if 'armclang' in out: if 'armclang' in out:
# The compiler version is not present in the first line of output, # The compiler version is not present in the first line of output,
@ -587,13 +580,13 @@ This is probably wrong, it should always point to the native compiler.''' % evar
return cls(ccache + compiler, version, is_cross, exe_wrap, full_version=full_version) return cls(ccache + compiler, version, is_cross, exe_wrap, full_version=full_version)
if 'clang' in out: if 'clang' in out:
if 'Apple' in out or mesonlib.for_darwin(want_cross, self): if 'Apple' in out or mesonlib.for_darwin(want_cross, self):
cltype = CLANG_OSX compiler_type = CompilerType.CLANG_OSX
elif 'windows' in out or mesonlib.for_windows(want_cross, self): elif 'windows' in out or mesonlib.for_windows(want_cross, self):
cltype = CLANG_WIN compiler_type = CompilerType.CLANG_MINGW
else: else:
cltype = CLANG_STANDARD compiler_type = CompilerType.CLANG_STANDARD
cls = ClangCCompiler if lang == 'c' else ClangCPPCompiler cls = ClangCCompiler if lang == 'c' else ClangCPPCompiler
return cls(ccache + compiler, version, cltype, is_cross, exe_wrap, full_version=full_version) return cls(ccache + compiler, version, compiler_type, is_cross, exe_wrap, full_version=full_version)
if 'Microsoft' in out or 'Microsoft' in err: if 'Microsoft' in out or 'Microsoft' in err:
# Latest versions of Visual Studio print version # Latest versions of Visual Studio print version
# number to stderr but earlier ones print version # number to stderr but earlier ones print version
@ -610,9 +603,9 @@ This is probably wrong, it should always point to the native compiler.''' % evar
return cls(compiler, version, is_cross, exe_wrap, is_64) return cls(compiler, version, is_cross, exe_wrap, is_64)
if '(ICC)' in out: if '(ICC)' in out:
# TODO: add microsoft add check OSX # TODO: add microsoft add check OSX
inteltype = ICC_STANDARD compiler_type = CompilerType.ICC_STANDARD
cls = IntelCCompiler if lang == 'c' else IntelCPPCompiler cls = IntelCCompiler if lang == 'c' else IntelCPPCompiler
return cls(ccache + compiler, version, inteltype, is_cross, exe_wrap, full_version=full_version) return cls(ccache + compiler, version, compiler_type, is_cross, exe_wrap, full_version=full_version)
if 'ARM' in out: if 'ARM' in out:
cls = ArmCCompiler if lang == 'c' else ArmCPPCompiler cls = ArmCCompiler if lang == 'c' else ArmCPPCompiler
return cls(ccache + compiler, version, is_cross, exe_wrap, full_version=full_version) return cls(ccache + compiler, version, is_cross, exe_wrap, full_version=full_version)
@ -651,14 +644,14 @@ This is probably wrong, it should always point to the native compiler.''' % evar
if not defines: if not defines:
popen_exceptions[' '.join(compiler)] = 'no pre-processor defines' popen_exceptions[' '.join(compiler)] = 'no pre-processor defines'
continue continue
gtype = self.get_gnu_compiler_type(defines) compiler_type = self.get_gnu_compiler_type(defines)
if guess_gcc_or_lcc == 'lcc': if guess_gcc_or_lcc == 'lcc':
version = self.get_lcc_version_from_defines(defines) version = self.get_lcc_version_from_defines(defines)
cls = ElbrusFortranCompiler cls = ElbrusFortranCompiler
else: else:
version = self.get_gnu_version_from_defines(defines) version = self.get_gnu_version_from_defines(defines)
cls = GnuFortranCompiler cls = GnuFortranCompiler
return cls(compiler, version, gtype, is_cross, exe_wrap, defines, full_version=full_version) return cls(compiler, version, compiler_type, is_cross, exe_wrap, defines, full_version=full_version)
if 'G95' in out: if 'G95' in out:
return G95FortranCompiler(compiler, version, is_cross, exe_wrap, full_version=full_version) return G95FortranCompiler(compiler, version, is_cross, exe_wrap, full_version=full_version)
@ -704,13 +697,13 @@ This is probably wrong, it should always point to the native compiler.''' % evar
if not defines: if not defines:
popen_exceptions[' '.join(compiler)] = 'no pre-processor defines' popen_exceptions[' '.join(compiler)] = 'no pre-processor defines'
continue continue
gtype = self.get_gnu_compiler_type(defines) compiler_type = self.get_gnu_compiler_type(defines)
version = self.get_gnu_version_from_defines(defines) version = self.get_gnu_version_from_defines(defines)
return GnuObjCCompiler(ccache + compiler, version, gtype, is_cross, exe_wrap, defines) return GnuObjCCompiler(ccache + compiler, version, compiler_type, is_cross, exe_wrap, defines)
if out.startswith('Apple LLVM'): if out.startswith('Apple LLVM'):
return ClangObjCCompiler(ccache + compiler, version, CLANG_OSX, is_cross, exe_wrap) return ClangObjCCompiler(ccache + compiler, version, CompilerType.CLANG_OSX, is_cross, exe_wrap)
if out.startswith('clang'): if out.startswith('clang'):
return ClangObjCCompiler(ccache + compiler, version, CLANG_STANDARD, is_cross, exe_wrap) return ClangObjCCompiler(ccache + compiler, version, CompilerType.CLANG_STANDARD, is_cross, exe_wrap)
self._handle_exceptions(popen_exceptions, compilers) self._handle_exceptions(popen_exceptions, compilers)
def detect_objcpp_compiler(self, want_cross): def detect_objcpp_compiler(self, want_cross):
@ -731,13 +724,13 @@ This is probably wrong, it should always point to the native compiler.''' % evar
if not defines: if not defines:
popen_exceptions[' '.join(compiler)] = 'no pre-processor defines' popen_exceptions[' '.join(compiler)] = 'no pre-processor defines'
continue continue
gtype = self.get_gnu_compiler_type(defines) compiler_type = self.get_gnu_compiler_type(defines)
version = self.get_gnu_version_from_defines(defines) version = self.get_gnu_version_from_defines(defines)
return GnuObjCPPCompiler(ccache + compiler, version, gtype, is_cross, exe_wrap, defines) return GnuObjCPPCompiler(ccache + compiler, version, compiler_type, is_cross, exe_wrap, defines)
if out.startswith('Apple LLVM'): if out.startswith('Apple LLVM'):
return ClangObjCPPCompiler(ccache + compiler, version, CLANG_OSX, is_cross, exe_wrap) return ClangObjCPPCompiler(ccache + compiler, version, CompilerType.CLANG_OSX, is_cross, exe_wrap)
if out.startswith('clang'): if out.startswith('clang'):
return ClangObjCPPCompiler(ccache + compiler, version, CLANG_STANDARD, is_cross, exe_wrap) return ClangObjCPPCompiler(ccache + compiler, version, CompilerType.CLANG_STANDARD, is_cross, exe_wrap)
self._handle_exceptions(popen_exceptions, compilers) self._handle_exceptions(popen_exceptions, compilers)
def detect_java_compiler(self): def detect_java_compiler(self):

26
run_unittests.py
Unescape View File

@ -265,7 +265,7 @@ class InternalTests(unittest.TestCase):
def test_compiler_args_class_gnuld(self): def test_compiler_args_class_gnuld(self):
cargsfunc = mesonbuild.compilers.CompilerArgs cargsfunc = mesonbuild.compilers.CompilerArgs
## Test --start/end-group ## Test --start/end-group
gcc = mesonbuild.compilers.GnuCCompiler([], 'fake', 0, False) gcc = mesonbuild.compilers.GnuCCompiler([], 'fake', mesonbuild.compilers.CompilerType.GCC_STANDARD, False)
## Test that 'direct' append and extend works ## Test that 'direct' append and extend works
l = cargsfunc(gcc, ['-Lfoodir', '-lfoo']) l = cargsfunc(gcc, ['-Lfoodir', '-lfoo'])
self.assertEqual(l.to_native(copy=True), ['-Lfoodir', '-Wl,--start-group', '-lfoo', '-Wl,--end-group']) self.assertEqual(l.to_native(copy=True), ['-Lfoodir', '-Wl,--start-group', '-lfoo', '-Wl,--end-group'])
@ -1642,30 +1642,30 @@ class AllPlatformTests(BasePlatformTests):
if isinstance(cc, gnu): if isinstance(cc, gnu):
self.assertIsInstance(linker, ar) self.assertIsInstance(linker, ar)
if is_osx(): if is_osx():
self.assertEqual(cc.gcc_type, mesonbuild.compilers.GCC_OSX) self.assertEqual(cc.compiler_type, mesonbuild.compilers.CompilerType.GCC_OSX)
elif is_windows(): elif is_windows():
self.assertEqual(cc.gcc_type, mesonbuild.compilers.GCC_MINGW) self.assertEqual(cc.compiler_type, mesonbuild.compilers.CompilerType.GCC_MINGW)
elif is_cygwin(): elif is_cygwin():
self.assertEqual(cc.gcc_type, mesonbuild.compilers.GCC_CYGWIN) self.assertEqual(cc.compiler_type, mesonbuild.compilers.CompilerType.GCC_CYGWIN)
else: else:
self.assertEqual(cc.gcc_type, mesonbuild.compilers.GCC_STANDARD) self.assertEqual(cc.compiler_type, mesonbuild.compilers.CompilerType.GCC_STANDARD)
if isinstance(cc, clang): if isinstance(cc, clang):
self.assertIsInstance(linker, ar) self.assertIsInstance(linker, ar)
if is_osx(): if is_osx():
self.assertEqual(cc.clang_type, mesonbuild.compilers.CLANG_OSX) self.assertEqual(cc.compiler_type, mesonbuild.compilers.CompilerType.CLANG_OSX)
elif is_windows(): elif is_windows():
# Not implemented yet # Not implemented yet
self.assertEqual(cc.clang_type, mesonbuild.compilers.CLANG_WIN) self.assertEqual(cc.compiler_type, mesonbuild.compilers.CompilerType.CLANG_MINGW)
else: else:
self.assertEqual(cc.clang_type, mesonbuild.compilers.CLANG_STANDARD) self.assertEqual(cc.compiler_type, mesonbuild.compilers.CompilerType.CLANG_STANDARD)
if isinstance(cc, intel): if isinstance(cc, intel):
self.assertIsInstance(linker, ar) self.assertIsInstance(linker, ar)
if is_osx(): if is_osx():
self.assertEqual(cc.icc_type, mesonbuild.compilers.ICC_OSX) self.assertEqual(cc.compiler_type, mesonbuild.compilers.CompilerType.ICC_OSX)
elif is_windows(): elif is_windows():
self.assertEqual(cc.icc_type, mesonbuild.compilers.ICC_WIN) self.assertEqual(cc.compiler_type, mesonbuild.compilers.CompilerType.ICC_WIN)
else: else:
self.assertEqual(cc.icc_type, mesonbuild.compilers.ICC_STANDARD) self.assertEqual(cc.compiler_type, mesonbuild.compilers.CompilerType.ICC_STANDARD)
if isinstance(cc, msvc): if isinstance(cc, msvc):
self.assertTrue(is_windows()) self.assertTrue(is_windows())
self.assertIsInstance(linker, lib) self.assertIsInstance(linker, lib)
@ -3457,11 +3457,11 @@ class LinuxlikeTests(BasePlatformTests):
for v in compiler.get_options()[lang_std].choices: for v in compiler.get_options()[lang_std].choices:
if (compiler.get_id() == 'clang' and '17' in v and if (compiler.get_id() == 'clang' and '17' in v and
(version_compare(compiler.version, '<5.0.0') or (version_compare(compiler.version, '<5.0.0') or
(compiler.clang_type == mesonbuild.compilers.CLANG_OSX and version_compare(compiler.version, '<9.1')))): (compiler.compiler_type == mesonbuild.compilers.CompilerType.CLANG_OSX and version_compare(compiler.version, '<9.1')))):
continue continue
if (compiler.get_id() == 'clang' and '2a' in v and if (compiler.get_id() == 'clang' and '2a' in v and
(version_compare(compiler.version, '<6.0.0') or (version_compare(compiler.version, '<6.0.0') or
(compiler.clang_type == mesonbuild.compilers.CLANG_OSX and version_compare(compiler.version, '<9.1')))): (compiler.compiler_type == mesonbuild.compilers.CompilerType.CLANG_OSX and version_compare(compiler.version, '<9.1')))):
continue continue
if (compiler.get_id() == 'gcc' and '2a' in v and version_compare(compiler.version, '<8.0.0')): if (compiler.get_id() == 'gcc' and '2a' in v and version_compare(compiler.version, '<8.0.0')):
continue continue

Write Preview
Loading…
Cancel
Save