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
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
|
// Copyright 2016 The Bazel Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "src/main/cpp/util/file_platform.h"
#include <windows.h>
#include "src/main/cpp/util/errors.h"
#include "src/main/cpp/util/exit_code.h"
#include "src/main/cpp/util/file.h"
namespace blaze_util {
using std::pair;
using std::string;
class WindowsPipe : public IPipe {
public:
WindowsPipe(const HANDLE& read_handle, const HANDLE& write_handle)
: _read_handle(read_handle), _write_handle(write_handle) {}
WindowsPipe() = delete;
virtual ~WindowsPipe() {
if (_read_handle != INVALID_HANDLE_VALUE) {
CloseHandle(_read_handle);
_read_handle = INVALID_HANDLE_VALUE;
}
if (_write_handle != INVALID_HANDLE_VALUE) {
CloseHandle(_write_handle);
_write_handle = INVALID_HANDLE_VALUE;
}
}
bool Send(const void* buffer, int size) override {
DWORD actually_written = 0;
return ::WriteFile(_write_handle, buffer, size, &actually_written, NULL) ==
TRUE;
}
int Receive(void* buffer, int size) override {
DWORD actually_read = 0;
return ::ReadFile(_read_handle, buffer, size, &actually_read, NULL)
? actually_read
: -1;
}
private:
HANDLE _read_handle;
HANDLE _write_handle;
};
IPipe* CreatePipe() {
// The pipe HANDLEs can be inherited.
SECURITY_ATTRIBUTES sa = {sizeof(SECURITY_ATTRIBUTES), NULL, TRUE};
HANDLE read_handle = INVALID_HANDLE_VALUE;
HANDLE write_handle = INVALID_HANDLE_VALUE;
if (!CreatePipe(&read_handle, &write_handle, &sa, 0)) {
pdie(blaze_exit_code::LOCAL_ENVIRONMENTAL_ERROR,
"CreatePipe failed, err=%d", GetLastError());
}
return new WindowsPipe(read_handle, write_handle);
}
static bool IsRootDirectory(const string& path) {
// Return true if path is "/", "\", "c:/", "c:\", "\\?\c:\", or "\??\c:\".
//
// It is unclear whether the UNC prefix is just "\\?\" or is "\??\" also
// valid (in some cases it seems to be, though MSDN doesn't mention it).
return
// path is "/" or "\"
(path.size() == 1 && (path[0] == '/' || path[0] == '\\')) ||
// path is "c:/" or "c:\"
(path.size() == 3 && isalpha(path[0]) && path[1] == ':' &&
(path[2] == '/' || path[2] == '\\')) ||
// path is "\\?\c:\" or "\??\c:\"
(path.size() == 7 && path[0] == '\\' &&
(path[1] == '\\' || path[1] == '?') && path[2] == '?' &&
path[3] == '\\' && isalpha(path[4]) && path[5] == ':' &&
path[6] == '\\');
}
pair<string, string> SplitPath(const string& path) {
if (path.empty()) {
return std::make_pair("", "");
}
size_t pos = path.size() - 1;
for (auto it = path.crbegin(); it != path.crend(); ++it, --pos) {
if (*it == '/' || *it == '\\') {
if ((pos == 2 || pos == 6) && IsRootDirectory(path.substr(0, pos + 1))) {
// Windows path, top-level directory, e.g. "c:\foo",
// result is ("c:\", "foo").
// Or UNC path, top-level directory, e.g. "\\?\c:\foo"
// result is ("\\?\c:\", "foo").
return std::make_pair(
// Include the "/" or "\" in the drive specifier.
path.substr(0, pos + 1), path.substr(pos + 1));
} else {
// Unix path, or relative path.
return std::make_pair(
// If the only "/" is the leading one, then that shall be the first
// pair element, otherwise the substring up to the rightmost "/".
pos == 0 ? path.substr(0, 1) : path.substr(0, pos),
// If the rightmost "/" is the tail, then the second pair element
// should be empty.
pos == path.size() - 1 ? "" : path.substr(pos + 1));
}
}
}
// Handle the case with no '/' or '\' in `path`.
return std::make_pair("", path);
}
#ifdef COMPILER_MSVC
bool ReadFile(const string& filename, string* content, int max_size) {
// TODO(bazel-team): implement this.
pdie(255, "blaze_util::ReadFile is not implemented on Windows");
return false;
}
#else // not COMPILER_MSVC
#endif // COMPILER_MSVC
#ifdef COMPILER_MSVC
bool WriteFile(const void* data, size_t size, const string& filename) {
// TODO(bazel-team): implement this.
pdie(255, "blaze_util::WriteFile is not implemented on Windows");
return false;
}
#else // not COMPILER_MSVC
#endif // COMPILER_MSVC
#ifdef COMPILER_MSVC
bool UnlinkPath(const string& file_path) {
// TODO(bazel-team): implement this.
pdie(255, "blaze_util::UnlinkPath is not implemented on Windows");
return false;
}
#else // not COMPILER_MSVC
#endif // COMPILER_MSVC
#ifdef COMPILER_MSVC
string Which(const string &executable) {
pdie(255, "blaze_util::Which is not implemented on Windows");
return "";
}
#else // not COMPILER_MSVC
#endif // COMPILER_MSVC
#ifdef COMPILER_MSVC
bool PathExists(const string& path) {
// TODO(bazel-team): implement this.
pdie(255, "blaze_util::PathExists is not implemented on Windows");
return false;
}
#else // not COMPILER_MSVC
#endif // COMPILER_MSVC
#ifdef COMPILER_MSVC
string MakeCanonical(const char *path) {
// TODO(bazel-team): implement this.
pdie(255, "blaze_util::MakeCanonical is not implemented on Windows");
return "";
}
#else // not COMPILER_MSVC
#endif // COMPILER_MSVC
#ifdef COMPILER_MSVC
bool CanAccess(const string& path, bool read, bool write, bool exec) {
// TODO(bazel-team): implement this.
pdie(255, "blaze_util::CanAccess is not implemented on Windows");
return false;
}
#else // not COMPILER_MSVC
#endif // COMPILER_MSVC
#ifdef COMPILER_MSVC
bool IsDirectory(const string& path) {
// TODO(bazel-team): implement this.
pdie(255, "blaze_util::IsDirectory is not implemented on Windows");
return false;
}
#else // not COMPILER_MSVC
#endif // COMPILER_MSVC
#ifdef COMPILER_MSVC
void SyncFile(const string& path) {
// No-op on Windows native; unsupported by Cygwin.
}
#else // not COMPILER_MSVC
#endif // COMPILER_MSVC
#ifdef COMPILER_MSVC
time_t GetMtimeMillisec(const string& path) {
// TODO(bazel-team): implement this.
pdie(255, "blaze_util::GetMtimeMillisec is not implemented on Windows");
return -1;
}
#else // not COMPILER_MSVC
#endif // COMPILER_MSVC
#ifdef COMPILER_MSVC
bool SetMtimeMillisec(const string& path, time_t mtime) {
// TODO(bazel-team): implement this.
pdie(255, "blaze_util::SetMtimeMillisec is not implemented on Windows");
return false;
}
#else // not COMPILER_MSVC
#endif // COMPILER_MSVC
#ifdef COMPILER_MSVC
bool MakeDirectories(const string& path, unsigned int mode) {
// TODO(bazel-team): implement this.
pdie(255, "blaze::MakeDirectories is not implemented on Windows");
return false;
}
#else // not COMPILER_MSVC
#endif // COMPILER_MSVC
#ifdef COMPILER_MSVC
string GetCwd() {
// TODO(bazel-team): implement this.
pdie(255, "blaze_util::GetCwd is not implemented on Windows");
return "";
}
#else // not COMPILER_MSVC
#endif // COMPILER_MSVC
#ifdef COMPILER_MSVC
bool ChangeDirectory(const string& path) {
// TODO(bazel-team): implement this.
pdie(255, "blaze_util::ChangeDirectory is not implemented on Windows");
return false;
}
#else // not COMPILER_MSVC
#endif // COMPILER_MSVC
#ifdef COMPILER_MSVC
void ForEachDirectoryEntry(const string &path,
DirectoryEntryConsumer *consume) {
// TODO(bazel-team): implement this.
pdie(255, "blaze_util::ForEachDirectoryEntry is not implemented on Windows");
}
#else // not COMPILER_MSVC
#endif // COMPILER_MSVC
} // namespace blaze_util
|
