Chiebot-Mirror
/
meson
mirror of https://github.com/mesonbuild/meson.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

The mass flags -> args renaming for consistency.

Browse Source
pull/15/head
Jussi Pakkanen 11 years ago
parent ec167c8107
commit d2b5e5c7a5
10 changed files with 326 additions and 326 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 20
      backends.py
  2. 20
      build.py
  3. 132
      dependencies.py
  4. 280
      environment.py
  5. 30
      interpreter.py
  6. 20
      mesonconf.py
  7. 16
      mesongui.py
  8. 108
      ninjabackend.py
  9. 2
      test cases/linuxlike/3 linker script/meson.build
  10. 24
      xcodebackend.py

20
backends.py
Unescape View File

@ -327,24 +327,24 @@ class Backend():
args = [includearg] + args
return args
def generate_basic_compiler_flags(self, target, compiler):
def generate_basic_compiler_args(self, target, compiler):
commands = []
commands += compiler.get_always_flags()
commands += self.build.get_global_flags(compiler)
commands += compiler.get_always_args()
commands += self.build.get_global_args(compiler)
commands += self.environment.coredata.external_args[compiler.get_language()]
commands += target.get_extra_args(compiler.get_language())
if self.environment.coredata.buildtype != 'plain':
commands += compiler.get_debug_flags()
commands += compiler.get_std_warn_flags()
commands += compiler.get_buildtype_flags(self.environment.coredata.buildtype)
commands += compiler.get_debug_args()
commands += compiler.get_std_warn_args()
commands += compiler.get_buildtype_args(self.environment.coredata.buildtype)
if self.environment.coredata.coverage:
commands += compiler.get_coverage_flags()
commands += compiler.get_coverage_args()
if isinstance(target, build.SharedLibrary):
commands += compiler.get_pic_flags()
commands += compiler.get_pic_args()
for dep in target.get_external_deps():
commands += dep.get_compile_flags()
commands += dep.get_compile_args()
if isinstance(target, build.Executable):
commands += dep.get_exe_flags()
commands += dep.get_exe_args()
return commands

20
build.py
Unescape View File

@ -86,7 +86,7 @@ class Build:
def get_configure_files(self):
return self.configure_files
def get_global_flags(self, compiler):
def get_global_args(self, compiler):
return self.global_args.get(compiler.get_language(), [])
def get_external_args(self, compiler):
@ -241,12 +241,12 @@ class BuildTarget():
if not isinstance(cpplist, list):
cpplist = [cpplist]
self.add_compiler_args('cpp', cpplist)
self.link_flags = kwargs.get('link_flags', [])
if not isinstance(self.link_flags, list):
self.link_flags = [self.link_flags]
for i in self.link_flags:
self.link_args = kwargs.get('link_args', [])
if not isinstance(self.link_args, list):
self.link_args = [self.link_args]
for i in self.link_args:
if not isinstance(i, str):
raise InvalidArguments('Link_flags arguments must be strings.')
raise InvalidArguments('Link_args arguments must be strings.')
self.link_depends = kwargs.get('link_depends', [])
if not isinstance(self.link_depends, list):
self.link_depends = [self.link_depends]
@ -393,14 +393,14 @@ class BuildTarget():
ids.append(a)
self.include_dirs += ids
def add_compiler_args(self, language, flags):
for a in flags:
def add_compiler_args(self, language, args):
for a in args:
if not isinstance(a, str):
raise InvalidArguments('A non-string passed to compiler args.')
if language in self.extra_args:
self.extra_args[language] += flags
self.extra_args[language] += args
else:
self.extra_args[language] = flags
self.extra_args[language] = args
def get_aliaslist(self):
return []

132
dependencies.py
Unescape View File

@ -42,10 +42,10 @@ class Dependency():
def __init__(self):
self.name = "null"
def get_compile_flags(self):
def get_compile_args(self):
return []
def get_link_flags(self):
def get_link_args(self):
return []
def found(self):
@ -64,7 +64,7 @@ class Dependency():
def get_generate_rules(self):
return []
def get_exe_flags(self):
def get_exe_args(self):
return []
class PkgConfigDependency(Dependency):
@ -85,7 +85,7 @@ class PkgConfigDependency(Dependency):
if required:
raise DependencyException('Required dependency %s not found.' % name)
self.modversion = 'none'
self.cflags = []
self.cargs = []
self.libs = []
else:
mlog.log('Dependency', mlog.bold(name), 'found:', mlog.green('YES'))
@ -95,8 +95,8 @@ class PkgConfigDependency(Dependency):
stderr=subprocess.PIPE)
out = p.communicate()[0]
if p.returncode != 0:
raise RuntimeError('Could not generate cflags for %s.' % name)
self.cflags = out.decode().split()
raise RuntimeError('Could not generate cargs for %s.' % name)
self.cargs = out.decode().split()
p = subprocess.Popen(['pkg-config', '--libs', name], stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
@ -108,10 +108,10 @@ class PkgConfigDependency(Dependency):
def get_modversion(self):
return self.modversion
def get_compile_flags(self):
return self.cflags
def get_compile_args(self):
return self.cargs
def get_link_flags(self):
def get_link_args(self):
return self.libs
def check_pkgconfig(self):
@ -166,7 +166,7 @@ class ExternalLibrary(Dependency):
def found(self):
return self.fullpath is not None
def get_link_flags(self):
def get_link_args(self):
if self.found():
return [self.fullpath]
return []
@ -215,11 +215,11 @@ class BoostDependency(Dependency):
else:
mlog.log("Dependency Boost (%s) found:" % module_str, mlog.red('NO'))
def get_compile_flags(self):
flags = []
def get_compile_args(self):
args = []
if self.boost_root is not None:
flags.append('-I' + os.path.join(self.boost_root, 'include'))
return flags
args.append('-I' + os.path.join(self.boost_root, 'include'))
return args
def get_requested(self, kwargs):
modules = 'modules'
@ -281,21 +281,21 @@ class BoostDependency(Dependency):
else:
self.lib_modules[name] = True
def get_link_flags(self):
flags = []
def get_link_args(self):
args = []
if self.boost_root:
# FIXME, these are in gcc format, not msvc.
# On the other hand, so are the flags that
# On the other hand, so are the args that
# pkg-config returns.
flags.append('-L' + os.path.join(self.boost_root, 'lib'))
args.append('-L' + os.path.join(self.boost_root, 'lib'))
for module in self.requested_modules:
if module in self.lib_modules or module in self.lib_modules_mt:
linkcmd = '-lboost_' + module
flags.append(linkcmd)
args.append(linkcmd)
elif module + '-mt' in self.lib_modules_mt:
linkcmd = '-lboost_' + module + '-mt'
flags.append(linkcmd)
return flags
args.append(linkcmd)
return args
def get_sources(self):
return []
@ -323,16 +323,16 @@ class GTestDependency(Dependency):
mainname = os.path.join(self.libdir, self.libmain_name)
if os.path.exists(libname) and os.path.exists(mainname):
self.is_found = True
self.compile_flags = []
self.link_flags = ['-lgtest']
self.compile_args = []
self.link_args = ['-lgtest']
if self.main:
self.link_flags.append('-lgtest_main')
self.link_args.append('-lgtest_main')
self.sources = []
mlog.log('Dependency GTest found:', mlog.green('YES'), '(prebuilt)')
elif os.path.exists(self.src_dir):
self.is_found = True
self.compile_flags = ['-I' + self.src_include_dir]
self.link_flags = []
self.compile_args = ['-I' + self.src_include_dir]
self.link_args = []
if self.main:
self.sources = [self.all_src, self.main_src]
else:
@ -342,18 +342,18 @@ class GTestDependency(Dependency):
mlog.log('Dependency GTest found:', mlog.red('NO'))
self.is_found = False
if self.is_found:
self.link_flags.append('-lpthread')
self.link_args.append('-lpthread')
return self.is_found
def get_compile_flags(self):
def get_compile_args(self):
arr = []
if self.include_dir != '/usr/include':
arr.append('-I' + self.include_dir)
arr.append('-I' + self.src_include_dir)
return arr
def get_link_flags(self):
return self.link_flags
def get_link_args(self):
return self.link_args
def get_version(self):
return '1.something_maybe'
def get_sources(self):
@ -374,14 +374,14 @@ class GMockDependency(Dependency):
fname = os.path.join(self.libdir, self.libname)
if os.path.exists(fname):
self.is_found = True
self.compile_flags = []
self.link_flags = ['-lgmock']
self.compile_args = []
self.link_args = ['-lgmock']
self.sources = []
mlog.log('Dependency GMock found:', mlog.green('YES'), '(prebuilt)')
elif os.path.exists(self.src_dir):
self.is_found = True
self.compile_flags = ['-I' + self.src_include_dir]
self.link_flags = []
self.compile_args = ['-I' + self.src_include_dir]
self.link_args = []
if kwargs.get('main', False):
self.sources = [self.all_src, self.main_src]
else:
@ -395,14 +395,14 @@ class GMockDependency(Dependency):
def get_version(self):
return '1.something_maybe'
def get_compile_flags(self):
return self.compile_flags
def get_compile_args(self):
return self.compile_args
def get_sources(self):
return self.sources
def get_link_flags(self):
return self.link_flags
def get_link_args(self):
return self.link_args
def found(self):
return self.is_found
@ -501,20 +501,20 @@ class Qt5Dependency(Dependency):
def get_version(self):
return self.modules[0].get_version()
def get_compile_flags(self):
flags = []
def get_compile_args(self):
args = []
for m in self.modules:
flags += m.get_compile_flags()
return flags
args += m.get_compile_args()
return args
def get_sources(self):
return []
def get_link_flags(self):
flags = []
def get_link_args(self):
args = []
for module in self.modules:
flags += module.get_link_flags()
return flags
args += module.get_link_args()
return args
def found(self):
if not self.moc.found():
@ -543,7 +543,7 @@ class Qt5Dependency(Dependency):
'rc_compile', 'Compiling @INFILE@ with the rrc compiler')
return [moc_rule, mocsrc_rule, ui_rule, rrc_rule]
def get_exe_flags(self):
def get_exe_args(self):
# Qt5 seems to require this always.
# Fix this to be more portable, especially to MSVC.
return ['-fPIE']
@ -560,29 +560,29 @@ class GnuStepDependency(Dependency):
stdout=subprocess.PIPE, stderr=subprocess.PIPE)
gp.communicate()
if gp.returncode != 0:
self.flags = None
self.args = None
mlog.log('Dependency GnuStep found:', mlog.red('NO'))
return
if 'gui' in self.modules:
arg = '--gui-libs'
else:
arg = '--base-libs'
fp = subprocess.Popen([confprog, '--objc-flags'],
fp = subprocess.Popen([confprog, '--objc-args'],
stdout=subprocess.PIPE, stderr=subprocess.PIPE)
(flagtxt, flagerr) = fp.communicate()
flagtxt = flagtxt.decode()
flagerr = flagerr.decode()
if fp.returncode != 0:
raise DependencyException('Error getting objc-flags: %s %s' % (flagtxt, flagerr))
flags = flagtxt.split()
self.flags = self.filter_flags(flags)
raise DependencyException('Error getting objc-args: %s %s' % (flagtxt, flagerr))
args = flagtxt.split()
self.args = self.filter_arsg(args)
fp = subprocess.Popen([confprog, arg],
stdout=subprocess.PIPE, stderr=subprocess.PIPE)
(libtxt, liberr) = fp.communicate()
libtxt = libtxt.decode()
liberr = liberr.decode()
if fp.returncode != 0:
raise DependencyException('Error getting objc-lib flags: %s %s' % (libtxt, liberr))
raise DependencyException('Error getting objc-lib args: %s %s' % (libtxt, liberr))
self.libs = self.weird_filter(libtxt.split())
mlog.log('Dependency GnuStep found:', mlog.green('YES'))
@ -593,11 +593,11 @@ why. As a hack filter out everything that is not a flag."""
return [e for e in elems if e.startswith('-')]
def filter_flags(self, flags):
"""gnustep-config returns a bunch of garbage flags such
def filter_arsg(self, args):
"""gnustep-config returns a bunch of garbage args such
as -O2 and so on. Drop everything that is not needed."""
result = []
for f in flags:
for f in args:
if f.startswith('-D') or f.startswith('-f') or \
f.startswith('-I') or f == '-pthread' or\
(f.startswith('-W') and not f == '-Wall'):
@ -605,14 +605,14 @@ why. As a hack filter out everything that is not a flag."""
return result
def found(self):
return self.flags is not None
return self.args is not None
def get_compile_flags(self):
if self.flags is None:
def get_compile_args(self):
if self.args is None:
return []
return self.flags
return self.args
def get_link_flags(self):
def get_link_args(self):
return self.libs
class AppleFrameworks(Dependency):
@ -625,12 +625,12 @@ class AppleFrameworks(Dependency):
raise DependencyException("AppleFrameworks dependency requires at least one module.")
self.frameworks = modules
def get_link_flags(self):
flags = []
def get_link_args(self):
args = []
for f in self.frameworks:
flags.append('-framework')
flags.append(f)
return flags
args.append('-framework')
args.append(f)
return args
def found(self):
return environment.is_osx()

280
environment.py
Unescape View File

@ -35,29 +35,29 @@ class RunResult():
self.stdout = stdout
self.stderr = stderr
gnulike_buildtype_flags = {'plain' : [],
gnulike_buildtype_args = {'plain' : [],
'debug' : ['-g'],
'debugoptimized' : ['-O2', '-g'],
'release' : ['-O3'],
}
msvc_buildtype_flags = {'plain' : [],
msvc_buildtype_args = {'plain' : [],
'debug' : ["/MDd", "/Zi", "/Ob0", "/Od", "/RTC1"],
'debugoptimized' : ["/MD", "/Zi", "/O2", "/Ob1", "/D"],
'release' : ["/MD", "/O2", "/Ob2"]}
gnulike_buildtype_linker_flags = {'plain' : [],
gnulike_buildtype_linker_args = {'plain' : [],
'debug' : [],
'debugoptimized' : [],
'release' : ['-Wl,-O1'],
}
msvc_buildtype_linker_flags = {'plain' : [],
msvc_buildtype_linker_args = {'plain' : [],
'debug' : [],
'debugoptimized' : [],
'release' : []}
rust_buildtype_flags = {'plain' : [],
rust_buildtype_args = {'plain' : [],
'debug' : ['-g'],
'debugoptimized' : ['-g', '--opt-level', '2'],
'release' : ['--opt-level', '3']}
@ -83,13 +83,13 @@ class CCompiler():
def needs_static_linker(self):
return True # When compiling static libraries, so yes.
def get_always_flags(self):
def get_always_args(self):
return []
def get_linker_always_flags(self):
def get_linker_always_args(self):
return []
def get_soname_flags(self, shlib_name, path):
def get_soname_args(self, shlib_name, path):
return []
def split_shlib_to_parts(self, fname):
@ -101,7 +101,7 @@ class CCompiler():
def get_id(self):
return self.id
def get_dependency_gen_flags(self, outtarget, outfile):
def get_dependency_gen_args(self, outtarget, outfile):
return ['-MMD', '-MQ', outtarget, '-MF', outfile]
def get_depfile_suffix(self):
@ -119,31 +119,31 @@ class CCompiler():
def get_linker_exelist(self):
return self.exelist[:]
def get_compile_only_flags(self):
def get_compile_only_args(self):
return ['-c']
def get_output_flags(self, target):
def get_output_args(self, target):
return ['-o', target]
def get_linker_output_flags(self, outputname):
def get_linker_output_args(self, outputname):
return ['-o', outputname]
def get_debug_flags(self):
def get_debug_args(self):
return ['-g']
def get_coverage_flags(self):
def get_coverage_args(self):
return ['--coverage']
def get_coverage_link_flags(self):
def get_coverage_link_args(self):
return ['-lgcov']
def get_std_exe_link_flags(self):
def get_std_exe_link_args(self):
return []
def get_include_arg(self, path):
return '-I' + path
def get_std_shared_lib_link_flags(self):
def get_std_shared_lib_link_args(self):
return ['-shared']
def can_compile(self, filename):
@ -152,7 +152,7 @@ class CCompiler():
return True
return False
def get_pic_flags(self):
def get_pic_args(self):
return ['-fPIC']
def name_string(self):
@ -200,7 +200,7 @@ int someSymbolHereJustForFun;
ofile.write(code)
ofile.close()
commands = self.get_exelist()
commands += self.get_compile_only_flags()
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()
@ -227,7 +227,7 @@ int someSymbolHereJustForFun;
exename = srcname + '.exe' # Is guaranteed to be executable on every platform.
commands = self.get_exelist()
commands.append(srcname)
commands += self.get_output_flags(exename)
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)
@ -430,13 +430,13 @@ class JavaCompiler():
self.id = 'unknown'
self.javarunner = 'java'
def get_always_flags(self):
def get_always_args(self):
return []
def get_linker_always_flags(self):
def get_linker_always_args(self):
return []
def get_soname_flags(self, shlib_name, path):
def get_soname_args(self, shlib_name, path):
return []
def split_shlib_to_parts(self, fname):
@ -448,7 +448,7 @@ class JavaCompiler():
def get_id(self):
return self.id
def get_dependency_gen_flags(self, outtarget, outfile):
def get_dependency_gen_args(self, outtarget, outfile):
return []
def get_language(self):
@ -463,33 +463,33 @@ class JavaCompiler():
def get_linker_exelist(self):
return self.exelist[:]
def get_compile_only_flags(self):
def get_compile_only_args(self):
return []
def get_output_flags(self, subdir):
def get_output_args(self, subdir):
if subdir == '':
subdir = './'
return ['-d', subdir, '-s', subdir]
def get_linker_output_flags(self, outputname):
def get_linker_output_args(self, outputname):
return []
def get_debug_flags(self):
def get_debug_args(self):
return ['-g']
def get_coverage_flags(self):
def get_coverage_args(self):
return []
def get_coverage_link_flags(self):
def get_coverage_link_args(self):
return []
def get_std_exe_link_flags(self):
def get_std_exe_link_args(self):
return []
def get_include_arg(self, path):
return ''
def get_std_shared_lib_link_flags(self):
def get_std_shared_lib_link_args(self):
return []
def can_compile(self, filename):
@ -498,7 +498,7 @@ class JavaCompiler():
return True
return False
def get_pic_flags(self):
def get_pic_args(self):
return []
def name_string(self):
@ -633,32 +633,32 @@ class RustCompiler():
def can_compile(self, fname):
return fname.endswith('.rs')
def get_dependency_gen_flags(self, outfile):
def get_dependency_gen_args(self, outfile):
return ['--dep-info', outfile]
def get_buildtype_flags(self, buildtype):
return rust_buildtype_flags[buildtype]
def get_buildtype_args(self, buildtype):
return rust_buildtype_args[buildtype]
class VisualStudioCCompiler(CCompiler):
std_warn_flags = ['/W3']
std_opt_flags= ['/O2']
always_flags = ['/nologo', '/showIncludes']
std_warn_args = ['/W3']
std_opt_args= ['/O2']
always_args = ['/nologo', '/showIncludes']
def __init__(self, exelist, version, is_cross, exe_wrap):
CCompiler.__init__(self, exelist, version, is_cross, exe_wrap)
self.id = 'msvc'
def get_always_flags(self):
return VisualStudioCCompiler.always_flags
def get_always_args(self):
return VisualStudioCCompiler.always_args
def get_std_warn_flags(self):
return VisualStudioCCompiler.std_warn_flags
def get_std_warn_args(self):
return VisualStudioCCompiler.std_warn_args
def get_buildtype_flags(self, buildtype):
return msvc_buildtype_flags[buildtype]
def get_buildtype_args(self, buildtype):
return msvc_buildtype_args[buildtype]
def get_buildtype_linker_flags(self, buildtype):
return msvc_buildtype_linker_flags[buildtype]
def get_buildtype_linker_args(self, buildtype):
return msvc_buildtype_linker_args[buildtype]
def get_pch_suffix(self):
return 'pch'
@ -674,33 +674,33 @@ class VisualStudioCCompiler(CCompiler):
pchname = self.get_pch_name(header)
return ['/FI' + base, '/Yu' + base, '/Fp' + os.path.join(pch_dir, pchname)]
def get_debug_flags(self):
def get_debug_args(self):
return ['/D_DEBUG', '/Zi', '/MDd', '/Ob0', '/RTC1']
def get_compile_only_flags(self):
def get_compile_only_args(self):
return ['/c']
def get_output_flags(self, target):
def get_output_args(self, target):
if target.endswith('.exe'):
return ['/Fe' + target]
return ['/Fo' + target]
def get_dependency_gen_flags(self, outtarget, outfile):
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_flags(self):
def get_linker_always_args(self):
return ['/nologo']
def get_linker_output_flags(self, outputname):
def get_linker_output_args(self, outputname):
return ['/OUT:' + outputname]
def get_pic_flags(self):
def get_pic_args(self):
return ['/LD']
def get_std_shared_lib_link_flags(self):
def get_std_shared_lib_link_args(self):
return ['/DLL']
def gen_pch_args(self, header, source, pchname):
@ -756,7 +756,7 @@ GCC_STANDARD = 0
GCC_OSX = 1
GCC_MINGW = 2
def get_gcc_soname_flags(gcc_type, shlib_name, path):
def get_gcc_soname_args(gcc_type, shlib_name, path):
if gcc_type == GCC_STANDARD:
return ['-Wl,-soname,lib%s.so' % shlib_name]
elif gcc_type == GCC_OSX:
@ -765,24 +765,24 @@ def get_gcc_soname_flags(gcc_type, shlib_name, path):
raise RuntimeError('Not impelented yet.')
class GnuCCompiler(CCompiler):
std_warn_flags = ['-Wall', '-Winvalid-pch']
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_flags(self):
def get_always_args(self):
return ['-pipe']
def get_std_warn_flags(self):
return GnuCCompiler.std_warn_flags
def get_std_warn_args(self):
return GnuCCompiler.std_warn_args
def get_buildtype_flags(self, buildtype):
return gnulike_buildtype_flags[buildtype]
def get_buildtype_args(self, buildtype):
return gnulike_buildtype_args[buildtype]
def get_buildtype_linker_flags(self, buildtype):
return gnulike_buildtype_linker_flags[buildtype]
def get_buildtype_linker_args(self, buildtype):
return gnulike_buildtype_linker_args[buildtype]
def get_pch_suffix(self):
return 'gch'
@ -795,24 +795,24 @@ class GnuCCompiler(CCompiler):
return []
return ['-Wl,-rpath,' + ':'.join([os.path.join(build_dir, p) for p in rpath_paths])]
def get_soname_flags(self, shlib_name, path):
return get_gcc_soname_flags(self.gcc_type, shlib_name, path)
def get_soname_args(self, shlib_name, path):
return get_gcc_soname_args(self.gcc_type, shlib_name, path)
class GnuObjCCompiler(ObjCCompiler):
std_warn_flags = ['-Wall', '-Winvalid-pch']
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_flags(self):
return GnuObjCCompiler.std_warn_flags
def get_std_warn_args(self):
return GnuObjCCompiler.std_warn_args
def get_buildtype_flags(self, buildtype):
return gnulike_buildtype_flags[buildtype]
def get_buildtype_args(self, buildtype):
return gnulike_buildtype_args[buildtype]
def get_buildtype_linker_flags(self, buildtype):
return gnulike_buildtype_linker_flags[buildtype]
def get_buildtype_linker_args(self, buildtype):
return gnulike_buildtype_linker_args[buildtype]
def get_pch_suffix(self):
return 'gch'
@ -822,25 +822,25 @@ class GnuObjCCompiler(ObjCCompiler):
return []
return ['-Wl,-rpath,' + ':'.join([os.path.join(build_dir, p) for p in rpath_paths])]
def get_soname_flags(self, shlib_name, path):
return get_gcc_soname_flags(self.gcc_type, shlib_name, path)
def get_soname_args(self, shlib_name, path):
return get_gcc_soname_args(self.gcc_type, shlib_name, path)
class GnuObjCPPCompiler(ObjCPPCompiler):
std_warn_flags = ['-Wall', '-Winvalid-pch']
std_opt_flags = ['-O2']
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_flags(self):
return GnuObjCPPCompiler.std_warn_flags
def get_std_warn_args(self):
return GnuObjCPPCompiler.std_warn_args
def get_buildtype_flags(self, buildtype):
return gnulike_buildtype_flags[buildtype]
def get_buildtype_args(self, buildtype):
return gnulike_buildtype_args[buildtype]
def get_buildtype_linker_flags(self, buildtype):
return gnulike_buildtype_linker_flags[buildtype]
def get_buildtype_linker_args(self, buildtype):
return gnulike_buildtype_linker_args[buildtype]
def get_pch_suffix(self):
return 'gch'
@ -850,8 +850,8 @@ class GnuObjCPPCompiler(ObjCPPCompiler):
return []
return ['-Wl,-rpath,' + ':'.join([os.path.join(build_dir, p) for p in rpath_paths])]
def get_soname_flags(self, shlib_name, path):
return get_gcc_soname_flags(self.gcc_type, shlib_name, path)
def get_soname_args(self, shlib_name, path):
return get_gcc_soname_args(self.gcc_type, shlib_name, path)
class ClangObjCCompiler(GnuObjCCompiler):
def __init__(self, exelist, version, is_cross, exe_wrapper=None):
@ -864,20 +864,20 @@ class ClangObjCPPCompiler(GnuObjCPPCompiler):
self.id = 'clang'
class ClangCCompiler(CCompiler):
std_warn_flags = ['-Wall', '-Winvalid-pch']
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_flags(self):
return ClangCCompiler.std_warn_flags
def get_std_warn_args(self):
return ClangCCompiler.std_warn_args
def get_buildtype_flags(self, buildtype):
return gnulike_buildtype_flags[buildtype]
def get_buildtype_args(self, buildtype):
return gnulike_buildtype_args[buildtype]
def get_buildtype_linker_flags(self, buildtype):
return gnulike_buildtype_linker_flags[buildtype]
def get_buildtype_linker_args(self, buildtype):
return gnulike_buildtype_linker_args[buildtype]
def get_pch_suffix(self):
return 'pch'
@ -888,29 +888,29 @@ class ClangCCompiler(CCompiler):
return ['-Wl,-rpath,' + ':'.join([os.path.join(build_dir, p) for p in rpath_paths])]
class GnuCPPCompiler(CPPCompiler):
std_warn_flags = ['-Wall', '-Winvalid-pch']
# may need to separate the latter to extra_debug_flags or something
std_debug_flags = ['-g']
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_flags(self):
def get_always_args(self):
return ['-pipe']
def get_debug_flags(self):
return GnuCPPCompiler.std_debug_flags
def get_debug_args(self):
return GnuCPPCompiler.std_debug_args
def get_std_warn_flags(self):
return GnuCPPCompiler.std_warn_flags
def get_std_warn_args(self):
return GnuCPPCompiler.std_warn_args
def get_buildtype_flags(self, buildtype):
return gnulike_buildtype_flags[buildtype]
def get_buildtype_args(self, buildtype):
return gnulike_buildtype_args[buildtype]
def get_buildtype_linker_flags(self, buildtype):
return gnulike_buildtype_linker_flags[buildtype]
def get_buildtype_linker_args(self, buildtype):
return gnulike_buildtype_linker_args[buildtype]
def get_pch_suffix(self):
return 'gch'
@ -920,24 +920,24 @@ class GnuCPPCompiler(CPPCompiler):
return []
return ['-Wl,-rpath,' + ':'.join([os.path.join(build_dir, p) for p in rpath_paths])]
def get_soname_flags(self, shlib_name, path):
return get_gcc_soname_flags(self.gcc_type, shlib_name, path)
def get_soname_args(self, shlib_name, path):
return get_gcc_soname_args(self.gcc_type, shlib_name, path)
class ClangCPPCompiler(CPPCompiler):
std_warn_flags = ['-Wall', '-Winvalid-pch']
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_flags(self):
return ClangCPPCompiler.std_warn_flags
def get_std_warn_args(self):
return ClangCPPCompiler.std_warn_args
def get_buildtype_flags(self, buildtype):
return gnulike_buildtype_flags[buildtype]
def get_buildtype_args(self, buildtype):
return gnulike_buildtype_args[buildtype]
def get_buildtype_linker_flags(self, buildtype):
return gnulike_buildtype_linker_flags[buildtype]
def get_buildtype_linker_args(self, buildtype):
return gnulike_buildtype_linker_args[buildtype]
def get_pch_suffix(self):
return 'pch'
@ -948,36 +948,36 @@ class ClangCPPCompiler(CPPCompiler):
return ['-Wl,-rpath,' + ':'.join([os.path.join(build_dir, p) for p in rpath_paths])]
class VisualStudioLinker():
always_flags = ['/NOLOGO']
always_args = ['/NOLOGO']
def __init__(self, exelist):
self.exelist = exelist
def get_exelist(self):
return self.exelist
def get_std_link_flags(self):
def get_std_link_args(self):
return []
def get_buildtype_linker_flags(self, buildtype):
def get_buildtype_linker_args(self, buildtype):
return []
def get_output_flags(self, target):
def get_output_args(self, target):
return ['/OUT:' + target]
def get_coverage_link_flags(self):
def get_coverage_link_args(self):
return []
def get_always_flags(self):
return VisualStudioLinker.always_flags
def get_always_args(self):
return VisualStudioLinker.always_args
def get_linker_always_flags(self):
return VisualStudioLinker.always_flags
def get_linker_always_args(self):
return VisualStudioLinker.always_args
def build_rpath_args(self, build_dir, rpath_paths):
return []
class ArLinker():
std_flags = ['csr']
std_args = ['csr']
def __init__(self, exelist):
self.exelist = exelist
@ -988,22 +988,22 @@ class ArLinker():
def get_exelist(self):
return self.exelist
def get_std_link_flags(self):
return self.std_flags
def get_std_link_args(self):
return self.std_args
def get_output_flags(self, target):
def get_output_args(self, target):
return [target]
def get_buildtype_linker_flags(self, buildtype):
def get_buildtype_linker_args(self, buildtype):
return []
def get_linker_always_flags(self):
def get_linker_always_args(self):
return []
def get_coverage_link_flags(self):
def get_coverage_link_args(self):
return []
def get_always_flags(self):
def get_always_args(self):
return []
def exe_exists(arglist):
@ -1522,19 +1522,19 @@ def get_library_dirs():
unixdirs.append('/usr/local/lib')
return unixdirs
def get_flags_from_envvars(lang):
def get_args_from_envvars(lang):
if lang == 'c':
compile_flags = os.environ.get('CFLAGS', '').split()
compile_flags += os.environ.get('CPPFLAGS', '').split()
link_flags = compile_flags + os.environ.get('LDFLAGS', '').split()
compile_args = os.environ.get('CFLAGS', '').split()
link_args = compile_args + os.environ.get('LDFLAGS', '').split()
compile_args += os.environ.get('CPPFLAGS', '').split()
elif lang == 'cpp':
compile_flags = os.environ.get('CXXFLAGS', '').split()
compile_flags += os.environ.get('CPPFLAGS', '').split()
link_flags = compile_flags + os.environ.get('LDFLAGS', '').split()
compile_args = os.environ.get('CXXFLAGS', '').split()
link_args = compile_args + os.environ.get('LDFLAGS', '').split()
compile_args += os.environ.get('CPPFLAGS', '').split()
else:
compile_flags = []
link_flags = []
return (compile_flags, link_flags)
compile_args = []
link_args = []
return (compile_args, link_args)
class CrossBuildInfo():
def __init__(self, filename):

30
interpreter.py
Unescape View File

@ -200,14 +200,14 @@ class ExternalLibraryHolder(InterpreterObject):
def get_name(self):
return self.el.name
def get_compile_flags(self):
return self.el.get_compile_flags()
def get_compile_args(self):
return self.el.get_compile_args()
def get_link_flags(self):
return self.el.get_link_flags()
def get_link_args(self):
return self.el.get_link_args()
def get_exe_flags(self):
return self.el.get_exe_flags()
def get_exe_args(self):
return self.el.get_exe_args()
class GeneratorHolder(InterpreterObject):
def __init__(self, args, kwargs):
@ -649,7 +649,7 @@ class Interpreter():
self.coredata = self.environment.get_coredata()
self.generators = []
self.visited_subdirs = {}
self.global_flags_frozen = False
self.global_args_frozen = False
self.subprojects = {}
self.subproject_stack = []
@ -863,7 +863,7 @@ class Interpreter():
abs_subdir = os.path.join(self.build.environment.get_source_dir(), subdir)
if not os.path.isdir(abs_subdir):
raise InterpreterException('Subproject directory does not exist.')
self.global_flags_frozen = True
self.global_args_frozen = True
mlog.log('\nExecuting subproject ', mlog.bold(dirname), '.\n', sep='')
subi = Interpreter(self.build, dirname, subdir)
@ -965,9 +965,9 @@ class Interpreter():
self.coredata.cross_compilers[lang] = cross_comp
mlog.log('Using native %s compiler "' % lang, mlog.bold(' '.join(comp.get_exelist())), '". (%s %s)' % (comp.id, comp.version), sep='')
if not comp.get_language() in self.coredata.external_args:
(ext_compile_flags, ext_link_flags) = environment.get_flags_from_envvars(comp.get_language())
self.coredata.external_args[comp.get_language()] = ext_compile_flags
self.coredata.external_link_args[comp.get_language()] = ext_link_flags
(ext_compile_args, ext_link_args) = environment.get_args_from_envvars(comp.get_language())
self.coredata.external_args[comp.get_language()] = ext_compile_args
self.coredata.external_link_args[comp.get_language()] = ext_link_args
self.build.add_compiler(comp)
if is_cross:
mlog.log('Using cross %s compiler "' % lang, mlog.bold(' '.join(cross_comp.get_exelist())), '". (%s %s)' % (cross_comp.id, cross_comp.version), sep='')
@ -1207,9 +1207,9 @@ class Interpreter():
if not isinstance(a, str):
raise InvalidArguments('Argument %s is not a string.' % str(a))
if self.subproject != '':
raise InvalidCode('Global flags can not be set in subprojects because there is no way to make that reliable.')
if self.global_flags_frozen:
raise InvalidCode('Tried to set global flags after they have become immutable.')
raise InvalidCode('Global arguments can not be set in subprojects because there is no way to make that reliable.')
if self.global_args_frozen:
raise InvalidCode('Tried to set global arguments after they have become immutable.')
if not 'language' in kwargs:
raise InvalidCode('Missing language definition in add_global_arguments')
lang = kwargs['language'].lower()
@ -1273,7 +1273,7 @@ class Interpreter():
txt = ' build '
displayname = os.path.join(l.held_object.subdir, name)
mlog.log('Creating', txt, 'target ', mlog.bold(displayname), ' with %d files.' % len(sources), sep='')
self.global_flags_frozen = True
self.global_args_frozen = True
return l
def check_sources_exist(self, subdir, sources):

20
mesonconf.py
Unescape View File

@ -132,18 +132,18 @@ class Conf:
tgt.set_value(v)
else:
raise ConfException('Internal error, unknown option type.')
elif k.endswith('linkflags'):
elif k.endswith('linkargs'):
lang = k[:-9]
if not lang in self.coredata.external_link_args:
raise ConfException('Unknown language %s in linkflags.' % lang)
raise ConfException('Unknown language %s in linkargs.' % lang)
# TODO, currently split on spaces, make it so that user
# can pass in an array string.
newvalue = v.split()
self.coredata.external_link_args[lang] = newvalue
elif k.endswith('flags'):
elif k.endswith('args'):
lang = k[:-5]
if not lang in self.coredata.external_args:
raise ConfException('Unknown language %s in compile flags' % lang)
raise ConfException('Unknown language %s in compile args' % lang)
# TODO same fix as above
newvalue = v.split()
self.coredata.external_args[lang] = newvalue
@ -165,13 +165,13 @@ class Conf:
carr.append(['unity', 'Unity build', self.coredata.unity])
self.print_aligned(carr)
print('')
print('Compiler flags\n')
for (lang, flags) in self.coredata.external_args.items():
print(lang + 'flags', str(flags))
print('Compiler arguments\n')
for (lang, args) in self.coredata.external_args.items():
print(lang + 'args', str(args))
print('')
print('Linker flags\n')
for (lang, flags) in self.coredata.external_link_args.items():
print(lang + 'linkflags', str(flags))
print('Linker args\n')
for (lang, args) in self.coredata.external_link_args.items():
print(lang + 'linkargs', str(args))
print('')
print('Directories\n')
parr = []

16
mesongui.py
Unescape View File

@ -34,7 +34,7 @@ class PathModel(QAbstractItemModel):
self.attr_name = ['prefix', 'libdir', 'bindir', 'includedir', 'datadir', \
'mandir', 'localedir']
def flags(self, index):
def args(self, index):
if index.column() == 1:
editable = PyQt5.QtCore.Qt.ItemIsEditable
else:
@ -104,7 +104,7 @@ class TargetModel(QAbstractItemModel):
installed = 'No'
self.targets.append((name, typename, installed, num_sources))
def flags(self, index):
def args(self, index):
return PyQt5.QtCore.Qt.ItemIsSelectable | PyQt5.QtCore.Qt.ItemIsEnabled
def rowCount(self, index):
@ -148,8 +148,8 @@ class DependencyModel(QAbstractItemModel):
name = k
found = bd.found()
if found:
cflags = str(bd.get_compile_flags())
libs = str(bd.get_link_flags())
cflags = str(bd.get_compile_args())
libs = str(bd.get_link_args())
found = 'yes'
else:
cflags = ''
@ -157,7 +157,7 @@ class DependencyModel(QAbstractItemModel):
found = 'no'
self.deps.append((name, found, cflags, libs))
def flags(self, index):
def args(self, index):
return PyQt5.QtCore.Qt.ItemIsSelectable | PyQt5.QtCore.Qt.ItemIsEnabled
def rowCount(self, index):
@ -172,9 +172,9 @@ class DependencyModel(QAbstractItemModel):
if role != PyQt5.QtCore.Qt.DisplayRole:
return QVariant()
if section == 3:
return QVariant('Link flags')
return QVariant('Link args')
if section == 2:
return QVariant('Compile flags')
return QVariant('Compile args')
if section == 1:
return QVariant('Found')
return QVariant('Name')
@ -201,7 +201,7 @@ class CoreModel(QAbstractItemModel):
for langname, comp in core_data.cross_compilers.items():
self.elems.append((langname + ' cross compiler', str(comp.get_exelist())))
def flags(self, index):
def args(self, index):
return PyQt5.QtCore.Qt.ItemIsSelectable | PyQt5.QtCore.Qt.ItemIsEnabled
def rowCount(self, index):

108
ninjabackend.py
Unescape View File

@ -422,27 +422,27 @@ class NinjaBackend(backends.Backend):
commands += class_list
elem = NinjaBuildElement(outname_rel, jar_rule, [])
elem.add_dep([os.path.join(self.get_target_private_dir(target), i) for i in class_list])
elem.add_item('FLAGS', commands)
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 = []
if buildtype == 'debug':
args += compiler.get_debug_flags()
args += compiler.get_output_flags(self.get_target_private_dir(target))
args += compiler.get_debug_args()
args += compiler.get_output_args(self.get_target_private_dir(target))
rel_src = os.path.join(self.build_to_src, subdir, src)
plain_class_path = src[:-4] + 'class'
rel_obj = os.path.join(self.get_target_private_dir(target), plain_class_path)
element = NinjaBuildElement(rel_obj,
compiler.get_language() + '_COMPILER', rel_src)
element.add_item('FLAGS', args)
element.add_item('ARGS', args)
element.write(outfile)
return plain_class_path
def generate_java_link(self, outfile):
rule = 'rule java_LINKER\n'
command = ' command = jar $FLAGS\n'
command = ' command = jar $ARGS\n'
description = ' description = Creating jar $out.\n'
outfile.write(rule)
outfile.write(command)
@ -456,10 +456,10 @@ class NinjaBackend(backends.Backend):
continue
vapibase = os.path.basename(s)[:-4] + 'vapi'
rel_vapi = os.path.join(self.get_target_dir(target), target.get_basename() + '.dir', vapibase)
flags = ['--fast-vapi=' + rel_vapi]
args = ['--fast-vapi=' + rel_vapi]
rel_s = os.path.join(self.build_to_src, s)
element = NinjaBuildElement(rel_vapi, valac.get_language() + '_COMPILER', rel_s)
element.add_item('FLAGS', flags)
element.add_item('ARGS', args)
element.write(outfile)
fastvapis[s] = (vapibase, rel_vapi)
return fastvapis
@ -472,25 +472,25 @@ class NinjaBackend(backends.Backend):
for s in target.get_sources():
if not s.endswith('.vala'):
continue
flags = ['-d', self.get_target_private_dir(target)]
args = ['-d', self.get_target_private_dir(target)]
sc = os.path.basename(s)[:-4] + 'c'
flags += ['-C', '-o', sc]
args += ['-C', '-o', sc]
vapi_order_deps = []
for (sourcefile, vapi_info) in fast_vapis.items():
if sourcefile == s:
continue
(vapibase, rel_vapi) = vapi_info
flags += ['--use-fast-vapi=' + rel_vapi]
args += ['--use-fast-vapi=' + rel_vapi]
vapi_order_deps.append(rel_vapi)
relsc = os.path.join(self.get_target_dir(target), target.get_basename() + '.dir', sc)
rel_s = os.path.join(self.build_to_src, s)
flags += ['--deps', relsc + '.d']
args += ['--deps', relsc + '.d']
for d in target.external_deps:
if isinstance(d, dependencies.PkgConfigDependency):
flags += ['--pkg', d.name]
args += ['--pkg', d.name]
generated_c += [relsc]
element = NinjaBuildElement(relsc, valac.get_language() + '_COMPILER', rel_s)
element.add_item('FLAGS', flags)
element.add_item('ARGS', args)
element.add_orderdep(vapi_order_deps)
element.write(outfile)
return generated_c
@ -503,17 +503,17 @@ class NinjaBackend(backends.Backend):
raise InvalidArguments('Rust target %s contains a non-rust source file.' % target.get_basename())
relsrc.append(os.path.join(self.build_to_src, i))
target_name = os.path.join(target.subdir, target.get_filename())
flags = ['--crate-type']
args = ['--crate-type']
if isinstance(target, build.Executable):
flags.append('bin')
args.append('bin')
elif isinstance(target, build.SharedLibrary):
flags.append('dylib')
args.append('dylib')
else:
raise InvalidArguments('Unknown target type for rustc.')
flags += rustc.get_buildtype_flags(self.environment.coredata.buildtype)
args += rustc.get_buildtype_args(self.environment.coredata.buildtype)
depfile = target_name + '.d'
flags += ['--out-dir', target.subdir, '-o', target.get_filename()]
flags += ['--dep-info', depfile]
args += ['--out-dir', target.subdir, '-o', target.get_filename()]
args += ['--dep-info', depfile]
orderdeps = [os.path.join(t.subdir, t.get_filename()) for t in target.link_targets]
linkdirs = {}
for d in target.link_targets:
@ -521,11 +521,11 @@ class NinjaBackend(backends.Backend):
for d in linkdirs.keys():
if d == '':
d = '.'
flags += ['-L', d]
args += ['-L', d]
element = NinjaBuildElement(target_name, 'rust_COMPILER', relsrc)
if len(orderdeps) > 0:
element.add_orderdep(orderdeps)
element.add_item('FLAGS', flags)
element.add_item('ARGS', args)
element.add_item('targetdep', depfile)
element.write(outfile)
@ -542,9 +542,9 @@ class NinjaBackend(backends.Backend):
if static_linker is None:
return
rule = 'rule STATIC%s_LINKER\n' % crstr
command = ' command = %s $LINK_FLAGS %s $in\n' % \
command = ' command = %s $LINK_ARGS %s $in\n' % \
(' '.join(static_linker.get_exelist()),
' '.join(static_linker.get_output_flags('$out')))
' '.join(static_linker.get_output_args('$out')))
description = ' description = Static linking library $out\n\n'
outfile.write(rule)
outfile.write(command)
@ -561,10 +561,10 @@ class NinjaBackend(backends.Backend):
if is_cross:
crstr = '_CROSS'
rule = 'rule %s%s_LINKER\n' % (langname, crstr)
command = ' command = %s %s $FLAGS %s $in $LINK_FLAGS $aliasing\n' % \
command = ' command = %s %s $ARGS %s $in $LINK_ARGS $aliasing\n' % \
(execute_wrapper,
' '.join(compiler.get_linker_exelist()),\
' '.join(compiler.get_linker_output_flags('$out')))
' '.join(compiler.get_linker_output_args('$out')))
description = ' description = Linking target $out'
outfile.write(rule)
outfile.write(command)
@ -587,7 +587,7 @@ class NinjaBackend(backends.Backend):
def generate_java_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 $FLAGS $in\n' % invoc
command = ' command = %s $ARGS $in\n' % invoc
description = ' description = Compiling Java object $in.\n'
outfile.write(rule)
outfile.write(command)
@ -597,7 +597,7 @@ class NinjaBackend(backends.Backend):
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()])
command = ' command = %s $FLAGS $in\n' % invoc
command = ' command = %s $ARGS $in\n' % invoc
description = ' description = Compiling Vala source $in.\n'
restat = ' restat = 1\n' # ValaC does this always to take advantage of it.
depfile = ' depfile = $out.d\n'
@ -613,7 +613,7 @@ class NinjaBackend(backends.Backend):
def generate_rust_compile_rules(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 $FLAGS $in\n' % invoc
command = ' command = %s $ARGS $in\n' % invoc
description = ' description = Compiling Rust source $in.\n'
depfile = ' depfile = $out.d\n'
depstyle = ' deps = gcc\n'
@ -642,12 +642,12 @@ class NinjaBackend(backends.Backend):
else:
crstr = ''
rule = 'rule %s%s_COMPILER\n' % (langname, crstr)
depflags = compiler.get_dependency_gen_flags('$out', '$DEPFILE')
command = " command = %s $FLAGS %s %s %s $in\n" % \
depargs = compiler.get_dependency_gen_args('$out', '$DEPFILE')
command = " command = %s $ARGS %s %s %s $in\n" % \
(' '.join(compiler.get_exelist()),\
' '.join([qstr % d for d in depflags]),\
' '.join(compiler.get_output_flags('$out')),\
' '.join(compiler.get_compile_only_flags()))
' '.join([qstr % d for d in depargs]),\
' '.join(compiler.get_output_args('$out')),\
' '.join(compiler.get_compile_only_args()))
description = ' description = Compiling %s object $out\n' % langname
if compiler.get_id() == 'msvc':
deps = ' deps = msvc\n'
@ -668,16 +668,16 @@ class NinjaBackend(backends.Backend):
else:
crstr = ''
rule = 'rule %s%s_PCH\n' % (langname, crstr)
depflags = compiler.get_dependency_gen_flags('$out', '$DEPFILE')
depargs = compiler.get_dependency_gen_args('$out', '$DEPFILE')
if compiler.get_id() == 'msvc':
output = ''
else:
output = ' '.join(compiler.get_output_flags('$out'))
command = " command = %s $FLAGS %s %s %s $in\n" % \
output = ' '.join(compiler.get_output_args('$out'))
command = " command = %s $ARGS %s %s %s $in\n" % \
(' '.join(compiler.get_exelist()),\
' '.join([qstr % d for d in depflags]),\
' '.join([qstr % d for d in depargs]),\
output,\
' '.join(compiler.get_compile_only_flags()))
' '.join(compiler.get_compile_only_args()))
description = ' description = Precompiling header %s\n' % '$in'
if compiler.get_id() == 'msvc':
deps = ' deps = msvc\n'
@ -744,7 +744,7 @@ class NinjaBackend(backends.Backend):
def generate_single_compile(self, target, outfile, src, is_generated=False, header_deps=[], order_deps=[]):
compiler = self.get_compiler_for_source(src)
commands = self.generate_basic_compiler_flags(target, compiler)
commands = self.generate_basic_compiler_args(target, compiler)
commands.append(compiler.get_include_arg(self.get_target_private_dir(target)))
if is_generated:
if '/' in src:
@ -799,7 +799,7 @@ class NinjaBackend(backends.Backend):
element.add_orderdep(d)
element.add_orderdep(pch_dep)
element.add_item('DEPFILE', dep_file)
element.add_item('FLAGS', commands)
element.add_item('ARGS', commands)
element.write(outfile)
return rel_obj
@ -812,7 +812,7 @@ class NinjaBackend(backends.Backend):
dst = os.path.join(self.get_target_private_dir(target), pchname)
commands = []
commands += self.generate_basic_compiler_flags(target, compiler)
commands += self.generate_basic_compiler_args(target, compiler)
just_name = os.path.split(header)[1]
commands += compiler.gen_pch_args(just_name, source, dst)
@ -821,7 +821,7 @@ class NinjaBackend(backends.Backend):
def generate_gcc_pch_command(self, target, compiler, pch):
commands = []
commands += self.generate_basic_compiler_flags(target, compiler)
commands += self.generate_basic_compiler_args(target, compiler)
dst = os.path.join(self.get_target_private_dir(target),
os.path.split(pch)[-1] + '.' + compiler.get_pch_suffix())
dep = dst + '.' + compiler.get_depfile_suffix()
@ -850,7 +850,7 @@ class NinjaBackend(backends.Backend):
elem = NinjaBuildElement(dst, rulename, src)
if extradep is not None:
elem.add_dep(extradep)
elem.add_item('FLAGS', commands)
elem.add_item('ARGS', commands)
elem.add_item('DEPFILE', dep)
elem.write(outfile)
@ -876,36 +876,36 @@ class NinjaBackend(backends.Backend):
linker_rule = linker_base + crstr + '_LINKER'
abspath = os.path.join(self.environment.get_build_dir(), target.subdir)
commands = []
commands += linker.get_linker_always_flags()
commands += linker.get_buildtype_linker_flags(self.environment.coredata.buildtype)
commands += linker.get_linker_always_args()
commands += linker.get_buildtype_linker_args(self.environment.coredata.buildtype)
if not(isinstance(target, build.StaticLibrary)):
commands += self.environment.coredata.external_link_args[linker.get_language()]
if isinstance(target, build.Executable):
commands += linker.get_std_exe_link_flags()
commands += linker.get_std_exe_link_args()
elif isinstance(target, build.SharedLibrary):
commands += linker.get_std_shared_lib_link_flags()
commands += linker.get_pic_flags()
commands += linker.get_soname_flags(target.name, abspath)
commands += linker.get_std_shared_lib_link_args()
commands += linker.get_pic_args()
commands += linker.get_soname_args(target.name, abspath)
elif isinstance(target, build.StaticLibrary):
commands += linker.get_std_link_flags()
commands += linker.get_std_link_args()
else:
raise RuntimeError('Unknown build target type.')
dependencies = target.get_dependencies()
commands += self.build_target_link_arguments(linker, dependencies)
commands += target.link_flags
commands += target.link_args
# External deps must be last because target link libraries may depend on them.
if not(isinstance(target, build.StaticLibrary)):
for dep in target.get_external_deps():
commands += dep.get_link_flags()
commands += dep.get_link_args()
commands += linker.build_rpath_args(self.environment.get_build_dir(), target.get_rpaths())
if self.environment.coredata.coverage:
commands += linker.get_coverage_link_flags()
commands += linker.get_coverage_link_args()
dep_targets = [self.get_dependency_filename(t) for t in dependencies]
dep_targets += [os.path.join(self.environment.source_dir,
target.subdir, t) for t in target.link_depends]
elem = NinjaBuildElement(outname, linker_rule, obj_list)
elem.add_dep(dep_targets)
elem.add_item('LINK_FLAGS', commands)
elem.add_item('LINK_ARGS', commands)
return elem
def get_dependency_filename(self, t):

2
test cases/linuxlike/3 linker script/meson.build
Unescape View File

@ -3,6 +3,6 @@ project('linker script', 'c')
mapfile = 'bob.map'
vflag = '-Wl,--version-script,@0@/@1@'.format(meson.current_source_dir(), mapfile)
l = shared_library('bob', 'bob.c', link_flags : vflag, link_depends : mapfile)
l = shared_library('bob', 'bob.c', link_args : vflag, link_depends : mapfile)
e = executable('prog', 'prog.c', link_with : l)
test('core', e)

24
xcodebackend.py
Unescape View File

@ -226,8 +226,8 @@ class XCodeBackend(backends.Backend):
fullpath = os.path.join(self.environment.get_source_dir(), s)
fileref = self.filemap[s]
fullpath2 = fullpath
compiler_flags = ''
self.ofile.write(templ % (idval, fullpath, fileref, fullpath2, compiler_flags))
compiler_args = ''
self.ofile.write(templ % (idval, fullpath, fileref, fullpath2, compiler_args))
for o in t.objects:
o = os.path.join(t.subdir, o)
idval = self.buildmap[o]
@ -636,18 +636,18 @@ class XCodeBackend(backends.Backend):
product_name = target_name + '.' + dylib_version
else:
product_name = target_name
ldargs += target.link_flags
ldargs += target.link_args
ldstr = ' '.join(ldargs)
valid = self.buildconfmap[target_name][buildtype]
langflags = {}
langargs = {}
for lang in self.environment.coredata.compilers:
if lang not in langnamemap:
continue
gflags = self.build.global_args.get(lang, [])
tflags = target.get_extra_args(lang)
flags = gflags + tflags
if len(flags) > 0:
langflags[langnamemap[lang]] = flags
gargs = self.build.global_args.get(lang, [])
targs = target.get_extra_args(lang)
args = gargs + targs
if len(args) > 0:
langargs[langnamemap[lang]] = args
symroot = os.path.join(self.environment.get_build_dir(), target.subdir)
self.write_line('%s /* %s */ = {' % (valid, buildtype))
self.indent_level+=1
@ -675,9 +675,9 @@ class XCodeBackend(backends.Backend):
self.write_line('LIBRARY_SEARCH_PATHS = "";')
if isinstance(target, build.SharedLibrary):
self.write_line('LIBRARY_STYLE = DYNAMIC;')
for langname, flags in langflags.items():
flagstr = ' '.join(flags)
self.write_line('OTHER_%sFLAGS = "%s";' % (langname, flagstr))
for langname, args in langargs.items():
argstr = ' '.join(args)
self.write_line('OTHER_%sFLAGS = "%s";' % (langname, argstr))
self.write_line('OTHER_LDFLAGS = "%s";' % ldstr)
self.write_line('OTHER_REZFLAGS = "";')
self.write_line('PRODUCT_NAME = %s;' % product_name)

Write Preview
Loading…
Cancel
Save