Can compile C# programs with Mono.

pull/15/head
Jussi Pakkanen 11 years ago
parent 83237f2b38
commit fb884e3856
  1. 9
      backends.py
  2. 158
      environment.py
  3. 4
      interpreter.py
  4. 32
      ninjabackend.py
  5. 4
      test cases/csharp/1 basic/meson.build
  6. 7
      test cases/csharp/1 basic/prog.cs

@ -191,6 +191,12 @@ class Backend():
return True
return False
def has_cs(self, target):
for s in target.get_sources():
if s.endswith('.cs'):
return True
return False
def generate_target(self, target, outfile):
if isinstance(target, build.CustomTarget):
self.generate_custom_target(target, outfile)
@ -206,6 +212,9 @@ class Backend():
if 'rust' in self.environment.coredata.compilers.keys() and self.has_rust(target):
self.generate_rust_target(target, outfile)
return
if 'cs' in self.environment.coredata.compilers.keys() and self.has_cs(target):
self.generate_cs_target(target, outfile)
return
if 'vala' in self.environment.coredata.compilers.keys() and self.has_vala(target):
gen_src_deps += self.generate_vala_compile(target, outfile)
# The following deals with C/C++ compilation.

@ -445,6 +445,143 @@ class ObjCPPCompiler(CPPCompiler):
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_soname_args(self, shlib_name, path):
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_arg(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.')
class JavaCompiler():
def __init__(self, exelist, version):
if type(exelist) == type(''):
@ -468,6 +605,9 @@ class JavaCompiler():
def get_soname_args(self, shlib_name, path):
return []
def get_werror_args(self):
return ['-Werror']
def split_shlib_to_parts(self, fname):
return (None, fname)
@ -1369,6 +1509,24 @@ class Environment():
return JavaCompiler(exelist, version)
raise EnvironmentException('Unknown compiler "' + ' '.join(exelist) + '"')
def detect_cs_compiler(self):
exelist = ['mcs']
try:
p = subprocess.Popen(exelist + ['--version'], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
except OSError:
raise EnvironmentException('Could not execute C# compiler "%s"' % ' '.join(exelist))
(out, err) = p.communicate()
out = out.decode()
err = err.decode()
vmatch = re.search(Environment.version_regex, out)
if vmatch:
version = vmatch.group(0)
else:
version = 'unknown version'
if 'Mono' in out:
return MonoCompiler(exelist, version)
raise EnvironmentException('Unknown compiler "' + ' '.join(exelist) + '"')
def detect_vala_compiler(self):
exelist = ['valac']
try:

@ -963,6 +963,10 @@ class Interpreter():
comp = self.environment.detect_java_compiler()
if is_cross:
cross_comp = comp # Java is platform independent.
elif lang == 'cs':
comp = self.environment.detect_cs_compiler()
if is_cross:
cross_comp = comp # C# is platform independent.
elif lang == 'vala':
comp = self.environment.detect_vala_compiler()
if is_cross:

@ -433,6 +433,21 @@ class NinjaBackend(backends.Backend):
elem.add_item('ARGS', commands)
elem.write(outfile)
def generate_cs_target(self, target, outfile):
fname = target.get_filename()
subdir = target.get_subdir()
outname_rel = os.path.join(subdir, fname)
src_list = target.get_sources()
class_list = []
compiler = self.get_compiler_for_source(src_list[0])
assert(compiler.get_language() == 'cs')
rel_srcs = [os.path.join(self.build_to_src, s) for s in src_list]
commands = []
commands += compiler.get_output_args(outname_rel)
elem = NinjaBuildElement(outname_rel, 'cs_COMPILER', rel_srcs)
elem.add_item('ARGS', commands)
elem.write(outfile)
def generate_single_java_compile(self, subdir, src, target, compiler, outfile):
buildtype = self.environment.coredata.buildtype
args = []
@ -569,7 +584,8 @@ class NinjaBackend(backends.Backend):
for (complist, is_cross) in ctypes:
for compiler in complist:
langname = compiler.get_language()
if langname == 'java' or langname == 'vala' or langname == 'rust':
if langname == 'java' or langname == 'vala' or\
langname == 'rust' or langname == 'cs':
continue
crstr = ''
if is_cross:
@ -608,6 +624,16 @@ class NinjaBackend(backends.Backend):
outfile.write(description)
outfile.write('\n')
def generate_cs_compile_rule(self, compiler, outfile):
rule = 'rule %s_COMPILER\n' % compiler.get_language()
invoc = ' '.join([ninja_quote(i) for i in compiler.get_exelist()])
command = ' command = %s $ARGS $in\n' % invoc
description = ' description = Compiling cs target $out.\n'
outfile.write(rule)
outfile.write(command)
outfile.write(description)
outfile.write('\n')
def generate_vala_compile_rules(self, compiler, outfile):
rule = 'rule %s_COMPILER\n' % compiler.get_language()
invoc = ' '.join([ninja_quote(i) for i in compiler.get_exelist()])
@ -647,6 +673,10 @@ class NinjaBackend(backends.Backend):
if not is_cross:
self.generate_java_compile_rule(compiler, outfile)
return
if langname == 'cs':
if not is_cross:
self.generate_cs_compile_rule(compiler, outfile)
return
if langname == 'vala':
if not is_cross:
self.generate_vala_compile_rules(compiler, outfile)

@ -0,0 +1,4 @@
project('simple c#', 'cs')
e = executable('prog', 'prog.cs')
test('basic', e)

@ -0,0 +1,7 @@
using System;
public class Prog {
static public void Main () {
Console.WriteLine("C# is working.");
}
}
Loading…
Cancel
Save