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
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 22
      mesonbuild/compilers/__init__.py
  2. 39
      mesonbuild/compilers/c.py
  3. 137
      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'
__all__ = [
'CLANG_OSX',
'CLANG_STANDARD',
'CLANG_WIN',
'GCC_CYGWIN',
'GCC_MINGW',
'GCC_OSX',
'GCC_STANDARD',
'ICC_OSX',
'ICC_STANDARD',
'ICC_WIN',
'CompilerType',
'all_languages',
'base_options',
@ -94,16 +85,7 @@ __all__ = [
# Bring symbols from each module into compilers sub-package namespace
from .compilers import (
GCC_OSX,
GCC_MINGW,
GCC_CYGWIN,
GCC_STANDARD,
CLANG_OSX,
CLANG_WIN,
CLANG_STANDARD,
ICC_OSX,
ICC_WIN,
ICC_STANDARD,
CompilerType,
all_languages,
base_options,
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 .compilers import (
GCC_MINGW,
CompilerType,
get_largefile_args,
gnu_winlibs,
msvc_winlibs,
@ -121,7 +121,7 @@ class CCompiler(Compiler):
# The default behavior is this, override in MSVC
@functools.lru_cache(maxsize=None)
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_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
'''
if self.id == 'clang':
if self.clang_type == compilers.CLANG_OSX:
# 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:
if self.id in ('clang', 'gcc'):
if self.compiler_type.is_osx_compiler:
# Apple ld
return ['-Wl,-undefined,dynamic_lookup']
else:
@ -1064,9 +1057,9 @@ class CCompiler(Compiler):
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)
ClangCompiler.__init__(self, clang_type)
ClangCompiler.__init__(self, compiler_type)
default_warn_args = ['-Wall', '-Winvalid-pch']
self.warn_args = {'1': default_warn_args,
'2': default_warn_args + ['-Wextra'],
@ -1092,7 +1085,7 @@ class ClangCCompiler(ClangCompiler, CCompiler):
def get_linker_always_args(self):
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
@ -1126,9 +1119,9 @@ class ArmclangCCompiler(ArmclangCompiler, 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)
GnuCompiler.__init__(self, gcc_type, defines)
GnuCompiler.__init__(self, compiler_type, defines)
default_warn_args = ['-Wall', '-Winvalid-pch']
self.warn_args = {'1': default_warn_args,
'2': default_warn_args + ['-Wextra'],
@ -1140,7 +1133,7 @@ class GnuCCompiler(GnuCompiler, CCompiler):
['none', 'c89', 'c99', 'c11',
'gnu89', 'gnu99', 'gnu11'],
'none')})
if self.gcc_type == GCC_MINGW:
if self.compiler_type == CompilerType.GCC_MINGW:
opts.update({
'c_winlibs': coredata.UserArrayOption('c_winlibs', 'Standard Win libraries to link against',
gnu_winlibs), })
@ -1154,7 +1147,7 @@ class GnuCCompiler(GnuCompiler, CCompiler):
return args
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 []
@ -1166,9 +1159,9 @@ class GnuCCompiler(GnuCompiler, CCompiler):
class ElbrusCCompiler(GnuCCompiler, ElbrusCompiler):
def __init__(self, exelist, version, gcc_type, is_cross, exe_wrapper=None, defines=None, **kwargs):
GnuCCompiler.__init__(self, exelist, version, gcc_type, is_cross, exe_wrapper, defines, **kwargs)
ElbrusCompiler.__init__(self, gcc_type, defines)
def __init__(self, exelist, version, compiler_type, is_cross, exe_wrapper=None, defines=None, **kwargs):
GnuCCompiler.__init__(self, exelist, version, compiler_type, is_cross, exe_wrapper, defines, **kwargs)
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.
def get_options(self):
@ -1190,9 +1183,9 @@ class ElbrusCCompiler(GnuCCompiler, ElbrusCompiler):
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)
IntelCompiler.__init__(self, icc_type)
IntelCompiler.__init__(self, compiler_type)
self.lang_header = 'c-header'
default_warn_args = ['-Wall', '-w3', '-diag-disable:remark', '-Wpch-messages']
self.warn_args = {'1': default_warn_args,

137
mesonbuild/compilers/compilers.py
Unescape View File

@ -12,7 +12,7 @@
# See the License for the specific language governing permissions and
# limitations under the License.
import contextlib, os.path, re, tempfile, shlex
import contextlib, enum, os.path, re, tempfile, shlex
import subprocess
from ..linkers import StaticLinker
@ -1141,19 +1141,35 @@ class Compiler:
raise EnvironmentException(
'Language {} does not support function attributes.'.format(self.get_display_language()))
GCC_STANDARD = 0
GCC_OSX = 1
GCC_MINGW = 2
GCC_CYGWIN = 3
CLANG_STANDARD = 0
CLANG_OSX = 1
CLANG_WIN = 2
# Possibly clang-cl?
@enum.unique
class CompilerType(enum.Enum):
GCC_STANDARD = 0
GCC_OSX = 1
GCC_MINGW = 2
GCC_CYGWIN = 3
CLANG_STANDARD = 10
CLANG_OSX = 11
CLANG_MINGW = 12
# Possibly clang-cl?
ICC_STANDARD = 20
ICC_OSX = 21
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')
ICC_STANDARD = 0
ICC_OSX = 1
ICC_WIN = 2
# GNU ld cannot be installed on macOS
# 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'
return '@rpath/' + install_name
def get_gcc_soname_args(gcc_type, prefix, shlib_name, suffix, soversion, darwin_versions, is_shared_module):
if gcc_type == GCC_STANDARD:
def get_gcc_soname_args(compiler_type, prefix, shlib_name, suffix, soversion, darwin_versions, is_shared_module):
if compiler_type.is_standard_compiler:
sostr = '' if soversion is None else '.' + soversion
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
return []
elif gcc_type == GCC_OSX:
elif compiler_type.is_osx_compiler:
if is_shared_module:
return []
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.')
def get_compiler_is_linuxlike(compiler):
if (getattr(compiler, 'gcc_type', None) == GCC_STANDARD) or \
(getattr(compiler, 'clang_type', None) == CLANG_STANDARD) or \
(getattr(compiler, 'icc_type', None) == ICC_STANDARD):
return True
return False
compiler_type = getattr(compiler, 'compiler_type', None)
return compiler_type and compiler_type.is_standard_compiler
def get_compiler_uses_gnuld(c):
# FIXME: Perhaps we should detect the linker in the environment?
# 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 \
(getattr(c, 'clang_type', None) in (CLANG_STANDARD, CLANG_WIN)) or \
(getattr(c, 'icc_type', None) in (ICC_STANDARD, ICC_WIN)):
return True
return False
compiler_type = getattr(c, 'compiler_type', None)
return compiler_type in (
CompilerType.GCC_STANDARD,
CompilerType.GCC_MINGW,
CompilerType.GCC_CYGWIN,
CompilerType.CLANG_STANDARD,
CompilerType.CLANG_MINGW,
CompilerType.ICC_STANDARD,
CompilerType.ICC_WIN)
def get_largefile_args(compiler):
'''
@ -1262,13 +1279,13 @@ def gnulike_default_include_dirs(compiler, lang):
class GnuCompiler:
# 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.gcc_type = gcc_type
self.compiler_type = compiler_type
self.defines = defines or {}
self.base_options = ['b_pch', 'b_lto', 'b_pgo', 'b_sanitize', 'b_coverage',
'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')
else:
self.base_options.append('b_lundef')
@ -1279,7 +1296,7 @@ class GnuCompiler:
# TODO: centralise this policy more globally, instead
# of fragmenting it into GnuCompiler and ClangCompiler
def get_asneeded_args(self):
if self.gcc_type == GCC_OSX:
if self.compiler_type.is_osx_compiler:
return APPLE_LD_AS_NEEDED
else:
return GNU_LD_AS_NEEDED
@ -1305,7 +1322,7 @@ class GnuCompiler:
return self.defines[define]
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 ['-fPIC']
@ -1319,7 +1336,7 @@ class GnuCompiler:
return clike_debug_args[is_debug]
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 gnulike_buildtype_linker_args[buildtype]
@ -1330,7 +1347,7 @@ class GnuCompiler:
return os.path.dirname(fname), fname
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):
return ['-shared']
@ -1343,13 +1360,13 @@ class GnuCompiler:
raise RuntimeError('Module definitions file should be str')
# On Windows targets, .def files may be specified on the linker command
# 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]
# For other targets, discard the .def file.
return []
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 []
@ -1368,8 +1385,8 @@ class GnuCompiler:
class ElbrusCompiler(GnuCompiler):
# Elbrus compiler is nearly like GCC, but does not support
# PCH, LTO, sanitizers and color output as of version 1.21.x.
def __init__(self, gcc_type, defines):
GnuCompiler.__init__(self, gcc_type, defines)
def __init__(self, compiler_type, defines):
GnuCompiler.__init__(self, compiler_type, defines)
self.id = 'lcc'
self.base_options = ['b_pgo', 'b_coverage',
'b_ndebug', 'b_staticpic',
@ -1404,12 +1421,12 @@ class ElbrusCompiler(GnuCompiler):
return paths
class ClangCompiler:
def __init__(self, clang_type):
def __init__(self, compiler_type):
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',
'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')
else:
self.base_options.append('b_lundef')
@ -1420,13 +1437,13 @@ class ClangCompiler:
# TODO: centralise this policy more globally, instead
# of fragmenting it into GnuCompiler and ClangCompiler
def get_asneeded_args(self):
if self.clang_type == CLANG_OSX:
if self.compiler_type.is_osx_compiler:
return APPLE_LD_AS_NEEDED
else:
return GNU_LD_AS_NEEDED
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 ['-fPIC']
@ -1437,7 +1454,7 @@ class ClangCompiler:
return gnulike_buildtype_args[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 gnulike_buildtype_linker_args[buildtype]
@ -1457,15 +1474,7 @@ class ClangCompiler:
return ['-include-pch', os.path.join(pch_dir, self.get_pch_name(header))]
def get_soname_args(self, *args):
if self.clang_type == CLANG_STANDARD:
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)
return get_gcc_soname_args(self.compiler_type, *args)
def has_multi_arguments(self, args, env):
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
# -mmacosx-version-min, -miphoneos-version-min, etc.
# 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')
return super().has_function(funcname, prefix, env, extra_args, dependencies)
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 ['-shared']
def get_link_whole_for(self, args):
if self.clang_type == CLANG_OSX:
if self.compiler_type.is_osx_compiler:
result = []
for a in args:
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
class IntelCompiler:
def __init__(self, icc_type):
def __init__(self, compiler_type):
self.id = 'intel'
self.icc_type = icc_type
self.compiler_type = compiler_type
self.lang_header = 'none'
self.base_options = ['b_pch', 'b_lto', 'b_pgo', 'b_sanitize', 'b_coverage',
'b_colorout', 'b_ndebug', 'b_staticpic', 'b_lundef', 'b_asneeded']
@ -1625,27 +1634,19 @@ class IntelCompiler:
return os.path.dirname(fname), fname
def get_soname_args(self, *args):
if self.icc_type == ICC_STANDARD:
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)
return get_gcc_soname_args(self.compiler_type, *args)
# TODO: centralise this policy more globally, instead
# of fragmenting it into GnuCompiler and ClangCompiler
def get_asneeded_args(self):
if self.icc_type == CLANG_OSX:
if self.compiler_type.is_osx_compiler:
return APPLE_LD_AS_NEEDED
else:
return GNU_LD_AS_NEEDED
def get_std_shared_lib_link_args(self):
# 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 ['-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 .compilers import (
GCC_MINGW,
CompilerType,
gnu_winlibs,
msvc_winlibs,
ClangCompiler,
@ -126,9 +126,9 @@ class CPPCompiler(CCompiler):
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)
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'],
@ -185,9 +185,9 @@ class ArmclangCPPCompiler(ArmclangCompiler, 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)
GnuCompiler.__init__(self, gcc_type, defines)
GnuCompiler.__init__(self, compiler_type, defines)
default_warn_args = ['-Wall', '-Winvalid-pch', '-Wnon-virtual-dtor']
self.warn_args = {'1': default_warn_args,
'2': default_warn_args + ['-Wextra'],
@ -202,7 +202,7 @@ class GnuCPPCompiler(GnuCompiler, CPPCompiler):
'cpp_debugstl': coredata.UserBooleanOption('cpp_debugstl',
'STL debug mode',
False)})
if self.gcc_type == GCC_MINGW:
if self.compiler_type == CompilerType.GCC_MINGW:
opts.update({
'cpp_winlibs': coredata.UserArrayOption('cpp_winlibs', 'Standard Win libraries to link against',
gnu_winlibs), })
@ -218,7 +218,7 @@ class GnuCPPCompiler(GnuCompiler, CPPCompiler):
return args
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 []
@ -230,9 +230,9 @@ class GnuCPPCompiler(GnuCompiler, CPPCompiler):
class ElbrusCPPCompiler(GnuCPPCompiler, ElbrusCompiler):
def __init__(self, exelist, version, gcc_type, is_cross, exe_wrapper=None, defines=None, **kwargs):
GnuCPPCompiler.__init__(self, exelist, version, gcc_type, is_cross, exe_wrapper, defines, **kwargs)
ElbrusCompiler.__init__(self, gcc_type, defines)
def __init__(self, exelist, version, compiler_type, is_cross, exe_wrapper=None, defines=None, **kwargs):
GnuCPPCompiler.__init__(self, exelist, version, compiler_type, is_cross, exe_wrapper, defines, **kwargs)
ElbrusCompiler.__init__(self, compiler_type, defines)
# It does not support c++/gnu++ 17 and 1z, but still does support 0x, 1y, and gnu++98.
def get_options(self):
@ -253,9 +253,9 @@ class ElbrusCPPCompiler(GnuCPPCompiler, ElbrusCompiler):
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)
IntelCompiler.__init__(self, icc_type)
IntelCompiler.__init__(self, compiler_type)
self.lang_header = 'c++-header'
default_warn_args = ['-Wall', '-w3', '-diag-disable:remark',
'-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 .compilers import (
GCC_STANDARD,
GCC_OSX,
CompilerType,
d_dmd_buildtype_args,
d_gdc_buildtype_args,
d_ldc_buildtype_args,
@ -152,12 +151,12 @@ class DCompiler(Compiler):
if is_windows():
return []
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:
return ['-Wl,' + ','.join(soname_args)]
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):
res = []

14
mesonbuild/compilers/fortran.py
Unescape View File

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

16
mesonbuild/compilers/objcpp.py
Unescape View File

@ -52,17 +52,21 @@ class ObjCPPCompiler(CPPCompiler):
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)
GnuCompiler.__init__(self, gcc_type, defines)
GnuCompiler.__init__(self, compiler_type, defines)
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']}
class ClangObjCPPCompiler(ClangCompiler, GnuObjCPPCompiler):
def __init__(self, exelist, version, cltype, is_cross, exe_wrapper=None):
GnuObjCPPCompiler.__init__(self, exelist, version, cltype, is_cross, exe_wrapper)
ClangCompiler.__init__(self, cltype)
class ClangObjCPPCompiler(ClangCompiler, ObjCPPCompiler):
def __init__(self, exelist, version, compiler_type, is_cross, exe_wrapper=None):
ObjCPPCompiler.__init__(self, exelist, version, is_cross, exe_wrapper)
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']

53
mesonbuild/environment.py
Unescape View File

@ -22,14 +22,7 @@ from . import mlog
from . import compilers
from .compilers import (
CLANG_OSX,
CLANG_STANDARD,
CLANG_WIN,
GCC_CYGWIN,
GCC_MINGW,
GCC_OSX,
GCC_STANDARD,
ICC_STANDARD,
CompilerType,
is_assembly,
is_header,
is_library,
@ -451,12 +444,12 @@ class Environment:
def get_gnu_compiler_type(defines):
# Detect GCC type (Apple, MinGW, Cygwin, Unix)
if '__APPLE__' in defines:
return GCC_OSX
return CompilerType.GCC_OSX
elif '__MINGW32__' in defines or '__MINGW64__' in defines:
return GCC_MINGW
return CompilerType.GCC_MINGW
elif '__CYGWIN__' in defines:
return GCC_CYGWIN
return GCC_STANDARD
return CompilerType.GCC_CYGWIN
return CompilerType.GCC_STANDARD
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')
@ -560,14 +553,14 @@ This is probably wrong, it should always point to the native compiler.''' % evar
if not defines:
popen_exceptions[' '.join(compiler)] = 'no pre-processor defines'
continue
gtype = self.get_gnu_compiler_type(defines)
compiler_type = self.get_gnu_compiler_type(defines)
if guess_gcc_or_lcc == 'lcc':
version = self.get_lcc_version_from_defines(defines)
cls = ElbrusCCompiler if lang == 'c' else ElbrusCPPCompiler
else:
version = self.get_gnu_version_from_defines(defines)
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:
# 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)
if 'clang' in out:
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):
cltype = CLANG_WIN
compiler_type = CompilerType.CLANG_MINGW
else:
cltype = CLANG_STANDARD
compiler_type = CompilerType.CLANG_STANDARD
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:
# Latest versions of Visual Studio 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)
if '(ICC)' in out:
# TODO: add microsoft add check OSX
inteltype = ICC_STANDARD
compiler_type = CompilerType.ICC_STANDARD
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:
cls = ArmCCompiler if lang == 'c' else ArmCPPCompiler
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:
popen_exceptions[' '.join(compiler)] = 'no pre-processor defines'
continue
gtype = self.get_gnu_compiler_type(defines)
compiler_type = self.get_gnu_compiler_type(defines)
if guess_gcc_or_lcc == 'lcc':
version = self.get_lcc_version_from_defines(defines)
cls = ElbrusFortranCompiler
else:
version = self.get_gnu_version_from_defines(defines)
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:
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:
popen_exceptions[' '.join(compiler)] = 'no pre-processor defines'
continue
gtype = self.get_gnu_compiler_type(defines)
compiler_type = self.get_gnu_compiler_type(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'):
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'):
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)
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:
popen_exceptions[' '.join(compiler)] = 'no pre-processor defines'
continue
gtype = self.get_gnu_compiler_type(defines)
compiler_type = self.get_gnu_compiler_type(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'):
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'):
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)
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):
cargsfunc = mesonbuild.compilers.CompilerArgs
## 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
l = cargsfunc(gcc, ['-Lfoodir', '-lfoo'])
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):
self.assertIsInstance(linker, ar)
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():
self.assertEqual(cc.gcc_type, mesonbuild.compilers.GCC_MINGW)
self.assertEqual(cc.compiler_type, mesonbuild.compilers.CompilerType.GCC_MINGW)
elif is_cygwin():
self.assertEqual(cc.gcc_type, mesonbuild.compilers.GCC_CYGWIN)
self.assertEqual(cc.compiler_type, mesonbuild.compilers.CompilerType.GCC_CYGWIN)
else:
self.assertEqual(cc.gcc_type, mesonbuild.compilers.GCC_STANDARD)
self.assertEqual(cc.compiler_type, mesonbuild.compilers.CompilerType.GCC_STANDARD)
if isinstance(cc, clang):
self.assertIsInstance(linker, ar)
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():
# Not implemented yet
self.assertEqual(cc.clang_type, mesonbuild.compilers.CLANG_WIN)
self.assertEqual(cc.compiler_type, mesonbuild.compilers.CompilerType.CLANG_MINGW)
else:
self.assertEqual(cc.clang_type, mesonbuild.compilers.CLANG_STANDARD)
self.assertEqual(cc.compiler_type, mesonbuild.compilers.CompilerType.CLANG_STANDARD)
if isinstance(cc, intel):
self.assertIsInstance(linker, ar)
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():
self.assertEqual(cc.icc_type, mesonbuild.compilers.ICC_WIN)
self.assertEqual(cc.compiler_type, mesonbuild.compilers.CompilerType.ICC_WIN)
else:
self.assertEqual(cc.icc_type, mesonbuild.compilers.ICC_STANDARD)
self.assertEqual(cc.compiler_type, mesonbuild.compilers.CompilerType.ICC_STANDARD)
if isinstance(cc, msvc):
self.assertTrue(is_windows())
self.assertIsInstance(linker, lib)
@ -3457,11 +3457,11 @@ class LinuxlikeTests(BasePlatformTests):
for v in compiler.get_options()[lang_std].choices:
if (compiler.get_id() == 'clang' and '17' in v and
(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
if (compiler.get_id() == 'clang' and '2a' in v and
(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
if (compiler.get_id() == 'gcc' and '2a' in v and version_compare(compiler.version, '<8.0.0')):
continue

Write Preview
Loading…
Cancel
Save