cook: rename classes

1 files changed, 37 insertions, 61 deletions

diff --git a/cook.py b/cook.py
index 9a0d66d..2c10e6b 100755
--- a/cook.py
+++ b/cook.py
@@ -49,13 +49,13 @@ C_COMPILERS = {
 }
 
 C_LINKERS = {
-    'gcc': lambda: Machine(
+    'gcc': lambda: Processor(
         "ld-gcc",
         find_program("gcc"),
         lambda o, i, ea: "-o %s %s %s" % (o, i, ea),
         lambda o, i, cmd: "LD %s" % (o)
     ),
-    'clang': lambda: Machine(
+    'clang': lambda: Processor(
         "ld-clang",
         find_program("clang"),
         lambda o, i, ea: "-o %s %s %s" % (o, i, ea),
@@ -113,12 +113,12 @@ class File(metaclass = FileMeta):
     def resolve(*args):
         return [File(file) for file in flatten(args)]
 
-class Process(File):
-    def __init__(self, path, machine, inputs, extra_args = []):
+class Target(File):
+    def __init__(self, path, processor, inputs, extra_args = []):
         super().__init__(path)
         
         # The generator that created this process
-        self.machine = machine
+        self.processor = processor
         
         # The inputs
         self.inputs = inputs
@@ -127,15 +127,15 @@ class Process(File):
         self.extra_args = extra_args
     
     def gen_makefile(self):
-        return self.machine.gen_proc_makefile(self)
+        return self.processor.gen_target_makefile(self)
     
     def gen_ninja(self):
-        return self.machine.gen_proc_ninja(self)
+        return self.processor.gen_target_ninja(self)
 
-class MachineMeta(type):
+class ProcessorMeta(type):
     def __call__(cls, name, *rest, **krest):
         # If already a file, return it
-        if issubclass(type(name), Machine):
+        if issubclass(type(name), Processor):
             return name
     
         if name in cls.mdb:
@@ -146,11 +146,11 @@ class MachineMeta(type):
         cls.mdb[name] = obj
         return obj
 
-class Machine(metaclass = MachineMeta):
+class Processor(metaclass = ProcessorMeta):
     mdb = dict()
 
     def __init__(self, name, exe, mkargs, desc=DEFDESC):
-        # The name of the machine
+        # The name of the processor
         self.name = name
         
         # Executable used in the process
@@ -169,13 +169,13 @@ class Machine(metaclass = MachineMeta):
         inputs = File.resolve(args)
         path = BUILD / Path.cwd().relative_to(ROOT) / name
         
-        return Process(path, self, inputs, extra_args)
+        return Target(path, self, inputs, extra_args)
     
-    def gen_proc_makefile(self, proc):
-        inputs = " ".join([str(x) for x in proc.inputs])
-        extra_args = " ".join([x for x in proc.extra_args])
+    def gen_target_makefile(self, target):
+        inputs = " ".join([str(x) for x in target.inputs])
+        extra_args = " ".join([x for x in target.extra_args])
 
-        out = "%s: %s\n" % (proc.path, inputs)
+        out = "%s: %s\n" % (target.path, inputs)
         out += "\t@$(%s) %s\n" % (self.name, self.mkargs("$@", inputs, extra_args))
         out += "\t@echo '%s'" % (self.desc("$@", inputs, extra_args))
         
@@ -184,12 +184,12 @@ class Machine(metaclass = MachineMeta):
     def gen_makefile(self):
         return "%s = %s" % (self.name, self.exe)
 
-    def gen_proc_ninja(self, proc):
-        inputs = " ".join([str(x) for x in proc.inputs])
+    def gen_target_ninja(self, target):
+        inputs = " ".join([str(x) for x in target.inputs])
         
-        out = "build %s: %s %s" % (proc.path, self.name, inputs)
-        if proc.extra_args != []:
-            extra_args = " ".join([x for x in proc.extra_args])
+        out = "build %s: %s %s" % (target.path, self.name, inputs)
+        if target.extra_args != []:
+            extra_args = " ".join([x for x in target.extra_args])
             out += "\n  extra = %s" % (extra_args)
             
         return out
@@ -203,7 +203,7 @@ class Machine(metaclass = MachineMeta):
         out += "  description = %s\n" % (self.desc("$out", "$in", cmd))
         return out
 
-class Vec(Machine):
+class Vec(Processor):
     def __init__(self, name, exe, mkargs, mkout, desc=DEFDESC):
         super().__init__(name, exe, mkargs, desc=desc)
         self.mkout = wrap_lambda(mkout)
@@ -215,13 +215,13 @@ class Vec(Machine):
         args = File.resolve(args)
         extra_args = flatten(extra_args)
         
-        procs = []
+        targets = []
         for i in args:
             path = BUILD / i.path.parent / self.mkout(i.path)
 
-            procs.append(Process(path, self, [i], extra_args))
+            targets.append(Target(path, self, [i], extra_args))
 
-        return procs
+        return targets
 
 class CC(Vec):
     def __init__(self, name, exe, mkargs, mkout, mkinc, mkdep=None, depstyle=None, desc=DEFDESC):
@@ -253,12 +253,12 @@ class CC(Vec):
         
         return out
         
-    def gen_proc_makefile(self, proc):
-        out = super().gen_proc_makefile(proc)
+    def gen_target_makefile(self, target):
+        out = super().gen_target_makefile(target)
         out += "\n"
 
         if self.mkdep and self.depstyle == "gcc":
-            out += "-include %s\n" % self.mkdep(proc.path)
+            out += "-include %s\n" % self.mkdep(target.path)
         elif self.mkdep:
             raise Exception("makefile dependencies for selected depstyle is unimplemented")
         
@@ -298,45 +298,21 @@ def subdir(dir):
 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)
+    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 = ""
-    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 = [mach.gen_makefile() + "\n" for mach in Processor.mdb.values()]
+    out += ["\n" + target.gen_makefile() for target in File.fdb.values() if issubclass(type(target), Target)]
     
-    out += "\n.PHONY: clean\nclean:\n\trm -f %s" % (all)
-    return out
+    return "".join(out)
     
 def gen_ninja():
-    out = ""
-    for mach in Machine.mdb.values():
-        out += mach.gen_ninja()
-        out += "\n"
-
-    for proc in File.fdb.values():
-        if not issubclass(type(proc), Process):
-            continue
-        
-        out += proc.gen_ninja()
-        out += "\n"
+    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 out
+    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")