Extracted compiler definitions to their own file.

7 files changed, 1554 insertions, 1515 deletions

diff --git a/compilers.py b/compilers.py
new file mode 100644
index 0000000..be5d0cc
--- /dev/null
+++ b/compilers.py
@@ -0,0 +1,1481 @@
+# Copyright 2012-2014 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.
+
+import subprocess, os.path
+import tempfile
+import mesonlib
+from coredata import MesonException
+
+"""This file contains the data files of all compilers Meson knows
+about. To support a new compiler, add its information below.
+Also add corresponding autodetection code in environment.py."""
+
+header_suffixes = ['h', 'hh', 'hpp', 'hxx', 'H']
+cpp_suffixes = ['cc', 'cpp', 'cxx', 'h', 'hh', 'hpp', 'hxx', 'c++']
+c_suffixes = ['c']
+clike_suffixes = c_suffixes + cpp_suffixes
+obj_suffixes = ['o', 'obj']
+
+def is_header(fname):
+    suffix = fname.split('.')[-1]
+    return suffix in header_suffixes
+
+def is_source(fname):
+    suffix = fname.split('.')[-1]
+    return suffix in clike_suffixes
+
+def is_object(fname):
+    suffix = fname.split('.')[-1]
+    return suffix in obj_suffixes
+
+gnulike_buildtype_args = {'plain' : [],
+                           'debug' : ['-g'],
+                           'debugoptimized' : ['-O2', '-g'],
+                           'release' : ['-O3'],
+                           }
+
+msvc_buildtype_args = {'plain' : [],
+                        'debug' : ["/MDd", "/Zi", "/Ob0", "/Od", "/RTC1"],
+                        'debugoptimized' : ["/MD", "/Zi", "/O2", "/Ob1", "/D"],
+                        'release' : ["/MD", "/O2", "/Ob2"]}
+
+gnulike_buildtype_linker_args = {}
+
+if mesonlib.is_osx():
+    gnulike_buildtype_linker_args.update({'plain' : [],
+                                          'debug' : [],
+                                          'debugoptimized' : [],
+                                          'release' : [],
+                                          })
+else:
+    gnulike_buildtype_linker_args.update({'plain' : [],
+                                          'debug' : [],
+                                          'debugoptimized' : [],
+                                          'release' : ['-Wl,-O1'],
+                                          })
+
+msvc_buildtype_linker_args = {'plain' : [],
+                               'debug' : [],
+                               'debugoptimized' : [],
+                               'release' : []}
+
+rust_buildtype_args = {'plain' : [],
+                        'debug' : ['-g'],
+                        'debugoptimized' : ['-g', '--opt-level', '2'],
+                        'release' : ['--opt-level', '3']}
+
+mono_buildtype_args = {'plain' : [],
+                       'debug' : ['-debug'],
+                       'debugoptimized': ['-debug', '-optimize+'],
+                       'release' : ['-optimize+']}
+
+def build_unix_rpath_args(build_dir, rpath_paths, install_rpath):
+        if len(rpath_paths) == 0 and len(install_rpath) == 0:
+            return []
+        paths = ':'.join([os.path.join(build_dir, p) for p in rpath_paths])
+        if len(paths) < len(install_rpath):
+            padding = 'X'*(len(install_rpath) - len(paths))
+            if len(paths) == 0:
+                paths = padding
+            else:
+                paths = paths + ':' + padding
+        return ['-Wl,-rpath,' + paths]
+
+class EnvironmentException(MesonException):
+    def __init(self, *args, **kwargs):
+        Exception.__init__(self, *args, **kwargs)
+
+class CrossNoRunException(MesonException):
+    def __init(self, *args, **kwargs):
+        Exception.__init__(self, *args, **kwargs)
+
+class RunResult():
+    def __init__(self, compiled, returncode=999, stdout='UNDEFINED', stderr='UNDEFINED'):
+        self.compiled = compiled
+        self.returncode = returncode
+        self.stdout = stdout
+        self.stderr = stderr
+
+class CCompiler():
+    def __init__(self, exelist, version, is_cross, exe_wrapper=None):
+        if type(exelist) == type(''):
+            self.exelist = [exelist]
+        elif type(exelist) == type([]):
+            self.exelist = exelist
+        else:
+            raise TypeError('Unknown argument to CCompiler')
+        self.version = version
+        self.language = 'c'
+        self.default_suffix = 'c'
+        self.id = 'unknown'
+        self.is_cross = is_cross
+        if isinstance(exe_wrapper, str):
+            self.exe_wrapper = [exe_wrapper]
+        else:
+            self.exe_wrapper = exe_wrapper
+
+    def needs_static_linker(self):
+        return True # When compiling static libraries, so yes.
+
+    def get_always_args(self):
+        return []
+
+    def get_linker_always_args(self):
+        return []
+
+    def get_soname_args(self, shlib_name, path, soversion):
+        return []
+
+    def split_shlib_to_parts(self, fname):
+        return (None, fname)
+
+    # The default behaviour is this, override in
+    # OSX and MSVC.
+    def build_rpath_args(self, build_dir, rpath_paths, install_rpath):
+        return build_unix_rpath_args(build_dir, rpath_paths, install_rpath)
+
+    def get_id(self):
+        return self.id
+
+    def get_dependency_gen_args(self, outtarget, outfile):
+        return ['-MMD', '-MQ', outtarget, '-MF', outfile]
+
+    def get_depfile_suffix(self):
+        return 'd'
+
+    def get_language(self):
+        return self.language
+
+    def get_default_suffix(self):
+        return self.default_suffix
+
+    def get_exelist(self):
+        return self.exelist[:]
+
+    def get_linker_exelist(self):
+        return self.exelist[:]
+
+    def get_compile_only_args(self):
+        return ['-c']
+
+    def get_output_args(self, target):
+        return ['-o', target]
+
+    def get_linker_output_args(self, outputname):
+        return ['-o', outputname]
+
+    def get_debug_args(self):
+        return ['-g']
+
+    def get_coverage_args(self):
+        return ['--coverage']
+
+    def get_coverage_link_args(self):
+        return ['-lgcov']
+
+    def get_werror_args(self):
+        return ['-Werror']
+
+    def get_std_exe_link_args(self):
+        return []
+
+    def get_include_args(self, path):
+        return ['-I' + path]
+
+    def get_std_shared_lib_link_args(self):
+        return ['-shared']
+
+    def can_compile(self, filename):
+        suffix = filename.split('.')[-1]
+        if suffix == 'c' or suffix == 'h':
+            return True
+        return False
+
+    def get_pic_args(self):
+        return ['-fPIC']
+
+    def name_string(self):
+        return ' '.join(self.exelist)
+
+    def get_pch_use_args(self, pch_dir, header):
+        return ['-include', os.path.split(header)[-1]]
+
+    def get_pch_name(self, header_name):
+        return os.path.split(header_name)[-1] + '.' + self.get_pch_suffix()
+
+    def sanity_check(self, work_dir):
+        source_name = os.path.join(work_dir, 'sanitycheckc.c')
+        binary_name = os.path.join(work_dir, 'sanitycheckc')
+        ofile = open(source_name, 'w')
+        ofile.write('int main(int argc, char **argv) { int class=0; return class; }\n')
+        ofile.close()
+        pc = subprocess.Popen(self.exelist + [source_name, '-o', binary_name])
+        pc.wait()
+        if pc.returncode != 0:
+            raise EnvironmentException('Compiler %s can not compile programs.' % self.name_string())
+        if self.is_cross:
+            if self.exe_wrapper is None:
+                # Can't check if the binaries run so we have to assume they do
+                return
+            cmdlist = self.exe_wrapper + [binary_name]
+        else:
+            cmdlist = [binary_name]
+        pe = subprocess.Popen(cmdlist)
+        pe.wait()
+        if pe.returncode != 0:
+            raise EnvironmentException('Executables created by C compiler %s are not runnable.' % self.name_string())
+
+    def has_header(self, hname):
+        templ = '''#include<%s>
+int someSymbolHereJustForFun;
+'''
+        return self.compiles(templ % hname)
+
+    def compiles(self, code):
+        suflen = len(self.default_suffix)
+        (fd, srcname) = tempfile.mkstemp(suffix='.'+self.default_suffix)
+        os.close(fd)
+        ofile = open(srcname, 'w')
+        ofile.write(code)
+        ofile.close()
+        commands = self.get_exelist()
+        commands += self.get_compile_only_args()
+        commands.append(srcname)
+        p = subprocess.Popen(commands, cwd=os.path.split(srcname)[0], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        p.communicate()
+        os.remove(srcname)
+        try:
+            trial = srcname[:-suflen] + 'o'
+            os.remove(trial)
+        except FileNotFoundError:
+            pass
+        try:
+            os.remove(srcname[:-suflen] + 'obj')
+        except FileNotFoundError:
+            pass
+        return p.returncode == 0
+
+    def run(self, code):
+        if self.is_cross and self.exe_wrapper is None:
+            raise CrossNoRunException('Can not run test applications in this cross environment.')
+        (fd, srcname) = tempfile.mkstemp(suffix='.'+self.default_suffix)
+        os.close(fd)
+        ofile = open(srcname, 'w')
+        ofile.write(code)
+        ofile.close()
+        exename = srcname + '.exe' # Is guaranteed to be executable on every platform.
+        commands = self.get_exelist()
+        commands.append(srcname)
+        commands += self.get_output_args(exename)
+        p = subprocess.Popen(commands, cwd=os.path.split(srcname)[0], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        p.communicate()
+        os.remove(srcname)
+        if p.returncode != 0:
+            return RunResult(False)
+        if self.is_cross:
+            cmdlist = self.exe_wrapper + [exename]
+        else:
+            cmdlist = exename
+        pe = subprocess.Popen(cmdlist, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        (so, se) = pe.communicate()
+        os.remove(exename)
+        return RunResult(True, pe.returncode, so.decode(), se.decode())
+
+    def sizeof(self, element, prefix, env):
+        templ = '''#include<stdio.h>
+%s
+
+int main(int argc, char **argv) {
+    printf("%%ld\\n", (long)(sizeof(%s)));
+    return 0;
+};
+'''
+        varname = 'sizeof ' + element
+        varname = varname.replace(' ', '_')
+        if self.is_cross:
+            val = env.cross_info.get(varname)
+            if val is not None:
+                if isinstance(val, int):
+                    return val
+                raise EnvironmentException('Cross variable {0} is not an integer.'.format(varname))
+        cross_failed = False
+        try:
+            res = self.run(templ % (prefix, element))
+        except CrossNoRunException:
+            cross_failed = True
+        if cross_failed:
+            message = '''Can not determine size of {0} because cross compiled binaries are not runnable.
+Please define the corresponding variable {1} in your cross compilation definition file.'''.format(element, varname)
+            raise EnvironmentException(message)
+        if not res.compiled:
+            raise EnvironmentException('Could not compile sizeof test.')
+        if res.returncode != 0:
+            raise EnvironmentException('Could not run sizeof test binary.')
+        return int(res.stdout)
+
+    def alignment(self, typename, env):
+        templ = '''#include<stdio.h>
+#include<stddef.h>
+
+struct tmp {
+  char c;
+  %s target;
+};
+
+int main(int argc, char **argv) {
+  printf("%%d", (int)offsetof(struct tmp, target));
+  return 0;
+}
+'''
+        varname = 'alignment ' + typename
+        varname = varname.replace(' ', '_')
+        if self.is_cross:
+            val = env.cross_info.get(varname)
+            if val is not None:
+                if isinstance(val, int):
+                    return val
+                raise EnvironmentException('Cross variable {0} is not an integer.'.format(varname))
+        cross_failed = False
+        try:
+            res = self.run(templ % typename)
+        except CrossNoRunException:
+            cross_failed = True
+        if cross_failed:
+            message = '''Can not determine alignment of {0} because cross compiled binaries are not runnable.
+Please define the corresponding variable {1} in your cross compilation definition file.'''.format(typename, varname)
+            raise EnvironmentException(message)
+        if not res.compiled:
+            raise EnvironmentException('Could not compile alignment test.')
+        if res.returncode != 0:
+            raise EnvironmentException('Could not run alignment test binary.')
+        align = int(res.stdout)
+        if align == 0:
+            raise EnvironmentException('Could not determine alignment of %s. Sorry. You might want to file a bug.' % typename)
+        return align
+
+    def has_function(self, funcname, prefix, env):
+        # This fails (returns true) if funcname is a ptr or a variable.
+        # The correct check is a lot more difficult.
+        # Fix this to do that eventually.
+        templ = '''%s
+int main(int argc, char **argv) {
+    void *ptr = (void*)(%s);
+    return 0;
+};
+'''
+        varname = 'has function ' + funcname
+        varname = varname.replace(' ', '_')
+        if self.is_cross:
+            val = env.cross_info.get(varname)
+            if val is not None:
+                if isinstance(val, bool):
+                    return val
+                raise EnvironmentException('Cross variable {0} is not an boolean.'.format(varname))
+        return self.compiles(templ % (prefix, funcname))
+
+    def has_member(self, typename, membername, prefix):
+        templ = '''%s
+void bar() {
+    %s foo;
+    foo.%s;
+};
+'''
+        return self.compiles(templ % (prefix, typename, membername))
+
+class CPPCompiler(CCompiler):
+    def __init__(self, exelist, version, is_cross, exe_wrap):
+        CCompiler.__init__(self, exelist, version, is_cross, exe_wrap)
+        self.language = 'cpp'
+        self.default_suffix = 'cpp'
+
+    def can_compile(self, filename):
+        suffix = filename.split('.')[-1]
+        if suffix in cpp_suffixes:
+            return True
+        return False
+
+    def sanity_check(self, work_dir):
+        source_name = os.path.join(work_dir, 'sanitycheckcpp.cc')
+        binary_name = os.path.join(work_dir, 'sanitycheckcpp')
+        ofile = open(source_name, 'w')
+        ofile.write('class breakCCompiler;int main(int argc, char **argv) { return 0; }\n')
+        ofile.close()
+        pc = subprocess.Popen(self.exelist + [source_name, '-o', binary_name])
+        pc.wait()
+        if pc.returncode != 0:
+            raise EnvironmentException('Compiler %s can not compile programs.' % self.name_string())
+        if self.is_cross:
+            if self.exe_wrapper is None:
+                # Can't check if the binaries run so we have to assume they do
+                return
+            cmdlist = self.exe_wrapper + [binary_name]
+        else:
+            cmdlist = [binary_name]
+        pe = subprocess.Popen(cmdlist)
+        pe.wait()
+        if pe.returncode != 0:
+            raise EnvironmentException('Executables created by C++ compiler %s are not runnable.' % self.name_string())
+
+class ObjCCompiler(CCompiler):
+    def __init__(self, exelist, version, is_cross, exe_wrap):
+        CCompiler.__init__(self, exelist, version, is_cross, exe_wrap)
+        self.language = 'objc'
+        self.default_suffix = 'm'
+
+    def can_compile(self, filename):
+        suffix = filename.split('.')[-1]
+        if suffix == 'm' or suffix == 'h':
+            return True
+        return False
+
+    def sanity_check(self, work_dir):
+        source_name = os.path.join(work_dir, 'sanitycheckobjc.m')
+        binary_name = os.path.join(work_dir, 'sanitycheckobjc')
+        ofile = open(source_name, 'w')
+        ofile.write('#import<stdio.h>\nint main(int argc, char **argv) { return 0; }\n')
+        ofile.close()
+        pc = subprocess.Popen(self.exelist + [source_name, '-o', binary_name])
+        pc.wait()
+        if pc.returncode != 0:
+            raise EnvironmentException('ObjC compiler %s can not compile programs.' % self.name_string())
+        pe = subprocess.Popen(binary_name)
+        pe.wait()
+        if pe.returncode != 0:
+            raise EnvironmentException('Executables created by ObjC compiler %s are not runnable.' % self.name_string())
+
+class ObjCPPCompiler(CPPCompiler):
+    def __init__(self, exelist, version, is_cross, exe_wrap):
+        CPPCompiler.__init__(self, exelist, version, is_cross, exe_wrap)
+        self.language = 'objcpp'
+        self.default_suffix = 'mm'
+
+    def can_compile(self, filename):
+        suffix = filename.split('.')[-1]
+        if suffix == 'mm' or suffix == 'h':
+            return True
+        return False
+
+    def sanity_check(self, work_dir):
+        source_name = os.path.join(work_dir, 'sanitycheckobjcpp.mm')
+        binary_name = os.path.join(work_dir, 'sanitycheckobjcpp')
+        ofile = open(source_name, 'w')
+        ofile.write('#import<stdio.h>\nclass MyClass;int main(int argc, char **argv) { return 0; }\n')
+        ofile.close()
+        pc = subprocess.Popen(self.exelist + [source_name, '-o', binary_name])
+        pc.wait()
+        if pc.returncode != 0:
+            raise EnvironmentException('ObjC++ compiler %s can not compile programs.' % self.name_string())
+        pe = subprocess.Popen(binary_name)
+        pe.wait()
+        if pe.returncode != 0:
+            raise EnvironmentException('Executables created by ObjC++ compiler %s are not runnable.' % self.name_string())
+
+class MonoCompiler():
+    def __init__(self, exelist, version):
+        if type(exelist) == type(''):
+            self.exelist = [exelist]
+        elif type(exelist) == type([]):
+            self.exelist = exelist
+        else:
+            raise TypeError('Unknown argument to Mono compiler')
+        self.version = version
+        self.language = 'cs'
+        self.default_suffix = 'cs'
+        self.id = 'mono'
+        self.monorunner = 'mono'
+
+    def get_always_args(self):
+        return []
+
+    def get_output_args(self, fname):
+        return ['-out:' + fname]
+
+    def get_linker_always_args(self):
+        return []
+
+    def get_link_args(self, fname):
+        return ['-r:' + fname]
+
+    def get_soname_args(self, shlib_name, path, soversion):
+        return []
+
+    def get_werror_args(self):
+        return ['-warnaserror']
+
+    def split_shlib_to_parts(self, fname):
+        return (None, fname)
+
+    def build_rpath_args(self, build_dir, rpath_paths, install_rpath):
+        return []
+
+    def get_id(self):
+        return self.id
+
+    def get_dependency_gen_args(self, outtarget, outfile):
+        return []
+
+    def get_language(self):
+        return self.language
+
+    def get_default_suffix(self):
+        return self.default_suffix
+
+    def get_exelist(self):
+        return self.exelist[:]
+
+    def get_linker_exelist(self):
+        return self.exelist[:]
+
+    def get_compile_only_args(self):
+        return []
+
+    def get_linker_output_args(self, outputname):
+        return []
+
+    def get_debug_args(self):
+        return ['-g']
+
+    def get_coverage_args(self):
+        return []
+
+    def get_coverage_link_args(self):
+        return []
+
+    def get_std_exe_link_args(self):
+        return []
+
+    def get_include_args(self, path):
+        return []
+
+    def get_std_shared_lib_link_args(self):
+        return []
+
+    def can_compile(self, filename):
+        suffix = filename.split('.')[-1]
+        if suffix == 'cs':
+            return True
+        return False
+
+    def get_pic_args(self):
+        return []
+
+    def name_string(self):
+        return ' '.join(self.exelist)
+
+    def get_pch_use_args(self, pch_dir, header):
+        return []
+
+    def get_pch_name(self, header_name):
+        return ''
+
+    def sanity_check(self, work_dir):
+        src = 'sanity.cs'
+        obj = 'sanity.exe'
+        source_name = os.path.join(work_dir, src)
+        ofile = open(source_name, 'w')
+        ofile.write('''public class Sanity {
+    static public void Main () {
+    }
+}
+''')
+        ofile.close()
+        pc = subprocess.Popen(self.exelist + [src], cwd=work_dir)
+        pc.wait()
+        if pc.returncode != 0:
+            raise EnvironmentException('Mono compiler %s can not compile programs.' % self.name_string())
+        cmdlist = [self.monorunner, obj]
+        pe = subprocess.Popen(cmdlist, cwd=work_dir)
+        pe.wait()
+        if pe.returncode != 0:
+            raise EnvironmentException('Executables created by Mono compiler %s are not runnable.' % self.name_string())
+
+    def needs_static_linker(self):
+        return False
+
+    def has_header(self, hname):
+        raise EnvironmentException('Mono does not support header checks.')
+
+    def compiles(self, code):
+        raise EnvironmentException('Mono does not support compile checks.')
+
+    def run(self, code):
+        raise EnvironmentException('Mono does not support run checks.')
+
+    def sizeof(self, element, prefix, env):
+        raise EnvironmentException('Mono does not support sizeof checks.')
+
+    def alignment(self, typename, env):
+        raise EnvironmentException('Mono does not support alignment checks.')
+
+    def has_function(self, funcname, prefix, env):
+        raise EnvironmentException('Mono does not support function checks.')
+
+    def get_buildtype_args(self, buildtype):
+        return mono_buildtype_args[buildtype]
+
+class JavaCompiler():
+    def __init__(self, exelist, version):
+        if type(exelist) == type(''):
+            self.exelist = [exelist]
+        elif type(exelist) == type([]):
+            self.exelist = exelist
+        else:
+            raise TypeError('Unknown argument to JavaCompiler')
+        self.version = version
+        self.language = 'java'
+        self.default_suffix = 'java'
+        self.id = 'unknown'
+        self.javarunner = 'java'
+
+    def get_always_args(self):
+        return []
+
+    def get_linker_always_args(self):
+        return []
+
+    def get_soname_args(self, shlib_name, path, soversion):
+        return []
+
+    def get_werror_args(self):
+        return ['-Werror']
+
+    def split_shlib_to_parts(self, fname):
+        return (None, fname)
+
+    def build_rpath_args(self, build_dir, rpath_paths, install_rpath):
+        return []
+
+    def get_id(self):
+        return self.id
+
+    def get_dependency_gen_args(self, outtarget, outfile):
+        return []
+
+    def get_language(self):
+        return self.language
+
+    def get_default_suffix(self):
+        return self.default_suffix
+
+    def get_exelist(self):
+        return self.exelist[:]
+
+    def get_linker_exelist(self):
+        return self.exelist[:]
+
+    def get_compile_only_args(self):
+        return []
+
+    def get_output_args(self, subdir):
+        if subdir == '':
+            subdir = './'
+        return ['-d', subdir, '-s', subdir]
+
+    def get_linker_output_args(self, outputname):
+        return []
+
+    def get_debug_args(self):
+        return ['-g']
+
+    def get_coverage_args(self):
+        return []
+
+    def get_coverage_link_args(self):
+        return []
+
+    def get_std_exe_link_args(self):
+        return []
+
+    def get_include_args(self, path):
+        return []
+
+    def get_std_shared_lib_link_args(self):
+        return []
+
+    def can_compile(self, filename):
+        suffix = filename.split('.')[-1]
+        if suffix == 'java':
+            return True
+        return False
+
+    def get_pic_args(self):
+        return []
+
+    def name_string(self):
+        return ' '.join(self.exelist)
+
+    def get_pch_use_args(self, pch_dir, header):
+        return []
+
+    def get_pch_name(self, header_name):
+        return ''
+
+    def sanity_check(self, work_dir):
+        src = 'SanityCheck.java'
+        obj = 'SanityCheck'
+        source_name = os.path.join(work_dir, src)
+        ofile = open(source_name, 'w')
+        ofile.write('''class SanityCheck {
+  public static void main(String[] args) {
+    int i;
+  }
+}
+''')
+        ofile.close()
+        pc = subprocess.Popen(self.exelist + [src], cwd=work_dir)
+        pc.wait()
+        if pc.returncode != 0:
+            raise EnvironmentException('Java compiler %s can not compile programs.' % self.name_string())
+        cmdlist = [self.javarunner, obj]
+        pe = subprocess.Popen(cmdlist, cwd=work_dir)
+        pe.wait()
+        if pe.returncode != 0:
+            raise EnvironmentException('Executables created by Java compiler %s are not runnable.' % self.name_string())
+
+    def needs_static_linker(self):
+        return False
+
+    def has_header(self, hname):
+        raise EnvironmentException('Java does not support header checks.')
+
+    def compiles(self, code):
+        raise EnvironmentException('Java does not support compile checks.')
+
+    def run(self, code):
+        raise EnvironmentException('Java does not support run checks.')
+
+    def sizeof(self, element, prefix, env):
+        raise EnvironmentException('Java does not support sizeof checks.')
+
+    def alignment(self, typename, env):
+        raise EnvironmentException('Java does not support alignment checks.')
+
+    def has_function(self, funcname, prefix, env):
+        raise EnvironmentException('Java does not support function checks.')
+
+class ValaCompiler():
+    def __init__(self, exelist, version):
+        if isinstance(exelist, str):
+            self.exelist = [exelist]
+        elif type(exelist) == type([]):
+            self.exelist = exelist
+        else:
+            raise TypeError('Unknown argument to Vala compiler')
+        self.version = version
+        self.id = 'unknown'
+        self.language = 'vala'
+
+    def needs_static_linker(self):
+        return False # Because compiles into C.
+
+    def get_exelist(self):
+        return self.exelist
+
+    def get_werror_args(self):
+        return ['--fatal-warnings']
+
+    def get_language(self):
+        return self.language
+
+    def sanity_check(self, work_dir):
+        src = 'valatest.vala'
+        obj = 'valatest.c'
+        source_name = os.path.join(work_dir, src)
+        ofile = open(source_name, 'w')
+        ofile.write('''class SanityCheck : Object {
+}
+''')
+        ofile.close()
+        pc = subprocess.Popen(self.exelist + ['-C', '-o', obj, src], cwd=work_dir)
+        pc.wait()
+        if pc.returncode != 0:
+            raise EnvironmentException('Vala compiler %s can not compile programs.' % self.name_string())
+
+    def can_compile(self, fname):
+        return fname.endswith('.vala')
+
+class RustCompiler():
+    def __init__(self, exelist, version):
+        if isinstance(exelist, str):
+            self.exelist = [exelist]
+        elif type(exelist) == type([]):
+            self.exelist = exelist
+        else:
+            raise TypeError('Unknown argument to Rust compiler')
+        self.version = version
+        self.id = 'unknown'
+        self.language = 'rust'
+
+    def needs_static_linker(self):
+        return False
+
+    def get_exelist(self):
+        return self.exelist
+
+    def get_id(self):
+        return self.id
+
+    def get_language(self):
+        return self.language
+
+    def sanity_check(self, work_dir):
+        source_name = os.path.join(work_dir, 'sanity.rs')
+        output_name = os.path.join(work_dir, 'rusttest')
+        ofile = open(source_name, 'w')
+        ofile.write('''fn main() {
+}
+''')
+        ofile.close()
+        pc = subprocess.Popen(self.exelist + ['-o', output_name, source_name], cwd=work_dir)
+        pc.wait()
+        if pc.returncode != 0:
+            raise EnvironmentException('Rust compiler %s can not compile programs.' % self.name_string())
+        if subprocess.call(output_name) != 0:
+            raise EnvironmentException('Executables created by Rust compiler %s are not runnable.' % self.name_string())
+
+    def can_compile(self, fname):
+        return fname.endswith('.rs')
+
+    def get_dependency_gen_args(self, outfile):
+        return ['--dep-info', outfile]
+
+    def get_buildtype_args(self, buildtype):
+        return rust_buildtype_args[buildtype]
+
+class VisualStudioCCompiler(CCompiler):
+    std_warn_args = ['/W3']
+    std_opt_args= ['/O2']
+    vs2010_always_args = ['/nologo', '/showIncludes']
+    vs2013_always_args = ['/nologo', '/showIncludes', '/FS']
+
+    def __init__(self, exelist, version, is_cross, exe_wrap):
+        CCompiler.__init__(self, exelist, version, is_cross, exe_wrap)
+        self.id = 'msvc'
+        if int(version.split('.')[0]) > 17:
+            self.always_args = VisualStudioCCompiler.vs2013_always_args
+        else:
+            self.always_args = VisualStudioCCompiler.vs2010_always_args
+
+    def get_always_args(self):
+        return self.always_args
+
+    def get_std_warn_args(self):
+        return self.std_warn_args
+
+    def get_buildtype_args(self, buildtype):
+        return msvc_buildtype_args[buildtype]
+
+    def get_buildtype_linker_args(self, buildtype):
+        return msvc_buildtype_linker_args[buildtype]
+
+    def get_pch_suffix(self):
+        return 'pch'
+
+    def get_pch_name(self, header):
+        chopped = os.path.split(header)[-1].split('.')[:-1]
+        chopped.append(self.get_pch_suffix())
+        pchname = '.'.join(chopped)
+        return pchname
+
+    def get_pch_use_args(self, pch_dir, header):
+        base = os.path.split(header)[-1]
+        pchname = self.get_pch_name(header)
+        return ['/FI' + base, '/Yu' + base, '/Fp' + os.path.join(pch_dir, pchname)]
+
+    def get_debug_args(self):
+        return ['/D_DEBUG', '/Zi', '/MDd', '/Ob0', '/RTC1']
+
+    def get_compile_only_args(self):
+        return ['/c']
+
+    def get_output_args(self, target):
+        if target.endswith('.exe'):
+            return ['/Fe' + target]
+        return ['/Fo' + target]
+
+    def get_dependency_gen_args(self, outtarget, outfile):
+        return []
+
+    def get_linker_exelist(self):
+        return ['link'] # FIXME, should have same path as compiler.
+
+    def get_linker_always_args(self):
+        return ['/nologo']
+
+    def get_linker_output_args(self, outputname):
+        return ['/OUT:' + outputname]
+
+    def get_pic_args(self):
+        return ['/LD']
+
+    def get_std_shared_lib_link_args(self):
+        return ['/DLL']
+
+    def gen_pch_args(self, header, source, pchname):
+        objname = os.path.splitext(pchname)[0] + '.obj'
+        return (objname, ['/Yc' + header, '/Fp' + pchname, '/Fo' + objname ])
+
+    def sanity_check(self, work_dir):
+        source_name = 'sanitycheckc.c'
+        binary_name = 'sanitycheckc'
+        ofile = open(os.path.join(work_dir, source_name), 'w')
+        ofile.write('int main(int argc, char **argv) { return 0; }\n')
+        ofile.close()
+        pc = subprocess.Popen(self.exelist + [source_name, '/Fe' + binary_name],
+                              stdout=subprocess.DEVNULL,
+                              stderr=subprocess.DEVNULL,
+                              cwd=work_dir)
+        pc.wait()
+        if pc.returncode != 0:
+            raise EnvironmentException('Compiler %s can not compile programs.' % self.name_string())
+        pe = subprocess.Popen(os.path.join(work_dir, binary_name))
+        pe.wait()
+        if pe.returncode != 0:
+            raise EnvironmentException('Executables created by C++ compiler %s are not runnable.' % self.name_string())
+
+    def build_rpath_args(self, build_dir, rpath_paths, install_rpath):
+        return []
+
+class VisualStudioCPPCompiler(VisualStudioCCompiler):
+    def __init__(self, exelist, version, is_cross, exe_wrap):
+        VisualStudioCCompiler.__init__(self, exelist, version, is_cross, exe_wrap)
+        self.language = 'cpp'
+        self.default_suffix = 'cpp'
+
+    def can_compile(self, filename):
+        suffix = filename.split('.')[-1]
+        if suffix in cpp_suffixes:
+            return True
+        return False
+
+    def sanity_check(self, work_dir):
+        source_name = 'sanitycheckcpp.cpp'
+        binary_name = 'sanitycheckcpp'
+        ofile = open(os.path.join(work_dir, source_name), 'w')
+        ofile.write('class BreakPlainC;int main(int argc, char **argv) { return 0; }\n')
+        ofile.close()
+        pc = subprocess.Popen(self.exelist + [source_name, '/Fe' + binary_name],
+                              stdout=subprocess.DEVNULL,
+                              stderr=subprocess.DEVNULL,
+                              cwd=work_dir)
+        pc.wait()
+        if pc.returncode != 0:
+            raise EnvironmentException('Compiler %s can not compile programs.' % self.name_string())
+        pe = subprocess.Popen(os.path.join(work_dir, binary_name))
+        pe.wait()
+        if pe.returncode != 0:
+            raise EnvironmentException('Executables created by C++ compiler %s are not runnable.' % self.name_string())
+
+GCC_STANDARD = 0
+GCC_OSX = 1
+GCC_MINGW = 2
+
+def get_gcc_soname_args(gcc_type, shlib_name, path, soversion):
+    if soversion is None:
+        sostr = ''
+    else:
+        sostr = '.' + soversion
+    if gcc_type == GCC_STANDARD:
+        return ['-Wl,-soname,lib%s.so%s' % (shlib_name, sostr)]
+    elif gcc_type == GCC_OSX:
+        return ['-install_name', os.path.join(path, 'lib' + shlib_name + '.dylib')]
+    else:
+        raise RuntimeError('Not impelented yet.')
+
+class GnuCCompiler(CCompiler):
+    std_warn_args = ['-Wall', '-Winvalid-pch']
+
+    def __init__(self, exelist, version, gcc_type, is_cross, exe_wrapper=None):
+        CCompiler.__init__(self, exelist, version, is_cross, exe_wrapper)
+        self.id = 'gcc'
+        self.gcc_type = gcc_type
+
+    def get_always_args(self):
+        return ['-pipe']
+
+    def get_std_warn_args(self):
+        return GnuCCompiler.std_warn_args
+
+    def get_buildtype_args(self, buildtype):
+        return gnulike_buildtype_args[buildtype]
+
+    def get_buildtype_linker_args(self, buildtype):
+        return gnulike_buildtype_linker_args[buildtype]
+
+    def get_pch_suffix(self):
+        return 'gch'
+
+    def split_shlib_to_parts(self, fname):
+        return (os.path.split(fname)[0], fname)
+
+    def get_soname_args(self, shlib_name, path, soversion):
+        return get_gcc_soname_args(self.gcc_type, shlib_name, path, soversion)
+
+    def can_compile(self, filename):
+        return super().can_compile(filename) or filename.split('.')[-1] == 's' # Gcc can do asm, too.
+
+class GnuObjCCompiler(ObjCCompiler):
+    std_warn_args = ['-Wall', '-Winvalid-pch']
+
+    def __init__(self, exelist, version, is_cross, exe_wrapper=None):
+        ObjCCompiler.__init__(self, exelist, version, is_cross, exe_wrapper)
+        self.id = 'gcc'
+
+    def get_std_warn_args(self):
+        return GnuObjCCompiler.std_warn_args
+
+    def get_buildtype_args(self, buildtype):
+        return gnulike_buildtype_args[buildtype]
+
+    def get_buildtype_linker_args(self, buildtype):
+        return gnulike_buildtype_linker_args[buildtype]
+
+    def get_pch_suffix(self):
+        return 'gch'
+
+    def get_soname_args(self, shlib_name, path, soversion):
+        return get_gcc_soname_args(self.gcc_type, shlib_name, path, soversion)
+
+class GnuObjCPPCompiler(ObjCPPCompiler):
+    std_warn_args = ['-Wall', '-Winvalid-pch']
+    std_opt_args = ['-O2']
+
+    def __init__(self, exelist, version, is_cross, exe_wrapper=None):
+        ObjCCompiler.__init__(self, exelist, version, is_cross, exe_wrapper)
+        self.id = 'gcc'
+
+    def get_std_warn_args(self):
+        return GnuObjCPPCompiler.std_warn_args
+
+    def get_buildtype_args(self, buildtype):
+        return gnulike_buildtype_args[buildtype]
+
+    def get_buildtype_linker_args(self, buildtype):
+        return gnulike_buildtype_linker_args[buildtype]
+
+    def get_pch_suffix(self):
+        return 'gch'
+
+    def get_soname_args(self, shlib_name, path, soversion):
+        return get_gcc_soname_args(self.gcc_type, shlib_name, path, soversion)
+
+class ClangObjCCompiler(GnuObjCCompiler):
+    def __init__(self, exelist, version, is_cross, exe_wrapper=None):
+        super().__init__(exelist, version, is_cross, exe_wrapper)
+        self.id = 'clang'
+
+class ClangObjCPPCompiler(GnuObjCPPCompiler):
+    def __init__(self, exelist, version, is_cross, exe_wrapper=None):
+        super().__init__(exelist, version, is_cross, exe_wrapper)
+        self.id = 'clang'
+
+class ClangCCompiler(CCompiler):
+    std_warn_args = ['-Wall', '-Winvalid-pch']
+
+    def __init__(self, exelist, version, is_cross, exe_wrapper=None):
+        CCompiler.__init__(self, exelist, version, is_cross, exe_wrapper)
+        self.id = 'clang'
+
+    def get_std_warn_args(self):
+        return ClangCCompiler.std_warn_args
+
+    def get_buildtype_args(self, buildtype):
+        return gnulike_buildtype_args[buildtype]
+
+    def get_buildtype_linker_args(self, buildtype):
+        return gnulike_buildtype_linker_args[buildtype]
+
+    def get_pch_suffix(self):
+        return 'pch'
+
+    def can_compile(self, filename):
+        return super().can_compile(filename) or filename.split('.')[-1] == 's' # Clang can do asm, too.
+
+    def get_pch_use_args(self, pch_dir, header):
+        # Workaround for Clang bug http://llvm.org/bugs/show_bug.cgi?id=15136
+        # This flag is internal to Clang (or at least not documented on the man page)
+        # so it might change semantics at any time.
+        return ['-include-pch', os.path.join (pch_dir, self.get_pch_name (header))]
+
+
+class GnuCPPCompiler(CPPCompiler):
+    std_warn_args = ['-Wall', '-Winvalid-pch']
+    # may need to separate the latter to extra_debug_args or something
+    std_debug_args = ['-g']
+
+    def __init__(self, exelist, version, gcc_type, is_cross, exe_wrap):
+        CPPCompiler.__init__(self, exelist, version, is_cross, exe_wrap)
+        self.id = 'gcc'
+        self.gcc_type = gcc_type
+
+    def get_always_args(self):
+        return ['-pipe']
+
+    def get_debug_args(self):
+        return GnuCPPCompiler.std_debug_args
+
+    def get_std_warn_args(self):
+        return GnuCPPCompiler.std_warn_args
+
+    def get_buildtype_args(self, buildtype):
+        return gnulike_buildtype_args[buildtype]
+
+    def get_buildtype_linker_args(self, buildtype):
+        return gnulike_buildtype_linker_args[buildtype]
+
+    def get_pch_suffix(self):
+        return 'gch'
+
+    def get_soname_args(self, shlib_name, path, soversion):
+        return get_gcc_soname_args(self.gcc_type, shlib_name, path, soversion)
+
+class ClangCPPCompiler(CPPCompiler):
+    std_warn_args = ['-Wall', '-Winvalid-pch']
+
+    def __init__(self, exelist, version, is_cross, exe_wrapper=None):
+        CPPCompiler.__init__(self, exelist, version, is_cross, exe_wrapper)
+        self.id = 'clang'
+
+    def get_std_warn_args(self):
+        return ClangCPPCompiler.std_warn_args
+
+    def get_buildtype_args(self, buildtype):
+        return gnulike_buildtype_args[buildtype]
+
+    def get_buildtype_linker_args(self, buildtype):
+        return gnulike_buildtype_linker_args[buildtype]
+
+    def get_pch_suffix(self):
+        return 'pch'
+
+    def get_pch_use_args(self, pch_dir, header):
+        # Workaround for Clang bug http://llvm.org/bugs/show_bug.cgi?id=15136
+        # This flag is internal to Clang (or at least not documented on the man page)
+        # so it might change semantics at any time.
+        return ['-include-pch', os.path.join (pch_dir, self.get_pch_name (header))]
+
+class FortranCompiler():
+    std_warn_args = ['-Wall']
+
+    def __init__(self, exelist, version,is_cross, exe_wrapper=None):
+        super().__init__()
+        self.exelist = exelist
+        self.version = version
+        self.is_cross = is_cross
+        self.exe_wrapper = exe_wrapper
+        self.language = 'fortran'
+
+    def get_id(self):
+        return self.id
+
+    def get_exelist(self):
+        return self.exelist
+
+    def get_language(self):
+        return self.language
+
+    def needs_static_linker(self):
+        return True
+
+    def sanity_check(self, work_dir):
+        source_name = os.path.join(work_dir, 'sanitycheckf.f90')
+        binary_name = os.path.join(work_dir, 'sanitycheckf')
+        ofile = open(source_name, 'w')
+        ofile.write('''program prog
+     print *, "Fortran compilation is working."
+end program prog
+''')
+        ofile.close()
+        pc = subprocess.Popen(self.exelist + [source_name, '-o', binary_name])
+        pc.wait()
+        if pc.returncode != 0:
+            raise EnvironmentException('Compiler %s can not compile programs.' % self.name_string())
+        if self.is_cross:
+            if self.exe_wrapper is None:
+                # Can't check if the binaries run so we have to assume they do
+                return
+            cmdlist = self.exe_wrapper + [binary_name]
+        else:
+            cmdlist = [binary_name]
+        pe = subprocess.Popen(cmdlist, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        pe.wait()
+        if pe.returncode != 0:
+            raise EnvironmentException('Executables created by Fortran compiler %s are not runnable.' % self.name_string())
+
+    def get_always_args(self):
+        return ['-pipe']
+
+    def get_linker_always_args(self):
+        return []
+
+    def get_std_warn_args(self):
+        return FortranCompiler.std_warn_args
+
+    def get_buildtype_args(self, buildtype):
+        return gnulike_buildtype_args[buildtype]
+
+    def get_buildtype_linker_args(self, buildtype):
+        return gnulike_buildtype_linker_args[buildtype]
+
+    def split_shlib_to_parts(self, fname):
+        return (os.path.split(fname)[0], fname)
+
+    def get_soname_args(self, shlib_name, path, soversion):
+        return get_gcc_soname_args(self.gcc_type, shlib_name, path, soversion)
+
+    def get_dependency_gen_args(self, outtarget, outfile):
+        # Disabled until this is fixed:
+        # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=62162
+        #return ['-cpp', '-MMD', '-MQ', outtarget]
+        return []
+
+    def get_output_args(self, target):
+        return ['-o', target]
+
+    def get_compile_only_args(self):
+        return ['-c']
+
+    def get_linker_exelist(self):
+        return self.exelist[:]
+
+    def get_linker_output_args(self, outputname):
+        return ['-o', outputname]
+
+    def can_compile(self, src):
+        suffix = os.path.splitext(src)[1].lower()
+        if suffix == '.f' or suffix == '.f95' or suffix == '.f90':
+            return True
+        return False
+
+    def get_include_args(self, path):
+        return ['-I' + path]
+
+    def get_module_outdir_args(self, path):
+        return ['-J' + path]
+
+    def get_depfile_suffix(self):
+        return 'd'
+
+    def get_std_exe_link_args(self):
+        return []
+
+    def build_rpath_args(self, build_dir, rpath_paths, install_rpath):
+        return build_unix_rpath_args(build_dir, rpath_paths, install_rpath)
+
+    def module_name_to_filename(self, module_name):
+        return module_name.lower() + '.mod'
+
+class GnuFortranCompiler(FortranCompiler):
+    def __init__(self, exelist, version, gcc_type, is_cross, exe_wrapper=None):
+        super().__init__(exelist, version, is_cross, exe_wrapper=None)
+        self.gcc_type = gcc_type
+        self.id = 'gcc'
+
+class G95FortranCompiler(FortranCompiler):
+    def __init__(self, exelist, version, is_cross, exe_wrapper=None):
+        super().__init__(exelist, version, is_cross, exe_wrapper=None)
+        self.id = 'g95'
+
+    def get_module_outdir_args(self, path):
+        return ['-fmod='+path]
+
+class SunFortranCompiler(FortranCompiler):
+    def __init__(self, exelist, version, is_cross, exe_wrapper=None):
+        super().__init__(exelist, version, is_cross, exe_wrapper=None)
+        self.id = 'sun'
+
+    def get_dependency_gen_args(self, outtarget, outfile):
+        return ['-fpp']
+
+    def get_always_args(self):
+        return []
+
+    def get_std_warn_args(self):
+        return []
+
+    def get_module_outdir_args(self, path):
+        return ['-moddir='+path]
+
+class IntelFortranCompiler(FortranCompiler):
+    std_warn_args = ['-warn', 'all']
+    
+    def __init__(self, exelist, version, is_cross, exe_wrapper=None):
+        super().__init__(exelist, version, is_cross, exe_wrapper=None)
+        self.id = 'intel'
+        
+    def get_module_outdir_args(self, path):
+        return ['-module', path]
+
+    def get_always_args(self):
+        return []
+
+    def can_compile(self, src):
+        suffix = os.path.splitext(src)[1].lower()
+        if suffix == '.f' or suffix == '.f90':
+            return True
+        return False
+
+    def get_std_warn_args(self):
+        return IntelFortranCompiler.std_warn_args
+
+class PathScaleFortranCompiler(FortranCompiler):
+    std_warn_args = ['-fullwarn']
+
+    def __init__(self, exelist, version, is_cross, exe_wrapper=None):
+        super().__init__(exelist, version, is_cross, exe_wrapper=None)
+        self.id = 'pathscale'
+
+    def get_module_outdir_args(self, path):
+        return ['-module', path]
+
+    def get_always_args(self):
+        return []
+
+    def can_compile(self, src):
+        suffix = os.path.splitext(src)[1].lower()
+        if suffix == '.f' or suffix == '.f90' or suffix == '.f95':
+            return True
+        return False
+
+    def get_std_warn_args(self):
+        return PathScaleFortranCompiler.std_warn_args
+
+class PGIFortranCompiler(FortranCompiler):
+    std_warn_args = ['-Minform=inform']
+
+    def __init__(self, exelist, version, is_cross, exe_wrapper=None):
+        super().__init__(exelist, version, is_cross, exe_wrapper=None)
+        self.id = 'pgi'
+
+    def get_module_outdir_args(self, path):
+        return ['-module', path]
+
+    def get_always_args(self):
+        return []
+
+    def can_compile(self, src):
+        suffix = os.path.splitext(src)[1].lower()
+        if suffix == '.f' or suffix == '.f90' or suffix == '.f95':
+            return True
+        return False
+
+    def get_std_warn_args(self):
+        return PGIFortranCompiler.std_warn_args
+
+
+class Open64FortranCompiler(FortranCompiler):
+    std_warn_args = ['-fullwarn']
+
+    def __init__(self, exelist, version, is_cross, exe_wrapper=None):
+        super().__init__(exelist, version, is_cross, exe_wrapper=None)
+        self.id = 'open64'
+
+    def get_module_outdir_args(self, path):
+        return ['-module', path]
+
+    def get_always_args(self):
+        return []
+
+    def can_compile(self, src):
+        suffix = os.path.splitext(src)[1].lower()
+        if suffix == '.f' or suffix == '.f90' or suffix == '.f95':
+            return True
+        return False
+
+    def get_std_warn_args(self):
+        return Open64FortranCompiler.std_warn_args
+
+class NAGFortranCompiler(FortranCompiler):
+    std_warn_args = []
+
+    def __init__(self, exelist, version, is_cross, exe_wrapper=None):
+        super().__init__(exelist, version, is_cross, exe_wrapper=None)
+        self.id = 'nagfor'
+
+    def get_module_outdir_args(self, path):
+        return ['-mdir', path]
+
+    def get_always_args(self):
+        return []
+
+    def can_compile(self, src):
+        suffix = os.path.splitext(src)[1].lower()
+        if suffix == '.f' or suffix == '.f90' or suffix == '.f95':
+            return True
+        return False
+
+    def get_std_warn_args(self):
+        return NAGFortranCompiler.std_warn_args
+
+
+class VisualStudioLinker():
+    always_args = ['/NOLOGO']
+    def __init__(self, exelist):
+        self.exelist = exelist
+
+    def get_exelist(self):
+        return self.exelist
+
+    def get_std_link_args(self):
+        return []
+
+    def get_buildtype_linker_args(self, buildtype):
+        return []
+
+    def get_output_args(self, target):
+        return ['/OUT:' + target]
+
+    def get_coverage_link_args(self):
+        return []
+
+    def get_always_args(self):
+        return VisualStudioLinker.always_args
+
+    def get_linker_always_args(self):
+        return VisualStudioLinker.always_args
+
+    def build_rpath_args(self, build_dir, rpath_paths, install_rpath):
+        return []
+
+class ArLinker():
+    std_args = ['csr']
+
+    def __init__(self, exelist):
+        self.exelist = exelist
+        self.id = 'ar'
+
+    def build_rpath_args(self, build_dir, rpath_paths, install_rpath):
+        return []
+
+    def get_exelist(self):
+        return self.exelist
+
+    def get_std_link_args(self):
+        return self.std_args
+
+    def get_output_args(self, target):
+        return [target]
+
+    def get_buildtype_linker_args(self, buildtype):
+        return []
+
+    def get_linker_always_args(self):
+        return []
+
+    def get_coverage_link_args(self):
+        return []
+
+    def get_always_args(self):
+        return []
+
diff --git a/dependencies.py b/dependencies.py
index 496366a..5612f39 100644
--- a/dependencies.py
+++ b/dependencies.py
@@ -25,7 +25,7 @@ import os, stat, glob, subprocess, shutil
 from coredata import MesonException
 import environment
 import mlog
-from environment import is_windows
+import mesonlib
 
 class DependencyException(MesonException):
     def __init__(self, *args, **kwargs):
@@ -148,10 +148,10 @@ class ExternalProgram():
             if self.fullpath[0] is None and search_dir is not None:
                 trial = os.path.join(search_dir, name)
                 suffix = os.path.splitext(trial)[-1].lower()[1:]
-                if environment.is_windows() and (suffix == 'exe' or suffix == 'com'\
+                if mesonlib.is_windows() and (suffix == 'exe' or suffix == 'com'\
                                           or suffix == 'bat'):
                     self.fullpath = [trial]
-                elif not environment.is_windows() and os.access(trial, os.X_OK):
+                elif not mesonlib.is_windows() and os.access(trial, os.X_OK):
                     self.fullpath = [trial]
                 else:
                     # Now getting desperate. Maybe it is a script file that is a) not chmodded
@@ -160,7 +160,7 @@ class ExternalProgram():
                         first_line = open(trial).readline().strip()
                         if first_line.startswith('#!'):
                             commands = first_line[2:].split('#')[0].strip().split()
-                            if environment.is_windows():
+                            if mesonlib.is_windows():
                                 commands[0] = commands[0].split('/')[-1] # Windows does not have /usr/bin.
                             self.fullpath = commands + [trial]
                     except Exception:
@@ -665,7 +665,7 @@ class AppleFrameworks(Dependency):
         return args
 
     def found(self):
-        return environment.is_osx()
+        return mesonlib.is_osx()
 
 def get_dep_identifier(name, kwargs):
     elements = [name]
diff --git a/environment.py b/environment.py
index f4f21fc..a07d0be 100644
--- a/environment.py
+++ b/environment.py
@@ -12,1496 +12,29 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import subprocess, os.path, platform, re
+import re
 import coredata
 from glob import glob
-import tempfile
-from coredata import MesonException
+from compilers import *
 
 build_filename = 'meson.build'
 
-class EnvironmentException(MesonException):
-    def __init(self, *args, **kwargs):
-        Exception.__init__(self, *args, **kwargs)
-
-class CrossNoRunException(MesonException):
-    def __init(self, *args, **kwargs):
-        Exception.__init__(self, *args, **kwargs)
-
-class RunResult():
-    def __init__(self, compiled, returncode=999, stdout='UNDEFINED', stderr='UNDEFINED'):
-        self.compiled = compiled
-        self.returncode = returncode
-        self.stdout = stdout
-        self.stderr = stderr
-
-def is_osx():
-    return platform.system().lower() == 'darwin'
-
-def is_linux():
-    return platform.system().lower() == 'linux'
-
-def is_windows():
-    return platform.system().lower() == 'windows'
-
-def is_debianlike():
-    try:
-        open('/etc/debian_version', 'r')
-        return True
-    except FileNotFoundError:
-        return False
-
-gnulike_buildtype_args = {'plain' : [],
-                           'debug' : ['-g'],
-                           'debugoptimized' : ['-O2', '-g'],
-                           'release' : ['-O3'],
-                           }
-
-msvc_buildtype_args = {'plain' : [],
-                        'debug' : ["/MDd", "/Zi", "/Ob0", "/Od", "/RTC1"],
-                        'debugoptimized' : ["/MD", "/Zi", "/O2", "/Ob1", "/D"],
-                        'release' : ["/MD", "/O2", "/Ob2"]}
-
-gnulike_buildtype_linker_args = {}
-
-if is_osx():
-    gnulike_buildtype_linker_args.update({'plain' : [],
-                                          'debug' : [],
-                                          'debugoptimized' : [],
-                                          'release' : [],
-                                          })
-else:
-    gnulike_buildtype_linker_args.update({'plain' : [],
-                                          'debug' : [],
-                                          'debugoptimized' : [],
-                                          'release' : ['-Wl,-O1'],
-                                          })
-
-msvc_buildtype_linker_args = {'plain' : [],
-                               'debug' : [],
-                               'debugoptimized' : [],
-                               'release' : []}
-
-rust_buildtype_args = {'plain' : [],
-                        'debug' : ['-g'],
-                        'debugoptimized' : ['-g', '--opt-level', '2'],
-                        'release' : ['--opt-level', '3']}
-
-mono_buildtype_args = {'plain' : [],
-                       'debug' : ['-debug'],
-                       'debugoptimized': ['-debug', '-optimize+'],
-                       'release' : ['-optimize+']}
-
-def build_unix_rpath_args(build_dir, rpath_paths, install_rpath):
-        if len(rpath_paths) == 0 and len(install_rpath) == 0:
-            return []
-        paths = ':'.join([os.path.join(build_dir, p) for p in rpath_paths])
-        if len(paths) < len(install_rpath):
-            padding = 'X'*(len(install_rpath) - len(paths))
-            if len(paths) == 0:
-                paths = padding
-            else:
-                paths = paths + ':' + padding
-        return ['-Wl,-rpath,' + paths]
-
-class CCompiler():
-    def __init__(self, exelist, version, is_cross, exe_wrapper=None):
-        if type(exelist) == type(''):
-            self.exelist = [exelist]
-        elif type(exelist) == type([]):
-            self.exelist = exelist
-        else:
-            raise TypeError('Unknown argument to CCompiler')
-        self.version = version
-        self.language = 'c'
-        self.default_suffix = 'c'
-        self.id = 'unknown'
-        self.is_cross = is_cross
-        if isinstance(exe_wrapper, str):
-            self.exe_wrapper = [exe_wrapper]
-        else:
-            self.exe_wrapper = exe_wrapper
-
-    def needs_static_linker(self):
-        return True # When compiling static libraries, so yes.
-
-    def get_always_args(self):
-        return []
-
-    def get_linker_always_args(self):
-        return []
-
-    def get_soname_args(self, shlib_name, path, soversion):
-        return []
-
-    def split_shlib_to_parts(self, fname):
-        return (None, fname)
-
-    # The default behaviour is this, override in
-    # OSX and MSVC.
-    def build_rpath_args(self, build_dir, rpath_paths, install_rpath):
-        return build_unix_rpath_args(build_dir, rpath_paths, install_rpath)
-
-    def get_id(self):
-        return self.id
-
-    def get_dependency_gen_args(self, outtarget, outfile):
-        return ['-MMD', '-MQ', outtarget, '-MF', outfile]
-
-    def get_depfile_suffix(self):
-        return 'd'
-
-    def get_language(self):
-        return self.language
-
-    def get_default_suffix(self):
-        return self.default_suffix
-
-    def get_exelist(self):
-        return self.exelist[:]
-
-    def get_linker_exelist(self):
-        return self.exelist[:]
-
-    def get_compile_only_args(self):
-        return ['-c']
-
-    def get_output_args(self, target):
-        return ['-o', target]
-
-    def get_linker_output_args(self, outputname):
-        return ['-o', outputname]
-
-    def get_debug_args(self):
-        return ['-g']
-
-    def get_coverage_args(self):
-        return ['--coverage']
-
-    def get_coverage_link_args(self):
-        return ['-lgcov']
-
-    def get_werror_args(self):
-        return ['-Werror']
-
-    def get_std_exe_link_args(self):
-        return []
-
-    def get_include_args(self, path):
-        return ['-I' + path]
-
-    def get_std_shared_lib_link_args(self):
-        return ['-shared']
-
-    def can_compile(self, filename):
-        suffix = filename.split('.')[-1]
-        if suffix == 'c' or suffix == 'h':
-            return True
-        return False
-
-    def get_pic_args(self):
-        return ['-fPIC']
-
-    def name_string(self):
-        return ' '.join(self.exelist)
-
-    def get_pch_use_args(self, pch_dir, header):
-        return ['-include', os.path.split(header)[-1]]
-
-    def get_pch_name(self, header_name):
-        return os.path.split(header_name)[-1] + '.' + self.get_pch_suffix()
-
-    def sanity_check(self, work_dir):
-        source_name = os.path.join(work_dir, 'sanitycheckc.c')
-        binary_name = os.path.join(work_dir, 'sanitycheckc')
-        ofile = open(source_name, 'w')
-        ofile.write('int main(int argc, char **argv) { int class=0; return class; }\n')
-        ofile.close()
-        pc = subprocess.Popen(self.exelist + [source_name, '-o', binary_name])
-        pc.wait()
-        if pc.returncode != 0:
-            raise EnvironmentException('Compiler %s can not compile programs.' % self.name_string())
-        if self.is_cross:
-            if self.exe_wrapper is None:
-                # Can't check if the binaries run so we have to assume they do
-                return
-            cmdlist = self.exe_wrapper + [binary_name]
-        else:
-            cmdlist = [binary_name]
-        pe = subprocess.Popen(cmdlist)
-        pe.wait()
-        if pe.returncode != 0:
-            raise EnvironmentException('Executables created by C compiler %s are not runnable.' % self.name_string())
-
-    def has_header(self, hname):
-        templ = '''#include<%s>
-int someSymbolHereJustForFun;
-'''
-        return self.compiles(templ % hname)
-
-    def compiles(self, code):
-        suflen = len(self.default_suffix)
-        (fd, srcname) = tempfile.mkstemp(suffix='.'+self.default_suffix)
-        os.close(fd)
-        ofile = open(srcname, 'w')
-        ofile.write(code)
-        ofile.close()
-        commands = self.get_exelist()
-        commands += self.get_compile_only_args()
-        commands.append(srcname)
-        p = subprocess.Popen(commands, cwd=os.path.split(srcname)[0], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-        p.communicate()
-        os.remove(srcname)
-        try:
-            trial = srcname[:-suflen] + 'o'
-            os.remove(trial)
-        except FileNotFoundError:
-            pass
-        try:
-            os.remove(srcname[:-suflen] + 'obj')
-        except FileNotFoundError:
-            pass
-        return p.returncode == 0
-
-    def run(self, code):
-        if self.is_cross and self.exe_wrapper is None:
-            raise CrossNoRunException('Can not run test applications in this cross environment.')
-        (fd, srcname) = tempfile.mkstemp(suffix='.'+self.default_suffix)
-        os.close(fd)
-        ofile = open(srcname, 'w')
-        ofile.write(code)
-        ofile.close()
-        exename = srcname + '.exe' # Is guaranteed to be executable on every platform.
-        commands = self.get_exelist()
-        commands.append(srcname)
-        commands += self.get_output_args(exename)
-        p = subprocess.Popen(commands, cwd=os.path.split(srcname)[0], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-        p.communicate()
-        os.remove(srcname)
-        if p.returncode != 0:
-            return RunResult(False)
-        if self.is_cross:
-            cmdlist = self.exe_wrapper + [exename]
-        else:
-            cmdlist = exename
-        pe = subprocess.Popen(cmdlist, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-        (so, se) = pe.communicate()
-        os.remove(exename)
-        return RunResult(True, pe.returncode, so.decode(), se.decode())
-
-    def sizeof(self, element, prefix, env):
-        templ = '''#include<stdio.h>
-%s
-
-int main(int argc, char **argv) {
-    printf("%%ld\\n", (long)(sizeof(%s)));
-    return 0;
-};
-'''
-        varname = 'sizeof ' + element
-        varname = varname.replace(' ', '_')
-        if self.is_cross:
-            val = env.cross_info.get(varname)
-            if val is not None:
-                if isinstance(val, int):
-                    return val
-                raise EnvironmentException('Cross variable {0} is not an integer.'.format(varname))
-        cross_failed = False
-        try:
-            res = self.run(templ % (prefix, element))
-        except CrossNoRunException:
-            cross_failed = True
-        if cross_failed:
-            message = '''Can not determine size of {0} because cross compiled binaries are not runnable.
-Please define the corresponding variable {1} in your cross compilation definition file.'''.format(element, varname)
-            raise EnvironmentException(message)
-        if not res.compiled:
-            raise EnvironmentException('Could not compile sizeof test.')
-        if res.returncode != 0:
-            raise EnvironmentException('Could not run sizeof test binary.')
-        return int(res.stdout)
-
-    def alignment(self, typename, env):
-        templ = '''#include<stdio.h>
-#include<stddef.h>
-
-struct tmp {
-  char c;
-  %s target;
-};
-
-int main(int argc, char **argv) {
-  printf("%%d", (int)offsetof(struct tmp, target));
-  return 0;
-}
-'''
-        varname = 'alignment ' + typename
-        varname = varname.replace(' ', '_')
-        if self.is_cross:
-            val = env.cross_info.get(varname)
-            if val is not None:
-                if isinstance(val, int):
-                    return val
-                raise EnvironmentException('Cross variable {0} is not an integer.'.format(varname))
-        cross_failed = False
-        try:
-            res = self.run(templ % typename)
-        except CrossNoRunException:
-            cross_failed = True
-        if cross_failed:
-            message = '''Can not determine alignment of {0} because cross compiled binaries are not runnable.
-Please define the corresponding variable {1} in your cross compilation definition file.'''.format(typename, varname)
-            raise EnvironmentException(message)
-        if not res.compiled:
-            raise EnvironmentException('Could not compile alignment test.')
-        if res.returncode != 0:
-            raise EnvironmentException('Could not run alignment test binary.')
-        align = int(res.stdout)
-        if align == 0:
-            raise EnvironmentException('Could not determine alignment of %s. Sorry. You might want to file a bug.' % typename)
-        return align
-
-    def has_function(self, funcname, prefix, env):
-        # This fails (returns true) if funcname is a ptr or a variable.
-        # The correct check is a lot more difficult.
-        # Fix this to do that eventually.
-        templ = '''%s
-int main(int argc, char **argv) {
-    void *ptr = (void*)(%s);
-    return 0;
-};
-'''
-        varname = 'has function ' + funcname
-        varname = varname.replace(' ', '_')
-        if self.is_cross:
-            val = env.cross_info.get(varname)
-            if val is not None:
-                if isinstance(val, bool):
-                    return val
-                raise EnvironmentException('Cross variable {0} is not an boolean.'.format(varname))
-        return self.compiles(templ % (prefix, funcname))
-
-    def has_member(self, typename, membername, prefix):
-        templ = '''%s
-void bar() {
-    %s foo;
-    foo.%s;
-};
-'''
-        return self.compiles(templ % (prefix, typename, membername))
-
-class CPPCompiler(CCompiler):
-    def __init__(self, exelist, version, is_cross, exe_wrap):
-        CCompiler.__init__(self, exelist, version, is_cross, exe_wrap)
-        self.language = 'cpp'
-        self.default_suffix = 'cpp'
-
-    def can_compile(self, filename):
-        suffix = filename.split('.')[-1]
-        if suffix in cpp_suffixes:
-            return True
-        return False
-
-    def sanity_check(self, work_dir):
-        source_name = os.path.join(work_dir, 'sanitycheckcpp.cc')
-        binary_name = os.path.join(work_dir, 'sanitycheckcpp')
-        ofile = open(source_name, 'w')
-        ofile.write('class breakCCompiler;int main(int argc, char **argv) { return 0; }\n')
-        ofile.close()
-        pc = subprocess.Popen(self.exelist + [source_name, '-o', binary_name])
-        pc.wait()
-        if pc.returncode != 0:
-            raise EnvironmentException('Compiler %s can not compile programs.' % self.name_string())
-        if self.is_cross:
-            if self.exe_wrapper is None:
-                # Can't check if the binaries run so we have to assume they do
-                return
-            cmdlist = self.exe_wrapper + [binary_name]
-        else:
-            cmdlist = [binary_name]
-        pe = subprocess.Popen(cmdlist)
-        pe.wait()
-        if pe.returncode != 0:
-            raise EnvironmentException('Executables created by C++ compiler %s are not runnable.' % self.name_string())
-
-class ObjCCompiler(CCompiler):
-    def __init__(self, exelist, version, is_cross, exe_wrap):
-        CCompiler.__init__(self, exelist, version, is_cross, exe_wrap)
-        self.language = 'objc'
-        self.default_suffix = 'm'
-
-    def can_compile(self, filename):
-        suffix = filename.split('.')[-1]
-        if suffix == 'm' or suffix == 'h':
-            return True
-        return False
-
-    def sanity_check(self, work_dir):
-        source_name = os.path.join(work_dir, 'sanitycheckobjc.m')
-        binary_name = os.path.join(work_dir, 'sanitycheckobjc')
-        ofile = open(source_name, 'w')
-        ofile.write('#import<stdio.h>\nint main(int argc, char **argv) { return 0; }\n')
-        ofile.close()
-        pc = subprocess.Popen(self.exelist + [source_name, '-o', binary_name])
-        pc.wait()
-        if pc.returncode != 0:
-            raise EnvironmentException('ObjC compiler %s can not compile programs.' % self.name_string())
-        pe = subprocess.Popen(binary_name)
-        pe.wait()
-        if pe.returncode != 0:
-            raise EnvironmentException('Executables created by ObjC compiler %s are not runnable.' % self.name_string())
-
-class ObjCPPCompiler(CPPCompiler):
-    def __init__(self, exelist, version, is_cross, exe_wrap):
-        CPPCompiler.__init__(self, exelist, version, is_cross, exe_wrap)
-        self.language = 'objcpp'
-        self.default_suffix = 'mm'
-
-    def can_compile(self, filename):
-        suffix = filename.split('.')[-1]
-        if suffix == 'mm' or suffix == 'h':
-            return True
-        return False
-
-    def sanity_check(self, work_dir):
-        source_name = os.path.join(work_dir, 'sanitycheckobjcpp.mm')
-        binary_name = os.path.join(work_dir, 'sanitycheckobjcpp')
-        ofile = open(source_name, 'w')
-        ofile.write('#import<stdio.h>\nclass MyClass;int main(int argc, char **argv) { return 0; }\n')
-        ofile.close()
-        pc = subprocess.Popen(self.exelist + [source_name, '-o', binary_name])
-        pc.wait()
-        if pc.returncode != 0:
-            raise EnvironmentException('ObjC++ compiler %s can not compile programs.' % self.name_string())
-        pe = subprocess.Popen(binary_name)
-        pe.wait()
-        if pe.returncode != 0:
-            raise EnvironmentException('Executables created by ObjC++ compiler %s are not runnable.' % self.name_string())
-
-class MonoCompiler():
-    def __init__(self, exelist, version):
-        if type(exelist) == type(''):
-            self.exelist = [exelist]
-        elif type(exelist) == type([]):
-            self.exelist = exelist
-        else:
-            raise TypeError('Unknown argument to Mono compiler')
-        self.version = version
-        self.language = 'cs'
-        self.default_suffix = 'cs'
-        self.id = 'mono'
-        self.monorunner = 'mono'
-
-    def get_always_args(self):
-        return []
-
-    def get_output_args(self, fname):
-        return ['-out:' + fname]
-
-    def get_linker_always_args(self):
-        return []
-
-    def get_link_args(self, fname):
-        return ['-r:' + fname]
-
-    def get_soname_args(self, shlib_name, path, soversion):
-        return []
-
-    def get_werror_args(self):
-        return ['-warnaserror']
-
-    def split_shlib_to_parts(self, fname):
-        return (None, fname)
-
-    def build_rpath_args(self, build_dir, rpath_paths, install_rpath):
-        return []
-
-    def get_id(self):
-        return self.id
-
-    def get_dependency_gen_args(self, outtarget, outfile):
-        return []
-
-    def get_language(self):
-        return self.language
-
-    def get_default_suffix(self):
-        return self.default_suffix
-
-    def get_exelist(self):
-        return self.exelist[:]
-
-    def get_linker_exelist(self):
-        return self.exelist[:]
-
-    def get_compile_only_args(self):
-        return []
-
-    def get_linker_output_args(self, outputname):
-        return []
-
-    def get_debug_args(self):
-        return ['-g']
-
-    def get_coverage_args(self):
-        return []
-
-    def get_coverage_link_args(self):
-        return []
-
-    def get_std_exe_link_args(self):
-        return []
-
-    def get_include_args(self, path):
-        return []
-
-    def get_std_shared_lib_link_args(self):
-        return []
-
-    def can_compile(self, filename):
-        suffix = filename.split('.')[-1]
-        if suffix == 'cs':
-            return True
-        return False
-
-    def get_pic_args(self):
-        return []
-
-    def name_string(self):
-        return ' '.join(self.exelist)
-
-    def get_pch_use_args(self, pch_dir, header):
-        return []
-
-    def get_pch_name(self, header_name):
-        return ''
-
-    def sanity_check(self, work_dir):
-        src = 'sanity.cs'
-        obj = 'sanity.exe'
-        source_name = os.path.join(work_dir, src)
-        ofile = open(source_name, 'w')
-        ofile.write('''public class Sanity {
-    static public void Main () {
-    }
-}
-''')
-        ofile.close()
-        pc = subprocess.Popen(self.exelist + [src], cwd=work_dir)
-        pc.wait()
-        if pc.returncode != 0:
-            raise EnvironmentException('Mono compiler %s can not compile programs.' % self.name_string())
-        cmdlist = [self.monorunner, obj]
-        pe = subprocess.Popen(cmdlist, cwd=work_dir)
-        pe.wait()
-        if pe.returncode != 0:
-            raise EnvironmentException('Executables created by Mono compiler %s are not runnable.' % self.name_string())
-
-    def needs_static_linker(self):
-        return False
-
-    def has_header(self, hname):
-        raise EnvironmentException('Mono does not support header checks.')
-
-    def compiles(self, code):
-        raise EnvironmentException('Mono does not support compile checks.')
-
-    def run(self, code):
-        raise EnvironmentException('Mono does not support run checks.')
-
-    def sizeof(self, element, prefix, env):
-        raise EnvironmentException('Mono does not support sizeof checks.')
-
-    def alignment(self, typename, env):
-        raise EnvironmentException('Mono does not support alignment checks.')
-
-    def has_function(self, funcname, prefix, env):
-        raise EnvironmentException('Mono does not support function checks.')
-
-    def get_buildtype_args(self, buildtype):
-        return mono_buildtype_args[buildtype]
-
-class JavaCompiler():
-    def __init__(self, exelist, version):
-        if type(exelist) == type(''):
-            self.exelist = [exelist]
-        elif type(exelist) == type([]):
-            self.exelist = exelist
-        else:
-            raise TypeError('Unknown argument to JavaCompiler')
-        self.version = version
-        self.language = 'java'
-        self.default_suffix = 'java'
-        self.id = 'unknown'
-        self.javarunner = 'java'
-
-    def get_always_args(self):
-        return []
-
-    def get_linker_always_args(self):
-        return []
-
-    def get_soname_args(self, shlib_name, path, soversion):
-        return []
-
-    def get_werror_args(self):
-        return ['-Werror']
-
-    def split_shlib_to_parts(self, fname):
-        return (None, fname)
-
-    def build_rpath_args(self, build_dir, rpath_paths, install_rpath):
-        return []
-
-    def get_id(self):
-        return self.id
-
-    def get_dependency_gen_args(self, outtarget, outfile):
-        return []
-
-    def get_language(self):
-        return self.language
-
-    def get_default_suffix(self):
-        return self.default_suffix
-
-    def get_exelist(self):
-        return self.exelist[:]
-
-    def get_linker_exelist(self):
-        return self.exelist[:]
-
-    def get_compile_only_args(self):
-        return []
-
-    def get_output_args(self, subdir):
-        if subdir == '':
-            subdir = './'
-        return ['-d', subdir, '-s', subdir]
-
-    def get_linker_output_args(self, outputname):
-        return []
-
-    def get_debug_args(self):
-        return ['-g']
-
-    def get_coverage_args(self):
-        return []
-
-    def get_coverage_link_args(self):
-        return []
-
-    def get_std_exe_link_args(self):
-        return []
-
-    def get_include_args(self, path):
-        return []
-
-    def get_std_shared_lib_link_args(self):
-        return []
-
-    def can_compile(self, filename):
-        suffix = filename.split('.')[-1]
-        if suffix == 'java':
-            return True
-        return False
-
-    def get_pic_args(self):
-        return []
-
-    def name_string(self):
-        return ' '.join(self.exelist)
-
-    def get_pch_use_args(self, pch_dir, header):
-        return []
-
-    def get_pch_name(self, header_name):
-        return ''
-
-    def sanity_check(self, work_dir):
-        src = 'SanityCheck.java'
-        obj = 'SanityCheck'
-        source_name = os.path.join(work_dir, src)
-        ofile = open(source_name, 'w')
-        ofile.write('''class SanityCheck {
-  public static void main(String[] args) {
-    int i;
-  }
-}
-''')
-        ofile.close()
-        pc = subprocess.Popen(self.exelist + [src], cwd=work_dir)
-        pc.wait()
-        if pc.returncode != 0:
-            raise EnvironmentException('Java compiler %s can not compile programs.' % self.name_string())
-        cmdlist = [self.javarunner, obj]
-        pe = subprocess.Popen(cmdlist, cwd=work_dir)
-        pe.wait()
-        if pe.returncode != 0:
-            raise EnvironmentException('Executables created by Java compiler %s are not runnable.' % self.name_string())
-
-    def needs_static_linker(self):
-        return False
-
-    def has_header(self, hname):
-        raise EnvironmentException('Java does not support header checks.')
-
-    def compiles(self, code):
-        raise EnvironmentException('Java does not support compile checks.')
-
-    def run(self, code):
-        raise EnvironmentException('Java does not support run checks.')
-
-    def sizeof(self, element, prefix, env):
-        raise EnvironmentException('Java does not support sizeof checks.')
-
-    def alignment(self, typename, env):
-        raise EnvironmentException('Java does not support alignment checks.')
-
-    def has_function(self, funcname, prefix, env):
-        raise EnvironmentException('Java does not support function checks.')
-
-class ValaCompiler():
-    def __init__(self, exelist, version):
-        if isinstance(exelist, str):
-            self.exelist = [exelist]
-        elif type(exelist) == type([]):
-            self.exelist = exelist
-        else:
-            raise TypeError('Unknown argument to Vala compiler')
-        self.version = version
-        self.id = 'unknown'
-        self.language = 'vala'
-
-    def needs_static_linker(self):
-        return False # Because compiles into C.
-
-    def get_exelist(self):
-        return self.exelist
-
-    def get_werror_args(self):
-        return ['--fatal-warnings']
-
-    def get_language(self):
-        return self.language
-
-    def sanity_check(self, work_dir):
-        src = 'valatest.vala'
-        obj = 'valatest.c'
-        source_name = os.path.join(work_dir, src)
-        ofile = open(source_name, 'w')
-        ofile.write('''class SanityCheck : Object {
-}
-''')
-        ofile.close()
-        pc = subprocess.Popen(self.exelist + ['-C', '-o', obj, src], cwd=work_dir)
-        pc.wait()
-        if pc.returncode != 0:
-            raise EnvironmentException('Vala compiler %s can not compile programs.' % self.name_string())
-
-    def can_compile(self, fname):
-        return fname.endswith('.vala')
-
-class RustCompiler():
-    def __init__(self, exelist, version):
-        if isinstance(exelist, str):
-            self.exelist = [exelist]
-        elif type(exelist) == type([]):
-            self.exelist = exelist
-        else:
-            raise TypeError('Unknown argument to Rust compiler')
-        self.version = version
-        self.id = 'unknown'
-        self.language = 'rust'
-
-    def needs_static_linker(self):
-        return False
-
-    def get_exelist(self):
-        return self.exelist
-
-    def get_id(self):
-        return self.id
-
-    def get_language(self):
-        return self.language
-
-    def sanity_check(self, work_dir):
-        source_name = os.path.join(work_dir, 'sanity.rs')
-        output_name = os.path.join(work_dir, 'rusttest')
-        ofile = open(source_name, 'w')
-        ofile.write('''fn main() {
-}
-''')
-        ofile.close()
-        pc = subprocess.Popen(self.exelist + ['-o', output_name, source_name], cwd=work_dir)
-        pc.wait()
-        if pc.returncode != 0:
-            raise EnvironmentException('Rust compiler %s can not compile programs.' % self.name_string())
-        if subprocess.call(output_name) != 0:
-            raise EnvironmentException('Executables created by Rust compiler %s are not runnable.' % self.name_string())
-
-    def can_compile(self, fname):
-        return fname.endswith('.rs')
-
-    def get_dependency_gen_args(self, outfile):
-        return ['--dep-info', outfile]
-
-    def get_buildtype_args(self, buildtype):
-        return rust_buildtype_args[buildtype]
-
-class VisualStudioCCompiler(CCompiler):
-    std_warn_args = ['/W3']
-    std_opt_args= ['/O2']
-    vs2010_always_args = ['/nologo', '/showIncludes']
-    vs2013_always_args = ['/nologo', '/showIncludes', '/FS']
-
-    def __init__(self, exelist, version, is_cross, exe_wrap):
-        CCompiler.__init__(self, exelist, version, is_cross, exe_wrap)
-        self.id = 'msvc'
-        if int(version.split('.')[0]) > 17:
-            self.always_args = VisualStudioCCompiler.vs2013_always_args
-        else:
-            self.always_args = VisualStudioCCompiler.vs2010_always_args
-
-    def get_always_args(self):
-        return self.always_args
-
-    def get_std_warn_args(self):
-        return self.std_warn_args
-
-    def get_buildtype_args(self, buildtype):
-        return msvc_buildtype_args[buildtype]
-
-    def get_buildtype_linker_args(self, buildtype):
-        return msvc_buildtype_linker_args[buildtype]
-
-    def get_pch_suffix(self):
-        return 'pch'
-
-    def get_pch_name(self, header):
-        chopped = os.path.split(header)[-1].split('.')[:-1]
-        chopped.append(self.get_pch_suffix())
-        pchname = '.'.join(chopped)
-        return pchname
-
-    def get_pch_use_args(self, pch_dir, header):
-        base = os.path.split(header)[-1]
-        pchname = self.get_pch_name(header)
-        return ['/FI' + base, '/Yu' + base, '/Fp' + os.path.join(pch_dir, pchname)]
-
-    def get_debug_args(self):
-        return ['/D_DEBUG', '/Zi', '/MDd', '/Ob0', '/RTC1']
-
-    def get_compile_only_args(self):
-        return ['/c']
-
-    def get_output_args(self, target):
-        if target.endswith('.exe'):
-            return ['/Fe' + target]
-        return ['/Fo' + target]
-
-    def get_dependency_gen_args(self, outtarget, outfile):
-        return []
-
-    def get_linker_exelist(self):
-        return ['link'] # FIXME, should have same path as compiler.
-
-    def get_linker_always_args(self):
-        return ['/nologo']
-
-    def get_linker_output_args(self, outputname):
-        return ['/OUT:' + outputname]
-
-    def get_pic_args(self):
-        return ['/LD']
-
-    def get_std_shared_lib_link_args(self):
-        return ['/DLL']
-
-    def gen_pch_args(self, header, source, pchname):
-        objname = os.path.splitext(pchname)[0] + '.obj'
-        return (objname, ['/Yc' + header, '/Fp' + pchname, '/Fo' + objname ])
-
-    def sanity_check(self, work_dir):
-        source_name = 'sanitycheckc.c'
-        binary_name = 'sanitycheckc'
-        ofile = open(os.path.join(work_dir, source_name), 'w')
-        ofile.write('int main(int argc, char **argv) { return 0; }\n')
-        ofile.close()
-        pc = subprocess.Popen(self.exelist + [source_name, '/Fe' + binary_name],
-                              stdout=subprocess.DEVNULL,
-                              stderr=subprocess.DEVNULL,
-                              cwd=work_dir)
-        pc.wait()
-        if pc.returncode != 0:
-            raise EnvironmentException('Compiler %s can not compile programs.' % self.name_string())
-        pe = subprocess.Popen(os.path.join(work_dir, binary_name))
-        pe.wait()
-        if pe.returncode != 0:
-            raise EnvironmentException('Executables created by C++ compiler %s are not runnable.' % self.name_string())
-
-    def build_rpath_args(self, build_dir, rpath_paths, install_rpath):
-        return []
-
-class VisualStudioCPPCompiler(VisualStudioCCompiler):
-    def __init__(self, exelist, version, is_cross, exe_wrap):
-        VisualStudioCCompiler.__init__(self, exelist, version, is_cross, exe_wrap)
-        self.language = 'cpp'
-        self.default_suffix = 'cpp'
-
-    def can_compile(self, filename):
-        suffix = filename.split('.')[-1]
-        if suffix in cpp_suffixes:
-            return True
-        return False
-
-    def sanity_check(self, work_dir):
-        source_name = 'sanitycheckcpp.cpp'
-        binary_name = 'sanitycheckcpp'
-        ofile = open(os.path.join(work_dir, source_name), 'w')
-        ofile.write('class BreakPlainC;int main(int argc, char **argv) { return 0; }\n')
-        ofile.close()
-        pc = subprocess.Popen(self.exelist + [source_name, '/Fe' + binary_name],
-                              stdout=subprocess.DEVNULL,
-                              stderr=subprocess.DEVNULL,
-                              cwd=work_dir)
-        pc.wait()
-        if pc.returncode != 0:
-            raise EnvironmentException('Compiler %s can not compile programs.' % self.name_string())
-        pe = subprocess.Popen(os.path.join(work_dir, binary_name))
-        pe.wait()
-        if pe.returncode != 0:
-            raise EnvironmentException('Executables created by C++ compiler %s are not runnable.' % self.name_string())
-
-GCC_STANDARD = 0
-GCC_OSX = 1
-GCC_MINGW = 2
-
-def get_gcc_soname_args(gcc_type, shlib_name, path, soversion):
-    if soversion is None:
-        sostr = ''
-    else:
-        sostr = '.' + soversion
-    if gcc_type == GCC_STANDARD:
-        return ['-Wl,-soname,lib%s.so%s' % (shlib_name, sostr)]
-    elif gcc_type == GCC_OSX:
-        return ['-install_name', os.path.join(path, 'lib' + shlib_name + '.dylib')]
-    else:
-        raise RuntimeError('Not impelented yet.')
-
-class GnuCCompiler(CCompiler):
-    std_warn_args = ['-Wall', '-Winvalid-pch']
-
-    def __init__(self, exelist, version, gcc_type, is_cross, exe_wrapper=None):
-        CCompiler.__init__(self, exelist, version, is_cross, exe_wrapper)
-        self.id = 'gcc'
-        self.gcc_type = gcc_type
-
-    def get_always_args(self):
-        return ['-pipe']
-
-    def get_std_warn_args(self):
-        return GnuCCompiler.std_warn_args
-
-    def get_buildtype_args(self, buildtype):
-        return gnulike_buildtype_args[buildtype]
-
-    def get_buildtype_linker_args(self, buildtype):
-        return gnulike_buildtype_linker_args[buildtype]
-
-    def get_pch_suffix(self):
-        return 'gch'
-
-    def split_shlib_to_parts(self, fname):
-        return (os.path.split(fname)[0], fname)
-
-    def get_soname_args(self, shlib_name, path, soversion):
-        return get_gcc_soname_args(self.gcc_type, shlib_name, path, soversion)
-
-    def can_compile(self, filename):
-        return super().can_compile(filename) or filename.split('.')[-1] == 's' # Gcc can do asm, too.
-
-class GnuObjCCompiler(ObjCCompiler):
-    std_warn_args = ['-Wall', '-Winvalid-pch']
-
-    def __init__(self, exelist, version, is_cross, exe_wrapper=None):
-        ObjCCompiler.__init__(self, exelist, version, is_cross, exe_wrapper)
-        self.id = 'gcc'
-
-    def get_std_warn_args(self):
-        return GnuObjCCompiler.std_warn_args
-
-    def get_buildtype_args(self, buildtype):
-        return gnulike_buildtype_args[buildtype]
-
-    def get_buildtype_linker_args(self, buildtype):
-        return gnulike_buildtype_linker_args[buildtype]
-
-    def get_pch_suffix(self):
-        return 'gch'
-
-    def get_soname_args(self, shlib_name, path, soversion):
-        return get_gcc_soname_args(self.gcc_type, shlib_name, path, soversion)
-
-class GnuObjCPPCompiler(ObjCPPCompiler):
-    std_warn_args = ['-Wall', '-Winvalid-pch']
-    std_opt_args = ['-O2']
-
-    def __init__(self, exelist, version, is_cross, exe_wrapper=None):
-        ObjCCompiler.__init__(self, exelist, version, is_cross, exe_wrapper)
-        self.id = 'gcc'
-
-    def get_std_warn_args(self):
-        return GnuObjCPPCompiler.std_warn_args
-
-    def get_buildtype_args(self, buildtype):
-        return gnulike_buildtype_args[buildtype]
-
-    def get_buildtype_linker_args(self, buildtype):
-        return gnulike_buildtype_linker_args[buildtype]
-
-    def get_pch_suffix(self):
-        return 'gch'
-
-    def get_soname_args(self, shlib_name, path, soversion):
-        return get_gcc_soname_args(self.gcc_type, shlib_name, path, soversion)
-
-class ClangObjCCompiler(GnuObjCCompiler):
-    def __init__(self, exelist, version, is_cross, exe_wrapper=None):
-        super().__init__(exelist, version, is_cross, exe_wrapper)
-        self.id = 'clang'
-
-class ClangObjCPPCompiler(GnuObjCPPCompiler):
-    def __init__(self, exelist, version, is_cross, exe_wrapper=None):
-        super().__init__(exelist, version, is_cross, exe_wrapper)
-        self.id = 'clang'
-
-class ClangCCompiler(CCompiler):
-    std_warn_args = ['-Wall', '-Winvalid-pch']
-
-    def __init__(self, exelist, version, is_cross, exe_wrapper=None):
-        CCompiler.__init__(self, exelist, version, is_cross, exe_wrapper)
-        self.id = 'clang'
-
-    def get_std_warn_args(self):
-        return ClangCCompiler.std_warn_args
-
-    def get_buildtype_args(self, buildtype):
-        return gnulike_buildtype_args[buildtype]
-
-    def get_buildtype_linker_args(self, buildtype):
-        return gnulike_buildtype_linker_args[buildtype]
-
-    def get_pch_suffix(self):
-        return 'pch'
-
-    def can_compile(self, filename):
-        return super().can_compile(filename) or filename.split('.')[-1] == 's' # Clang can do asm, too.
-
-    def get_pch_use_args(self, pch_dir, header):
-        # Workaround for Clang bug http://llvm.org/bugs/show_bug.cgi?id=15136
-        # This flag is internal to Clang (or at least not documented on the man page)
-        # so it might change semantics at any time.
-        return ['-include-pch', os.path.join (pch_dir, self.get_pch_name (header))]
-
-
-class GnuCPPCompiler(CPPCompiler):
-    std_warn_args = ['-Wall', '-Winvalid-pch']
-    # may need to separate the latter to extra_debug_args or something
-    std_debug_args = ['-g']
-
-    def __init__(self, exelist, version, gcc_type, is_cross, exe_wrap):
-        CPPCompiler.__init__(self, exelist, version, is_cross, exe_wrap)
-        self.id = 'gcc'
-        self.gcc_type = gcc_type
-
-    def get_always_args(self):
-        return ['-pipe']
-
-    def get_debug_args(self):
-        return GnuCPPCompiler.std_debug_args
-
-    def get_std_warn_args(self):
-        return GnuCPPCompiler.std_warn_args
-
-    def get_buildtype_args(self, buildtype):
-        return gnulike_buildtype_args[buildtype]
-
-    def get_buildtype_linker_args(self, buildtype):
-        return gnulike_buildtype_linker_args[buildtype]
-
-    def get_pch_suffix(self):
-        return 'gch'
-
-    def get_soname_args(self, shlib_name, path, soversion):
-        return get_gcc_soname_args(self.gcc_type, shlib_name, path, soversion)
-
-class ClangCPPCompiler(CPPCompiler):
-    std_warn_args = ['-Wall', '-Winvalid-pch']
-
-    def __init__(self, exelist, version, is_cross, exe_wrapper=None):
-        CPPCompiler.__init__(self, exelist, version, is_cross, exe_wrapper)
-        self.id = 'clang'
-
-    def get_std_warn_args(self):
-        return ClangCPPCompiler.std_warn_args
-
-    def get_buildtype_args(self, buildtype):
-        return gnulike_buildtype_args[buildtype]
-
-    def get_buildtype_linker_args(self, buildtype):
-        return gnulike_buildtype_linker_args[buildtype]
-
-    def get_pch_suffix(self):
-        return 'pch'
-
-    def get_pch_use_args(self, pch_dir, header):
-        # Workaround for Clang bug http://llvm.org/bugs/show_bug.cgi?id=15136
-        # This flag is internal to Clang (or at least not documented on the man page)
-        # so it might change semantics at any time.
-        return ['-include-pch', os.path.join (pch_dir, self.get_pch_name (header))]
-
-class FortranCompiler():
-    std_warn_args = ['-Wall']
-
-    def __init__(self, exelist, version,is_cross, exe_wrapper=None):
-        super().__init__()
-        self.exelist = exelist
-        self.version = version
-        self.is_cross = is_cross
-        self.exe_wrapper = exe_wrapper
-        self.language = 'fortran'
-
-    def get_id(self):
-        return self.id
-
-    def get_exelist(self):
-        return self.exelist
-
-    def get_language(self):
-        return self.language
-
-    def needs_static_linker(self):
-        return True
-
-    def sanity_check(self, work_dir):
-        source_name = os.path.join(work_dir, 'sanitycheckf.f90')
-        binary_name = os.path.join(work_dir, 'sanitycheckf')
-        ofile = open(source_name, 'w')
-        ofile.write('''program prog
-     print *, "Fortran compilation is working."
-end program prog
-''')
-        ofile.close()
-        pc = subprocess.Popen(self.exelist + [source_name, '-o', binary_name])
-        pc.wait()
-        if pc.returncode != 0:
-            raise EnvironmentException('Compiler %s can not compile programs.' % self.name_string())
-        if self.is_cross:
-            if self.exe_wrapper is None:
-                # Can't check if the binaries run so we have to assume they do
-                return
-            cmdlist = self.exe_wrapper + [binary_name]
-        else:
-            cmdlist = [binary_name]
-        pe = subprocess.Popen(cmdlist, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-        pe.wait()
-        if pe.returncode != 0:
-            raise EnvironmentException('Executables created by Fortran compiler %s are not runnable.' % self.name_string())
-
-    def get_always_args(self):
-        return ['-pipe']
-
-    def get_linker_always_args(self):
-        return []
-
-    def get_std_warn_args(self):
-        return FortranCompiler.std_warn_args
-
-    def get_buildtype_args(self, buildtype):
-        return gnulike_buildtype_args[buildtype]
-
-    def get_buildtype_linker_args(self, buildtype):
-        return gnulike_buildtype_linker_args[buildtype]
-
-    def split_shlib_to_parts(self, fname):
-        return (os.path.split(fname)[0], fname)
-
-    def get_soname_args(self, shlib_name, path, soversion):
-        return get_gcc_soname_args(self.gcc_type, shlib_name, path, soversion)
-
-    def get_dependency_gen_args(self, outtarget, outfile):
-        # Disabled until this is fixed:
-        # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=62162
-        #return ['-cpp', '-MMD', '-MQ', outtarget]
-        return []
-
-    def get_output_args(self, target):
-        return ['-o', target]
-
-    def get_compile_only_args(self):
-        return ['-c']
-
-    def get_linker_exelist(self):
-        return self.exelist[:]
-
-    def get_linker_output_args(self, outputname):
-        return ['-o', outputname]
-
-    def can_compile(self, src):
-        suffix = os.path.splitext(src)[1].lower()
-        if suffix == '.f' or suffix == '.f95' or suffix == '.f90':
-            return True
-        return False
-
-    def get_include_args(self, path):
-        return ['-I' + path]
-
-    def get_module_outdir_args(self, path):
-        return ['-J' + path]
-
-    def get_depfile_suffix(self):
-        return 'd'
-
-    def get_std_exe_link_args(self):
-        return []
-
-    def build_rpath_args(self, build_dir, rpath_paths, install_rpath):
-        return build_unix_rpath_args(build_dir, rpath_paths, install_rpath)
-
-    def module_name_to_filename(self, module_name):
-        return module_name.lower() + '.mod'
-
-class GnuFortranCompiler(FortranCompiler):
-    def __init__(self, exelist, version, gcc_type, is_cross, exe_wrapper=None):
-        super().__init__(exelist, version, is_cross, exe_wrapper=None)
-        self.gcc_type = gcc_type
-        self.id = 'gcc'
-
-class G95FortranCompiler(FortranCompiler):
-    def __init__(self, exelist, version, is_cross, exe_wrapper=None):
-        super().__init__(exelist, version, is_cross, exe_wrapper=None)
-        self.id = 'g95'
-
-    def get_module_outdir_args(self, path):
-        return ['-fmod='+path]
-
-class SunFortranCompiler(FortranCompiler):
-    def __init__(self, exelist, version, is_cross, exe_wrapper=None):
-        super().__init__(exelist, version, is_cross, exe_wrapper=None)
-        self.id = 'sun'
-
-    def get_dependency_gen_args(self, outtarget, outfile):
-        return ['-fpp']
-
-    def get_always_args(self):
-        return []
-
-    def get_std_warn_args(self):
-        return []
-
-    def get_module_outdir_args(self, path):
-        return ['-moddir='+path]
-
-class IntelFortranCompiler(FortranCompiler):
-    std_warn_args = ['-warn', 'all']
-    
-    def __init__(self, exelist, version, is_cross, exe_wrapper=None):
-        super().__init__(exelist, version, is_cross, exe_wrapper=None)
-        self.id = 'intel'
-        
-    def get_module_outdir_args(self, path):
-        return ['-module', path]
-
-    def get_always_args(self):
-        return []
-
-    def can_compile(self, src):
-        suffix = os.path.splitext(src)[1].lower()
-        if suffix == '.f' or suffix == '.f90':
-            return True
-        return False
-
-    def get_std_warn_args(self):
-        return IntelFortranCompiler.std_warn_args
-
-class PathScaleFortranCompiler(FortranCompiler):
-    std_warn_args = ['-fullwarn']
-
-    def __init__(self, exelist, version, is_cross, exe_wrapper=None):
-        super().__init__(exelist, version, is_cross, exe_wrapper=None)
-        self.id = 'pathscale'
-
-    def get_module_outdir_args(self, path):
-        return ['-module', path]
-
-    def get_always_args(self):
-        return []
-
-    def can_compile(self, src):
-        suffix = os.path.splitext(src)[1].lower()
-        if suffix == '.f' or suffix == '.f90' or suffix == '.f95':
-            return True
-        return False
-
-    def get_std_warn_args(self):
-        return PathScaleFortranCompiler.std_warn_args
-
-class PGIFortranCompiler(FortranCompiler):
-    std_warn_args = ['-Minform=inform']
-
-    def __init__(self, exelist, version, is_cross, exe_wrapper=None):
-        super().__init__(exelist, version, is_cross, exe_wrapper=None)
-        self.id = 'pgi'
-
-    def get_module_outdir_args(self, path):
-        return ['-module', path]
-
-    def get_always_args(self):
-        return []
-
-    def can_compile(self, src):
-        suffix = os.path.splitext(src)[1].lower()
-        if suffix == '.f' or suffix == '.f90' or suffix == '.f95':
-            return True
-        return False
-
-    def get_std_warn_args(self):
-        return PGIFortranCompiler.std_warn_args
-
-
-class Open64FortranCompiler(FortranCompiler):
-    std_warn_args = ['-fullwarn']
-
-    def __init__(self, exelist, version, is_cross, exe_wrapper=None):
-        super().__init__(exelist, version, is_cross, exe_wrapper=None)
-        self.id = 'open64'
-
-    def get_module_outdir_args(self, path):
-        return ['-module', path]
-
-    def get_always_args(self):
-        return []
-
-    def can_compile(self, src):
-        suffix = os.path.splitext(src)[1].lower()
-        if suffix == '.f' or suffix == '.f90' or suffix == '.f95':
-            return True
-        return False
-
-    def get_std_warn_args(self):
-        return Open64FortranCompiler.std_warn_args
-
-class NAGFortranCompiler(FortranCompiler):
-    std_warn_args = []
-
-    def __init__(self, exelist, version, is_cross, exe_wrapper=None):
-        super().__init__(exelist, version, is_cross, exe_wrapper=None)
-        self.id = 'nagfor'
-
-    def get_module_outdir_args(self, path):
-        return ['-mdir', path]
-
-    def get_always_args(self):
-        return []
-
-    def can_compile(self, src):
-        suffix = os.path.splitext(src)[1].lower()
-        if suffix == '.f' or suffix == '.f90' or suffix == '.f95':
-            return True
-        return False
-
-    def get_std_warn_args(self):
-        return NAGFortranCompiler.std_warn_args
-
-
-class VisualStudioLinker():
-    always_args = ['/NOLOGO']
-    def __init__(self, exelist):
-        self.exelist = exelist
-
-    def get_exelist(self):
-        return self.exelist
-
-    def get_std_link_args(self):
-        return []
-
-    def get_buildtype_linker_args(self, buildtype):
-        return []
-
-    def get_output_args(self, target):
-        return ['/OUT:' + target]
-
-    def get_coverage_link_args(self):
-        return []
-
-    def get_always_args(self):
-        return VisualStudioLinker.always_args
-
-    def get_linker_always_args(self):
-        return VisualStudioLinker.always_args
-
-    def build_rpath_args(self, build_dir, rpath_paths, install_rpath):
-        return []
-
-class ArLinker():
-    std_args = ['csr']
-
-    def __init__(self, exelist):
-        self.exelist = exelist
-        self.id = 'ar'
-
-    def build_rpath_args(self, build_dir, rpath_paths, install_rpath):
-        return []
-
-    def get_exelist(self):
-        return self.exelist
-
-    def get_std_link_args(self):
-        return self.std_args
-
-    def get_output_args(self, target):
-        return [target]
-
-    def get_buildtype_linker_args(self, buildtype):
-        return []
-
-    def get_linker_always_args(self):
-        return []
-
-    def get_coverage_link_args(self):
-        return []
-
-    def get_always_args(self):
-        return []
-
-def exe_exists(arglist):
-    try:
-        p = subprocess.Popen(arglist, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-        p.communicate()
-        if p.returncode == 0:
-            return True
-    except FileNotFoundError:
-        pass
-    return False
-
 def find_coverage_tools():
     gcovr_exe = 'gcovr'
     lcov_exe = 'lcov'
     genhtml_exe = 'genhtml'
 
-    if not exe_exists([gcovr_exe, '--version']):
+    if not mesonlib.exe_exists([gcovr_exe, '--version']):
         gcovr_exe = None
-    if not exe_exists([lcov_exe, '--version']):
+    if not mesonlib.exe_exists([lcov_exe, '--version']):
         lcov_exe = None
-    if not exe_exists([genhtml_exe, '--version']):
+    if not mesonlib.exe_exists([genhtml_exe, '--version']):
         genhtml_exe = None
     return (gcovr_exe, lcov_exe, genhtml_exe)
 
 def find_valgrind():
     valgrind_exe = 'valgrind'
-    if not exe_exists([valgrind_exe, '--version']):
+    if not mesonlib.exe_exists([valgrind_exe, '--version']):
         valgrind_exe = None
     return valgrind_exe
 
@@ -1516,24 +49,6 @@ def detect_ninja():
             return n
 
 
-header_suffixes = ['h', 'hh', 'hpp', 'hxx', 'H']
-cpp_suffixes = ['cc', 'cpp', 'cxx', 'h', 'hh', 'hpp', 'hxx', 'c++']
-c_suffixes = ['c']
-clike_suffixes = c_suffixes + cpp_suffixes
-obj_suffixes = ['o', 'obj']
-
-def is_header(fname):
-    suffix = fname.split('.')[-1]
-    return suffix in header_suffixes
-
-def is_source(fname):
-    suffix = fname.split('.')[-1]
-    return suffix in clike_suffixes
-
-def is_object(fname):
-    suffix = fname.split('.')[-1]
-    return suffix in obj_suffixes
-
 class Environment():
     private_dir = 'meson-private'
     log_dir = 'meson-logs'
@@ -1561,7 +76,7 @@ class Environment():
         self.cmd_line_options = options.projectoptions
 
         # List of potential compilers.
-        if is_windows():
+        if mesonlib.is_windows():
             self.default_c = ['cl', 'cc']
             self.default_cpp = ['cl', 'c++']
         else:
@@ -1574,7 +89,7 @@ class Environment():
         self.vs_static_linker = 'lib'
 
         cross = self.is_cross_build()
-        if (not cross and is_windows()) \
+        if (not cross and mesonlib.is_windows()) \
         or (cross and self.cross_info['name'] == 'windows'):
             self.exe_suffix = 'exe'
             self.import_lib_suffix = 'lib'
@@ -1585,7 +100,7 @@ class Environment():
             self.object_suffix = 'obj'
         else:
             self.exe_suffix = ''
-            if (not cross and is_osx()) or \
+            if (not cross and mesonlib.is_osx()) or \
             (cross and self.cross_info['name'] == 'darwin'):
                 self.shared_lib_suffix = 'dylib'
             else:
@@ -2046,9 +561,9 @@ class Environment():
         return get_library_dirs()
 
 def get_library_dirs():
-        if is_windows():
+        if mesonlib.is_windows():
             return ['C:/mingw/lib'] # Fixme
-        if is_osx():
+        if mesonlib.is_osx():
             return ['/usr/lib'] # Fix me as well.
         # The following is probably Debian/Ubuntu specific.
         unixdirs = ['/usr/lib', '/lib']
diff --git a/meson.py b/meson.py
index adb44d1..3080ff4 100755
--- a/meson.py
+++ b/meson.py
@@ -17,7 +17,7 @@
 from optparse import OptionParser
 import sys, stat, traceback, pickle
 import os.path
-import environment, interpreter
+import environment, interpreter, mesonlib
 import build
 import mlog, coredata
 
@@ -35,7 +35,7 @@ backendlist = ['ninja', 'vs2010', 'xcode']
 backend_help = 'backend to use, one of: %s' % ', '.join(backendlist)
 backend_help += ' (default: %default)'
 
-if environment.is_windows():
+if mesonlib.is_windows():
     def_prefix = 'c:/'
 else:
     def_prefix = '/usr/local'
diff --git a/mesonlib.py b/mesonlib.py
new file mode 100644
index 0000000..c30057e
--- /dev/null
+++ b/mesonlib.py
@@ -0,0 +1,43 @@
+# Copyright 2012-2014 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.
+
+"""A library of random helper functionality."""
+
+import platform, subprocess
+
+def is_osx():
+    return platform.system().lower() == 'darwin'
+
+def is_linux():
+    return platform.system().lower() == 'linux'
+
+def is_windows():
+    return platform.system().lower() == 'windows'
+
+def is_debianlike():
+    try:
+        open('/etc/debian_version', 'r')
+        return True
+    except FileNotFoundError:
+        return False
+
+def exe_exists(arglist):
+    try:
+        p = subprocess.Popen(arglist, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        p.communicate()
+        if p.returncode == 0:
+            return True
+    except FileNotFoundError:
+        pass
+    return False
diff --git a/ninjabackend.py b/ninjabackend.py
index 2c8ef89..831812f 100644
--- a/ninjabackend.py
+++ b/ninjabackend.py
@@ -13,7 +13,7 @@
 # limitations under the License.
 
 import backends
-import environment
+import environment, mesonlib
 import build
 import mlog
 import dependencies
@@ -22,7 +22,7 @@ from build import InvalidArguments
 from coredata import MesonException
 import os, sys, shutil, pickle, re
 
-if environment.is_windows():
+if mesonlib.is_windows():
     quote_char = '"'
     execute_wrapper = 'cmd /c'
 else:
@@ -870,7 +870,7 @@ class NinjaBackend(backends.Backend):
         outfile.write('\n')
 
     def generate_fortran_dep_hack(self, outfile):
-        if environment.is_windows():
+        if mesonlib.is_windows():
             cmd = 'cmd /C ""'
         else:
             cmd = 'true'
diff --git a/run_tests.py b/run_tests.py
index 366de28..c572257 100755
--- a/run_tests.py
+++ b/run_tests.py
@@ -17,7 +17,7 @@
 from glob import glob
 import os, subprocess, shutil, sys, platform, signal
 import environment
-from environment import is_windows
+import mesonlib
 
 passing_tests = 0
 failing_tests = 0
@@ -47,7 +47,7 @@ if msbuild_exe is not None:
     compile_commands = ['msbuild']
     test_commands = ['msbuild', 'RUN_TESTS.vcxproj']
     install_commands = []
-elif environment.is_osx():
+elif mesonlib.is_osx():
     backend_flags = ['--backend=xcode']
     compile_commands = ['xcodebuild']
     test_commands = ['xcodebuild', '-target', 'RUN_TESTS']
@@ -186,22 +186,22 @@ def run_tests():
     commontests = gather_tests('test cases/common')
     failtests = gather_tests('test cases/failing')
     objtests = gather_tests('test cases/prebuilt object')
-    if environment.is_linux():
+    if mesonlib.is_linux():
         cpuid = platform.machine()
         if cpuid != 'x86_64' and cpuid != 'i386' and cpuid != 'i686':
             # Don't have a prebuilt object file for those so skip.
             objtests = []
-    if environment.is_osx():
+    if mesonlib.is_osx():
         platformtests = gather_tests('test cases/osx')
-    elif environment.is_windows():
+    elif mesonlib.is_windows():
         platformtests = gather_tests('test cases/windows')
     else:
         platformtests = gather_tests('test cases/linuxlike')
-    if not environment.is_osx() and not environment.is_windows():
+    if not mesonlib.is_osx() and not mesonlib.is_windows():
         frameworktests = gather_tests('test cases/frameworks')
     else:
         frameworktests = []
-    if not environment.is_osx() and shutil.which('javac'):
+    if not mesonlib.is_osx() and shutil.which('javac'):
         javatests = gather_tests('test cases/java')
     else:
         javatests = []
@@ -217,7 +217,7 @@ def run_tests():
         rusttests = gather_tests('test cases/rust')
     else:
         rusttests = []
-    if not environment.is_windows():
+    if not mesonlib.is_windows():
         objctests = gather_tests('test cases/objc')
     else:
         objctests = []
@@ -308,7 +308,7 @@ def generate_prebuilt_object():
         objectfile = objectbase + 'obj'
         cmd = ['cl', '/nologo', '/Fo'+objectfile, '/c', source]
     else:
-        if is_windows():
+        if mesonlib.is_windows():
             objectfile = objectbase + 'obj'
         else:
             objectfile = objectbase + 'o'