1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
|
import Foundation
enum Endianness {
case big
case little
}
extension Data {
init(_ val: UInt8) {
self.init()
self.appendUInt8(val)
}
init(_ val: UInt16) {
self.init()
self.appendUInt16(val)
}
init(_ val: UInt32) {
self.init()
self.appendUInt32(val)
}
func readUInt8(at offset: Int) -> UInt8? {
guard offset >= 0, offset + 1 <= self.count else {
return nil
}
return self[offset]
}
func readUInt16(at offset: Int) -> UInt16? {
guard offset >= 0, offset + 2 <= self.count else {
return nil
}
return (UInt16(self[offset]) << 8) + UInt16(self[offset + 1])
}
func readUInt32(at offset: Int) -> UInt32? {
guard offset >= 0, offset + 4 <= self.count else {
return nil
}
return (UInt32(self[offset]) << 24) + (UInt32(self[offset + 1]) << 16) + (UInt32(self[offset + 2]) << 8) + UInt32(self[offset + 3])
}
func readData(at offset: Int, length: Int) -> Data? {
guard offset >= 0, offset + length <= self.count else {
return nil
}
return self.subdata(in: offset..<(offset + length))
}
func readString(at offset: Int, length: Int) -> String? {
var str: String?
str = String(data: self[offset..<(offset + length)], encoding: .utf8)
if str == nil {
str = String(data: self[offset..<(offset + length)], encoding: .ascii)
}
return str
}
func readPString(at offset: Int) -> (String?, Int) {
let len = Int(self.readUInt8(at: offset)!)
return (self.readString(at: offset+1, length: len), 1 + len)
}
func readLongPString(at offset: Int) -> (String?, Int) {
let len = Int(self.readUInt16(at: offset)!)
return (self.readString(at: offset+2, length: len), 2 + len)
}
mutating func appendUInt8(_ value: UInt8, endianness: Endianness = .big) {
var val = endianness == .big ? value.bigEndian : value.littleEndian
append(&val, count: MemoryLayout<UInt8>.size)
}
mutating func appendUInt16(_ value: UInt16, endianness: Endianness = .big) {
var val = endianness == .big ? value.bigEndian : value.littleEndian
Swift.withUnsafeBytes(of: &val) { buffer in
append(buffer.bindMemory(to: UInt8.self))
}
// append(&val, count: MemoryLayout<UInt16>.size)
}
mutating func appendUInt32(_ value: UInt32, endianness: Endianness = .big) {
var val = endianness == .big ? value.bigEndian : value.littleEndian
Swift.withUnsafeBytes(of: &val) { buffer in
append(buffer.bindMemory(to: UInt8.self))
}
// append(&val, count: MemoryLayout<UInt32>.size)
}
}
extension UInt32 {
func toStringLiteral() -> String {
let bytes = [
UInt8((self >> 24) & 0xFF),
UInt8((self >> 16) & 0xFF),
UInt8((self >> 8) & 0xFF),
UInt8(self & 0xFF)
]
return String(bytes: bytes, encoding: .utf8) ?? ""
}
}
|
