pkgconfig System Module Search Paths

Sources/Build/Buildable.swift

@@ -59,6 +59,30 @@ extension Module: Buildable {
     }
 }
 
+extension SwiftModule {
+    func pkgConfigArgs() throws -> [String] {
+        return try recursiveDependencies.flatMap { module -> [String] in
+            guard case let module as CModule = module, let pkgConfigName = module.pkgConfig else {
+                return []
+            }
+
+            do {
+                var pkgConfig = try PkgConfig(name: pkgConfigName)
+                try pkgConfig.load()
+                return pkgConfig.cFlags.map{["-Xcc", $0]}.flatten() + pkgConfig.libs
+            }
+            catch PkgConfigError.CouldNotFindConfigFile {
+                if let providers = module.providers,
+                    provider = SystemPackageProvider.providerForCurrentPlatform(providers: providers) {
+                    print("note: you may be able to install \(pkgConfigName) using your system-packager:\n")
+                    print(provider.installText)
+                }
+            }
+            return []
+        }
+    }
+}
+
 extension Product: Buildable {
     var isTest: Bool {
         if case .Test = type {

Sources/Build/Command.compile(SwiftModule).swift

@@ -14,8 +14,8 @@ import Utility
 extension Command {
     static func compile(swiftModule module: SwiftModule, configuration conf: Configuration, prefix: String, otherArgs: [String], SWIFT_EXEC: String) throws -> (Command, [Command]) {
 
-        let otherArgs = otherArgs + module.XccFlags(prefix)
-
+        let otherArgs = otherArgs + module.XccFlags(prefix) + (try module.pkgConfigArgs())
+        
         func cmd(_ tool: ToolProtocol) -> Command {
             return Command(node: module.targetName, tool: tool)
         }

Sources/Build/Command.link().swift

@@ -81,7 +81,11 @@ extension Command {
         case .Executable:
             args.append("-emit-executable")
         }
-
+
+        for module in product.modules {
+            args += try module.pkgConfigArgs()
+        }
+
         args += objects
 
         if case .Library(.Static) = product.type {

Sources/Build/PkgConfig.swift

@@ -0,0 +1,161 @@
+/*
+ This source file is part of the Swift.org open source project
+
+ Copyright 2015 - 2016 Apple Inc. and the Swift project authors
+ Licensed under Apache License v2.0 with Runtime Library Exception
+
+ See http://swift.org/LICENSE.txt for license information
+ See http://swift.org/CONTRIBUTORS.txt for Swift project authors 
+*/
+
+import Utility
+import func POSIX.getenv
+
+enum PkgConfigError: ErrorProtocol {
+    case CouldNotFindConfigFile
+}
+
+struct PkgConfig {
+    static let searchPaths = ["/usr/local/lib/pkgconfig",
+                              "/usr/local/share/pkgconfig",
+                              "/usr/lib/pkgconfig",
+                              "/usr/share/pkgconfig",
+                              // FIXME: These should only be searched for linux?
+                              "/usr/lib/x86_64-linux-gnu/pkgconfig",
+                              "/usr/local/lib/x86_64-linux-gnu/pkgconfig",
+                              ]
+
+    let name: String
+    let pcFile: String
+    var cFlags = [String]()
+    var libs = [String]()
+    private var parser: PkgConfigParser
+
+    init(name: String) throws {
+        self.name = name
+        self.pcFile = try PkgConfig.locatePCFile(name: name)
+        parser = PkgConfigParser(pcFile: pcFile)
+    }
+
+    static var envSearchPaths: [String] {
+        if let configPath = getenv("PKG_CONFIG_PATH") {
+            return configPath.characters.split(separator: ":").map(String.init)
+        }
+        return []
+    }
+
+    static func locatePCFile(name: String) throws -> String {
+        for path in (searchPaths + envSearchPaths) {
+            let pcFile = Path.join(path, "\(name).pc")
+            if pcFile.isFile {
+                return pcFile
+            }
+        }
+        throw PkgConfigError.CouldNotFindConfigFile
+    }
+
+    mutating func load() throws {
+        cFlags = [String]()
+        libs = [String]()
+        try parser.parse()
+        if let cFlags = parser.cFlags {
+            // FIXME: handle spaces in paths.
+            self.cFlags += cFlags.characters.split(separator: " ").map(String.init)
+        }
+        if let libs = parser.libs {
+            // FIXME: handle spaces in paths.
+            self.libs += libs.characters.split(separator: " ").map(String.init)
+        }
+
+        if(parser.dependencies.isEmpty) {
+            return
+        }
+
+        for dep in parser.dependencies {
+            var pkg = try PkgConfig(name: dep)
+            try pkg.load()
+            self.cFlags += pkg.cFlags
+            self.libs += pkg.libs
+        }
+    }
+}
+
+private struct PkgConfigParser {
+    let pcFile: String
+    var variables = [String: String]()
+    var dependencies = [String]()
+    var cFlags: String?
+    var libs: String?
+
+    enum Token {
+        case CFlats(String)
+        case Libs(String)
+        case Dependencies(String)
+        case Variable(name: String, value: String)
+    }
+
+    init(pcFile: String) {
+        self.pcFile = pcFile
+    }
+
+    mutating func parse() throws {
+        let file = File(path: self.pcFile)
+        for line in try file.enumerate() {
+            if !line.characters.contains(":") && line.characters.contains("=")  {
+                let equalsIndex = line.characters.index(of: "=")!
+                let name = line[line.startIndex..<equalsIndex]
+                let value = line[equalsIndex.successor()..<line.endIndex]
+                variables[name] = resolveVariables(value)
+            } else if line.hasPrefix("Requires: ") {
+                dependencies = parseDependencies(value(line: line))
+            } else if line.hasPrefix("Libs: ") {
+                libs = resolveVariables(value(line: line)).chomp()
+            } else if line.hasPrefix("Cflags: ") {
+                cFlags = resolveVariables( value(line: line)).chomp()
+            }
+        }
+    }
+
+    func parseDependencies(_ depString: String) -> [String] {
+        let exploded = depString.characters.split(separator: " ").map(String.init)
+        let operators = ["=", "<", ">", "<=", ">="]
+        var deps = [String]()
+        var skipNext = false
+        for depString in exploded {
+            if skipNext {
+                skipNext = false
+                continue
+            }
+            if operators.contains(depString) {
+                skipNext = true
+            } else {
+                deps.append(depString)
+            }
+        }
+        return deps
+    }
+
+    func resolveVariables(_ line: String) -> String {
+        func resolve(_ string: String) -> String {
+            var resolvedString = string
+            guard let dollar = resolvedString.characters.index(of: "$") else { return string }
+            guard let variableEndIndex = resolvedString.characters.index(of: "}") else {return string }
+            let variable = string[dollar.successor().successor()..<variableEndIndex]
+            let value = variables[variable]!
+            resolvedString = resolvedString[resolvedString.startIndex..<dollar] + value + resolvedString[variableEndIndex.successor()..<resolvedString.endIndex]
+            return resolvedString
+        }
+        var resolved = line
+        while resolved.characters.contains("$") {
+            resolved = resolve(resolved)
+        }
+        return resolved
+    }
+
+    func value(line: String) -> String {
+        guard let colonIndex = line.characters.index(of: ":") else {
+            return ""
+        }
+        return line[colonIndex.successor().successor()..<line.endIndex]
+    }
+}

Sources/Build/misc.swift

@@ -173,3 +173,41 @@ extension Product {
         return ((), plist: s)
     }
 }
+
+extension SystemPackageProvider {
+
+    var installText: String {
+        switch self {
+        case .Brew(let name):
+            return "    brew install \(name)\n"
+        case .Apt(let name):
+            return "    apt-get install \(name)\n"
+        }
+    }
+
+    static func providerForCurrentPlatform(providers: [SystemPackageProvider]) -> SystemPackageProvider? {
+        guard let uname = try? popen(["uname"]).chomp().lowercased() else { return nil }
+        switch uname {
+        case "darwin":
+            for provider in providers {
+                if case .Brew = provider {
+                    return provider
+                }
+            }
+        case "linux":
+            if "/etc/debian_version".isFile {
+                for provider in providers {
+                    if case .Apt = provider {
+                        return provider
+                    }
+                }
+            }
+            break
+
+        default:
+            return nil
+        }
+        return nil
+    }
+}
+

Sources/ManifestParser/fromTOML().swift

@@ -22,6 +22,11 @@ extension PackageDescription.Package {
         if case .String(let value)? = table.items["name"] {
             name = value
         }
+
+        var pkgConfig: String? = nil
+        if case .String(let value)? = table.items["pkgConfig"] {
+            pkgConfig = value
+        }
 
         // Parse the targets.
         var targets: [PackageDescription.Target] = []
@@ -30,7 +35,15 @@ extension PackageDescription.Package {
                 targets.append(PackageDescription.Target.fromTOML(item))
             }
         }
-
+
+        var providers: [PackageDescription.SystemPackageProvider]? = nil
+        if case .Array(let array)? = table.items["providers"] {
+            providers = []
+            for item in array.items {
+                providers?.append(PackageDescription.SystemPackageProvider.fromTOML(item))
+            }
+        }
+
         // Parse the dependencies.
         var dependencies: [PackageDescription.Package.Dependency] = []
         if case .Array(let array)? = table.items["dependencies"] {
@@ -56,7 +69,7 @@ extension PackageDescription.Package {
             }
         }
 
-        return PackageDescription.Package(name: name, targets: targets, dependencies: dependencies, testDependencies: testDependencies, exclude: exclude)
+        return PackageDescription.Package(name: name, pkgConfig: pkgConfig, providers: providers, targets: targets, dependencies: dependencies, testDependencies: testDependencies, exclude: exclude)
     }
 }
 
@@ -85,6 +98,22 @@ extension PackageDescription.Package.Dependency {
     }
 }
 
+extension PackageDescription.SystemPackageProvider {
+    private static func fromTOML(_ item: TOMLItem) -> PackageDescription.SystemPackageProvider {
+        guard case .Table(let table) = item else { fatalError("unexpected item") }
+        guard case .String(let name)? = table.items["name"] else { fatalError("missing name") }
+        guard case .String(let value)? = table.items["value"] else { fatalError("missing value") }
+        switch name {
+        case "Brew":
+            return .Brew(value)
+        case "Apt":
+            return .Apt(value)
+        default:
+            fatalError("unexpected string")
+        }
+    }
+}
+
 extension PackageDescription.Target {
     private static func fromTOML(_ item: TOMLItem) -> PackageDescription.Target {
         // This is a private API, currently, so we do not currently try and