path: root/cook.py

#!/usr/bin/python

import sys
import os
from pathlib import Path
from threading import local
import shutil
import argparse

def error(*args):
    print(*args, file = sys.stderr)

def find_program(prog, required=True):
    path = shutil.which(prog)
    if path == None and required:
        raise Exception("Required program '%s' not found on the system" % (prog))
    return File(path)

def flatten(el):
    if type(el) == list or type(el) == tuple:
        return [a for b in el for a in flatten(b)]
    else:
        return [el]

ROOT = Path.cwd()
BUILD = Path("bld").resolve().relative_to(ROOT)
DEFMKDESC = lambda o, i, cmd: "%s" % (cmd)
DEFMKOUT = lambda i: "%s" % (i)

def wrap_lambda(s):
    if callable(s):
        return s
    else:
        return lambda *args: s


class FileMeta(type):
    def __call__(cls, path, *rest, **krest):
        # If none, return none
        if path == None:
            return None
    
        # If already a file, return it
        if issubclass(type(path), File):
            return path
    
        # Adjust name to be a path
        if type(path) == str:
            p = Path(path).resolve()
            if p.is_relative_to(ROOT):
                path = p.relative_to(ROOT)
            else:
                path = p
    
        idx = str(path) + cls.__name__
    
        if idx in cls.fdb:
            return cls.fdb[idx]
        
        obj = cls.__new__(cls, path, *rest, **krest)
        cls.__init__(obj, path, *rest, **krest)
        cls.fdb[idx] = obj
        return obj

class File(metaclass = FileMeta):
    fdb = dict()

    def __init__(self, path):
        # The name corresponding to
        # the target: this can be
        # a path or an abstract name
        self.path = path
                
    def __str__(self):
        return str(self.path)

    def resolve(*args):
        return [File(file) for file in flatten(args)]

class Target(File):
    def __init__(self, path, processor, inputs, extra_args = []):
        super().__init__(path)
        
        # The generator that created this process
        self.processor = processor
        
        # The inputs
        self.inputs = File.resolve(inputs)
        
        # The extra arguments taken
        self.extra_args = extra_args
    
    def gen_makefile(self):
        inputs = " ".join([str(x) for x in self.inputs])
        extra_args = " ".join([x for x in self.extra_args])

        out = "%s: %s\n" % (self.path, inputs)
        out += "\t@$(%s) %s\n" % (self.processor.name, self.processor.mkargs("$@", inputs, extra_args))
        out += "\t@echo '%s'" % (self.processor.mkdesc("$@", inputs, extra_args))
        
        return out
    
    def gen_ninja(self):
        inputs = " ".join([str(x) for x in self.inputs])
        extra_args = " ".join(self.extra_args)
        
        out = "build %s: %s %s" % (self.path, self.processor.name, inputs)
        if self.extra_args != []:
            out += "\n  extra = %s" % (extra_args)

        return out

class ProcessorMeta(type):
    def __call__(cls, name, *rest, **krest):
        # If already a file, return it
        if issubclass(type(name), Processor):
            return name
    
        if name in cls.mdb:
            return cls.mdb[name]
        
        obj = cls.__new__(cls, name, *rest, **krest)
        cls.__init__(obj, name, *rest, **krest)
        cls.mdb[name] = obj
        return obj

class Processor(metaclass = ProcessorMeta):
    mdb = dict()

    def __init__(self, name, exe, mkargs, mkout=DEFMKOUT, mkdesc=DEFMKDESC):
        # The name of the processor
        self.name = name
        
        # Executable used in the process
        self.exe = File(exe)
        
        # The arguments that is used to launch the process
        self.mkargs = wrap_lambda(mkargs)
        
        # The way to generate output path
        self.mkout = wrap_lambda(mkout)
        
        # The description
        self.mkdesc = wrap_lambda(mkdesc)

    def __call__(self, name, *args, extra_args = []):
        return self.gen(name, *args, extra_args = extra_args)
    
    def gen(self, name, *args, extra_args = []):
        inputs = File.resolve(args)
        path = BUILD / Path(".").resolve().relative_to(ROOT) / self.mkout(name)
        
        return Target(path, self, inputs, extra_args)

    def gen_makefile(self):
        return "%s = %s" % (self.name, self.exe)

    def gen_ninja(self):
        out = "rule %s\n" % (self.name)
        
        cmd = "%s %s" % (self.exe, self.mkargs("$out", "$in", "$extra"))
        
        out += "  command = %s\n" % (cmd)
        out += "  description = %s\n" % (self.mkdesc("$out", "$in", cmd))
        return out

class Vec(Processor):
    def __init__(self, name, exe, mkargs, mkout, mkdesc=DEFMKDESC):
        super().__init__(name, exe, mkargs, mkout = mkout, mkdesc = mkdesc)
    
    def __call__(self, *args, extra_args = []):
        return self.gen(*args, extra_args = extra_args)
    
    def gen(self, *args, extra_args = []):
        args = File.resolve(args)
        extra_args = flatten(extra_args)
        
        targets = []
        for i in args:
            path = BUILD / i.path.parent / self.mkout(i.path)

            targets.append(Target(path, self, [i], extra_args))

        return targets

class CTarget(Target):
    def __init__(self, path, processor, inputs, header_depends, extra_args = []):
        super().__init__(path, processor, inputs, extra_args = extra_args)
        self.header_depends = File.resolve(header_depends)
    
    def gen_makefile(self):
        out = []

        if self.header_depends != []:
            out += ["-include %s\n" % hdep for hdep in self.header_depends]
        
        out += super().gen_makefile()
        return "".join(out)

class CC(Vec):
    def __init__(self, name, exe, mkargs, mkout, mkinc, mkdep=None, depstyle=None, mkdesc=DEFMKDESC):
        super().__init__(name, exe, mkargs, mkout, mkdesc=mkdesc)
        self.mkinc = mkinc
        self.mkdep = mkdep
        self.depstyle = depstyle
    
    def __call__(self, *args, extra_args = [], include_dirs = []):
        return self.gen(*args, extra_args = extra_args, include_dirs = include_dirs)
    
    def gen(self, *args, extra_args = [], include_dirs = []):
        inputs = File.resolve(args)
    
        extra_args = flatten(extra_args)
        include_dirs = File.resolve(include_dirs)

        include_args = [self.mkinc(str(x)) for x in include_dirs]
        extra_args += include_args
        
        targets = []
        for input in inputs:
            out = self.mkout(input.path)
            path = BUILD / out
            hdep = BUILD / self.mkdep(out)

            targets.append(CTarget(path, self, input, header_depends = hdep, extra_args = extra_args))

        return targets
        
    def gen_ninja(self):
        out = super().gen_ninja()
        
        if self.mkdep and self.depstyle == "gcc":
            out += "  deps = gcc\n"
            out += "  depfile = %s\n" % (self.mkdep("$out"))
        elif self.mkdep:
            raise Exception("ninja dependencies for selected depstyle is unimplemented")
        
        return out

class CExe(Processor):
    def __init__(self, name, exe, mkargs, mklib, mkout = DEFMKOUT, mkdesc=DEFMKDESC):
        super().__init__(name, exe, mkargs, mkout = mkout, mkdesc = mkdesc)
        
        self.mklib = mklib
    
    def __call__(self, name, *args, libs = [], extra_args = []):
        return self.gen(name, *args, libs = libs, extra_args = extra_args)
    
    def gen(self, name, *args, libs, extra_args = []):
        extra_args = flatten(extra_args)
        libs = flatten(libs)
        
        # Note: this is bad, perhaps take a "depends" also/instead
        # XXX Handling of libraries is temporary
        libs_args = [self.mklib(lib) for lib in libs]
        extra_args += libs_args
        
        return super().gen(name, *args, extra_args = extra_args)

def CCStyleToolchain(name, gccname, arname, suffix="", c_args=[], ld_args=[]):
    ccname = name + suffix
    exename = name + "exe" + suffix
    libname = name + "lib" + suffix
    shlibname = name + "shlib" + suffix
    
    c_args = " ".join(flatten(c_args))
    ld_args = " ".join(flatten(ld_args))
    
    gcc = find_program(gccname)
    ar = find_program(arname)

    cc = CC(
        name=ccname,
        exe=gcc,
        mkargs=lambda o, i, ea: "-MD -MF %s.d -o %s -c %s %s %s" % (o, o, i, c_args, ea),
        mkout=lambda i: "%s.o" % (i),
        mkinc=lambda inc: "-I%s" % (inc),
        mkdep=lambda i: "%s.d" % (i),
        depstyle="gcc",
        mkdesc=lambda o, i, cmd: "CC %s" % (o),
    )
    exe = CExe(
        name=exename,
        exe=gcc,
        mkargs=lambda o, i, ea: "-o %s %s %s %s" % (o, i, ld_args, ea),
        mklib=lambda l: "-l" + l,
        mkdesc=lambda o, i, cmd: "LD %s" % (o)
    )
    lib = CExe(
        name=libname,
        exe=ar,
        mkargs=lambda o, i, ea: "-rcs %s %s %s" % (o, i, ea),
        mklib=lambda l: "", # TODO: this should not be needed
        mkdesc=lambda o, i, cmd: "AR %s" % (o),
        mkout=lambda n: "lib%s.a" % (n)
    )
    shlib = CExe(
        name=shlibname,
        exe=gcc,
        mkargs=lambda o, i, ea: "-o %s %s %s -fPIC --shared %s" % (o, i, ld_args, ea),
        mklib=lambda l: "-l" + l,
        mkdesc=lambda o, i, cmd: "SO %s" % (o),
        mkout=lambda n: "lib%s.so" % (n)
    )
    return cc, exe, lib, shlib

def GccToolchain(suffix="", c_args=[], ld_args=[]):
    return CCStyleToolchain("gcc", "gcc", "gcc-ar", suffix, c_args, ld_args)

def ClangToolchain(suffix="", c_args=[], ld_args=[]):
    return CCStyleToolchain("clang", "clang", "llvm-ar", suffix, c_args, ld_args)

def CCToolchain(suffix="", c_args=[], ld_args=[]):
    return CCStyleToolchain("cc", "cc", "ar", suffix, c_args, ld_args)

CTOOLCHAINS = {
    'cc': CCToolchain,
    'clang': ClangToolchain,
    'gcc': GccToolchain
}


def CToolchain(name="system", suffix="", c_args=[], ld_args=[]):
    if suffix == "" and (c_args != [] or ld_args != []):
        error("warning: instanciating default toolchain %s with non-default arguments" % (name))
        error("note: to fix this, add a suffix")

    if name != "system":
        if not name in CTOOLCHAINS:
            raise Exception("No such C toolchain available")
        
        return CTOOLCHAINS[name](suffix, c_args, ld_args)

    for t in CTOOLCHAINS.values():
        try:
            return t(suffix, c_args, ld_args)
        except:
            pass
    
    raise Exception("No C toolchain found on system")

global cc, exe, lib, shlib
cc, exe, lib, shlib = CToolchain()

def find_one(names):
    for name in names:
        program = find_program(name, required=False)
        if program:
            return name
    return None

def subdir(dir):
    # Save the previous location
    PWD = Path.cwd()
    
    # Go into subdir
    sub = PWD / dir
    os.chdir(sub)
    
    # Set helper path
    CWD = Path.cwd().relative_to(ROOT)
    exec(open('.build').read())
    
    # Revert the current directory;
    os.chdir(PWD)

subdir(".")

def gen_bld():
    return [target.path.parent.mkdir(parents=True, exist_ok=True)
        for target in File.fdb.values()
        if issubclass(type(target), Target)]

def gen_makefile():
    out = [mach.gen_makefile() + "\n" for mach in Processor.mdb.values()]
    out += ["\n\n" + target.gen_makefile() for target in File.fdb.values() if issubclass(type(target), Target)]
    
    return "".join(out)
    
def gen_ninja():
    out = [mach.gen_ninja() + "\n" for mach in Processor.mdb.values()]
    out += [target.gen_ninja() + "\n" for target in File.fdb.values() if issubclass(type(target), Target)]
    
    return "".join(out)

parser = argparse.ArgumentParser(description="cook build system")
parser.add_argument("-G", type=str, metavar="backend", help="Backend to generate for: ninja or makefile")
args = parser.parse_args()

backend = "ninja"
if args.G:
    backend = args.G

gen_bld()
open(ROOT / BUILD / ".gitignore", "w").write("*")
if backend == "ninja":
    open(ROOT / 'build.ninja', 'w').write(gen_ninja())
elif backend == "makefile":
    open(ROOT / 'makefile', 'w').write(gen_makefile())
else:
    print("No such backend %s" % (backend))