Add basic support for building C via swiftpm. As of now assumes module.modulemap will be available inside a include directory, doesn't generates it automatically. Also creates only shared libraries and not executable for now.

aciidgh · aciidgh · commit 7e285fa86761 · 2016-03-09T20:03:50.000+05:30
diff --git a/Sources/Build/describe().swift b/Sources/Build/describe().swift
@@ -103,6 +103,40 @@ public func describe(prefix: String, _ conf: Configuration, _ modules: [Module],
         }
     }
 
+    //For C language Modules
+    //FIXME: Probably needs more compiler options for debug and release modes
+    //FIXME: Incremental builds
+    //FIXME: Add support for executables
+    for case let module as CLangModule in modules {
+        let inputs = module.dependencies.map{ $0.targetName } + module.sources.paths
+        let productPath = Path.join(prefix, "\(module.c99name).o")
+        let wd = Path.join(prefix, "\(module.c99name).build")
+        mkdirs.insert(wd)
+        
+        var args: [String] = []
+        args += ["-fmodules", "-fmodule-name=\(module.name)"]
+        args += ["-fmodule-map-file=\(module.moduleMapPath)", "-working-directory", Path.join(prefix, "\(module.c99name).build")]
+        
+        switch conf {
+        case .Debug:
+            args += ["-g", "-O0"]
+        case .Release:
+            args += ["-O2"]
+        }
+        
+        args += module.sources.paths
+        args += ["-shared", "-o", Path.join(prefix, "lib\(module.c99name).so")]
+
+        let clang = ShellTool(
+            description: "Compiling \(module.name)",
+            inputs: inputs,
+            outputs: [productPath, module.targetName],
+            args: [Resources.path.clang] + args)
+        
+        let command = Command(name: module.targetName, tool: clang)
+        append(command, buildable: module)
+    }
+    
     // make eg .build/debug/foo.build/subdir for eg. Sources/foo/subdir/bar.swift
     // TODO swift-build-tool should do this
     for dir in mkdirs {
@@ -171,6 +205,7 @@ public func describe(prefix: String, _ conf: Configuration, _ modules: [Module],
         }
         args += platformArgs() //TODO don't need all these here or above: split outname
         args += Xld
+        args += ["-L\(prefix)"]
         args += ["-o", outpath]
         args += objects
 
diff --git a/Sources/Build/misc.swift b/Sources/Build/misc.swift
@@ -32,6 +32,8 @@ extension Module {
             if let module = module as? CModule {
                 let moduleMapPath = Path.join(module.path, "module.modulemap")
                 return ["-Xcc", "-fmodule-map-file=\(moduleMapPath)"]
+            } else if let cmodule = module as? CLangModule {
+                return ["-Xcc", "-fmodule-map-file=\(cmodule.moduleMapPath)"]
             } else {
                 return []
             }
diff --git a/Sources/PackageType/Module.swift b/Sources/PackageType/Module.swift
@@ -70,6 +70,18 @@ public class CModule: Module {
     }
 }
 
+public class CLangModule: Module {
+    public let sources: Sources
+    public let moduleMapPath: String
+    
+    public init(name: String, sources: Sources) {
+        self.sources = sources
+        //TODO: generate this with swiftpm if layout supports
+        moduleMapPath = sources.root + "/include/module.modulemap"
+        super.init(name: name)
+    }
+}
+
 public class TestModule: SwiftModule {
 
     public init(basename: String, sources: Sources) {
diff --git a/Sources/PackageType/Sources.swift b/Sources/PackageType/Sources.swift
@@ -11,6 +11,11 @@
 import Utility
 
 public struct Sources {
+
+    static public var validExtensions: [String] {
+        return [".swift", ".c"]
+    }
+
     public let relativePaths: [String]
     public let root: String
 
diff --git a/Sources/Transmute/Error.swift b/Sources/Transmute/Error.swift
@@ -26,5 +26,6 @@ extension Package {
 extension Module {
     public enum Error: ErrorType {
         case NoSources(String)
+        case MixedSources(String)
     }
 }
diff --git a/Sources/Transmute/Package+modules.swift b/Sources/Transmute/Package+modules.swift
@@ -38,19 +38,28 @@ extension Package {
         let modules: [Module]
         if maybeModules.isEmpty {
             do {
-                modules = [SwiftModule(name: self.name, sources: try sourcify(srcroot))]
+                let sourcified = try sourcify(srcroot)
+                if sourcified.isSwiftModule {
+                    modules = [SwiftModule(name: self.name, sources: sourcified.sources)]
+                } else {
+                    modules = [CLangModule(name: self.name, sources: sourcified.sources)]
+                }
+                
             } catch Module.Error.NoSources {
                 throw ModuleError.NoModules(self)
             }
         } else {
-            modules = try maybeModules.map(sourcify).map { sources in
+            modules = try maybeModules.map(sourcify).map { sourcified in
                 let name: String
-                if sources.root == srcroot {
+                if sourcified.sources.root == srcroot {
                     name = self.name
                 } else {
-                    name = sources.root.basename
+                    name = sourcified.sources.root.basename
+                }
+                if sourcified.isSwiftModule {
+                    return SwiftModule(name: name, sources: sourcified.sources)
                 }
-                return SwiftModule(name: name, sources: sources)
+                return CLangModule(name: name, sources: sourcified.sources)
             }
         }
 
@@ -75,18 +84,26 @@ extension Package {
         return modules
     }
 
-    func sourcify(path: String) throws -> Sources {
+    func sourcify(path: String) throws -> (sources: Sources, isSwiftModule: Bool) {
         let sources = walk(path, recursing: shouldConsiderDirectory).filter(isValidSource)
         guard sources.count > 0 else { throw Module.Error.NoSources(path) }
-        return Sources(paths: sources, root: path)
+        let partioned = sources.partition { $0.hasSuffix(".swift") }
+        guard !(partioned.0.count > 0 && partioned.1.count > 0) else { throw Module.Error.MixedSources(path) }
+        return (sources: Sources(paths: sources, root: path), isSwiftModule: partioned.0.count > 0)
     }
 
     func isValidSource(path: String) -> Bool {
         if path.basename.hasPrefix(".") { return false }
         let path = path.normpath
         if path == manifest.path.normpath { return false }
         if excludes.contains(path) { return false }
-        return path.lowercaseString.hasSuffix(".swift") && path.isFile
+        if !path.isFile { return false }
+        for ext in Sources.validExtensions {
+            if path.lowercaseString.hasSuffix(ext) {
+                return true
+            }
+        }
+        return false
     }
 
     private func targetForName(name: String) -> Target? {
diff --git a/Sources/Transmute/Package+shouldConsiderDirectory.swift b/Sources/Transmute/Package+shouldConsiderDirectory.swift
@@ -15,6 +15,7 @@ extension Package {
     func shouldConsiderDirectory(path: String) -> Bool {
         let base = path.basename.lowercaseString
         if base == "tests" { return false }
+        if base.hasSuffix("include") { return false }
         if base.hasSuffix(".xcodeproj") { return false }
         if base.hasSuffix(".playground") { return false }
         if base.hasPrefix(".") { return false }  // eg .git
diff --git a/Sources/Transmute/Package+testModules.swift b/Sources/Transmute/Package+testModules.swift
@@ -17,8 +17,8 @@ extension Package {
         //Don't try to walk Tests if it is in excludes
         if testsPath.isDirectory && excludes.contains(testsPath) { return [] }
         return walk(testsPath, recursively: false).filter(shouldConsiderDirectory).flatMap { dir in
-            if let sources = try? self.sourcify(dir) {
-                return TestModule(basename: dir.basename, sources: sources)
+            if let sourcified = try? self.sourcify(dir) {
+                return TestModule(basename: dir.basename, sources: sourcified.sources)
             } else {
                 print("warning: no sources in test module: \(path)")
                 return nil
diff --git a/Sources/Transmute/fillModuleGraph().swift b/Sources/Transmute/fillModuleGraph().swift
@@ -20,6 +20,8 @@ func fillModuleGraph(packages: [Package], modulesForPackage: (Package) -> [Modul
                     return false
                 case let module as SwiftModule where module.type == .Library:
                     return true
+                case is CLangModule:
+                    return true
                 case is CModule:
                     return true
                 default:
diff --git a/Sources/Utility/Resources.swift b/Sources/Utility/Resources.swift
@@ -58,6 +58,10 @@ public final class Resources {
         public static var swiftc: String = {
             return getenv("SWIFT_EXEC") ?? Resources.findExecutable("swiftc")
         }()
+        
+        public static var clang: String = {
+            return getenv("CLANG_EXEC") ?? Resources.findExecutable("clang")
+        }()
 
         public static var swift_build_tool: String = {
             return getenv("SWIFT_BUILD_TOOL") ?? Resources.findExecutable("swift-build-tool")

Original file line number	Diff line number	Diff line change
`@@ -32,6 +32,8 @@ extension Module {`
`32`	`32`	`if let module = module as? CModule {`
`33`	`33`	`let moduleMapPath = Path.join(module.path, "module.modulemap")`
`34`	`34`	`return ["-Xcc", "-fmodule-map-file=\(moduleMapPath)"]`
	`35`	`+ } else if let cmodule = module as? CLangModule {`
	`36`	`+ return ["-Xcc", "-fmodule-map-file=\(cmodule.moduleMapPath)"]`
`35`	`37`	`} else {`
`36`	`38`	`return []`
`37`	`39`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,5 +26,6 @@ extension Package {`
`26`	`26`	`extension Module {`
`27`	`27`	`public enum Error: ErrorType {`
`28`	`28`	`case NoSources(String)`
	`29`	`+ case MixedSources(String)`
`29`	`30`	`}`
`30`	`31`	`}`