Library and program objects can be serialised.

3 files changed, 68 insertions, 33 deletions

diff --git a/backends.py b/backends.py
index 0de3ff4..cf116a2 100755
--- a/backends.py
+++ b/backends.py
@@ -143,8 +143,7 @@ class Backend():
         if isinstance(target, interpreter.SharedLibrary):
             commands += compiler.get_pic_flags()
         for dep in target.get_external_deps():
-            if isinstance(dep, environment.Dependency):
-                commands += dep.get_compile_flags()
+            commands += dep.get_compile_flags()
         return commands
 
     def build_target_link_arguments(self, deps):
@@ -538,10 +537,7 @@ class NinjaBackend(Backend):
         else:
             raise RuntimeError('Unknown build target type.')
         for dep in target.get_external_deps():
-            if isinstance(dep, environment.Dependency):
-                commands += dep.get_link_flags()
-            else:
-                commands.append(dep.get_filename())
+            commands += dep.get_link_flags()
         dependencies = target.get_dependencies()
         commands += self.build_target_link_arguments(dependencies)
         if self.environment.coredata.coverage:
diff --git a/environment.py b/environment.py
index e32b7e5..c0b1c03 100755
--- a/environment.py
+++ b/environment.py
@@ -509,7 +509,37 @@ class PkgConfigDependency(Dependency):
     def found(self):
         return self.is_found
 
-# Fixme, move to environment.
+class ExternalProgram():
+    def __init__(self, name, fullpath=None):
+        self.name = name
+        self.fullpath = fullpath
+
+    def found(self):
+        return self.fullpath is not None
+
+    def get_command(self):
+        return self.fullpath
+
+    def get_name(self):
+        return self.name
+
+class ExternalLibrary(Dependency):
+    def __init__(self, name, fullpath=None):
+        Dependency.__init__(self)
+        self.name = name
+        self.fullpath = fullpath
+
+    def found(self):
+        return self.fullpath is not None
+
+    def get_name(self):
+        return self.name
+    
+    def get_link_flags(self):
+        if self.found():
+            return [self.fullpath]
+        return []
+
 def find_external_dependency(name, kwargs):
     required = kwargs.get('required', False)
     return PkgConfigDependency(name, required)
diff --git a/interpreter.py b/interpreter.py
index f9c566a..d745719 100755
--- a/interpreter.py
+++ b/interpreter.py
@@ -39,43 +39,50 @@ class InterpreterObject():
             return self.methods[method_name](args, kwargs)
         raise InvalidCode('Unknown method "%s" in object.' % method_name)
 
-class ExternalProgram(InterpreterObject):
-    def __init__(self, name, fullpath=None):
-        InterpreterObject.__init__(self)
-        self.name = name
-        self.fullpath = fullpath
-        #self.methods.update({'found': self.found_method})
+# Interpreter objects can not be pickled so we must have
+# these wrappers.
 
-    def found(self):
-        return self.fullpath is not None
+class ExternalProgramHolder(InterpreterObject):
+    def __init__(self, ep):
+        InterpreterObject.__init__(self)
+        self.ep = ep
+        self.methods.update({'found': self.found_method})
 
     def found_method(self, args, kwargs):
         return self.found()
 
+    def found(self):
+        return self.ep.found()
+
     def get_command(self):
-        return self.fullpath
+        return self.ep.fullpath
 
     def get_name(self):
-        return self.name
+        return self.ep.name
 
-class ExternalLibrary(InterpreterObject):
-    def __init__(self, name, fullpath=None):
+class ExternalLibraryHolder(InterpreterObject):
+    def __init__(self, el):
         InterpreterObject.__init__(self)
-        self.name = name
-        self.fullpath = fullpath
-        #self.methods.update({'found': self.found_method})
+        self.el = el
+        self.methods.update({'found': self.found_method})
 
     def found(self):
-        return self.fullpath is not None
+        return self.el.found()
 
     def found_method(self, args, kwargs):
         return self.found()
 
     def get_filename(self):
-        return self.fullpath
+        return self.el.fullpath
 
     def get_name(self):
-        return self.name
+        return self.el.name
+    
+    def get_compile_flags(self):
+        return self.el.get_compile_flags()
+    
+    def get_link_flags(self):
+        return self.el.get_link_flags()
 
 class Generator(InterpreterObject):
 
@@ -84,7 +91,7 @@ class Generator(InterpreterObject):
         if len(args) != 1:
             raise InvalidArguments('Generator requires one and only one positional argument')
         if not isinstance(args[0], Executable) and \
-           not isinstance(args[0], ExternalProgram):
+           not isinstance(args[0], ExternalProgramHolder):
             raise InvalidArguments('First generator argument must be an executable object.')
         self.exe = args[0]
         self.methods.update({'process' : self.process_method})
@@ -369,7 +376,7 @@ class BuildTarget(InterpreterObject):
     def add_external_deps(self, deps):
         for dep in deps:
             if not isinstance(dep, environment.Dependency) and\
-               not isinstance(dep, ExternalLibrary):
+               not isinstance(dep, ExternalLibraryHolder):
                 raise InvalidArguments('Argument is not an external dependency')
             self.external_deps.append(dep)
 
@@ -638,10 +645,11 @@ class Interpreter():
         exename = args[0]
         if exename in self.coredata.ext_progs and\
            self.coredata.ext_progs[exename].found():
-            return self.coredata.ext_progs[exename]
+            return ExternalProgramHolder(self.coredata.ext_progs[exename])
         result = shutil.which(exename) # Does .exe appending on Windows.
-        progobj = ExternalProgram(exename, result)
-        self.coredata.ext_progs[exename] = progobj
+        extprog = environment.ExternalProgram(exename, result)
+        progobj = ExternalProgramHolder(extprog)
+        self.coredata.ext_progs[exename] = extprog
         if required and not progobj.found():
             raise InvalidArguments('Line %d: program "%s" not found.' % (node.lineno(), exename))
         return progobj
@@ -654,10 +662,11 @@ class Interpreter():
         libname = args[0]
         if libname in self.coredata.ext_libs and\
            self.coredata.ext_libs[libname].found():
-            return self.coredata.ext_progs[libname]
+            return ExternalLibraryHolder(self.coredata.ext_progs[libname])
         result = self.environment.find_library(libname)
-        libobj = ExternalLibrary(libname, result)
-        self.coredata.ext_libs[libname] = libobj
+        extlib = environment.ExternalLibrary(libname, result)
+        libobj = ExternalLibraryHolder(extlib)
+        self.coredata.ext_libs[libname] = extlib
         if required and not libobj.found():
             raise InvalidArguments('Line %d: external library "%s" not found.' % (node.lineno(), libname))
         return libobj