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
183
|
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2020 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
package import Foundation
package import LanguageServerProtocol
import LanguageServerProtocolExtensions
import SKLogging
import SwiftExtensions
import TSCExtensions
#if os(Windows)
import WinSDK
#endif
/// A single compilation database command.
///
/// See https://clang.llvm.org/docs/JSONCompilationDatabase.html
package struct CompilationDatabaseCompileCommand: Equatable, Codable {
/// The working directory for the compilation.
package var directory: String
/// The path of the main file for the compilation, which may be relative to `directory`.
package var filename: String
/// The compile command as a list of strings, with the program name first.
package var commandLine: [String]
/// The name of the build output, or nil.
package var output: String? = nil
package init(directory: String, filename: String, commandLine: [String], output: String? = nil) {
self.directory = directory
self.filename = filename
self.commandLine = commandLine
self.output = output
}
private enum CodingKeys: String, CodingKey {
case directory
case file
case command
case arguments
case output
}
package init(from decoder: Decoder) throws {
let container = try decoder.container(keyedBy: CodingKeys.self)
self.directory = try container.decode(String.self, forKey: .directory)
self.filename = try container.decode(String.self, forKey: .file)
self.output = try container.decodeIfPresent(String.self, forKey: .output)
if let arguments = try container.decodeIfPresent([String].self, forKey: .arguments) {
self.commandLine = arguments
} else if let command = try container.decodeIfPresent(String.self, forKey: .command) {
#if os(Windows)
self.commandLine = splitWindowsCommandLine(command, initialCommandName: true)
#else
self.commandLine = splitShellEscapedCommand(command)
#endif
} else {
throw CompilationDatabaseDecodingError.missingCommandOrArguments
}
}
package func encode(to encoder: Encoder) throws {
var container = encoder.container(keyedBy: CodingKeys.self)
try container.encode(directory, forKey: .directory)
try container.encode(filename, forKey: .file)
try container.encode(commandLine, forKey: .arguments)
try container.encodeIfPresent(output, forKey: .output)
}
/// The `DocumentURI` for this file. If `filename` is relative and `directory` is
/// absolute, returns the concatenation. However, if both paths are relative,
/// it falls back to `filename`, which is more likely to be the identifier
/// that a caller will be looking for.
package var uri: DocumentURI {
if filename.isAbsolutePath || !directory.isAbsolutePath {
return DocumentURI(filePath: filename, isDirectory: false)
} else {
return DocumentURI(URL(fileURLWithPath: directory).appendingPathComponent(filename, isDirectory: false))
}
}
}
/// The JSON clang-compatible compilation database.
///
/// Example:
///
/// ```
/// [
/// {
/// "directory": "/src",
/// "file": "/src/file.cpp",
/// "command": "clang++ file.cpp"
/// }
/// ]
/// ```
///
/// See https://clang.llvm.org/docs/JSONCompilationDatabase.html
package struct JSONCompilationDatabase: Equatable, Codable {
private var pathToCommands: [DocumentURI: [Int]] = [:]
var commands: [CompilationDatabaseCompileCommand] = []
package init(_ commands: [CompilationDatabaseCompileCommand] = []) {
for command in commands {
add(command)
}
}
package init(from decoder: Decoder) throws {
var container = try decoder.unkeyedContainer()
while !container.isAtEnd {
self.add(try container.decode(CompilationDatabaseCompileCommand.self))
}
}
/// Loads the compilation database located in `directory`, if any.
///
/// - Returns: `nil` if `compile_commands.json` was not found
package init(directory: URL) throws {
let path = directory.appendingPathComponent(JSONCompilationDatabaseBuildSystem.dbName)
try self.init(file: path)
}
/// Loads the compilation database from `file`
/// - Returns: `nil` if the file does not exist
package init(file: URL) throws {
let data = try Data(contentsOf: file)
self = try JSONDecoder().decode(JSONCompilationDatabase.self, from: data)
}
package func encode(to encoder: Encoder) throws {
var container = encoder.unkeyedContainer()
try commands.forEach { try container.encode($0) }
}
package subscript(_ uri: DocumentURI) -> [CompilationDatabaseCompileCommand] {
if let indices = pathToCommands[uri] {
return indices.map { commands[$0] }
}
if let fileURL = try? uri.fileURL?.realpath, let indices = pathToCommands[DocumentURI(fileURL)] {
return indices.map { commands[$0] }
}
return []
}
private mutating func add(_ command: CompilationDatabaseCompileCommand) {
let uri = command.uri
pathToCommands[uri, default: []].append(commands.count)
if let symlinkTarget = uri.symlinkTarget {
pathToCommands[symlinkTarget, default: []].append(commands.count)
}
commands.append(command)
}
}
enum CompilationDatabaseDecodingError: Error {
case missingCommandOrArguments
case fixedDatabaseDecodingError
}
fileprivate extension String {
var isAbsolutePath: Bool {
#if os(Windows)
Array(self.utf16).withUnsafeBufferPointer { buffer in
return !PathIsRelativeW(buffer.baseAddress)
}
#else
return self.hasPrefix("/")
#endif
}
}
|
