diff options
Diffstat (limited to 'mesonbuild/compilers/detect.py')
| -rw-r--r-- | mesonbuild/compilers/detect.py | 189 |
1 files changed, 103 insertions, 86 deletions
diff --git a/mesonbuild/compilers/detect.py b/mesonbuild/compilers/detect.py index c128a9b..021ae8e 100644 --- a/mesonbuild/compilers/detect.py +++ b/mesonbuild/compilers/detect.py @@ -270,6 +270,8 @@ def _handle_exceptions( # =============== def detect_static_linker(env: 'Environment', compiler: Compiler) -> StaticLinker: + from . import d + from ..linkers import linkers linker = env.lookup_binary_entry(compiler.for_machine, 'ar') if linker is not None: trials = [linker] @@ -314,41 +316,41 @@ def detect_static_linker(env: 'Environment', compiler: Compiler) -> StaticLinker popen_exceptions[join_args(linker + [arg])] = e continue if "xilib: executing 'lib'" in err: - return IntelVisualStudioLinker(linker, getattr(compiler, 'machine', None)) + return linkers.IntelVisualStudioLinker(linker, getattr(compiler, 'machine', None)) if '/OUT:' in out.upper() or '/OUT:' in err.upper(): - return VisualStudioLinker(linker, getattr(compiler, 'machine', None)) + return linkers.VisualStudioLinker(linker, getattr(compiler, 'machine', None)) if 'ar-Error-Unknown switch: --version' in err: - return PGIStaticLinker(linker) + return linkers.PGIStaticLinker(linker) if p.returncode == 0 and 'armar' in linker_name: - return ArmarLinker(linker) + return linkers.ArmarLinker(linker) if 'DMD32 D Compiler' in out or 'DMD64 D Compiler' in out: - assert isinstance(compiler, DCompiler) - return DLinker(linker, compiler.arch) + assert isinstance(compiler, d.DCompiler) + return linkers.DLinker(linker, compiler.arch) if 'LDC - the LLVM D compiler' in out: - assert isinstance(compiler, DCompiler) - return DLinker(linker, compiler.arch, rsp_syntax=compiler.rsp_file_syntax()) + assert isinstance(compiler, d.DCompiler) + return linkers.DLinker(linker, compiler.arch, rsp_syntax=compiler.rsp_file_syntax()) if 'GDC' in out and ' based on D ' in out: - assert isinstance(compiler, DCompiler) - return DLinker(linker, compiler.arch) + assert isinstance(compiler, d.DCompiler) + return linkers.DLinker(linker, compiler.arch) if err.startswith('Renesas') and 'rlink' in linker_name: - return CcrxLinker(linker) + return linkers.CcrxLinker(linker) if out.startswith('GNU ar') and 'xc16-ar' in linker_name: - return Xc16Linker(linker) + return linkers.Xc16Linker(linker) if 'Texas Instruments Incorporated' in out: if 'ar2000' in linker_name: - return C2000Linker(linker) + return linkers.C2000Linker(linker) else: - return TILinker(linker) + return linkers.TILinker(linker) if out.startswith('The CompCert'): - return CompCertLinker(linker) + return linkers.CompCertLinker(linker) if p.returncode == 0: - return ArLinker(compiler.for_machine, linker) + return linkers.ArLinker(compiler.for_machine, linker) if p.returncode == 1 and err.startswith('usage'): # OSX - return AppleArLinker(compiler.for_machine, linker) + return linkers.AppleArLinker(compiler.for_machine, linker) if p.returncode == 1 and err.startswith('Usage'): # AIX - return AIXArLinker(linker) + return linkers.AIXArLinker(linker) if p.returncode == 1 and err.startswith('ar: bad option: --'): # Solaris - return ArLinker(compiler.for_machine, linker) + return linkers.ArLinker(compiler.for_machine, linker) _handle_exceptions(popen_exceptions, trials, 'linker') @@ -363,6 +365,8 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin the compiler (GCC or Clang usually) as their shared linker, to find the linker they need. """ + from . import c, cpp + from ..linkers import linkers popen_exceptions: T.Dict[str, T.Union[Exception, str]] = {} compilers, ccache, exe_wrap = _get_compilers(env, lang, for_machine) if override_compiler is not None: @@ -451,10 +455,10 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin if guess_gcc_or_lcc == 'lcc': version = _get_lcc_version_from_defines(defines) - cls = ElbrusCCompiler if lang == 'c' else ElbrusCPPCompiler + cls = c.ElbrusCCompiler if lang == 'c' else cpp.ElbrusCPPCompiler else: version = _get_gnu_version_from_defines(defines) - cls = GnuCCompiler if lang == 'c' else GnuCPPCompiler + cls = c.GnuCCompiler if lang == 'c' else cpp.GnuCPPCompiler linker = guess_nix_linker(env, compiler, cls, version, for_machine) @@ -464,7 +468,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin linker=linker) if 'Emscripten' in out: - cls = EmscriptenCCompiler if lang == 'c' else EmscriptenCPPCompiler + cls = c.EmscriptenCCompiler if lang == 'c' else cpp.EmscriptenCPPCompiler env.coredata.add_lang_args(cls.language, cls, for_machine, env) # emcc requires a file input in order to pass arguments to the @@ -475,7 +479,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin cmd = compiler + [cls.LINKER_PREFIX + "--version", f.name] _, o, _ = Popen_safe(cmd) - linker = WASMDynamicLinker( + linker = linkers.WASMDynamicLinker( compiler, for_machine, cls.LINKER_PREFIX, [], version=search_version(o)) return cls( @@ -487,9 +491,9 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin assert arm_ver_match is not None, 'for mypy' # because mypy *should* be complaning that this could be None version = '.'.join([x for x in arm_ver_match.groups() if x is not None]) if lang == 'c': - cls = ArmLtdClangCCompiler + cls = c.ArmLtdClangCCompiler elif lang == 'cpp': - cls = ArmLtdClangCPPCompiler + cls = cpp.ArmLtdClangCPPCompiler linker = guess_nix_linker(env, compiler, cls, version, for_machine) return cls( ccache + compiler, version, for_machine, is_cross, info, @@ -508,8 +512,8 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin # Override previous values version = search_version(arm_ver_str) full_version = arm_ver_str - cls = ArmclangCCompiler if lang == 'c' else ArmclangCPPCompiler - linker = ArmClangDynamicLinker(for_machine, version=version) + cls = c.ArmclangCCompiler if lang == 'c' else cpp.ArmclangCPPCompiler + linker = linkers.ArmClangDynamicLinker(for_machine, version=version) env.coredata.add_lang_args(cls.language, cls, for_machine, env) return cls( ccache + compiler, version, for_machine, is_cross, info, @@ -528,7 +532,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin target = match.group(1) else: target = 'unknown target' - cls = ClangClCCompiler if lang == 'c' else ClangClCPPCompiler + cls = c.ClangClCCompiler if lang == 'c' else cpp.ClangClCPPCompiler linker = guess_win_linker(env, ['lld-link'], cls, version, for_machine) return cls( compiler, version, for_machine, is_cross, info, target, @@ -541,9 +545,9 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin # Even if the for_machine is darwin, we could be using vanilla # clang. if 'Apple' in out: - cls = AppleClangCCompiler if lang == 'c' else AppleClangCPPCompiler + cls = c.AppleClangCCompiler if lang == 'c' else cpp.AppleClangCPPCompiler else: - cls = ClangCCompiler if lang == 'c' else ClangCPPCompiler + cls = c.ClangCCompiler if lang == 'c' else cpp.ClangCPPCompiler if 'windows' in out or env.machines[for_machine].is_windows(): # If we're in a MINGW context this actually will use a gnu @@ -563,9 +567,9 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin if 'Intel(R) C++ Intel(R)' in err: version = search_version(err) target = 'x86' if 'IA-32' in err else 'x86_64' - cls = IntelClCCompiler if lang == 'c' else IntelClCPPCompiler + cls = c.IntelClCCompiler if lang == 'c' else cpp.IntelClCPPCompiler env.coredata.add_lang_args(cls.language, cls, for_machine, env) - linker = XilinkDynamicLinker(for_machine, [], version=version) + linker = linkers.XilinkDynamicLinker(for_machine, [], version=version) return cls( compiler, version, for_machine, is_cross, info, target, exe_wrap, linker=linker) @@ -587,7 +591,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin else: m = f'Failed to detect MSVC compiler target architecture: \'cl /?\' output is\n{cl_signature}' raise EnvironmentException(m) - cls = VisualStudioCCompiler if lang == 'c' else VisualStudioCPPCompiler + cls = c.VisualStudioCCompiler if lang == 'c' else cpp.VisualStudioCPPCompiler linker = guess_win_linker(env, ['link'], cls, version, for_machine) # As of this writing, CCache does not support MSVC but sccache does. if 'sccache' in ccache: @@ -598,33 +602,33 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin final_compiler, version, for_machine, is_cross, info, target, exe_wrap, full_version=cl_signature, linker=linker) if 'PGI Compilers' in out: - cls = PGICCompiler if lang == 'c' else PGICPPCompiler + cls = c.PGICCompiler if lang == 'c' else cpp.PGICPPCompiler env.coredata.add_lang_args(cls.language, cls, for_machine, env) - linker = PGIDynamicLinker(compiler, for_machine, cls.LINKER_PREFIX, [], version=version) + linker = linkers.PGIDynamicLinker(compiler, for_machine, cls.LINKER_PREFIX, [], version=version) return cls( ccache + compiler, version, for_machine, is_cross, info, exe_wrap, linker=linker) if 'NVIDIA Compilers and Tools' in out: - cls = NvidiaHPC_CCompiler if lang == 'c' else NvidiaHPC_CPPCompiler + cls = c.NvidiaHPC_CCompiler if lang == 'c' else cpp.NvidiaHPC_CPPCompiler env.coredata.add_lang_args(cls.language, cls, for_machine, env) - linker = NvidiaHPC_DynamicLinker(compiler, for_machine, cls.LINKER_PREFIX, [], version=version) + linker = linkers.NvidiaHPC_DynamicLinker(compiler, for_machine, cls.LINKER_PREFIX, [], version=version) return cls( ccache + compiler, version, for_machine, is_cross, info, exe_wrap, linker=linker) if '(ICC)' in out: - cls = IntelCCompiler if lang == 'c' else IntelCPPCompiler + cls = c.IntelCCompiler if lang == 'c' else cpp.IntelCPPCompiler l = guess_nix_linker(env, compiler, cls, version, for_machine) return cls( ccache + compiler, version, for_machine, is_cross, info, exe_wrap, full_version=full_version, linker=l) if 'TMS320C2000 C/C++' in out or 'MSP430 C/C++' in out or 'TI ARM C/C++ Compiler' in out: - lnk: T.Union[T.Type[C2000DynamicLinker], T.Type[TIDynamicLinker]] + lnk: T.Union[T.Type[linkers.C2000DynamicLinker], T.Type[linkers.TIDynamicLinker]] if 'TMS320C2000 C/C++' in out: - cls = C2000CCompiler if lang == 'c' else C2000CPPCompiler - lnk = C2000DynamicLinker + cls = c.C2000CCompiler if lang == 'c' else cpp.C2000CPPCompiler + lnk = linkers.C2000DynamicLinker else: - cls = TICCompiler if lang == 'c' else TICPPCompiler - lnk = TIDynamicLinker + cls = c.TICCompiler if lang == 'c' else cpp.TICPPCompiler + lnk = linkers.TIDynamicLinker env.coredata.add_lang_args(cls.language, cls, for_machine, env) linker = lnk(compiler, for_machine, version=version) @@ -632,32 +636,32 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin ccache + compiler, version, for_machine, is_cross, info, exe_wrap, full_version=full_version, linker=linker) if 'ARM' in out: - cls = ArmCCompiler if lang == 'c' else ArmCPPCompiler + cls = c.ArmCCompiler if lang == 'c' else cpp.ArmCPPCompiler env.coredata.add_lang_args(cls.language, cls, for_machine, env) - linker = ArmDynamicLinker(for_machine, version=version) + linker = linkers.ArmDynamicLinker(for_machine, version=version) return cls( ccache + compiler, version, for_machine, is_cross, info, exe_wrap, full_version=full_version, linker=linker) if 'RX Family' in out: - cls = CcrxCCompiler if lang == 'c' else CcrxCPPCompiler + cls = c.CcrxCCompiler if lang == 'c' else cpp.CcrxCPPCompiler env.coredata.add_lang_args(cls.language, cls, for_machine, env) - linker = CcrxDynamicLinker(for_machine, version=version) + linker = linkers.CcrxDynamicLinker(for_machine, version=version) return cls( ccache + compiler, version, for_machine, is_cross, info, exe_wrap, full_version=full_version, linker=linker) if 'Microchip Technology' in out: - cls = Xc16CCompiler + cls = c.Xc16CCompiler env.coredata.add_lang_args(cls.language, cls, for_machine, env) - linker = Xc16DynamicLinker(for_machine, version=version) + linker = linkers.Xc16DynamicLinker(for_machine, version=version) return cls( ccache + compiler, version, for_machine, is_cross, info, exe_wrap, full_version=full_version, linker=linker) if 'CompCert' in out: - cls = CompCertCCompiler + cls = c.CompCertCCompiler env.coredata.add_lang_args(cls.language, cls, for_machine, env) - linker = CompCertDynamicLinker(for_machine, version=version) + linker = linkers.CompCertDynamicLinker(for_machine, version=version) return cls( ccache + compiler, version, for_machine, is_cross, info, exe_wrap, full_version=full_version, linker=linker) @@ -672,6 +676,8 @@ def detect_cpp_compiler(env: 'Environment', for_machine: MachineChoice) -> Compi return _detect_c_or_cpp_compiler(env, 'cpp', for_machine) def detect_cuda_compiler(env: 'Environment', for_machine: MachineChoice) -> Compiler: + from .cuda import CudaCompiler + from ..linkers.linkers import CudaLinker popen_exceptions = {} is_cross = env.is_cross_build(for_machine) compilers, ccache, exe_wrap = _get_compilers(env, 'cuda', for_machine) @@ -707,6 +713,8 @@ def detect_cuda_compiler(env: 'Environment', for_machine: MachineChoice) -> Comp raise EnvironmentException(f'Could not find suitable CUDA compiler: "{"; ".join([" ".join(c) for c in compilers])}"') def detect_fortran_compiler(env: 'Environment', for_machine: MachineChoice) -> Compiler: + from . import fortran + from ..linkers import linkers popen_exceptions: T.Dict[str, T.Union[Exception, str]] = {} compilers, ccache, exe_wrap = _get_compilers(env, 'fortran', for_machine) is_cross = env.is_cross_build(for_machine) @@ -736,21 +744,21 @@ def detect_fortran_compiler(env: 'Environment', for_machine: MachineChoice) -> C continue if guess_gcc_or_lcc == 'lcc': version = _get_lcc_version_from_defines(defines) - cls = ElbrusFortranCompiler + cls = fortran.ElbrusFortranCompiler linker = guess_nix_linker(env, compiler, cls, version, for_machine) return cls( compiler, version, for_machine, is_cross, info, exe_wrap, defines, full_version=full_version, linker=linker) else: version = _get_gnu_version_from_defines(defines) - cls = GnuFortranCompiler + cls = fortran.GnuFortranCompiler linker = guess_nix_linker(env, compiler, cls, version, for_machine) return cls( compiler, version, for_machine, is_cross, info, exe_wrap, defines, full_version=full_version, linker=linker) if 'Arm C/C++/Fortran Compiler' in out: - cls = ArmLtdFlangFortranCompiler + cls = fortran.ArmLtdFlangFortranCompiler arm_ver_match = re.search(r'version (\d+)\.(\d+)\.?(\d+)? \(build number (\d+)\)', out) assert arm_ver_match is not None, 'for mypy' # because mypy *should* be complaning that this could be None version = '.'.join([x for x in arm_ver_match.groups() if x is not None]) @@ -759,7 +767,7 @@ def detect_fortran_compiler(env: 'Environment', for_machine: MachineChoice) -> C ccache + compiler, version, for_machine, is_cross, info, exe_wrap, linker=linker) if 'G95' in out: - cls = G95FortranCompiler + cls = fortran.G95FortranCompiler linker = guess_nix_linker(env, compiler, cls, version, for_machine) return cls( compiler, version, for_machine, is_cross, info, @@ -767,7 +775,7 @@ def detect_fortran_compiler(env: 'Environment', for_machine: MachineChoice) -> C if 'Sun Fortran' in err: version = search_version(err) - cls = SunFortranCompiler + cls = fortran.SunFortranCompiler linker = guess_nix_linker(env, compiler, cls, version, for_machine) return cls( compiler, version, for_machine, is_cross, info, @@ -776,45 +784,45 @@ def detect_fortran_compiler(env: 'Environment', for_machine: MachineChoice) -> C if 'Intel(R) Visual Fortran' in err or 'Intel(R) Fortran' in err: version = search_version(err) target = 'x86' if 'IA-32' in err else 'x86_64' - cls = IntelClFortranCompiler + cls = fortran.IntelClFortranCompiler env.coredata.add_lang_args(cls.language, cls, for_machine, env) - linker = XilinkDynamicLinker(for_machine, [], version=version) + linker = linkers.XilinkDynamicLinker(for_machine, [], version=version) return cls( compiler, version, for_machine, is_cross, info, target, exe_wrap, linker=linker) if 'ifort (IFORT)' in out: - cls = IntelFortranCompiler + cls = fortran.IntelFortranCompiler linker = guess_nix_linker(env, compiler, cls, version, for_machine) return cls( compiler, version, for_machine, is_cross, info, exe_wrap, full_version=full_version, linker=linker) if 'PathScale EKOPath(tm)' in err: - return PathScaleFortranCompiler( + return fortran.PathScaleFortranCompiler( compiler, version, for_machine, is_cross, info, exe_wrap, full_version=full_version) if 'PGI Compilers' in out: - cls = PGIFortranCompiler + cls = fortran.PGIFortranCompiler env.coredata.add_lang_args(cls.language, cls, for_machine, env) - linker = PGIDynamicLinker(compiler, for_machine, - cls.LINKER_PREFIX, [], version=version) + linker = linkers.PGIDynamicLinker(compiler, for_machine, + cls.LINKER_PREFIX, [], version=version) return cls( compiler, version, for_machine, is_cross, info, exe_wrap, full_version=full_version, linker=linker) if 'NVIDIA Compilers and Tools' in out: - cls = NvidiaHPC_FortranCompiler + cls = fortran.NvidiaHPC_FortranCompiler env.coredata.add_lang_args(cls.language, cls, for_machine, env) - linker = PGIDynamicLinker(compiler, for_machine, - cls.LINKER_PREFIX, [], version=version) + linker = linkers.PGIDynamicLinker(compiler, for_machine, + cls.LINKER_PREFIX, [], version=version) return cls( compiler, version, for_machine, is_cross, info, exe_wrap, full_version=full_version, linker=linker) if 'flang' in out or 'clang' in out: - cls = FlangFortranCompiler + cls = fortran.FlangFortranCompiler linker = guess_nix_linker(env, compiler, cls, version, for_machine) return cls( @@ -822,7 +830,7 @@ def detect_fortran_compiler(env: 'Environment', for_machine: MachineChoice) -> C exe_wrap, full_version=full_version, linker=linker) if 'Open64 Compiler Suite' in err: - cls = Open64FortranCompiler + cls = fortran.Open64FortranCompiler linker = guess_nix_linker(env, compiler, cls, version, for_machine) return cls( @@ -832,9 +840,9 @@ def detect_fortran_compiler(env: 'Environment', for_machine: MachineChoice) -> C if 'NAG Fortran' in err: full_version = err.split('\n', 1)[0] version = full_version.split()[-1] - cls = NAGFortranCompiler + cls = fortran.NAGFortranCompiler env.coredata.add_lang_args(cls.language, cls, for_machine, env) - linker = NAGDynamicLinker( + linker = linkers.NAGDynamicLinker( compiler, for_machine, cls.LINKER_PREFIX, [], version=version) return cls( @@ -851,11 +859,12 @@ def detect_objcpp_compiler(env: 'Environment', for_machine: MachineChoice) -> 'C return _detect_objc_or_objcpp_compiler(env, 'objcpp', for_machine) def _detect_objc_or_objcpp_compiler(env: 'Environment', lang: str, for_machine: MachineChoice) -> 'Compiler': + from . import objc, objcpp popen_exceptions: T.Dict[str, T.Union[Exception, str]] = {} compilers, ccache, exe_wrap = _get_compilers(env, lang, for_machine) is_cross = env.is_cross_build(for_machine) info = env.machines[for_machine] - comp: T.Union[T.Type[ObjCCompiler], T.Type[ObjCPPCompiler]] + comp: T.Union[T.Type[objc.ObjCCompiler], T.Type[objcpp.ObjCPPCompiler]] for compiler in compilers: arg = ['--version'] @@ -871,7 +880,7 @@ def _detect_objc_or_objcpp_compiler(env: 'Environment', lang: str, for_machine: popen_exceptions[join_args(compiler)] = 'no pre-processor defines' continue version = _get_gnu_version_from_defines(defines) - comp = GnuObjCCompiler if lang == 'objc' else GnuObjCPPCompiler + comp = objc.GnuObjCCompiler if lang == 'objc' else objcpp.GnuObjCPPCompiler linker = guess_nix_linker(env, compiler, comp, version, for_machine) return comp( ccache + compiler, version, for_machine, is_cross, info, @@ -883,9 +892,9 @@ def _detect_objc_or_objcpp_compiler(env: 'Environment', lang: str, for_machine: popen_exceptions[join_args(compiler)] = 'no pre-processor defines' continue if 'Apple' in out: - comp = AppleClangObjCCompiler if lang == 'objc' else AppleClangObjCPPCompiler + comp = objc.AppleClangObjCCompiler if lang == 'objc' else objcpp.AppleClangObjCPPCompiler else: - comp = ClangObjCCompiler if lang == 'objc' else ClangObjCPPCompiler + comp = objc.ClangObjCCompiler if lang == 'objc' else objcpp.ClangObjCPPCompiler if 'windows' in out or env.machines[for_machine].is_windows(): # If we're in a MINGW context this actually will use a gnu style ld try: @@ -902,6 +911,7 @@ def _detect_objc_or_objcpp_compiler(env: 'Environment', lang: str, for_machine: raise EnvironmentException('Unreachable code (exception to make mypy happy)') def detect_java_compiler(env: 'Environment', for_machine: MachineChoice) -> Compiler: + from .java import JavaCompiler exelist = env.lookup_binary_entry(for_machine, 'java') info = env.machines[for_machine] if exelist is None: @@ -924,6 +934,7 @@ def detect_java_compiler(env: 'Environment', for_machine: MachineChoice) -> Comp raise EnvironmentException('Unknown compiler: ' + join_args(exelist)) def detect_cs_compiler(env: 'Environment', for_machine: MachineChoice) -> Compiler: + from . import cs compilers, ccache, exe_wrap = _get_compilers(env, 'cs', for_machine) popen_exceptions = {} info = env.machines[for_machine] @@ -935,11 +946,11 @@ def detect_cs_compiler(env: 'Environment', for_machine: MachineChoice) -> Compil continue version = search_version(out) - cls: T.Union[T.Type[MonoCompiler], T.Type[VisualStudioCsCompiler]] + cls: T.Union[T.Type[cs.MonoCompiler], T.Type[cs.VisualStudioCsCompiler]] if 'Mono' in out: - cls = MonoCompiler + cls = cs.MonoCompiler elif "Visual C#" in out: - cls = VisualStudioCsCompiler + cls = cs.VisualStudioCsCompiler else: continue env.coredata.add_lang_args(cls.language, cls, for_machine, env) @@ -950,6 +961,7 @@ def detect_cs_compiler(env: 'Environment', for_machine: MachineChoice) -> Compil def detect_cython_compiler(env: 'Environment', for_machine: MachineChoice) -> Compiler: """Search for a cython compiler.""" + from .cython import CythonCompiler compilers, _, _ = _get_compilers(env, 'cython', MachineChoice.BUILD) is_cross = env.is_cross_build(for_machine) info = env.machines[for_machine] @@ -971,6 +983,7 @@ def detect_cython_compiler(env: 'Environment', for_machine: MachineChoice) -> Co raise EnvironmentException('Unreachable code (exception to make mypy happy)') def detect_vala_compiler(env: 'Environment', for_machine: MachineChoice) -> Compiler: + from .vala import ValaCompiler exelist = env.lookup_binary_entry(MachineChoice.BUILD, 'vala') is_cross = env.is_cross_build(for_machine) info = env.machines[for_machine] @@ -990,13 +1003,15 @@ def detect_vala_compiler(env: 'Environment', for_machine: MachineChoice) -> Comp raise EnvironmentException('Unknown compiler: ' + join_args(exelist)) def detect_rust_compiler(env: 'Environment', for_machine: MachineChoice) -> RustCompiler: + from . import rust + from ..linkers import linkers popen_exceptions = {} # type: T.Dict[str, Exception] compilers, _, exe_wrap = _get_compilers(env, 'rust', for_machine) is_cross = env.is_cross_build(for_machine) info = env.machines[for_machine] cc = detect_c_compiler(env, for_machine) - is_link_exe = isinstance(cc.linker, VisualStudioLikeLinkerMixin) + is_link_exe = isinstance(cc.linker, linkers.VisualStudioLikeLinkerMixin) override = env.lookup_binary_entry(for_machine, 'rust_ld') for compiler in compilers: @@ -1008,13 +1023,13 @@ def detect_rust_compiler(env: 'Environment', for_machine: MachineChoice) -> Rust continue version = search_version(out) - cls: T.Type[RustCompiler] = RustCompiler + cls: T.Type[RustCompiler] = rust.RustCompiler # Clippy is a wrapper around rustc, but it doesn't have rustc in it's # output. We can otherwise treat it as rustc. if 'clippy' in out: out = 'rustc' - cls = ClippyRustCompiler + cls = rust.ClippyRustCompiler if 'rustc' in out: # On Linux and mac rustc will invoke gcc (clang for mac @@ -1069,7 +1084,7 @@ def detect_rust_compiler(env: 'Environment', for_machine: MachineChoice) -> Rust override, cls, version, for_machine, use_linker_prefix=False) # rustc takes linker arguments without a prefix, and # inserts the correct prefix itself. - assert isinstance(linker, VisualStudioLikeLinkerMixin) + assert isinstance(linker, linkers.VisualStudioLikeLinkerMixin) linker.direct = True compiler.extend(cls.use_linker_args(linker.exelist[0], '')) else: @@ -1094,12 +1109,13 @@ def detect_rust_compiler(env: 'Environment', for_machine: MachineChoice) -> Rust raise EnvironmentException('Unreachable code (exception to make mypy happy)') def detect_d_compiler(env: 'Environment', for_machine: MachineChoice) -> Compiler: + from . import c, d info = env.machines[for_machine] # Detect the target architecture, required for proper architecture handling on Windows. # MSVC compiler is required for correct platform detection. c_compiler = {'c': detect_c_compiler(env, for_machine)} - is_msvc = isinstance(c_compiler['c'], VisualStudioCCompiler) + is_msvc = isinstance(c_compiler['c'], c.VisualStudioCCompiler) if not is_msvc: c_compiler = {} @@ -1112,7 +1128,7 @@ def detect_d_compiler(env: 'Environment', for_machine: MachineChoice) -> Compile popen_exceptions = {} is_cross = env.is_cross_build(for_machine) compilers, ccache, exe_wrap = _get_compilers(env, 'd', for_machine) - cls: T.Type[DCompiler] + cls: T.Type[d.DCompiler] for exelist in compilers: # Search for a D compiler. # We prefer LDC over GDC unless overridden with the DC @@ -1131,7 +1147,7 @@ def detect_d_compiler(env: 'Environment', for_machine: MachineChoice) -> Compile full_version = out.split('\n', 1)[0] if 'LLVM D compiler' in out: - cls = LLVMDCompiler + cls = d.LLVMDCompiler # LDC seems to require a file # We cannot use NamedTemproraryFile on windows, its documented # to not work for our uses. So, just use mkstemp and only have @@ -1162,14 +1178,14 @@ def detect_d_compiler(env: 'Environment', for_machine: MachineChoice) -> Compile exelist, version, for_machine, info, arch, full_version=full_version, linker=linker, version_output=out) elif 'gdc' in out: - cls = GnuDCompiler + cls = d.GnuDCompiler linker = guess_nix_linker(env, exelist, cls, version, for_machine) return cls( exelist, version, for_machine, info, arch, exe_wrapper=exe_wrap, is_cross=is_cross, full_version=full_version, linker=linker) elif 'The D Language Foundation' in out or 'Digital Mars' in out: - cls = DmdDCompiler + cls = d.DmdDCompiler # DMD seems to require a file # We cannot use NamedTemproraryFile on windows, its documented # to not work for our uses. So, just use mkstemp and only have @@ -1204,6 +1220,7 @@ def detect_d_compiler(env: 'Environment', for_machine: MachineChoice) -> Compile raise EnvironmentException('Unreachable code (exception to make mypy happy)') def detect_swift_compiler(env: 'Environment', for_machine: MachineChoice) -> Compiler: + from .swift import SwiftCompiler exelist = env.lookup_binary_entry(for_machine, 'swift') is_cross = env.is_cross_build(for_machine) info = env.machines[for_machine] |