Add EvalResult and clean up implementation of withUnsafeCStringBuffer

Author: harlanhaskins

Sources/Clang/EvalResult.swift

@@ -2,63 +2,64 @@
 import cclang
 #endif
 
-protocol EvalResultKind {
+protocol EvalResult {
   var clang: CXEvalResult { get }
 }
 
-public struct IntResult: EvalResultKind {
+public struct IntResult: EvalResult {
   let clang: CXEvalResult
   public var value: Int {
     return Int(clang_EvalResult_getAsInt(clang))
   }
 }
 
-public struct FloatResult: EvalResultKind {
+public struct FloatResult: EvalResult {
   let clang: CXEvalResult
   public var value: Double {
-    return Double(clang_EvalResult_getAsDouble(clang))
+    return clang_EvalResult_getAsDouble(clang)
   }
 }
 
-public struct ObjCStrLiteralResult: EvalResultKind {
+public struct ObjCStrLiteralResult: EvalResult {
   let clang: CXEvalResult
   public var value: String {
     return String(cString: clang_EvalResult_getAsStr(clang))
   }
 }
 
-public struct StrLiteralResult: EvalResultKind {
+public struct StrLiteralResult: EvalResult {
   let clang: CXEvalResult
   public var value: String {
     return String(cString: clang_EvalResult_getAsStr(clang))
   }
 }
 
-public struct CFStrResult: EvalResultKind {
+public struct CFStrResult: EvalResult {
   let clang: CXEvalResult
   public var value: String {
     return String(cString: clang_EvalResult_getAsStr(clang))
   }
 }
 
-public struct OtherResult: EvalResultKind {
+public struct OtherResult: EvalResult {
   let clang: CXEvalResult
 }
 
-public struct UnExposedResult: EvalResultKind {
+public struct UnExposedResult: EvalResult {
   let clang: CXEvalResult
 }
 
-/// Converts a CXEvalResultKind to a EvalResultKind, returning `nil` if it was unsuccessful
-func convertEvalResultKind(_ clang: CXEvalResult) -> EvalResultKind? {
-  switch clang_EvalResult_getKind(clang) {
+/// Converts a CXEvalResult to a EvalResult, returning `nil` if it was unsuccessful
+func convertEvalResult(_ clang: CXEvalResult) -> EvalResult? {
+  let kind = clang_EvalResult_getKind(clang)
+  switch kind {
   case CXEval_Int: return IntResult(clang: clang)
   case CXEval_Float: return FloatResult(clang: clang)
   case CXEval_ObjCStrLiteral: return ObjCStrLiteralResult(clang: clang)
   case CXEval_StrLiteral: return StrLiteralResult(clang: clang)
   case CXEval_CFStr: return CFStrResult(clang: clang)
   case CXEval_Other: return OtherResult(clang: clang)
   case CXEval_UnExposed: return UnExposedResult(clang: clang)
-  default: fatalError("invalid CXEvalResultKindKind \(clang)")
+  default: fatalError("invalid CXEvalResultKind \(clang)")
   }
 }

Sources/Clang/Utilities.swift

@@ -1,48 +1,47 @@
 #if !NO_SWIFTPM
-import cclang
+  import cclang
 #endif
 
 internal extension Bool {
-    func asClang() -> Int32 {
-        return self ? 1 : 0
-    }
+  func asClang() -> Int32 {
+    return self ? 1 : 0
+  }
 }
 
 
 extension CXString {
-    func asSwiftOptional() -> String? {
-        guard let cStr = clang_getCString(self) else { return nil }
-        defer { clang_disposeString(self) }
-        return String(cString: cStr)
-    }
-    func asSwift() -> String {
-        return asSwiftOptional() ?? ""
-    }
+  func asSwiftOptional() -> String? {
+    guard let cStr = clang_getCString(self) else { return nil }
+    defer { clang_disposeString(self) }
+    return String(cString: cStr)
+  }
+  func asSwift() -> String {
+    return asSwiftOptional() ?? ""
+  }
 }
 
 extension Collection where Iterator.Element == String, IndexDistance == Int {
-    func withUnsafeCStringBuffer<Result>(_ f: @escaping (UnsafeMutableBufferPointer<UnsafePointer<Int8>?>) throws -> Result) rethrows -> Result {
-        let ptr = UnsafeMutablePointer<UnsafeMutablePointer<Int8>?>.allocate(capacity: self.count)
-        defer  { freelist(ptr, count: self.count) }
-        for (idx, str) in enumerated() {
-            str.withCString { cStr in
-                ptr[idx] = strdup(cStr)
-            }
-        }
-      return try ptr.withMemoryRebound(to: Optional<UnsafePointer<Int8>>.self, capacity: self.count) { constPtr in
-        return try f(UnsafeMutableBufferPointer(start: constPtr, count: self.count))
+
+  func withUnsafeCStringBuffer<Result>(_ f: (UnsafeMutableBufferPointer<UnsafePointer<Int8>?>) throws -> Result) rethrows -> Result {
+    var arr = [UnsafePointer<Int8>?]()
+    defer {
+      for cStr in arr {
+        free(UnsafeMutablePointer(mutating: cStr))
       }
     }
-}
-
-func freelist<T>(_ ptr: UnsafeMutablePointer<UnsafeMutablePointer<T>?>, count: Int) {
-    for i in 0..<count {
-        free(ptr[i])
+    for str in self {
+      str.withCString { cStr in
+        arr.append(UnsafePointer(strdup(cStr)))
+      }
+    }
+    return try arr.withUnsafeMutableBufferPointer { buf in
+      return try f(UnsafeMutableBufferPointer(start: buf.baseAddress,
+                                              count: buf.count))
     }
-    free(ptr)
+  }
 }
 
 internal class Box<T> {
-    public var value: T
-    init(_ value: T) { self.value = value }
+  public var value: T
+  init(_ value: T) { self.value = value }
 }