path: root/cook.py

#!/usr/bin/python

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


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)

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

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_inner(tgt, arg):
        if type(arg) == list or type(arg) == tuple:
            for a in arg:
                File.resolve_inner(tgt, a)
        elif type(arg) == str:
            tgt.append(File(arg))
        elif issubclass(type(arg), File):
            tgt.append(arg)
        
    def resolve(*args):
        tgt = []
        for a in args:
            File.resolve_inner(tgt, a)
        return tgt

class Process(File):
    def __init__(self, path, machine, inputs, extra_args = None):
        super().__init__(path)
        
        # The generator that created this process
        self.machine = machine
        
        # The inputs
        self.inputs = 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 = self.extra_args if self.extra_args else ""

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

        return out

class MachineMeta(type):
    def __call__(cls, name, *rest, **krest):
        # If already a file, return it
        if issubclass(type(name), Machine):
            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 Machine(metaclass = MachineMeta):
    mdb = dict()

    def __init__(self, name, exe, mkargs, desc=DEFDESC):
        # The name of the machine
        self.name = name
        
        # Executable used in the process
        self.exe = File(exe)
        
        # The arguments that is used to launch the process
        self.mkargs = mkargs
        
        # The description
        self.desc = desc

    def __call__(self, name, *args, extra_args=None):
        return self.gen(name, *args, extra_args=extra_args)
    
    def gen(self, name, *args, extra_args=None):
        inputs = File.resolve(args)
        path = BUILD / Path.cwd().relative_to(ROOT) / name
        
        return Process(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" % (self.desc("$out", "$in", cmd))
        return out

class Vec(Machine):
    def __init__(self, name, exe, args, mkout, desc=DEFDESC):
        super().__init__(name, exe, args, desc=desc)
        self.mkout = mkout
    
    def __call__(self, *args, extra_args=None):
        return self.gen(*args, extra_args=extra_args)
    
    def gen(self, *args, extra_args=None):
        procs = []
        inputs = File.resolve(args)
        for i in inputs:
            path = BUILD / i.path.parent / self.mkout(i.path)

            procs.append(Process(path, self, [i], extra_args))

        return procs

def find_compiler(compilers):
    for c in compilers:
        cc = find_program(c, required=False)
        if cc:
            return cc
    return None

c_compiler = find_compiler(["cc", "gcc", "clang", "clang.exe", "clang-cl.exe", "cl.exe"])

cc = Vec(
    "cc",
    c_compiler,
    lambda o, i, ea: "-o %s -c %s %s" % (o, i, ea),
    lambda i: i.name + ".o",
    desc=lambda o, i, ea: "CC %s" % (o), 
)
ld = Machine(
    "ld",
    c_compiler,
    lambda o, i, ea: "-o %s %s %s" % (o, i, ea),
    desc=lambda o, i, ea: "LD %s" % (o)
)

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():
    for proc in File.fdb.values():
        if not issubclass(type(proc), Process):
            continue
        proc.path.parent.mkdir(parents=True, exist_ok=True)

def gen_makefile():
    out = ""
    for mach in Machine.mdb.values():
        out += mach.gen_makefile()
        out += "\n"
    
    all = []
    for proc in File.fdb.values():
        if not issubclass(type(proc), Process):
            continue

        out += "\n"
        out += proc.gen_makefile()
        out += "\n"
        all.append(str(proc))
    all = " ".join(all)
    
    out += "\n.PHONY: clean\nclean:\n\trm -f %s" % (all)
    return out
    
def gen_ninja():
    out = ""
    for mach in Machine.mdb.values():
        out += mach.gen_ninja()
        out += "\n"

    out += "\n"

    for proc in File.fdb.values():
        if not issubclass(type(proc), Process):
            continue
        
        out += proc.gen_ninja()
        out += "\n"
    
    return out
    
# Generate everything
gen_bld()
open(ROOT / BUILD / ".gitignore", "w").write("*")
open(ROOT / 'build.ninja', 'w').write(gen_ninja())