Merge pull request #119 from p-x9/feature/djustments-for-linux-support

p-x9 · web-flow · commit a1e8e8c701f6 · 2024-10-01T21:37:35.000+09:00
Some adjustments for linux support
diff --git a/Sources/MachOKit/DyldCache.swift b/Sources/MachOKit/DyldCache.swift
@@ -50,9 +50,14 @@ public class DyldCache {
         )
 
         // check magic of header
-        // FIXME: error instead of unwrap
-        let cpuType = header._cpuType!
-        let cpuSubType = header._cpuSubType!
+        guard header.magic.starts(with: "dyld_") else {
+            throw MachOKitError.invalidMagic
+        }
+
+        guard let cpuType = header._cpuType,
+              let cpuSubType = header._cpuSubType else {
+            throw MachOKitError.invalidCpuType
+        }
         self.cpu = .init(
             typeRawValue: cpuType.rawValue,
             subtypeRawValue: cpuSubType.rawValue
diff --git a/Sources/MachOKit/Header/CPU.swift b/Sources/MachOKit/Header/CPU.swift
@@ -44,6 +44,7 @@ extension CPU {
     }
 }
 
+#if canImport(Darwin)
 extension CPU {
     /// CPU type and subtype of host pc
     static var current: CPU? {
@@ -57,3 +58,4 @@ extension CPU {
         )
     }
 }
+#endif
diff --git a/Sources/MachOKit/Header/CPUSubType.swift b/Sources/MachOKit/Header/CPUSubType.swift
@@ -1051,10 +1051,10 @@ extension CPUARM64_32SubType: CustomStringConvertible {
     }
 }
 
+#if canImport(Darwin)
 extension CPUSubType {
     /// CPU subtype of host pc
     static var current: CPUSubType? {
-#if canImport(Darwin)
         guard let cpuType: CPUType = .current else {
             return nil
         }
@@ -1063,11 +1063,9 @@ extension CPUSubType {
         let ret = sysctlbyname("hw.cpusubtype", &subtype, &size, nil, 0)
         guard ret != -1 else { return  nil }
         return .init(rawValue: subtype, of: cpuType)
-#else
-        return nil
-#endif        
     }
 }
+#endif 
 
 /*
  I386 series declarations cannot be used from swift
diff --git a/Sources/MachOKit/Header/CPUType.swift b/Sources/MachOKit/Header/CPUType.swift
@@ -49,21 +49,21 @@ extension CPUType: RawRepresentable {
     public init?(rawValue: cpu_type_t) {
         switch rawValue {
         case RawValue(CPU_TYPE_ANY): self = .any
-        case CPU_TYPE_VAX: self = .vax
-        case CPU_TYPE_MC680x0: self = .mc680x0
-        case CPU_TYPE_X86: self = .x86
-        case CPU_TYPE_I386: self = .i386
-        case CPU_TYPE_X86_64: self = .x86_64
-        case CPU_TYPE_MC98000: self = .mc98000
-        case CPU_TYPE_HPPA: self = .hppa
-        case CPU_TYPE_ARM: self = .arm
-        case CPU_TYPE_ARM64: self = .arm64
-        case CPU_TYPE_ARM64_32: self = .arm64_32
-        case CPU_TYPE_MC88000: self = .mc88000
-        case CPU_TYPE_SPARC: self = .sparc
-        case CPU_TYPE_I860: self = .i860
-        case CPU_TYPE_POWERPC: self = .powerpc
-        case CPU_TYPE_POWERPC64: self = .powerpc64
+        case RawValue(CPU_TYPE_VAX): self = .vax
+        case RawValue(CPU_TYPE_MC680x0): self = .mc680x0
+        case RawValue(CPU_TYPE_X86): self = .x86
+        case RawValue(CPU_TYPE_I386): self = .i386
+        case RawValue(CPU_TYPE_X86_64): self = .x86_64
+        case RawValue(CPU_TYPE_MC98000): self = .mc98000
+        case RawValue(CPU_TYPE_HPPA): self = .hppa
+        case RawValue(CPU_TYPE_ARM): self = .arm
+        case RawValue(CPU_TYPE_ARM64): self = .arm64
+        case RawValue(CPU_TYPE_ARM64_32): self = .arm64_32
+        case RawValue(CPU_TYPE_MC88000): self = .mc88000
+        case RawValue(CPU_TYPE_SPARC): self = .sparc
+        case RawValue(CPU_TYPE_I860): self = .i860
+        case RawValue(CPU_TYPE_POWERPC): self = .powerpc
+        case RawValue(CPU_TYPE_POWERPC64): self = .powerpc64
         default:
             return nil
         }
@@ -72,21 +72,21 @@ extension CPUType: RawRepresentable {
     public var rawValue: cpu_type_t {
         switch self {
         case .any: RawValue(CPU_TYPE_ANY)
-        case .vax: CPU_TYPE_VAX
-        case .mc680x0: CPU_TYPE_MC680x0
-        case .x86: CPU_TYPE_X86
-        case .i386: CPU_TYPE_I386
-        case .x86_64: CPU_TYPE_X86_64
-        case .mc98000: CPU_TYPE_MC98000
-        case .hppa: CPU_TYPE_HPPA
-        case .arm: CPU_TYPE_ARM
-        case .arm64: CPU_TYPE_ARM64
-        case .arm64_32: CPU_TYPE_ARM64_32
-        case .mc88000: CPU_TYPE_MC88000
-        case .sparc: CPU_TYPE_SPARC
-        case .i860: CPU_TYPE_I860
-        case .powerpc: CPU_TYPE_POWERPC
-        case .powerpc64: CPU_TYPE_POWERPC64
+        case .vax: RawValue(CPU_TYPE_VAX)
+        case .mc680x0: RawValue(CPU_TYPE_MC680x0)
+        case .x86: RawValue(CPU_TYPE_X86)
+        case .i386: RawValue(CPU_TYPE_I386)
+        case .x86_64: RawValue(CPU_TYPE_X86_64)
+        case .mc98000: RawValue(CPU_TYPE_MC98000)
+        case .hppa: RawValue(CPU_TYPE_HPPA)
+        case .arm: RawValue(CPU_TYPE_ARM)
+        case .arm64: RawValue(CPU_TYPE_ARM64)
+        case .arm64_32: RawValue(CPU_TYPE_ARM64_32)
+        case .mc88000: RawValue(CPU_TYPE_MC88000)
+        case .sparc: RawValue(CPU_TYPE_SPARC)
+        case .i860: RawValue(CPU_TYPE_I860)
+        case .powerpc: RawValue(CPU_TYPE_POWERPC)
+        case .powerpc64: RawValue(CPU_TYPE_POWERPC64)
         }
     }
 }
@@ -124,10 +124,10 @@ extension CPUType {
     }
 }
 
+#if canImport(Darwin)
 extension CPUType {
     /// CPU type of host pc
     static var current: CPUType? {
-#if canImport(Darwin)
         var type: cpu_type_t = 0
         var size = MemoryLayout<cpu_type_t>.size
         let ret = sysctlbyname("hw.cputype", &type, &size, nil, 0)
@@ -141,8 +141,6 @@ extension CPUType {
         }
 
         return .init(rawValue: type)
-#else
-        return nil
-#endif
     }
 }
+#endif
diff --git a/Sources/MachOKit/MachOImage+static.swift b/Sources/MachOKit/MachOImage+static.swift
@@ -8,11 +8,10 @@
 
 import Foundation
 
-
+#if canImport(Darwin)
 extension MachOImage {
     /// Sequence of loaded machO images.
     public static var images: AnySequence<MachOImage> {
-        #if canImport(Darwin)
         AnySequence(
             (0..<_dyld_image_count())
                 .lazy
@@ -21,9 +20,6 @@ extension MachOImage {
                     MachOImage(ptr: $0)
                 }
         )
-        #else
-        AnySequence([])
-        #endif
     }
 }
 
@@ -148,3 +144,4 @@ fileprivate extension MachOImage {
         return addressRange.contains(address)
     }
 }
+#endif
diff --git a/Sources/MachOKit/MachOKit.swift b/Sources/MachOKit/MachOKit.swift
@@ -5,12 +5,18 @@ public enum File {
     case fat(FatFile)
 }
 
+public enum MachOKitError: LocalizedError {
+    case invalidMagic
+    case invalidCpuType
+}
+
 public func loadFromFile(url: URL) throws -> File {
     let fileHandle = try FileHandle(forReadingFrom: url)
     let magicRaw: UInt32 = fileHandle.read(offset: 0)
-    
-    // FIXME: error instead of unwrap
-    let magic = Magic(rawValue: magicRaw)!
+
+    guard let magic = Magic(rawValue: magicRaw) else {
+        throw MachOKitError.invalidMagic
+    }
 
     if magic.isFat {
         return .fat(try FatFile(url: url))
diff --git a/Sources/MachOKit/Model/Codesign/CodeDirectory/CodeSignCodeDirectory.swift b/Sources/MachOKit/Model/Codesign/CodeDirectory/CodeSignCodeDirectory.swift
@@ -8,7 +8,11 @@
 
 import Foundation
 import MachOKitC
-import Crypto
+//#if compiler(>=5.10)
+//private import Crypto
+//#else
+@_implementationOnly import Crypto
+//#endif
 
 public struct CodeSignCodeDirectory: LayoutWrapper {
     public typealias Layout = CS_CodeDirectory
diff --git a/Tests/MachOKitTests/MachOPrintTests.swift b/Tests/MachOKitTests/MachOPrintTests.swift
@@ -406,7 +406,6 @@ extension MachOPrintTests {
     }
 }
 
-#if canImport(Darwin)
 extension MachOPrintTests {
     func testClosestSymbol() {
         for symbol in machO.symbols.shuffled().prefix(100) {
@@ -445,7 +444,6 @@ extension MachOPrintTests {
         }
     }
 }
-#endif
 
 extension MachOPrintTests {
     func testFindSymbolByName() {
@@ -473,7 +471,6 @@ extension MachOPrintTests {
     }
 }
 
-#if canImport(Darwin)
 extension MachOPrintTests {
     func testFunctionStarts() {
         guard let functionStarts = machO.functionStarts else { return }
@@ -500,7 +497,6 @@ extension MachOPrintTests {
         }
     }
 }
-#endif
 
 extension MachOPrintTests {
     func testDataInCode() {

Original file line number	Diff line number	Diff line change
`@@ -44,6 +44,7 @@ extension CPU {`
`44`	`44`	`}`
`45`	`45`	`}`
`46`	`46`
	`47`	`+#if canImport(Darwin)`
`47`	`48`	`extension CPU {`
`48`	`49`	`/// CPU type and subtype of host pc`
`49`	`50`	`static var current: CPU? {`
`@@ -57,3 +58,4 @@ extension CPU {`
`57`	`58`	`)`
`58`	`59`	`}`
`59`	`60`	`}`
	`61`	`+#endif`
Original file line number	Diff line number	Diff line change
`@@ -1051,10 +1051,10 @@ extension CPUARM64_32SubType: CustomStringConvertible {`
`1051`	`1051`	`}`
`1052`	`1052`	`}`
`1053`	`1053`
	`1054`	`+#if canImport(Darwin)`
`1054`	`1055`	`extension CPUSubType {`
`1055`	`1056`	`/// CPU subtype of host pc`
`1056`	`1057`	`static var current: CPUSubType? {`
`1057`		`-#if canImport(Darwin)`
`1058`	`1058`	`guard let cpuType: CPUType = .current else {`
`1059`	`1059`	`return nil`
`1060`	`1060`	`}`
`@@ -1063,11 +1063,9 @@ extension CPUSubType {`
`1063`	`1063`	`let ret = sysctlbyname("hw.cpusubtype", &subtype, &size, nil, 0)`
`1064`	`1064`	`guard ret != -1 else { return nil }`
`1065`	`1065`	`return .init(rawValue: subtype, of: cpuType)`
`1066`		`-#else`
`1067`		`- return nil`
`1068`		`-#endif`
`1069`	`1066`	`}`
`1070`	`1067`	`}`
	`1068`	`+#endif`
`1071`	`1069`
`1072`	`1070`	`/*`
`1073`	`1071`	`I386 series declarations cannot be used from swift`
Original file line number	Diff line number	Diff line change
`@@ -8,11 +8,10 @@`
`8`	`8`
`9`	`9`	`import Foundation`
`10`	`10`
`11`		`-`
	`11`	`+#if canImport(Darwin)`
`12`	`12`	`extension MachOImage {`
`13`	`13`	`/// Sequence of loaded machO images.`
`14`	`14`	`public static var images: AnySequence<MachOImage> {`
`15`		`- #if canImport(Darwin)`
`16`	`15`	`AnySequence(`
`17`	`16`	`(0..<_dyld_image_count())`
`18`	`17`	`.lazy`
`@@ -21,9 +20,6 @@ extension MachOImage {`
`21`	`20`	`MachOImage(ptr: $0)`
`22`	`21`	`}`
`23`	`22`	`)`
`24`		`- #else`
`25`		`- AnySequence([])`
`26`		`- #endif`
`27`	`23`	`}`
`28`	`24`	`}`
`29`	`25`
`@@ -148,3 +144,4 @@ fileprivate extension MachOImage {`
`148`	`144`	`return addressRange.contains(address)`
`149`	`145`	`}`
`150`	`146`	`}`
	`147`	`+#endif`
Original file line number	Diff line number	Diff line change
`@@ -406,7 +406,6 @@ extension MachOPrintTests {`
`406`	`406`	`}`
`407`	`407`	`}`
`408`	`408`
`409`		`-#if canImport(Darwin)`
`410`	`409`	`extension MachOPrintTests {`
`411`	`410`	`func testClosestSymbol() {`
`412`	`411`	`for symbol in machO.symbols.shuffled().prefix(100) {`
`@@ -445,7 +444,6 @@ extension MachOPrintTests {`
`445`	`444`	`}`
`446`	`445`	`}`
`447`	`446`	`}`
`448`		`-#endif`
`449`	`447`
`450`	`448`	`extension MachOPrintTests {`
`451`	`449`	`func testFindSymbolByName() {`
`@@ -473,7 +471,6 @@ extension MachOPrintTests {`
`473`	`471`	`}`
`474`	`472`	`}`
`475`	`473`
`476`		`-#if canImport(Darwin)`
`477`	`474`	`extension MachOPrintTests {`
`478`	`475`	`func testFunctionStarts() {`
`479`	`476`	`guard let functionStarts = machO.functionStarts else { return }`
`@@ -500,7 +497,6 @@ extension MachOPrintTests {`
`500`	`497`	`}`
`501`	`498`	`}`
`502`	`499`	`}`
`503`		`-#endif`
`504`	`500`
`505`	`501`	`extension MachOPrintTests {`
`506`	`502`	`func testDataInCode() {`