summaryrefslogtreecommitdiffstats
path: root/mesonbuild/compilers/c.py
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--mesonbuild/compilers/c.py740
1 files changed, 740 insertions, 0 deletions
diff --git a/mesonbuild/compilers/c.py b/mesonbuild/compilers/c.py
new file mode 100644
index 0000000..4d9283a
--- /dev/null
+++ b/mesonbuild/compilers/c.py
@@ -0,0 +1,740 @@
+# Copyright 2012-2020 The Meson development team
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+# http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from __future__ import annotations
+
+import os.path
+import typing as T
+
+from .. import coredata
+from .. import mlog
+from ..mesonlib import MesonException, version_compare, OptionKey
+from .c_function_attributes import C_FUNC_ATTRIBUTES
+from .mixins.clike import CLikeCompiler
+from .mixins.ccrx import CcrxCompiler
+from .mixins.xc16 import Xc16Compiler
+from .mixins.compcert import CompCertCompiler
+from .mixins.ti import TICompiler
+from .mixins.arm import ArmCompiler, ArmclangCompiler
+from .mixins.visualstudio import MSVCCompiler, ClangClCompiler
+from .mixins.gnu import GnuCompiler
+from .mixins.gnu import gnu_common_warning_args, gnu_c_warning_args
+from .mixins.intel import IntelGnuLikeCompiler, IntelVisualStudioLikeCompiler
+from .mixins.clang import ClangCompiler
+from .mixins.elbrus import ElbrusCompiler
+from .mixins.pgi import PGICompiler
+from .mixins.emscripten import EmscriptenMixin
+from .compilers import (
+ gnu_winlibs,
+ msvc_winlibs,
+ Compiler,
+)
+
+if T.TYPE_CHECKING:
+ from ..coredata import MutableKeyedOptionDictType, KeyedOptionDictType
+ from ..dependencies import Dependency
+ from ..envconfig import MachineInfo
+ from ..environment import Environment
+ from ..linkers import DynamicLinker
+ from ..mesonlib import MachineChoice
+ from ..programs import ExternalProgram
+ from .compilers import CompileCheckMode
+
+ CompilerMixinBase = Compiler
+else:
+ CompilerMixinBase = object
+
+
+class CCompiler(CLikeCompiler, Compiler):
+ def attribute_check_func(self, name: str) -> str:
+ try:
+ return C_FUNC_ATTRIBUTES[name]
+ except KeyError:
+ raise MesonException(f'Unknown function attribute "{name}"')
+
+ language = 'c'
+
+ def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool,
+ info: 'MachineInfo', exe_wrapper: T.Optional['ExternalProgram'] = None,
+ linker: T.Optional['DynamicLinker'] = None,
+ full_version: T.Optional[str] = None):
+ # If a child ObjC or CPP class has already set it, don't set it ourselves
+ Compiler.__init__(self, ccache, exelist, version, for_machine, info,
+ is_cross=is_cross, full_version=full_version, linker=linker)
+ CLikeCompiler.__init__(self, exe_wrapper)
+
+ def get_no_stdinc_args(self) -> T.List[str]:
+ return ['-nostdinc']
+
+ def sanity_check(self, work_dir: str, environment: 'Environment') -> None:
+ code = 'int main(void) { int class=0; return class; }\n'
+ return self._sanity_check_impl(work_dir, environment, 'sanitycheckc.c', code)
+
+ def has_header_symbol(self, hname: str, symbol: str, prefix: str,
+ env: 'Environment', *,
+ extra_args: T.Union[None, T.List[str], T.Callable[['CompileCheckMode'], T.List[str]]] = None,
+ dependencies: T.Optional[T.List['Dependency']] = None) -> T.Tuple[bool, bool]:
+ fargs = {'prefix': prefix, 'header': hname, 'symbol': symbol}
+ t = '''{prefix}
+ #include <{header}>
+ int main(void) {{
+ /* If it's not defined as a macro, try to use as a symbol */
+ #ifndef {symbol}
+ {symbol};
+ #endif
+ return 0;
+ }}'''
+ return self.compiles(t.format(**fargs), env, extra_args=extra_args,
+ dependencies=dependencies)
+
+ def get_options(self) -> 'MutableKeyedOptionDictType':
+ opts = super().get_options()
+ opts.update({
+ OptionKey('std', machine=self.for_machine, lang=self.language): coredata.UserComboOption(
+ 'C language standard to use',
+ ['none'],
+ 'none',
+ )
+ })
+ return opts
+
+
+class _ClangCStds(CompilerMixinBase):
+
+ """Mixin class for clang based compilers for setting C standards.
+
+ This is used by both ClangCCompiler and ClangClCompiler, as they share
+ the same versions
+ """
+
+ _C17_VERSION = '>=6.0.0'
+ _C18_VERSION = '>=8.0.0'
+ _C2X_VERSION = '>=9.0.0'
+
+ def get_options(self) -> 'MutableKeyedOptionDictType':
+ opts = super().get_options()
+ c_stds = ['c89', 'c99', 'c11']
+ g_stds = ['gnu89', 'gnu99', 'gnu11']
+ # https://releases.llvm.org/6.0.0/tools/clang/docs/ReleaseNotes.html
+ # https://en.wikipedia.org/wiki/Xcode#Latest_versions
+ if version_compare(self.version, self._C17_VERSION):
+ c_stds += ['c17']
+ g_stds += ['gnu17']
+ if version_compare(self.version, self._C18_VERSION):
+ c_stds += ['c18']
+ g_stds += ['gnu18']
+ if version_compare(self.version, self._C2X_VERSION):
+ c_stds += ['c2x']
+ g_stds += ['gnu2x']
+ opts[OptionKey('std', machine=self.for_machine, lang=self.language)].choices = ['none'] + c_stds + g_stds
+ return opts
+
+
+class ClangCCompiler(_ClangCStds, ClangCompiler, CCompiler):
+
+ def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool,
+ info: 'MachineInfo', exe_wrapper: T.Optional['ExternalProgram'] = None,
+ linker: T.Optional['DynamicLinker'] = None,
+ defines: T.Optional[T.Dict[str, str]] = None,
+ full_version: T.Optional[str] = None):
+ CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross, info, exe_wrapper, linker=linker, full_version=full_version)
+ ClangCompiler.__init__(self, defines)
+ default_warn_args = ['-Wall', '-Winvalid-pch']
+ self.warn_args = {'0': [],
+ '1': default_warn_args,
+ '2': default_warn_args + ['-Wextra'],
+ '3': default_warn_args + ['-Wextra', '-Wpedantic'],
+ 'everything': ['-Weverything']}
+
+ def get_options(self) -> 'MutableKeyedOptionDictType':
+ opts = super().get_options()
+ if self.info.is_windows() or self.info.is_cygwin():
+ opts.update({
+ OptionKey('winlibs', machine=self.for_machine, lang=self.language): coredata.UserArrayOption(
+ 'Standard Win libraries to link against',
+ gnu_winlibs,
+ ),
+ })
+ return opts
+
+ def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
+ args = []
+ std = options[OptionKey('std', machine=self.for_machine, lang=self.language)]
+ if std.value != 'none':
+ args.append('-std=' + std.value)
+ return args
+
+ def get_option_link_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
+ if self.info.is_windows() or self.info.is_cygwin():
+ # without a typedict mypy can't understand this.
+ libs = options[OptionKey('winlibs', machine=self.for_machine, lang=self.language)].value.copy()
+ assert isinstance(libs, list)
+ for l in libs:
+ assert isinstance(l, str)
+ return libs
+ return []
+
+
+class ArmLtdClangCCompiler(ClangCCompiler):
+
+ id = 'armltdclang'
+
+
+class AppleClangCCompiler(ClangCCompiler):
+
+ """Handle the differences between Apple Clang and Vanilla Clang.
+
+ Right now this just handles the differences between the versions that new
+ C standards were added.
+ """
+
+ _C17_VERSION = '>=10.0.0'
+ _C18_VERSION = '>=11.0.0'
+ _C2X_VERSION = '>=11.0.0'
+
+
+class EmscriptenCCompiler(EmscriptenMixin, ClangCCompiler):
+
+ id = 'emscripten'
+
+ def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool,
+ info: 'MachineInfo', exe_wrapper: T.Optional['ExternalProgram'] = None,
+ linker: T.Optional['DynamicLinker'] = None,
+ defines: T.Optional[T.Dict[str, str]] = None,
+ full_version: T.Optional[str] = None):
+ if not is_cross:
+ raise MesonException('Emscripten compiler can only be used for cross compilation.')
+ if not version_compare(version, '>=1.39.19'):
+ raise MesonException('Meson requires Emscripten >= 1.39.19')
+ ClangCCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
+ info, exe_wrapper=exe_wrapper, linker=linker,
+ defines=defines, full_version=full_version)
+
+
+class ArmclangCCompiler(ArmclangCompiler, CCompiler):
+ '''
+ Keil armclang
+ '''
+
+ def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool,
+ info: 'MachineInfo', exe_wrapper: T.Optional['ExternalProgram'] = None,
+ linker: T.Optional['DynamicLinker'] = None,
+ full_version: T.Optional[str] = None):
+ CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
+ info, exe_wrapper, linker=linker, full_version=full_version)
+ ArmclangCompiler.__init__(self)
+ default_warn_args = ['-Wall', '-Winvalid-pch']
+ self.warn_args = {'0': [],
+ '1': default_warn_args,
+ '2': default_warn_args + ['-Wextra'],
+ '3': default_warn_args + ['-Wextra', '-Wpedantic'],
+ 'everything': ['-Weverything']}
+
+ def get_options(self) -> 'MutableKeyedOptionDictType':
+ opts = CCompiler.get_options(self)
+ key = OptionKey('std', machine=self.for_machine, lang=self.language)
+ opts[key].choices = ['none', 'c90', 'c99', 'c11', 'gnu90', 'gnu99', 'gnu11']
+ return opts
+
+ def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
+ args = []
+ std = options[OptionKey('std', machine=self.for_machine, lang=self.language)]
+ if std.value != 'none':
+ args.append('-std=' + std.value)
+ return args
+
+ def get_option_link_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
+ return []
+
+
+class GnuCCompiler(GnuCompiler, CCompiler):
+
+ _C18_VERSION = '>=8.0.0'
+ _C2X_VERSION = '>=9.0.0'
+ _INVALID_PCH_VERSION = ">=3.4.0"
+
+ def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool,
+ info: 'MachineInfo', exe_wrapper: T.Optional['ExternalProgram'] = None,
+ linker: T.Optional['DynamicLinker'] = None,
+ defines: T.Optional[T.Dict[str, str]] = None,
+ full_version: T.Optional[str] = None):
+ CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross, info, exe_wrapper, linker=linker, full_version=full_version)
+ GnuCompiler.__init__(self, defines)
+ default_warn_args = ['-Wall']
+ if version_compare(self.version, self._INVALID_PCH_VERSION):
+ default_warn_args += ['-Winvalid-pch']
+ self.warn_args = {'0': [],
+ '1': default_warn_args,
+ '2': default_warn_args + ['-Wextra'],
+ '3': default_warn_args + ['-Wextra', '-Wpedantic'],
+ 'everything': (default_warn_args + ['-Wextra', '-Wpedantic'] +
+ self.supported_warn_args(gnu_common_warning_args) +
+ self.supported_warn_args(gnu_c_warning_args))}
+
+ def get_options(self) -> 'MutableKeyedOptionDictType':
+ opts = CCompiler.get_options(self)
+ c_stds = ['c89', 'c99', 'c11']
+ g_stds = ['gnu89', 'gnu99', 'gnu11']
+ if version_compare(self.version, self._C18_VERSION):
+ c_stds += ['c17', 'c18']
+ g_stds += ['gnu17', 'gnu18']
+ if version_compare(self.version, self._C2X_VERSION):
+ c_stds += ['c2x']
+ g_stds += ['gnu2x']
+ key = OptionKey('std', machine=self.for_machine, lang=self.language)
+ opts[key].choices = ['none'] + c_stds + g_stds
+ if self.info.is_windows() or self.info.is_cygwin():
+ opts.update({
+ key.evolve('winlibs'): coredata.UserArrayOption(
+ 'Standard Win libraries to link against',
+ gnu_winlibs,
+ ),
+ })
+ return opts
+
+ def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
+ args = []
+ std = options[OptionKey('std', lang=self.language, machine=self.for_machine)]
+ if std.value != 'none':
+ args.append('-std=' + std.value)
+ return args
+
+ def get_option_link_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
+ if self.info.is_windows() or self.info.is_cygwin():
+ # without a typeddict mypy can't figure this out
+ libs: T.List[str] = options[OptionKey('winlibs', lang=self.language, machine=self.for_machine)].value.copy()
+ assert isinstance(libs, list)
+ for l in libs:
+ assert isinstance(l, str)
+ return libs
+ return []
+
+ def get_pch_use_args(self, pch_dir: str, header: str) -> T.List[str]:
+ return ['-fpch-preprocess', '-include', os.path.basename(header)]
+
+
+class PGICCompiler(PGICompiler, CCompiler):
+ def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool,
+ info: 'MachineInfo', exe_wrapper: T.Optional['ExternalProgram'] = None,
+ linker: T.Optional['DynamicLinker'] = None,
+ full_version: T.Optional[str] = None):
+ CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
+ info, exe_wrapper, linker=linker, full_version=full_version)
+ PGICompiler.__init__(self)
+
+
+class NvidiaHPC_CCompiler(PGICompiler, CCompiler):
+
+ id = 'nvidia_hpc'
+
+ def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool,
+ info: 'MachineInfo', exe_wrapper: T.Optional['ExternalProgram'] = None,
+ linker: T.Optional['DynamicLinker'] = None,
+ full_version: T.Optional[str] = None):
+ CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
+ info, exe_wrapper, linker=linker, full_version=full_version)
+ PGICompiler.__init__(self)
+
+
+class ElbrusCCompiler(ElbrusCompiler, CCompiler):
+ def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool,
+ info: 'MachineInfo', exe_wrapper: T.Optional['ExternalProgram'] = None,
+ linker: T.Optional['DynamicLinker'] = None,
+ defines: T.Optional[T.Dict[str, str]] = None,
+ full_version: T.Optional[str] = None):
+ CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
+ info, exe_wrapper, linker=linker, full_version=full_version)
+ ElbrusCompiler.__init__(self)
+
+ def get_options(self) -> 'MutableKeyedOptionDictType':
+ opts = CCompiler.get_options(self)
+ stds = ['c89', 'c9x', 'c99', 'gnu89', 'gnu9x', 'gnu99']
+ stds += ['iso9899:1990', 'iso9899:199409', 'iso9899:1999']
+ if version_compare(self.version, '>=1.20.00'):
+ stds += ['c11', 'gnu11']
+ if version_compare(self.version, '>=1.21.00') and version_compare(self.version, '<1.22.00'):
+ stds += ['c90', 'c1x', 'gnu90', 'gnu1x', 'iso9899:2011']
+ if version_compare(self.version, '>=1.23.00'):
+ stds += ['c90', 'c1x', 'gnu90', 'gnu1x', 'iso9899:2011']
+ if version_compare(self.version, '>=1.26.00'):
+ stds += ['c17', 'c18', 'iso9899:2017', 'iso9899:2018', 'gnu17', 'gnu18']
+ opts[OptionKey('std', machine=self.for_machine, lang=self.language)].choices = ['none'] + stds
+ return opts
+
+ # Elbrus C compiler does not have lchmod, but there is only linker warning, not compiler error.
+ # So we should explicitly fail at this case.
+ def has_function(self, funcname: str, prefix: str, env: 'Environment', *,
+ extra_args: T.Optional[T.List[str]] = None,
+ dependencies: T.Optional[T.List['Dependency']] = None) -> T.Tuple[bool, bool]:
+ if funcname == 'lchmod':
+ return False, False
+ else:
+ return super().has_function(funcname, prefix, env,
+ extra_args=extra_args,
+ dependencies=dependencies)
+
+
+class IntelCCompiler(IntelGnuLikeCompiler, CCompiler):
+ def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool,
+ info: 'MachineInfo', exe_wrapper: T.Optional['ExternalProgram'] = None,
+ linker: T.Optional['DynamicLinker'] = None,
+ full_version: T.Optional[str] = None):
+ CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
+ info, exe_wrapper, linker=linker, full_version=full_version)
+ IntelGnuLikeCompiler.__init__(self)
+ self.lang_header = 'c-header'
+ default_warn_args = ['-Wall', '-w3']
+ self.warn_args = {'0': [],
+ '1': default_warn_args + ['-diag-disable:remark'],
+ '2': default_warn_args + ['-Wextra', '-diag-disable:remark'],
+ '3': default_warn_args + ['-Wextra', '-diag-disable:remark'],
+ 'everything': default_warn_args + ['-Wextra']}
+
+ def get_options(self) -> 'MutableKeyedOptionDictType':
+ opts = CCompiler.get_options(self)
+ c_stds = ['c89', 'c99']
+ g_stds = ['gnu89', 'gnu99']
+ if version_compare(self.version, '>=16.0.0'):
+ c_stds += ['c11']
+ opts[OptionKey('std', machine=self.for_machine, lang=self.language)].choices = ['none'] + c_stds + g_stds
+ return opts
+
+ def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
+ args = []
+ std = options[OptionKey('std', machine=self.for_machine, lang=self.language)]
+ if std.value != 'none':
+ args.append('-std=' + std.value)
+ return args
+
+
+class IntelLLVMCCompiler(ClangCCompiler):
+
+ id = 'intel-llvm'
+
+
+class VisualStudioLikeCCompilerMixin(CompilerMixinBase):
+
+ """Shared methods that apply to MSVC-like C compilers."""
+
+ def get_options(self) -> 'MutableKeyedOptionDictType':
+ opts = super().get_options()
+ opts.update({
+ OptionKey('winlibs', machine=self.for_machine, lang=self.language): coredata.UserArrayOption(
+ 'Windows libs to link against.',
+ msvc_winlibs,
+ ),
+ })
+ return opts
+
+ def get_option_link_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
+ # need a TypeDict to make this work
+ key = OptionKey('winlibs', machine=self.for_machine, lang=self.language)
+ libs = options[key].value.copy()
+ assert isinstance(libs, list)
+ for l in libs:
+ assert isinstance(l, str)
+ return libs
+
+
+class VisualStudioCCompiler(MSVCCompiler, VisualStudioLikeCCompilerMixin, CCompiler):
+
+ _C11_VERSION = '>=19.28'
+ _C17_VERSION = '>=19.28'
+
+ def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice,
+ is_cross: bool, info: 'MachineInfo', target: str,
+ exe_wrapper: T.Optional['ExternalProgram'] = None,
+ linker: T.Optional['DynamicLinker'] = None,
+ full_version: T.Optional[str] = None):
+ CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
+ info, exe_wrapper, linker=linker,
+ full_version=full_version)
+ MSVCCompiler.__init__(self, target)
+
+ def get_options(self) -> 'MutableKeyedOptionDictType':
+ opts = super().get_options()
+ c_stds = ['c89', 'c99']
+ # Need to have these to be compatible with projects
+ # that set c_std to e.g. gnu99.
+ # https://github.com/mesonbuild/meson/issues/7611
+ g_stds = ['gnu89', 'gnu90', 'gnu9x', 'gnu99']
+ if version_compare(self.version, self._C11_VERSION):
+ c_stds += ['c11']
+ g_stds += ['gnu1x', 'gnu11']
+ if version_compare(self.version, self._C17_VERSION):
+ c_stds += ['c17', 'c18']
+ g_stds += ['gnu17', 'gnu18']
+ key = OptionKey('std', machine=self.for_machine, lang=self.language)
+ opts[key].choices = ['none'] + c_stds + g_stds
+ return opts
+
+ def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
+ args = []
+ std = options[OptionKey('std', machine=self.for_machine, lang=self.language)]
+ if std.value.startswith('gnu'):
+ mlog.log_once(
+ 'cl.exe does not actually support gnu standards, and meson '
+ 'will instead demote to the nearest ISO C standard. This '
+ 'may cause compilation to fail.')
+ # As of MVSC 16.8, /std:c11 and /std:c17 are the only valid C standard options.
+ if std.value in {'c11', 'gnu1x', 'gnu11'}:
+ args.append('/std:c11')
+ elif std.value in {'c17', 'c18', 'gnu17', 'gnu18'}:
+ args.append('/std:c17')
+ return args
+
+
+class ClangClCCompiler(_ClangCStds, ClangClCompiler, VisualStudioLikeCCompilerMixin, CCompiler):
+ def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice,
+ is_cross: bool, info: 'MachineInfo', target: str,
+ exe_wrapper: T.Optional['ExternalProgram'] = None,
+ linker: T.Optional['DynamicLinker'] = None,
+ full_version: T.Optional[str] = None):
+ CCompiler.__init__(self, [], exelist, version, for_machine, is_cross,
+ info, exe_wrapper, linker=linker,
+ full_version=full_version)
+ ClangClCompiler.__init__(self, target)
+
+ def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
+ key = OptionKey('std', machine=self.for_machine, lang=self.language)
+ std = options[key].value
+ if std != "none":
+ return [f'/clang:-std={std}']
+ return []
+
+
+class IntelClCCompiler(IntelVisualStudioLikeCompiler, VisualStudioLikeCCompilerMixin, CCompiler):
+
+ """Intel "ICL" compiler abstraction."""
+
+ def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice,
+ is_cross: bool, info: 'MachineInfo', target: str,
+ exe_wrapper: T.Optional['ExternalProgram'] = None,
+ linker: T.Optional['DynamicLinker'] = None,
+ full_version: T.Optional[str] = None):
+ CCompiler.__init__(self, [], exelist, version, for_machine, is_cross,
+ info, exe_wrapper, linker=linker,
+ full_version=full_version)
+ IntelVisualStudioLikeCompiler.__init__(self, target)
+
+ def get_options(self) -> 'MutableKeyedOptionDictType':
+ opts = super().get_options()
+ key = OptionKey('std', machine=self.for_machine, lang=self.language)
+ opts[key].choices = ['none', 'c89', 'c99', 'c11']
+ return opts
+
+ def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
+ args = []
+ key = OptionKey('std', machine=self.for_machine, lang=self.language)
+ std = options[key]
+ if std.value == 'c89':
+ mlog.log_once("ICL doesn't explicitly implement c89, setting the standard to 'none', which is close.")
+ elif std.value != 'none':
+ args.append('/Qstd:' + std.value)
+ return args
+
+
+class IntelLLVMClCCompiler(IntelClCCompiler):
+
+ id = 'intel-llvm-cl'
+
+
+class ArmCCompiler(ArmCompiler, CCompiler):
+ def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice,
+ is_cross: bool, info: 'MachineInfo',
+ exe_wrapper: T.Optional['ExternalProgram'] = None,
+ linker: T.Optional['DynamicLinker'] = None,
+ full_version: T.Optional[str] = None):
+ CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
+ info, exe_wrapper, linker=linker,
+ full_version=full_version)
+ ArmCompiler.__init__(self)
+
+ def get_options(self) -> 'MutableKeyedOptionDictType':
+ opts = CCompiler.get_options(self)
+ key = OptionKey('std', machine=self.for_machine, lang=self.language)
+ opts[key].choices = ['none', 'c89', 'c99', 'c11']
+ return opts
+
+ def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
+ args = []
+ key = OptionKey('std', machine=self.for_machine, lang=self.language)
+ std = options[key]
+ if std.value != 'none':
+ args.append('--' + std.value)
+ return args
+
+
+class CcrxCCompiler(CcrxCompiler, CCompiler):
+ def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice,
+ is_cross: bool, info: 'MachineInfo',
+ exe_wrapper: T.Optional['ExternalProgram'] = None,
+ linker: T.Optional['DynamicLinker'] = None,
+ full_version: T.Optional[str] = None):
+ CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
+ info, exe_wrapper, linker=linker, full_version=full_version)
+ CcrxCompiler.__init__(self)
+
+ # Override CCompiler.get_always_args
+ def get_always_args(self) -> T.List[str]:
+ return ['-nologo']
+
+ def get_options(self) -> 'MutableKeyedOptionDictType':
+ opts = CCompiler.get_options(self)
+ key = OptionKey('std', machine=self.for_machine, lang=self.language)
+ opts[key].choices = ['none', 'c89', 'c99']
+ return opts
+
+ def get_no_stdinc_args(self) -> T.List[str]:
+ return []
+
+ def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
+ args = []
+ key = OptionKey('std', machine=self.for_machine, lang=self.language)
+ std = options[key]
+ if std.value == 'c89':
+ args.append('-lang=c')
+ elif std.value == 'c99':
+ args.append('-lang=c99')
+ return args
+
+ def get_compile_only_args(self) -> T.List[str]:
+ return []
+
+ def get_no_optimization_args(self) -> T.List[str]:
+ return ['-optimize=0']
+
+ def get_output_args(self, target: str) -> T.List[str]:
+ return [f'-output=obj={target}']
+
+ def get_werror_args(self) -> T.List[str]:
+ return ['-change_message=error']
+
+ def get_include_args(self, path: str, is_system: bool) -> T.List[str]:
+ if path == '':
+ path = '.'
+ return ['-include=' + path]
+
+
+class Xc16CCompiler(Xc16Compiler, CCompiler):
+ def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice,
+ is_cross: bool, info: 'MachineInfo',
+ exe_wrapper: T.Optional['ExternalProgram'] = None,
+ linker: T.Optional['DynamicLinker'] = None,
+ full_version: T.Optional[str] = None):
+ CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
+ info, exe_wrapper, linker=linker, full_version=full_version)
+ Xc16Compiler.__init__(self)
+
+ def get_options(self) -> 'MutableKeyedOptionDictType':
+ opts = CCompiler.get_options(self)
+ key = OptionKey('std', machine=self.for_machine, lang=self.language)
+ opts[key].choices = ['none', 'c89', 'c99', 'gnu89', 'gnu99']
+ return opts
+
+ def get_no_stdinc_args(self) -> T.List[str]:
+ return []
+
+ def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
+ args = []
+ key = OptionKey('std', machine=self.for_machine, lang=self.language)
+ std = options[key]
+ if std.value != 'none':
+ args.append('-ansi')
+ args.append('-std=' + std.value)
+ return args
+
+ def get_compile_only_args(self) -> T.List[str]:
+ return []
+
+ def get_no_optimization_args(self) -> T.List[str]:
+ return ['-O0']
+
+ def get_output_args(self, target: str) -> T.List[str]:
+ return [f'-o{target}']
+
+ def get_werror_args(self) -> T.List[str]:
+ return ['-change_message=error']
+
+ def get_include_args(self, path: str, is_system: bool) -> T.List[str]:
+ if path == '':
+ path = '.'
+ return ['-I' + path]
+
+class CompCertCCompiler(CompCertCompiler, CCompiler):
+ def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice,
+ is_cross: bool, info: 'MachineInfo',
+ exe_wrapper: T.Optional['ExternalProgram'] = None,
+ linker: T.Optional['DynamicLinker'] = None,
+ full_version: T.Optional[str] = None):
+ CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
+ info, exe_wrapper, linker=linker, full_version=full_version)
+ CompCertCompiler.__init__(self)
+
+ def get_options(self) -> 'MutableKeyedOptionDictType':
+ opts = CCompiler.get_options(self)
+ key = OptionKey('std', machine=self.for_machine, lang=self.language)
+ opts[key].choices = ['none', 'c89', 'c99']
+ return opts
+
+ def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
+ return []
+
+ def get_no_optimization_args(self) -> T.List[str]:
+ return ['-O0']
+
+ def get_output_args(self, target: str) -> T.List[str]:
+ return [f'-o{target}']
+
+ def get_werror_args(self) -> T.List[str]:
+ return ['-Werror']
+
+ def get_include_args(self, path: str, is_system: bool) -> T.List[str]:
+ if path == '':
+ path = '.'
+ return ['-I' + path]
+
+class TICCompiler(TICompiler, CCompiler):
+ def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice,
+ is_cross: bool, info: 'MachineInfo',
+ exe_wrapper: T.Optional['ExternalProgram'] = None,
+ linker: T.Optional['DynamicLinker'] = None,
+ full_version: T.Optional[str] = None):
+ CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
+ info, exe_wrapper, linker=linker, full_version=full_version)
+ TICompiler.__init__(self)
+
+ # Override CCompiler.get_always_args
+ def get_always_args(self) -> T.List[str]:
+ return []
+
+ def get_options(self) -> 'MutableKeyedOptionDictType':
+ opts = CCompiler.get_options(self)
+ key = OptionKey('std', machine=self.for_machine, lang=self.language)
+ opts[key].choices = ['none', 'c89', 'c99', 'c11']
+ return opts
+
+ def get_no_stdinc_args(self) -> T.List[str]:
+ return []
+
+ def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
+ args = []
+ key = OptionKey('std', machine=self.for_machine, lang=self.language)
+ std = options[key]
+ if std.value != 'none':
+ args.append('--' + std.value)
+ return args
+
+class C2000CCompiler(TICCompiler):
+ # Required for backwards compat with projects created before ti-cgt support existed
+ id = 'c2000'
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-11 05:21:35 +0000