| #!/usr/bin/env python |
| |
| # |
| # Kuroga, single python file meta-build system for ninja |
| # https://github.com/lighttransport/kuroga |
| # |
| # Requirements: python 2.6 or 2.7 |
| # |
| # Usage: $ python kuroga.py input.py |
| # |
| |
| import imp |
| import re |
| import textwrap |
| import glob |
| import os |
| import sys |
| |
| # gcc preset |
| def add_gnu_rule(ninja): |
| ninja.rule('gnucxx', description='CXX $out', |
| command='$gnucxx -MMD -MF $out.d $gnudefines $gnuincludes $gnucxxflags -c $in -o $out', |
| depfile='$out.d', deps='gcc') |
| ninja.rule('gnucc', description='CC $out', |
| command='$gnucc -MMD -MF $out.d $gnudefines $gnuincludes $gnucflags -c $in -o $out', |
| depfile='$out.d', deps='gcc') |
| ninja.rule('gnulink', description='LINK $out', pool='link_pool', |
| command='$gnuld -o $out $in $libs $gnuldflags') |
| ninja.rule('gnuar', description='AR $out', pool='link_pool', |
| command='$gnuar rsc $out $in') |
| ninja.rule('gnustamp', description='STAMP $out', command='touch $out') |
| ninja.newline() |
| |
| ninja.variable('gnucxx', 'g++') |
| ninja.variable('gnucc', 'gcc') |
| ninja.variable('gnuld', '$gnucxx') |
| ninja.variable('gnuar', 'ar') |
| ninja.newline() |
| |
| # clang preset |
| def add_clang_rule(ninja): |
| ninja.rule('clangcxx', description='CXX $out', |
| command='$clangcxx -MMD -MF $out.d $clangdefines $clangincludes $clangcxxflags -c $in -o $out', |
| depfile='$out.d', deps='gcc') |
| ninja.rule('clangcc', description='CC $out', |
| command='$clangcc -MMD -MF $out.d $clangdefines $clangincludes $clangcflags -c $in -o $out', |
| depfile='$out.d', deps='gcc') |
| ninja.rule('clanglink', description='LINK $out', pool='link_pool', |
| command='$clangld -o $out $in $libs $clangldflags') |
| ninja.rule('clangar', description='AR $out', pool='link_pool', |
| command='$clangar rsc $out $in') |
| ninja.rule('clangstamp', description='STAMP $out', command='touch $out') |
| ninja.newline() |
| |
| ninja.variable('clangcxx', 'clang++') |
| ninja.variable('clangcc', 'clang') |
| ninja.variable('clangld', '$clangcxx') |
| ninja.variable('clangar', 'ar') |
| ninja.newline() |
| |
| # msvc preset |
| def add_msvc_rule(ninja): |
| ninja.rule('msvccxx', description='CXX $out', |
| command='$msvccxx /TP /showIncludes $msvcdefines $msvcincludes $msvccxxflags -c $in /Fo$out', |
| depfile='$out.d', deps='msvc') |
| ninja.rule('msvccc', description='CC $out', |
| command='$msvccc /TC /showIncludes $msvcdefines $msvcincludes $msvccflags -c $in /Fo$out', |
| depfile='$out.d', deps='msvc') |
| ninja.rule('msvclink', description='LINK $out', pool='link_pool', |
| command='$msvcld $msvcldflags $in $libs /OUT:$out') |
| ninja.rule('msvcar', description='AR $out', pool='link_pool', |
| command='$msvcar $in /OUT:$out') |
| #ninja.rule('msvcstamp', description='STAMP $out', command='touch $out') |
| ninja.newline() |
| |
| ninja.variable('msvccxx', 'cl.exe') |
| ninja.variable('msvccc', 'cl.exe') |
| ninja.variable('msvcld', 'link.exe') |
| ninja.variable('msvcar', 'lib.exe') |
| ninja.newline() |
| |
| # -- from ninja_syntax.py -- |
| def escape_path(word): |
| return word.replace('$ ', '$$ ').replace(' ', '$ ').replace(':', '$:') |
| |
| class Writer(object): |
| def __init__(self, output, width=78): |
| self.output = output |
| self.width = width |
| |
| def newline(self): |
| self.output.write('\n') |
| |
| def comment(self, text, has_path=False): |
| for line in textwrap.wrap(text, self.width - 2, break_long_words=False, |
| break_on_hyphens=False): |
| self.output.write('# ' + line + '\n') |
| |
| def variable(self, key, value, indent=0): |
| if value is None: |
| return |
| if isinstance(value, list): |
| value = ' '.join(filter(None, value)) # Filter out empty strings. |
| self._line('%s = %s' % (key, value), indent) |
| |
| def pool(self, name, depth): |
| self._line('pool %s' % name) |
| self.variable('depth', depth, indent=1) |
| |
| def rule(self, name, command, description=None, depfile=None, |
| generator=False, pool=None, restat=False, rspfile=None, |
| rspfile_content=None, deps=None): |
| self._line('rule %s' % name) |
| self.variable('command', command, indent=1) |
| if description: |
| self.variable('description', description, indent=1) |
| if depfile: |
| self.variable('depfile', depfile, indent=1) |
| if generator: |
| self.variable('generator', '1', indent=1) |
| if pool: |
| self.variable('pool', pool, indent=1) |
| if restat: |
| self.variable('restat', '1', indent=1) |
| if rspfile: |
| self.variable('rspfile', rspfile, indent=1) |
| if rspfile_content: |
| self.variable('rspfile_content', rspfile_content, indent=1) |
| if deps: |
| self.variable('deps', deps, indent=1) |
| |
| def build(self, outputs, rule, inputs=None, implicit=None, order_only=None, |
| variables=None): |
| outputs = as_list(outputs) |
| out_outputs = [escape_path(x) for x in outputs] |
| all_inputs = [escape_path(x) for x in as_list(inputs)] |
| |
| if implicit: |
| implicit = [escape_path(x) for x in as_list(implicit)] |
| all_inputs.append('|') |
| all_inputs.extend(implicit) |
| if order_only: |
| order_only = [escape_path(x) for x in as_list(order_only)] |
| all_inputs.append('||') |
| all_inputs.extend(order_only) |
| |
| self._line('build %s: %s' % (' '.join(out_outputs), |
| ' '.join([rule] + all_inputs))) |
| |
| if variables: |
| if isinstance(variables, dict): |
| iterator = iter(variables.items()) |
| else: |
| iterator = iter(variables) |
| |
| for key, val in iterator: |
| self.variable(key, val, indent=1) |
| |
| return outputs |
| |
| def include(self, path): |
| self._line('include %s' % path) |
| |
| def subninja(self, path): |
| self._line('subninja %s' % path) |
| |
| def default(self, paths): |
| self._line('default %s' % ' '.join(as_list(paths))) |
| |
| def _count_dollars_before_index(self, s, i): |
| """Returns the number of '$' characters right in front of s[i].""" |
| dollar_count = 0 |
| dollar_index = i - 1 |
| while dollar_index > 0 and s[dollar_index] == '$': |
| dollar_count += 1 |
| dollar_index -= 1 |
| return dollar_count |
| |
| def _line(self, text, indent=0): |
| """Write 'text' word-wrapped at self.width characters.""" |
| leading_space = ' ' * indent |
| while len(leading_space) + len(text) > self.width: |
| # The text is too wide; wrap if possible. |
| |
| # Find the rightmost space that would obey our width constraint and |
| # that's not an escaped space. |
| available_space = self.width - len(leading_space) - len(' $') |
| space = available_space |
| while True: |
| space = text.rfind(' ', 0, space) |
| if (space < 0 or |
| self._count_dollars_before_index(text, space) % 2 == 0): |
| break |
| |
| if space < 0: |
| # No such space; just use the first unescaped space we can find. |
| space = available_space - 1 |
| while True: |
| space = text.find(' ', space + 1) |
| if (space < 0 or |
| self._count_dollars_before_index(text, space) % 2 == 0): |
| break |
| if space < 0: |
| # Give up on breaking. |
| break |
| |
| self.output.write(leading_space + text[0:space] + ' $\n') |
| text = text[space+1:] |
| |
| # Subsequent lines are continuations, so indent them. |
| leading_space = ' ' * (indent+2) |
| |
| self.output.write(leading_space + text + '\n') |
| |
| def close(self): |
| self.output.close() |
| |
| |
| def as_list(input): |
| if input is None: |
| return [] |
| if isinstance(input, list): |
| return input |
| return [input] |
| |
| # -- end from ninja_syntax.py -- |
| |
| def gen(ninja, toolchain, config): |
| |
| ninja.variable('ninja_required_version', '1.4') |
| ninja.newline() |
| |
| if hasattr(config, "builddir"): |
| builddir = config.builddir[toolchain] |
| ninja.variable(toolchain + 'builddir', builddir) |
| else: |
| builddir = '' |
| |
| ninja.variable(toolchain + 'defines', config.defines[toolchain] or []) |
| ninja.variable(toolchain + 'includes', config.includes[toolchain] or []) |
| ninja.variable(toolchain + 'cflags', config.cflags[toolchain] or []) |
| ninja.variable(toolchain + 'cxxflags', config.cxxflags[toolchain] or []) |
| ninja.variable(toolchain + 'ldflags', config.ldflags[toolchain] or []) |
| ninja.newline() |
| |
| if hasattr(config, "link_pool_depth"): |
| ninja.pool('link_pool', depth=config.link_pool_depth) |
| else: |
| ninja.pool('link_pool', depth=4) |
| ninja.newline() |
| |
| # Add default toolchain(gnu, clang and msvc) |
| add_gnu_rule(ninja) |
| add_clang_rule(ninja) |
| add_msvc_rule(ninja) |
| |
| obj_files = [] |
| |
| cc = toolchain + 'cc' |
| cxx = toolchain + 'cxx' |
| link = toolchain + 'link' |
| ar = toolchain + 'ar' |
| |
| if hasattr(config, "cxx_files"): |
| for src in config.cxx_files: |
| srcfile = src |
| obj = os.path.splitext(srcfile)[0] + '.o' |
| obj = os.path.join(builddir, obj); |
| obj_files.append(obj) |
| ninja.build(obj, cxx, srcfile) |
| ninja.newline() |
| |
| if hasattr(config, "c_files"): |
| for src in config.c_files: |
| srcfile = src |
| obj = os.path.splitext(srcfile)[0] + '.o' |
| obj = os.path.join(builddir, obj); |
| obj_files.append(obj) |
| ninja.build(obj, cc, srcfile) |
| ninja.newline() |
| |
| targetlist = [] |
| if hasattr(config, "exe"): |
| ninja.build(config.exe, link, obj_files) |
| targetlist.append(config.exe) |
| |
| if hasattr(config, "staticlib"): |
| ninja.build(config.staticlib, ar, obj_files) |
| targetlist.append(config.staticlib) |
| |
| ninja.build('all', 'phony', targetlist) |
| ninja.newline() |
| |
| ninja.default('all') |
| |
| def main(): |
| if len(sys.argv) < 2: |
| print("Usage: python kuroga.py config.py") |
| sys.exit(1) |
| |
| config = imp.load_source("config", sys.argv[1]) |
| |
| f = open('build.ninja', 'w') |
| ninja = Writer(f) |
| |
| if hasattr(config, "register_toolchain"): |
| config.register_toolchain(ninja) |
| |
| gen(ninja, config.toolchain, config) |
| f.close() |
| |
| main() |
