path: root/cook.py

#!/usr/bin/python

import subprocess
import sys
import os
from pathlib import Path
from threading import local
import shutil
import argparse
from xml.etree.ElementInclude import include

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

class ProgramNotFoundException(Exception):
    pass

def find_program(prog, required=True):
    path = shutil.which(prog)
    if path == None and required:
        raise ProgramNotFoundException(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

            header_depends = []
            if self.mkdep:
                header_depends += [BUILD / self.mkdep(out)]

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

        return targets

    def gen_ninja(self):
        out = super().gen_ninja()

        if self.depstyle == "gcc":
            out += "  deps = gcc\n"
        elif self.depstyle == "msvc":
            out += "  deps = msvc\n"
        else:
            raise Exception("ninja dependencies for selected depstyle is unimplemented")

        if self.mkdep and self.depstyle == "gcc":
            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 -Wl,--start-group %s -Wl,--end-group %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 -Wl,--start-group %s -Wl,--end-group %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)

def MSVCStyleToolchain(name, gccname, arname, ldname, 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))

    cl = find_program(gccname)
    lib = find_program(arname)
    link = find_program(ldname)

    cc = CC(
        name=ccname,
        exe=cl,
        mkargs=lambda o, i, ea: "/showIncludes /nologo /D_USRDLL /D_WINDLL /Fo%s /c %s /MT %s %s" % (o, i, c_args, ea),
        mkout=lambda i: "%s.obj" % (i),
        mkinc=lambda inc: "/I%s" % (inc),
        mkdesc=lambda o, i, cmd: "CC %s" % (o),
        depstyle="msvc"
    )
    exe = CExe(
        name=exename,
        exe=link,
        mkargs=lambda o, i, ea: "/NOLOGO /OUT:%s %s %s %s" % (o, i, ld_args, ea),
        mklib=lambda l: l,
        mkdesc=lambda o, i, cmd: "LD %s" % (o),
        mkout=lambda n: "%s.exe" % (n),
    )
    lib = CExe(
        name=libname,
        exe=lib,
        mkargs=lambda o, i, ea: "/NOLOGO /OUT:%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.lib" % (n)
    )
    shlib = CExe(
        name=shlibname,
        exe=cl,
        mkargs=lambda o, i, ea: "/nologo /D_USRDLL /D_WINDLL %s /MT /link /DLL /OUT:%s.dll /IMPLIB:%s %s %s" % (i, o, o, ld_args, ea),
        mklib=lambda l: "", # TODO: make this not needed, or perhaps yes by adding .lib but this seems weird
        mkdesc=lambda o, i, cmd: "SO %s" % (o),
        mkout=lambda n: "%s.lib" % (n)
    )
    return cc, exe, lib, shlib

def MSVCToolchain(suffix="", c_args=[], ld_args=[]):
    return MSVCStyleToolchain("msvc", "cl", "lib", "link", suffix, c_args, ld_args)
    
def ClangClToolchain(suffix="", c_args=[], ld_args=[]):
    # This toolchain depends on lib.exe shipped by microsoft. Is there a llvm way?
    return MSVCStyleToolchain("clang-cl", "clang-cl", "lib", "lld-link", suffix, c_args, ld_args)

CTOOLCHAINS = {
    'msvc': MSVCToolchain,
    'clang-cl': ClangClToolchain,
    '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 ProgramNotFoundException as e:
            continue
        except Exception as e:
            raise e

    raise Exception("No C toolchain found on system")

# NOTE: this implementation is very simple and bad but does what
#       i need
class CModule:
    def __init__(self, name, cc, exe, lib, shlib, root = None):
        self.name = name
        
        # The toolchain that the module uses
        self.cc = cc
        self.exe = exe
        self.lib = lib
        self.shlib = shlib
        
        # The root module. Is this needed?
        self.root = root
        
        # Executables instanciated by the module. Add shared libraries when applicable
        self.exes = dict()
        # Submodules instanciated by the module
        self.submodules = dict()
        
        # Objects accumulator
        self.objects = []
        
        # Private includes, libs and args
        self.includes = []
        self.libs = []
        self.ld_args = []
        self.cc_args = []
        
        # Shared includes, libs and args
        self.shared_includes = []
        self.shared_libs = []
        self.bcast_includes = []
        self.shared_ld_args = []
        self.shared_cc_args = []

    def eval(self):
        subdir(self.name)
    
    def submodule(self, name, toolchain = None):
        global mod
        prev = mod
        
        root = self.root if self.root else self
        cc = prev.cc
        exe = prev.exe
        lib = prev.lib
        shlib = prev.shlib
        if toolchain:
            cc, exe, lib, shlib = toolchain
            root = None
        
        mod = CModule(name, cc, exe, lib, shlib, root)
        #if root == None:
        #    pass
        # XXX: FIX this "if", temporary and put this elsewhere
        mod.includes += self.bcast_includes
        mod.eval()
        
        # Perhaps store everything the object created
        self.link(mod)
        
        mod, prev = prev, mod
        
        mod.submodules[name] = prev
    
        return prev
    
    def mklib(self):
        if self.objects == [] or self.lib == None:
            return None
        return self.lib(self.name, self.objects)
    
    def link(self, *mods):
        mods = flatten(mods)
        
        for mod in mods:
            if type(mod) == str:
                mod = CDependency(mod)
        
            obj = mod.mklib()
            if obj:
                self.objects += [obj]
            self.shared_includes += mod.shared_includes
            self.shared_libs += mod.shared_libs
            self.bcast_includes += mod.bcast_includes
            self.shared_ld_args += mod.shared_ld_args
            self.shared_cc_args += mod.shared_cc_args
    
    def src(self, *args, extra_args = [], include_dirs = []):
        obj = self.cc(*args, extra_args = [extra_args, self.cc_args, self.shared_cc_args], include_dirs = [include_dirs, self.includes, self.bcast_includes, self.shared_includes])
        self.objects += obj
    
    def mkdep(self, shared_includes = [], shared_libs = [], bcast_includes = [], shared_ld_args = [], shared_cc_args = []):
        self.shared_includes += flatten(shared_includes)
        self.shared_libs += flatten(shared_libs)
        self.shared_ld_args += flatten(shared_ld_args)
        self.shared_cc_args += flatten(shared_cc_args)
        self.bcast_includes += flatten(bcast_includes)
    
    def mkexe(self, name, extra_args = [], libs = []):
        self.exes[name] = self.exe(name, self.objects, extra_args = [extra_args, self.ld_args, self.shared_ld_args], libs = [libs, self.libs, self.shared_libs])
        return self.exes[name]

pkgconfig = find_program("pkg-config", False)

def subproc(*args, **kwargs):
    return subprocess.check_output(*args, **kwargs, stderr=subprocess.DEVNULL)

# XXX: make name a variadic
def CDependency(name):
    #if type(name) == list or type(name) is tuple:
    #    return [CDependency(n) for n in name]

    module = CModule(name, None, None, None, None, None)

    if pkgconfig:
        try:
            inc = subproc([pkgconfig.path, "--cflags", name]).strip().decode("utf-8")
            lib = subproc([pkgconfig.path, "--libs", name]).strip().decode("utf-8")
            module.mkdep(shared_ld_args = lib, shared_cc_args = inc)
            return module
        except subprocess.CalledProcessError:
            pass
    
    #if prog:
    # XXX: pkg-config
    # XXX: windows stuff

    # Use the system way of getting to know libraries (no includes specified)
    module.mkdep(shared_libs = name)
    return module
    

cc, exe, lib, shlib = CToolchain()

global root, mod
root = CModule("root", cc, exe, lib, shlib)
mod = root

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
    global CWD
    CWD = Path.cwd().relative_to(ROOT)
    exec(open('.build').read(), globals())

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