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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
|
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift open source project
//
// Copyright (c) 2025 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 the list of Swift project authors
//
//===----------------------------------------------------------------------===//
public import SWBUtil
public class BuildPhase: PolymorphicSerializable, @unchecked Sendable {
public static let implementations: [SerializableTypeCode : any PolymorphicSerializable.Type] = [
0: AppleScriptBuildPhase.self,
1: CopyFilesBuildPhase.self,
2: FrameworksBuildPhase.self,
3: HeadersBuildPhase.self,
4: JavaArchiveBuildPhase.self,
5: ResourcesBuildPhase.self,
6: RezBuildPhase.self,
7: ShellScriptBuildPhase.self,
8: SourcesBuildPhase.self,
]
public let guid: String
public init(guid: String) {
self.guid = guid
}
public func serialize<T: Serializer>(to serializer: T) {
serializer.serialize(guid)
}
public required init(from deserializer: any Deserializer) throws {
self.guid = try deserializer.deserialize()
}
}
public class BuildPhaseWithBuildFiles: BuildPhase, @unchecked Sendable {
public let buildFiles: [BuildFile]
public init(guid: String, buildFiles: [BuildFile]) {
self.buildFiles = buildFiles
super.init(guid: guid)
}
public override func serialize<T: Serializer>(to serializer: T) {
serializer.serializeAggregate(2) {
serializer.serialize(buildFiles)
super.serialize(to: serializer)
}
}
public required init(from deserializer: any Deserializer) throws {
try deserializer.beginAggregate(2)
self.buildFiles = try deserializer.deserialize()
try super.init(from: deserializer)
}
}
public final class AppleScriptBuildPhase: BuildPhaseWithBuildFiles, @unchecked Sendable {}
public final class FrameworksBuildPhase: BuildPhaseWithBuildFiles, @unchecked Sendable {}
public final class HeadersBuildPhase: BuildPhaseWithBuildFiles, @unchecked Sendable {}
public final class JavaArchiveBuildPhase: BuildPhaseWithBuildFiles, @unchecked Sendable {}
public final class ResourcesBuildPhase: BuildPhaseWithBuildFiles, @unchecked Sendable {}
public final class RezBuildPhase: BuildPhaseWithBuildFiles, @unchecked Sendable {}
public final class SourcesBuildPhase: BuildPhaseWithBuildFiles, @unchecked Sendable {}
public final class CopyFilesBuildPhase: BuildPhaseWithBuildFiles, @unchecked Sendable {
public let destinationSubfolder: MacroExpressionSource
public let destinationSubpath: MacroExpressionSource
public let runOnlyForDeploymentPostprocessing: Bool
public init(guid: String, buildFiles: [BuildFile], destinationSubfolder: MacroExpressionSource, destinationSubpath: MacroExpressionSource, runOnlyForDeploymentPostprocessing: Bool) {
self.destinationSubfolder = destinationSubfolder
self.destinationSubpath = destinationSubpath
self.runOnlyForDeploymentPostprocessing = runOnlyForDeploymentPostprocessing
super.init(guid: guid, buildFiles: buildFiles)
}
public override func serialize<T: Serializer>(to serializer: T) {
serializer.serializeAggregate(4) {
serializer.serialize(destinationSubfolder)
serializer.serialize(destinationSubpath)
serializer.serialize(runOnlyForDeploymentPostprocessing)
super.serialize(to: serializer)
}
}
public required init(from deserializer: any Deserializer) throws {
try deserializer.beginAggregate(4)
self.destinationSubfolder = try deserializer.deserialize()
self.destinationSubpath = try deserializer.deserialize()
self.runOnlyForDeploymentPostprocessing = try deserializer.deserialize()
try super.init(from: deserializer)
}
}
public enum SandboxingOverride: Int, Serializable, Sendable, Codable {
case forceDisabled = 0
case forceEnabled = 1
case basedOnBuildSetting = 2
}
public final class ShellScriptBuildPhase: BuildPhase, @unchecked Sendable {
public let name: String
// FIXME: This should be a MacroExpressionSource
public let shellPath: Path
public let scriptContents: String
public let originalObjectID: String
public let inputFilePaths: [MacroExpressionSource]
public let inputFileListPaths: [MacroExpressionSource]
public let outputFilePaths: [MacroExpressionSource]
public let outputFileListPaths: [MacroExpressionSource]
public let emitEnvironment: Bool
public let sandboxingOverride: SWBProtocol.SandboxingOverride
public let runOnlyForDeploymentPostprocessing: Bool
public let dependencyInfo: SWBProtocol.DependencyInfo?
public let alwaysOutOfDate: Bool
public let alwaysRunForInstallHdrs: Bool
public init(guid: String, name: String, shellPath: Path, scriptContents: String, originalObjectID: String, inputFilePaths: [MacroExpressionSource], inputFileListPaths: [MacroExpressionSource], outputFilePaths: [MacroExpressionSource], outputFileListPaths: [MacroExpressionSource], emitEnvironment: Bool, runOnlyForDeploymentPostprocessing: Bool, dependencyInfo: SWBProtocol.DependencyInfo? = nil, alwaysOutOfDate: Bool = false, sandboxingOverride: SandboxingOverride = .basedOnBuildSetting, alwaysRunForInstallHdrs: Bool = false) {
self.name = name
self.shellPath = shellPath
self.scriptContents = scriptContents
self.originalObjectID = originalObjectID
self.inputFilePaths = inputFilePaths
self.inputFileListPaths = inputFileListPaths
self.outputFilePaths = outputFilePaths
self.outputFileListPaths = outputFileListPaths
self.emitEnvironment = emitEnvironment
self.sandboxingOverride = sandboxingOverride
self.runOnlyForDeploymentPostprocessing = runOnlyForDeploymentPostprocessing
self.dependencyInfo = dependencyInfo
self.alwaysOutOfDate = alwaysOutOfDate
self.alwaysRunForInstallHdrs = alwaysRunForInstallHdrs
super.init(guid: guid)
}
public override func serialize<T: Serializer>(to serializer: T) {
serializer.serializeAggregate(15) {
serializer.serialize(name)
serializer.serialize(shellPath)
serializer.serialize(scriptContents)
serializer.serialize(originalObjectID)
serializer.serialize(inputFilePaths)
serializer.serialize(inputFileListPaths)
serializer.serialize(outputFilePaths)
serializer.serialize(outputFileListPaths)
serializer.serialize(emitEnvironment)
serializer.serialize(sandboxingOverride)
serializer.serialize(runOnlyForDeploymentPostprocessing)
serializer.serialize(dependencyInfo)
serializer.serialize(alwaysOutOfDate)
serializer.serialize(alwaysRunForInstallHdrs)
super.serialize(to: serializer)
}
}
public required init(from deserializer: any Deserializer) throws {
try deserializer.beginAggregate(15)
self.name = try deserializer.deserialize()
self.shellPath = try deserializer.deserialize()
self.scriptContents = try deserializer.deserialize()
self.originalObjectID = try deserializer.deserialize()
self.inputFilePaths = try deserializer.deserialize()
self.inputFileListPaths = try deserializer.deserialize()
self.outputFilePaths = try deserializer.deserialize()
self.outputFileListPaths = try deserializer.deserialize()
self.emitEnvironment = try deserializer.deserialize()
self.sandboxingOverride = try deserializer.deserialize()
self.runOnlyForDeploymentPostprocessing = try deserializer.deserialize()
self.dependencyInfo = try deserializer.deserialize()
self.alwaysOutOfDate = try deserializer.deserialize()
self.alwaysRunForInstallHdrs = try deserializer.deserialize()
try super.init(from: deserializer)
}
}
|
