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
|
//===--- DraftStore.cpp - File contents container ---------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "DraftStore.h"
#include "SourceCode.h"
#include "support/Logger.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/Support/Errc.h"
#include "llvm/Support/VirtualFileSystem.h"
#include <memory>
namespace clang {
namespace clangd {
llvm::Optional<DraftStore::Draft> DraftStore::getDraft(PathRef File) const {
std::lock_guard<std::mutex> Lock(Mutex);
auto It = Drafts.find(File);
if (It == Drafts.end())
return None;
return It->second.D;
}
std::vector<Path> DraftStore::getActiveFiles() const {
std::lock_guard<std::mutex> Lock(Mutex);
std::vector<Path> ResultVector;
for (auto DraftIt = Drafts.begin(); DraftIt != Drafts.end(); DraftIt++)
ResultVector.push_back(std::string(DraftIt->getKey()));
return ResultVector;
}
static void increment(std::string &S) {
// Ensure there is a numeric suffix.
if (S.empty() || !llvm::isDigit(S.back())) {
S.push_back('0');
return;
}
// Increment the numeric suffix.
auto I = S.rbegin(), E = S.rend();
for (;;) {
if (I == E || !llvm::isDigit(*I)) {
// Reached start of numeric section, it was all 9s.
S.insert(I.base(), '1');
break;
}
if (*I != '9') {
// Found a digit we can increment, we're done.
++*I;
break;
}
*I = '0'; // and keep incrementing to the left.
}
}
static void updateVersion(DraftStore::Draft &D,
llvm::StringRef SpecifiedVersion) {
if (!SpecifiedVersion.empty()) {
// We treat versions as opaque, but the protocol says they increase.
if (SpecifiedVersion.compare_numeric(D.Version) <= 0)
log("File version went from {0} to {1}", D.Version, SpecifiedVersion);
D.Version = SpecifiedVersion.str();
} else {
// Note that if D was newly-created, this will bump D.Version from "" to 1.
increment(D.Version);
}
}
std::string DraftStore::addDraft(PathRef File, llvm::StringRef Version,
llvm::StringRef Contents) {
std::lock_guard<std::mutex> Lock(Mutex);
auto &D = Drafts[File];
updateVersion(D.D, Version);
std::time(&D.MTime);
D.D.Contents = std::make_shared<std::string>(Contents);
return D.D.Version;
}
void DraftStore::removeDraft(PathRef File) {
std::lock_guard<std::mutex> Lock(Mutex);
Drafts.erase(File);
}
namespace {
/// A read only MemoryBuffer shares ownership of a ref counted string. The
/// shared string object must not be modified while an owned by this buffer.
class SharedStringBuffer : public llvm::MemoryBuffer {
const std::shared_ptr<const std::string> BufferContents;
const std::string Name;
public:
BufferKind getBufferKind() const override {
return MemoryBuffer::MemoryBuffer_Malloc;
}
StringRef getBufferIdentifier() const override { return Name; }
SharedStringBuffer(std::shared_ptr<const std::string> Data, StringRef Name)
: BufferContents(std::move(Data)), Name(Name) {
assert(BufferContents && "Can't create from empty shared_ptr");
MemoryBuffer::init(BufferContents->c_str(),
BufferContents->c_str() + BufferContents->size(),
/*RequiresNullTerminator=*/true);
}
};
} // namespace
llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> DraftStore::asVFS() const {
auto MemFS = llvm::makeIntrusiveRefCnt<llvm::vfs::InMemoryFileSystem>();
std::lock_guard<std::mutex> Guard(Mutex);
for (const auto &Draft : Drafts)
MemFS->addFile(Draft.getKey(), Draft.getValue().MTime,
std::make_unique<SharedStringBuffer>(
Draft.getValue().D.Contents, Draft.getKey()));
return MemFS;
}
} // namespace clangd
} // namespace clang
|
