|
|
|
# SPDX-License-Identifier: Apache-2.0
|
|
|
|
# Copyright 2019 The meson development team
|
|
|
|
|
|
|
|
from __future__ import annotations
|
|
|
|
|
|
|
|
"""Abstractions to simplify compilers that implement an MSVC compatible
|
|
|
|
interface.
|
|
|
|
"""
|
|
|
|
|
|
|
|
import abc
|
|
|
|
import os
|
|
|
|
import typing as T
|
|
|
|
|
|
|
|
from ... import arglist
|
|
|
|
from ... import mesonlib
|
|
|
|
from ... import mlog
|
|
|
|
from mesonbuild.compilers.compilers import CompileCheckMode
|
|
|
|
|
|
|
|
if T.TYPE_CHECKING:
|
|
|
|
from ...environment import Environment
|
|
|
|
from ...dependencies import Dependency
|
|
|
|
from .clike import CLikeCompiler as Compiler
|
|
|
|
else:
|
|
|
|
# This is a bit clever, for mypy we pretend that these mixins descend from
|
|
|
|
# Compiler, so we get all of the methods and attributes defined for us, but
|
|
|
|
# for runtime we make them descend from object (which all classes normally
|
|
|
|
# do). This gives up DRYer type checking, with no runtime impact
|
|
|
|
Compiler = object
|
|
|
|
|
|
|
|
vs32_instruction_set_args: T.Dict[str, T.Optional[T.List[str]]] = {
|
|
|
|
'mmx': ['/arch:SSE'], # There does not seem to be a flag just for MMX
|
|
|
|
'sse': ['/arch:SSE'],
|
|
|
|
'sse2': ['/arch:SSE2'],
|
|
|
|
'sse3': ['/arch:AVX'], # VS leaped from SSE2 directly to AVX.
|
|
|
|
'sse41': ['/arch:AVX'],
|
|
|
|
'sse42': ['/arch:AVX'],
|
|
|
|
'avx': ['/arch:AVX'],
|
|
|
|
'avx2': ['/arch:AVX2'],
|
|
|
|
'neon': None,
|
|
|
|
}
|
|
|
|
|
|
|
|
# The 64 bit compiler defaults to /arch:avx.
|
|
|
|
vs64_instruction_set_args: T.Dict[str, T.Optional[T.List[str]]] = {
|
|
|
|
'mmx': ['/arch:AVX'],
|
|
|
|
'sse': ['/arch:AVX'],
|
|
|
|
'sse2': ['/arch:AVX'],
|
|
|
|
'sse3': ['/arch:AVX'],
|
|
|
|
'ssse3': ['/arch:AVX'],
|
|
|
|
'sse41': ['/arch:AVX'],
|
|
|
|
'sse42': ['/arch:AVX'],
|
|
|
|
'avx': ['/arch:AVX'],
|
|
|
|
'avx2': ['/arch:AVX2'],
|
|
|
|
'neon': None,
|
|
|
|
}
|
|
|
|
|
|
|
|
msvc_optimization_args: T.Dict[str, T.List[str]] = {
|
|
|
|
'plain': [],
|
|
|
|
'0': ['/Od'],
|
|
|
|
'g': [], # No specific flag to optimize debugging, /Zi or /ZI will create debug information
|
|
|
|
'1': ['/O1'],
|
|
|
|
'2': ['/O2'],
|
|
|
|
'3': ['/O2', '/Gw'],
|
|
|
|
's': ['/O1', '/Gw'],
|
|
|
|
}
|
|
|
|
|
|
|
|
msvc_debug_args: T.Dict[bool, T.List[str]] = {
|
|
|
|
False: [],
|
|
|
|
True: ['/Zi']
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
class VisualStudioLikeCompiler(Compiler, metaclass=abc.ABCMeta):
|
|
|
|
|
|
|
|
"""A common interface for all compilers implementing an MSVC-style
|
|
|
|
interface.
|
|
|
|
|
|
|
|
A number of compilers attempt to mimic MSVC, with varying levels of
|
|
|
|
success, such as Clang-CL and ICL (the Intel C/C++ Compiler for Windows).
|
|
|
|
This class implements as much common logic as possible.
|
|
|
|
"""
|
|
|
|
|
|
|
|
std_warn_args = ['/W3']
|
|
|
|
std_opt_args = ['/O2']
|
|
|
|
ignore_libs = arglist.UNIXY_COMPILER_INTERNAL_LIBS + ['execinfo']
|
|
|
|
internal_libs: T.List[str] = []
|
|
|
|
|
|
|
|
crt_args: T.Dict[str, T.List[str]] = {
|
|
|
|
'none': [],
|
|
|
|
'md': ['/MD'],
|
|
|
|
'mdd': ['/MDd'],
|
|
|
|
'mt': ['/MT'],
|
|
|
|
'mtd': ['/MTd'],
|
|
|
|
}
|
|
|
|
|
|
|
|
# /showIncludes is needed for build dependency tracking in Ninja
|
|
|
|
# See: https://ninja-build.org/manual.html#_deps
|
|
|
|
# Assume UTF-8 sources by default, but self.unix_args_to_native() removes it
|
|
|
|
# if `/source-charset` is set too.
|
|
|
|
# It is also dropped if Visual Studio 2013 or earlier is used, since it would
|
|
|
|
# not be supported in that case.
|
|
|
|
always_args = ['/nologo', '/showIncludes', '/utf-8']
|
|
|
|
warn_args: T.Dict[str, T.List[str]] = {
|
|
|
|
'0': [],
|
|
|
|
'1': ['/W2'],
|
|
|
|
'2': ['/W3'],
|
|
|
|
'3': ['/W4'],
|
|
|
|
'everything': ['/Wall'],
|
|
|
|
}
|
|
|
|
|
|
|
|
INVOKES_LINKER = False
|
|
|
|
|
|
|
|
def __init__(self, target: str):
|
|
|
|
self.base_options = {mesonlib.OptionKey(o) for o in ['b_pch', 'b_ndebug', 'b_vscrt']} # FIXME add lto, pgo and the like
|
|
|
|
self.target = target
|
|
|
|
self.is_64 = ('x64' in target) or ('x86_64' in target)
|
|
|
|
# do some canonicalization of target machine
|
|
|
|
if 'x86_64' in target:
|
|
|
|
self.machine = 'x64'
|
|
|
|
elif '86' in target:
|
|
|
|
self.machine = 'x86'
|
|
|
|
elif 'aarch64' in target:
|
|
|
|
self.machine = 'arm64'
|
|
|
|
elif 'arm' in target:
|
|
|
|
self.machine = 'arm'
|
|
|
|
else:
|
|
|
|
self.machine = target
|
|
|
|
if mesonlib.version_compare(self.version, '>=19.28.29910'): # VS 16.9.0 includes cl 19.28.29910
|
|
|
|
self.base_options.add(mesonlib.OptionKey('b_sanitize'))
|
|
|
|
assert self.linker is not None
|
|
|
|
self.linker.machine = self.machine
|
|
|
|
|
|
|
|
# Override CCompiler.get_always_args
|
|
|
|
def get_always_args(self) -> T.List[str]:
|
|
|
|
# TODO: use ImmutableListProtocol[str] here instead
|
|
|
|
return self.always_args.copy()
|
|
|
|
|
|
|
|
def get_pch_suffix(self) -> str:
|
|
|
|
return 'pch'
|
|
|
|
|
|
|
|
def get_pch_name(self, name: str) -> str:
|
|
|
|
chopped = os.path.basename(name).split('.')[:-1]
|
|
|
|
chopped.append(self.get_pch_suffix())
|
|
|
|
pchname = '.'.join(chopped)
|
|
|
|
return pchname
|
|
|
|
|
|
|
|
def get_pch_base_name(self, header: str) -> str:
|
|
|
|
# This needs to be implemented by inheriting classes
|
|
|
|
raise NotImplementedError
|
|
|
|
|
|
|
|
def get_pch_use_args(self, pch_dir: str, header: str) -> T.List[str]:
|
|
|
|
base = self.get_pch_base_name(header)
|
|
|
|
pchname = self.get_pch_name(header)
|
|
|
|
return ['/FI' + base, '/Yu' + base, '/Fp' + os.path.join(pch_dir, pchname)]
|
|
|
|
|
|
|
|
def get_preprocess_only_args(self) -> T.List[str]:
|
|
|
|
return ['/EP']
|
|
|
|
|
|
|
|
def get_preprocess_to_file_args(self) -> T.List[str]:
|
|
|
|
return ['/EP', '/P']
|
|
|
|
|
|
|
|
def get_compile_only_args(self) -> T.List[str]:
|
|
|
|
return ['/c']
|
|
|
|
|
|
|
|
def get_no_optimization_args(self) -> T.List[str]:
|
|
|
|
return ['/Od', '/Oi-']
|
|
|
|
|
|
|
|
def sanitizer_compile_args(self, value: str) -> T.List[str]:
|
|
|
|
if value == 'none':
|
|
|
|
return []
|
|
|
|
if value != 'address':
|
|
|
|
raise mesonlib.MesonException('VS only supports address sanitizer at the moment.')
|
|
|
|
return ['/fsanitize=address']
|
|
|
|
|
|
|
|
def get_output_args(self, outputname: str) -> T.List[str]:
|
|
|
|
if self.mode == 'PREPROCESSOR':
|
|
|
|
return ['/Fi' + outputname]
|
|
|
|
if outputname.endswith('.exe'):
|
|
|
|
return ['/Fe' + outputname]
|
|
|
|
return ['/Fo' + outputname]
|
|
|
|
|
|
|
|
def get_debug_args(self, is_debug: bool) -> T.List[str]:
|
|
|
|
return msvc_debug_args[is_debug]
|
|
|
|
|
|
|
|
def get_optimization_args(self, optimization_level: str) -> T.List[str]:
|
|
|
|
args = msvc_optimization_args[optimization_level]
|
|
|
|
if mesonlib.version_compare(self.version, '<18.0'):
|
|
|
|
args = [arg for arg in args if arg != '/Gw']
|
|
|
|
return args
|
|
|
|
|
|
|
|
def linker_to_compiler_args(self, args: T.List[str]) -> T.List[str]:
|
|
|
|
return ['/link'] + args
|
|
|
|
|
|
|
|
def get_pic_args(self) -> T.List[str]:
|
|
|
|
return [] # PIC is handled by the loader on Windows
|
|
|
|
|
|
|
|
def gen_vs_module_defs_args(self, defsfile: str) -> T.List[str]:
|
|
|
|
if not isinstance(defsfile, str):
|
|
|
|
raise RuntimeError('Module definitions file should be str')
|
|
|
|
# With MSVC, DLLs only export symbols that are explicitly exported,
|
|
|
|
# so if a module defs file is specified, we use that to export symbols
|
|
|
|
return ['/DEF:' + defsfile]
|
|
|
|
|
|
|
|
def gen_pch_args(self, header: str, source: str, pchname: str) -> T.Tuple[str, T.List[str]]:
|
|
|
|
objname = os.path.splitext(source)[0] + '.obj'
|
|
|
|
return objname, ['/Yc' + header, '/Fp' + pchname, '/Fo' + objname]
|
|
|
|
|
|
|
|
def openmp_flags(self) -> T.List[str]:
|
|
|
|
return ['/openmp']
|
|
|
|
|
|
|
|
def openmp_link_flags(self) -> T.List[str]:
|
|
|
|
return []
|
|
|
|
|
|
|
|
# FIXME, no idea what these should be.
|
|
|
|
def thread_flags(self, env: 'Environment') -> T.List[str]:
|
|
|
|
return []
|
|
|
|
|
|
|
|
@classmethod
|
|
|
|
def unix_args_to_native(cls, args: T.List[str]) -> T.List[str]:
|
|
|
|
result: T.List[str] = []
|
|
|
|
for i in args:
|
|
|
|
# -mms-bitfields is specific to MinGW-GCC
|
|
|
|
# -pthread is only valid for GCC
|
|
|
|
if i in {'-mms-bitfields', '-pthread'}:
|
|
|
|
continue
|
|
|
|
if i.startswith('-LIBPATH:'):
|
|
|
|
i = '/LIBPATH:' + i[9:]
|
|
|
|
elif i.startswith('-L'):
|
|
|
|
i = '/LIBPATH:' + i[2:]
|
|
|
|
# Translate GNU-style -lfoo library name to the import library
|
|
|
|
elif i.startswith('-l'):
|
|
|
|
name = i[2:]
|
|
|
|
if name in cls.ignore_libs:
|
|
|
|
# With MSVC, these are provided by the C runtime which is
|
|
|
|
# linked in by default
|
|
|
|
continue
|
|
|
|
else:
|
|
|
|
i = name + '.lib'
|
|
|
|
elif i.startswith('-isystem'):
|
|
|
|
# just use /I for -isystem system include path s
|
|
|
|
if i.startswith('-isystem='):
|
|
|
|
i = '/I' + i[9:]
|
|
|
|
else:
|
|
|
|
i = '/I' + i[8:]
|
|
|
|
elif i.startswith('-idirafter'):
|
|
|
|
# same as -isystem, but appends the path instead
|
|
|
|
if i.startswith('-idirafter='):
|
|
|
|
i = '/I' + i[11:]
|
|
|
|
else:
|
|
|
|
i = '/I' + i[10:]
|
|
|
|
# -pthread in link flags is only used on Linux
|
|
|
|
elif i == '-pthread':
|
|
|
|
continue
|
|
|
|
# cl.exe does not allow specifying both, so remove /utf-8 that we
|
|
|
|
# added automatically in the case the user overrides it manually.
|
|
|
|
elif (i.startswith('/source-charset:')
|
|
|
|
or i.startswith('/execution-charset:')
|
|
|
|
or i == '/validate-charset-'):
|
|
|
|
try:
|
|
|
|
result.remove('/utf-8')
|
|
|
|
except ValueError:
|
|
|
|
pass
|
|
|
|
result.append(i)
|
|
|
|
return result
|
|
|
|
|
|
|
|
@classmethod
|
|
|
|
def native_args_to_unix(cls, args: T.List[str]) -> T.List[str]:
|
|
|
|
result: T.List[str] = []
|
|
|
|
for arg in args:
|
|
|
|
if arg.startswith(('/LIBPATH:', '-LIBPATH:')):
|
|
|
|
result.append('-L' + arg[9:])
|
|
|
|
elif arg.endswith(('.a', '.lib')) and not os.path.isabs(arg):
|
|
|
|
result.append('-l' + arg)
|
|
|
|
else:
|
|
|
|
result.append(arg)
|
|
|
|
return result
|
|
|
|
|
|
|
|
def get_werror_args(self) -> T.List[str]:
|
|
|
|
return ['/WX']
|
|
|
|
|
|
|
|
def get_include_args(self, path: str, is_system: bool) -> T.List[str]:
|
|
|
|
if path == '':
|
|
|
|
path = '.'
|
|
|
|
# msvc does not have a concept of system header dirs.
|
|
|
|
return ['-I' + path]
|
|
|
|
|
|
|
|
def compute_parameters_with_absolute_paths(self, parameter_list: T.List[str], build_dir: str) -> T.List[str]:
|
|
|
|
for idx, i in enumerate(parameter_list):
|
|
|
|
if i[:2] == '-I' or i[:2] == '/I':
|
|
|
|
parameter_list[idx] = i[:2] + os.path.normpath(os.path.join(build_dir, i[2:]))
|
|
|
|
elif i[:9] == '/LIBPATH:':
|
|
|
|
parameter_list[idx] = i[:9] + os.path.normpath(os.path.join(build_dir, i[9:]))
|
|
|
|
|
|
|
|
return parameter_list
|
|
|
|
|
|
|
|
# Visual Studio is special. It ignores some arguments it does not
|
|
|
|
# understand and you can't tell it to error out on those.
|
|
|
|
# http://stackoverflow.com/questions/15259720/how-can-i-make-the-microsoft-c-compiler-treat-unknown-flags-as-errors-rather-t
|
|
|
|
def has_arguments(self, args: T.List[str], env: 'Environment', code: str, mode: CompileCheckMode) -> T.Tuple[bool, bool]:
|
|
|
|
warning_text = '4044' if mode == CompileCheckMode.LINK else '9002'
|
|
|
|
with self._build_wrapper(code, env, extra_args=args, mode=mode) as p:
|
|
|
|
if p.returncode != 0:
|
|
|
|
return False, p.cached
|
|
|
|
return not (warning_text in p.stderr or warning_text in p.stdout), p.cached
|
|
|
|
|
|
|
|
def get_compile_debugfile_args(self, rel_obj: str, pch: bool = False) -> T.List[str]:
|
|
|
|
pdbarr = rel_obj.split('.')[:-1]
|
|
|
|
pdbarr += ['pdb']
|
|
|
|
args = ['/Fd' + '.'.join(pdbarr)]
|
|
|
|
return args
|
|
|
|
|
|
|
|
def get_instruction_set_args(self, instruction_set: str) -> T.Optional[T.List[str]]:
|
|
|
|
if self.is_64:
|
|
|
|
return vs64_instruction_set_args.get(instruction_set, None)
|
|
|
|
return vs32_instruction_set_args.get(instruction_set, None)
|
|
|
|
|
|
|
|
def _calculate_toolset_version(self, version: int) -> T.Optional[str]:
|
|
|
|
if version < 1310:
|
|
|
|
return '7.0'
|
|
|
|
elif version < 1400:
|
|
|
|
return '7.1' # (Visual Studio 2003)
|
|
|
|
elif version < 1500:
|
|
|
|
return '8.0' # (Visual Studio 2005)
|
|
|
|
elif version < 1600:
|
|
|
|
return '9.0' # (Visual Studio 2008)
|
|
|
|
elif version < 1700:
|
|
|
|
return '10.0' # (Visual Studio 2010)
|
|
|
|
elif version < 1800:
|
|
|
|
return '11.0' # (Visual Studio 2012)
|
|
|
|
elif version < 1900:
|
|
|
|
return '12.0' # (Visual Studio 2013)
|
|
|
|
elif version < 1910:
|
|
|
|
return '14.0' # (Visual Studio 2015)
|
|
|
|
elif version < 1920:
|
|
|
|
return '14.1' # (Visual Studio 2017)
|
|
|
|
elif version < 1930:
|
|
|
|
return '14.2' # (Visual Studio 2019)
|
|
|
|
elif version < 1940:
|
|
|
|
return '14.3' # (Visual Studio 2022)
|
|
|
|
mlog.warning(f'Could not find toolset for version {self.version!r}')
|
|
|
|
return None
|
|
|
|
|
|
|
|
def get_toolset_version(self) -> T.Optional[str]:
|
|
|
|
# See boost/config/compiler/visualc.cpp for up to date mapping
|
|
|
|
try:
|
|
|
|
version = int(''.join(self.version.split('.')[0:2]))
|
|
|
|
except ValueError:
|
|
|
|
return None
|
|
|
|
return self._calculate_toolset_version(version)
|
|
|
|
|
|
|
|
def get_default_include_dirs(self) -> T.List[str]:
|
|
|
|
if 'INCLUDE' not in os.environ:
|
|
|
|
return []
|
|
|
|
return os.environ['INCLUDE'].split(os.pathsep)
|
|
|
|
|
|
|
|
def get_crt_compile_args(self, crt_val: str, buildtype: str) -> T.List[str]:
|
|
|
|
crt_val = self.get_crt_val(crt_val, buildtype)
|
|
|
|
return self.crt_args[crt_val]
|
|
|
|
|
|
|
|
def has_func_attribute(self, name: str, env: 'Environment') -> T.Tuple[bool, bool]:
|
|
|
|
# MSVC doesn't have __attribute__ like Clang and GCC do, so just return
|
|
|
|
# false without compiling anything
|
|
|
|
return name in {'dllimport', 'dllexport'}, False
|
|
|
|
|
|
|
|
def get_argument_syntax(self) -> str:
|
|
|
|
return 'msvc'
|
|
|
|
|
|
|
|
def symbols_have_underscore_prefix(self, env: 'Environment') -> bool:
|
|
|
|
'''
|
|
|
|
Check if the compiler prefixes an underscore to global C symbols.
|
|
|
|
|
|
|
|
This overrides the Clike method, as for MSVC checking the
|
|
|
|
underscore prefix based on the compiler define never works,
|
|
|
|
so do not even try.
|
|
|
|
'''
|
|
|
|
# Try to consult a hardcoded list of cases we know
|
|
|
|
# absolutely have an underscore prefix
|
|
|
|
result = self._symbols_have_underscore_prefix_list(env)
|
|
|
|
if result is not None:
|
|
|
|
return result
|
|
|
|
|
|
|
|
# As a last resort, try search in a compiled binary
|
|
|
|
return self._symbols_have_underscore_prefix_searchbin(env)
|
|
|
|
|
|
|
|
|
|
|
|
class MSVCCompiler(VisualStudioLikeCompiler):
|
|
|
|
|
|
|
|
"""Specific to the Microsoft Compilers."""
|
|
|
|
|
|
|
|
id = 'msvc'
|
|
|
|
|
|
|
|
def __init__(self, target: str):
|
|
|
|
super().__init__(target)
|
|
|
|
|
|
|
|
# Visual Studio 2013 and earlier don't support the /utf-8 argument.
|
|
|
|
# We want to remove it. We also want to make an explicit copy so we
|
|
|
|
# don't mutate class constant state
|
|
|
|
if mesonlib.version_compare(self.version, '<19.00') and '/utf-8' in self.always_args:
|
|
|
|
self.always_args = [r for r in self.always_args if r != '/utf-8']
|
|
|
|
|
|
|
|
def get_compile_debugfile_args(self, rel_obj: str, pch: bool = False) -> T.List[str]:
|
|
|
|
args = super().get_compile_debugfile_args(rel_obj, pch)
|
|
|
|
# When generating a PDB file with PCH, all compile commands write
|
|
|
|
# to the same PDB file. Hence, we need to serialize the PDB
|
|
|
|
# writes using /FS since we do parallel builds. This slows down the
|
|
|
|
# build obviously, which is why we only do this when PCH is on.
|
|
|
|
# This was added in Visual Studio 2013 (MSVC 18.0). Before that it was
|
|
|
|
# always on: https://msdn.microsoft.com/en-us/library/dn502518.aspx
|
|
|
|
if pch and mesonlib.version_compare(self.version, '>=18.0'):
|
|
|
|
args = ['/FS'] + args
|
|
|
|
return args
|
|
|
|
|
|
|
|
# Override CCompiler.get_always_args
|
|
|
|
# We want to drop '/utf-8' for Visual Studio 2013 and earlier
|
|
|
|
def get_always_args(self) -> T.List[str]:
|
|
|
|
return self.always_args
|
|
|
|
|
|
|
|
def get_instruction_set_args(self, instruction_set: str) -> T.Optional[T.List[str]]:
|
|
|
|
if self.version.split('.')[0] == '16' and instruction_set == 'avx':
|
|
|
|
# VS documentation says that this exists and should work, but
|
|
|
|
# it does not. The headers do not contain AVX intrinsics
|
|
|
|
# and they cannot be called.
|
|
|
|
return None
|
|
|
|
return super().get_instruction_set_args(instruction_set)
|
|
|
|
|
|
|
|
def get_pch_base_name(self, header: str) -> str:
|
|
|
|
return os.path.basename(header)
|
|
|
|
|
|
|
|
|
|
|
|
class ClangClCompiler(VisualStudioLikeCompiler):
|
|
|
|
|
|
|
|
"""Specific to Clang-CL."""
|
|
|
|
|
|
|
|
id = 'clang-cl'
|
|
|
|
|
|
|
|
def __init__(self, target: str):
|
|
|
|
super().__init__(target)
|
|
|
|
|
|
|
|
# Assembly
|
|
|
|
self.can_compile_suffixes.add('s')
|
|
|
|
self.can_compile_suffixes.add('sx')
|
|
|
|
|
|
|
|
def has_arguments(self, args: T.List[str], env: 'Environment', code: str, mode: CompileCheckMode) -> T.Tuple[bool, bool]:
|
|
|
|
if mode != CompileCheckMode.LINK:
|
|
|
|
args = args + ['-Werror=unknown-argument', '-Werror=unknown-warning-option']
|
|
|
|
return super().has_arguments(args, env, code, mode)
|
|
|
|
|
|
|
|
def get_toolset_version(self) -> T.Optional[str]:
|
|
|
|
# XXX: what is the right thing to do here?
|
|
|
|
return '14.1'
|
|
|
|
|
|
|
|
def get_pch_base_name(self, header: str) -> str:
|
|
|
|
return header
|
|
|
|
|
|
|
|
def get_include_args(self, path: str, is_system: bool) -> T.List[str]:
|
|
|
|
if path == '':
|
|
|
|
path = '.'
|
|
|
|
return ['/clang:-isystem' + path] if is_system else ['-I' + path]
|
|
|
|
|
|
|
|
def get_dependency_compile_args(self, dep: 'Dependency') -> T.List[str]:
|
|
|
|
if dep.get_include_type() == 'system':
|
|
|
|
converted: T.List[str] = []
|
|
|
|
for i in dep.get_compile_args():
|
|
|
|
if i.startswith('-isystem'):
|
|
|
|
converted += ['/clang:' + i]
|
|
|
|
else:
|
|
|
|
converted += [i]
|
|
|
|
return converted
|
|
|
|
else:
|
|
|
|
return dep.get_compile_args()
|