Can build shared libraries.

environment.py

@@ -41,15 +41,21 @@ class CCompiler():
     def get_debug_flags(self):
         return ['-g']
     
-    def get_std_link_flags(self):
+    def get_std_exe_link_flags(self):
         return []
 
+    def get_std_shared_lib_link_flags(self):
+        return ['-shared']
+
     def can_compile(self, filename):
         suffix = filename.split('.')[-1]
         if suffix == 'c' or suffix == 'h':
             return True
         return False
     
+    def get_pic_flags(self):
+        return ['-fPIC']
+
     def name_string(self):
         return ' '.join(self.exelist)
     

interpreter.py

@@ -67,6 +67,9 @@ class Executable(BuildTarget):
 class StaticLibrary(BuildTarget):
     pass
 
+class SharedLibrary(BuildTarget):
+    pass
+
 class Interpreter():
 
     def __init__(self, code, environment):
@@ -155,36 +158,32 @@ class Interpreter():
             else:
                 raise InvalidCode('Tried to use unknown language "%s".' % lang)
 
-    def func_executable(self, node, args):
-        for a in args:
-            if not isinstance(a, str):
-                raise InvalidArguments('Line %d: Argument %s is not a string.' % (node.lineno(), str(a)))
-        name = args[0]
-        sources = args[1:]
-        if name in self.targets:
-            raise InvalidCode('Line %d, tried to create executable "%s", but a build target of that name already exists.' % (node.lineno(), name))
-        exe = Executable(name, sources)
-        self.targets[name] = exe
-        print('Creating executable %s with %d files.' % (name, len(sources)))
-        return exe
-    
     def func_find_dep(self, node, args):
         self.validate_arguments(args, 1, [str])
         name = args[0]
         dep = environment.find_external_dependency(name)
         return dep
-    
+
+    def func_executable(self, node, args):
+        return self.build_target(node, args, Executable)
+
     def func_static_lib(self, node, args):
+        return self.build_target(node, args, StaticLibrary)
+
+    def func_shared_lib(self, node, args):
+        return self.build_target(node, args, SharedLibrary)
+
+    def build_target(self, node, args, targetclass):
         for a in args:
             if not isinstance(a, str):
                 raise InvalidArguments('Line %d: Argument %s is not a string.' % (node.lineno(), str(a)))
         name= args[0]
         sources = args[1:]
         if name in self.targets:
-            raise InvalidCode('Line %d: tried to create static library "%s", but a target of that name already exists.' % (node.lineno(), name))
-        l = StaticLibrary(name, sources)
+            raise InvalidCode('Line %d: tried to create target "%s", but a target of that name already exists.' % (node.lineno(), name))
+        l = targetclass(name, sources)
         self.targets[name] = l
-        print('Creating static library "%s" with %d files.' % (name, len(sources)))
+        print('Creating build target "%s" with %d files.' % (name, len(sources)))
         return l
 
     def function_call(self, node):
@@ -202,6 +201,8 @@ class Interpreter():
             return self.func_find_dep(node, args)
         elif func_name == 'static_library':
             return self.func_static_lib(node, args)
+        elif func_name == 'shared_library':
+            return self.func_shared_lib(node, args)
         else:
             raise InvalidCode('Unknown function "%s".' % func_name)
 

shellgenerator.py

@@ -58,6 +58,8 @@ class ShellGenerator():
         commands += compiler.get_debug_flags()
         commands += compiler.get_std_warn_flags()
         commands += compiler.get_compile_only_flags()
+        if isinstance(target, interpreter.SharedLibrary):
+            commands += compiler.get_pic_flags()
         for dep in target.get_external_deps():
             commands += dep.get_compile_flags()
         commands.append(abs_src)
@@ -75,7 +77,14 @@ class ShellGenerator():
             linker = self.interpreter.compilers[0] # Fixme.
         commands = []
         commands += linker.get_exelist()
-        commands += linker.get_std_link_flags()
+        if isinstance(target, interpreter.Executable):
+            commands += linker.get_std_exe_link_flags()
+        elif isinstance(target, interpreter.SharedLibrary):
+            commands += linker.get_std_shared_lib_link_flags()
+        elif isinstance(target, interpreter.StaticLibrary):
+            commands += linker.get_std_link_flags()
+        else:
+            raise RuntimeError('Unknown build target type.')
         for dep in target.get_external_deps():
             commands += dep.get_link_flags()
         commands += linker.get_output_flags()
@@ -96,12 +105,16 @@ class ShellGenerator():
             target = i[1]
             print('Generating target', name)
             targetdir = self.get_target_dir(target)
+            prefix = ''
+            suffix = ''
             if isinstance(target, interpreter.Executable):
-                prefix = ''
                 suffix = self.environment.get_exe_suffix()
             elif isinstance(target, interpreter.StaticLibrary):
                 prefix = self.environment.get_static_lib_prefix()
                 suffix = self.environment.get_static_lib_suffix()
+            elif isinstance(target, interpreter.SharedLibrary):
+                prefix = self.environment.get_shared_lib_prefix()
+                suffix = self.environment.get_shared_lib_suffix()
             outname = os.path.join(targetdir, prefix + target.get_basename())
             if suffix != '':
                 outname = outname + '.' + suffix
@@ -116,7 +129,7 @@ if __name__ == '__main__':
     language('c')
     executable('prog', 'prog.c', 'dep.c')
     """
-    import interpreter, environment
+    import environment
     os.chdir(os.path.split(__file__)[0])
     envir = environment.Environment('.', 'work area')
     intpr = interpreter.Interpreter(code, envir)

test cases/4 shared/builder.txt

@@ -0,0 +1,3 @@
+project('shared library test')
+language('c')
+lib = shared_library('mylib', 'libfile.c')

test cases/4 shared/libfile.c

@@ -0,0 +1,3 @@
+int libfunc() {
+    return 3;
+}