'debug' : ['-g'],

'debugoptimized' : ['-O2', '-g'],

'release' : ['-O3'],

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

def __init__(self, compiled, returncode=999, stdout='UNDEFINED', stderr='UNDEFINED'):

self.compiled = compiled

self.returncode = returncode

self.stdout = stdout

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_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;

};

'''

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:

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:

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:

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_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):

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_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 get_buildtype_args(self, buildtype):

return java_buildtype_args[buildtype]

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):

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):

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):

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_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):

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:

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:

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):