style(3p/nix): Add braces around single-line conditionals
These were not caught by the previous clang-tidy invocation, but were
instead sorted out using amber[0] as such:
ambr --regex 'if (\(.+\))\s([a-z].*;)' 'if $1 { $2 }'
[0]: https://github.com/dalance/amber
This commit is contained in:
Vincent Ambo
parent
c6a31838cd
commit
867055133d
97 changed files with 2223 additions and 753 deletions
36
third_party/nix/src/libutil/archive.cc
vendored
36
third_party/nix/src/libutil/archive.cc
vendored
|
|
@ -46,7 +46,9 @@ static void dumpContents(const Path& path, size_t size, Sink& sink) {
|
|||
sink << "contents" << size;
|
||||
|
||||
AutoCloseFD fd = open(path.c_str(), O_RDONLY | O_CLOEXEC);
|
||||
if (!fd) throw SysError(format("opening file '%1%'") % path);
|
||||
if (!fd) {
|
||||
throw SysError(format("opening file '%1%'") % path);
|
||||
}
|
||||
|
||||
std::vector<unsigned char> buf(65536);
|
||||
size_t left = size;
|
||||
|
|
@ -162,7 +164,9 @@ static void parseContents(ParseSink& sink, Source& source, const Path& path) {
|
|||
while (left) {
|
||||
checkInterrupt();
|
||||
auto n = buf.size();
|
||||
if ((unsigned long long)n > left) n = left;
|
||||
if ((unsigned long long)n > left) {
|
||||
n = left;
|
||||
}
|
||||
source(buf.data(), n);
|
||||
sink.receiveContents(buf.data(), n);
|
||||
left -= n;
|
||||
|
|
@ -181,7 +185,9 @@ static void parse(ParseSink& sink, Source& source, const Path& path) {
|
|||
string s;
|
||||
|
||||
s = readString(source);
|
||||
if (s != "(") throw badArchive("expected open tag");
|
||||
if (s != "(") {
|
||||
throw badArchive("expected open tag");
|
||||
}
|
||||
|
||||
enum { tpUnknown, tpRegular, tpDirectory, tpSymlink } type = tpUnknown;
|
||||
|
||||
|
|
@ -197,7 +203,9 @@ static void parse(ParseSink& sink, Source& source, const Path& path) {
|
|||
}
|
||||
|
||||
else if (s == "type") {
|
||||
if (type != tpUnknown) throw badArchive("multiple type fields");
|
||||
if (type != tpUnknown) {
|
||||
throw badArchive("multiple type fields");
|
||||
}
|
||||
string t = readString(source);
|
||||
|
||||
if (t == "regular") {
|
||||
|
|
@ -225,7 +233,9 @@ static void parse(ParseSink& sink, Source& source, const Path& path) {
|
|||
|
||||
else if (s == "executable" && type == tpRegular) {
|
||||
auto s = readString(source);
|
||||
if (s != "") throw badArchive("executable marker has non-empty value");
|
||||
if (s != "") {
|
||||
throw badArchive("executable marker has non-empty value");
|
||||
}
|
||||
sink.isExecutable();
|
||||
}
|
||||
|
||||
|
|
@ -233,7 +243,9 @@ static void parse(ParseSink& sink, Source& source, const Path& path) {
|
|||
string name, prevName;
|
||||
|
||||
s = readString(source);
|
||||
if (s != "(") throw badArchive("expected open tag");
|
||||
if (s != "(") {
|
||||
throw badArchive("expected open tag");
|
||||
}
|
||||
|
||||
while (1) {
|
||||
checkInterrupt();
|
||||
|
|
@ -248,7 +260,9 @@ static void parse(ParseSink& sink, Source& source, const Path& path) {
|
|||
name.find('/') != string::npos ||
|
||||
name.find((char)0) != string::npos)
|
||||
throw Error(format("NAR contains invalid file name '%1%'") % name);
|
||||
if (name <= prevName) throw Error("NAR directory is not sorted");
|
||||
if (name <= prevName) {
|
||||
throw Error("NAR directory is not sorted");
|
||||
}
|
||||
prevName = name;
|
||||
if (archiveSettings.useCaseHack) {
|
||||
auto i = names.find(name);
|
||||
|
|
@ -306,12 +320,16 @@ struct RestoreSink : ParseSink {
|
|||
void createRegularFile(const Path& path) {
|
||||
Path p = dstPath + path;
|
||||
fd = open(p.c_str(), O_CREAT | O_EXCL | O_WRONLY | O_CLOEXEC, 0666);
|
||||
if (!fd) throw SysError(format("creating file '%1%'") % p);
|
||||
if (!fd) {
|
||||
throw SysError(format("creating file '%1%'") % p);
|
||||
}
|
||||
}
|
||||
|
||||
void isExecutable() {
|
||||
struct stat st;
|
||||
if (fstat(fd.get(), &st) == -1) throw SysError("fstat");
|
||||
if (fstat(fd.get(), &st) == -1) {
|
||||
throw SysError("fstat");
|
||||
}
|
||||
if (fchmod(fd.get(), st.st_mode | (S_IXUSR | S_IXGRP | S_IXOTH)) == -1)
|
||||
throw SysError("fchmod");
|
||||
}
|
||||
|
|
|
|||
40
third_party/nix/src/libutil/args.cc
vendored
40
third_party/nix/src/libutil/args.cc
vendored
|
|
@ -9,7 +9,9 @@ Args::FlagMaker Args::mkFlag() { return FlagMaker(*this); }
|
|||
Args::FlagMaker::~FlagMaker() {
|
||||
assert(flag->longName != "");
|
||||
args.longFlags[flag->longName] = flag;
|
||||
if (flag->shortName) args.shortFlags[flag->shortName] = flag;
|
||||
if (flag->shortName) {
|
||||
args.shortFlags[flag->shortName] = flag;
|
||||
}
|
||||
}
|
||||
|
||||
void Args::parseCmdline(const Strings& _cmdline) {
|
||||
|
|
@ -46,7 +48,9 @@ void Args::parseCmdline(const Strings& _cmdline) {
|
|||
throw UsageError(format("unrecognised flag '%1%'") % arg);
|
||||
} else {
|
||||
pendingArgs.push_back(*pos++);
|
||||
if (processArgs(pendingArgs, false)) pendingArgs.clear();
|
||||
if (processArgs(pendingArgs, false)) {
|
||||
pendingArgs.clear();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -58,13 +62,19 @@ void Args::printHelp(const string& programName, std::ostream& out) {
|
|||
for (auto& exp : expectedArgs) {
|
||||
std::cout << renderLabels({exp.label});
|
||||
// FIXME: handle arity > 1
|
||||
if (exp.arity == 0) std::cout << "...";
|
||||
if (exp.optional) std::cout << "?";
|
||||
if (exp.arity == 0) {
|
||||
std::cout << "...";
|
||||
}
|
||||
if (exp.optional) {
|
||||
std::cout << "?";
|
||||
}
|
||||
}
|
||||
std::cout << "\n";
|
||||
|
||||
auto s = description();
|
||||
if (s != "") std::cout << "\nSummary: " << s << ".\n";
|
||||
if (s != "") {
|
||||
std::cout << "\nSummary: " << s << ".\n";
|
||||
}
|
||||
|
||||
if (longFlags.size()) {
|
||||
std::cout << "\n";
|
||||
|
|
@ -76,7 +86,9 @@ void Args::printHelp(const string& programName, std::ostream& out) {
|
|||
void Args::printFlags(std::ostream& out) {
|
||||
Table2 table;
|
||||
for (auto& flag : longFlags) {
|
||||
if (hiddenCategories.count(flag.second->category)) continue;
|
||||
if (hiddenCategories.count(flag.second->category)) {
|
||||
continue;
|
||||
}
|
||||
table.push_back(std::make_pair(
|
||||
(flag.second->shortName
|
||||
? std::string("-") + flag.second->shortName + ", "
|
||||
|
|
@ -95,7 +107,9 @@ bool Args::processFlag(Strings::iterator& pos, Strings::iterator end) {
|
|||
std::vector<std::string> args;
|
||||
for (size_t n = 0; n < flag.arity; ++n) {
|
||||
if (pos == end) {
|
||||
if (flag.arity == ArityAny) break;
|
||||
if (flag.arity == ArityAny) {
|
||||
break;
|
||||
}
|
||||
throw UsageError(format("flag '%1%' requires %2% argument(s)") % name %
|
||||
flag.arity);
|
||||
}
|
||||
|
|
@ -107,14 +121,18 @@ bool Args::processFlag(Strings::iterator& pos, Strings::iterator end) {
|
|||
|
||||
if (string(*pos, 0, 2) == "--") {
|
||||
auto i = longFlags.find(string(*pos, 2));
|
||||
if (i == longFlags.end()) return false;
|
||||
if (i == longFlags.end()) {
|
||||
return false;
|
||||
}
|
||||
return process("--" + i->first, *i->second);
|
||||
}
|
||||
|
||||
if (string(*pos, 0, 1) == "-" && pos->size() == 2) {
|
||||
auto c = (*pos)[1];
|
||||
auto i = shortFlags.find(c);
|
||||
if (i == shortFlags.end()) return false;
|
||||
if (i == shortFlags.end()) {
|
||||
return false;
|
||||
}
|
||||
return process(std::string("-") + c, *i->second);
|
||||
}
|
||||
|
||||
|
|
@ -153,7 +171,9 @@ Args::FlagMaker& Args::FlagMaker::mkHashTypeFlag(HashType* ht) {
|
|||
description("hash algorithm ('md5', 'sha1', 'sha256', or 'sha512')");
|
||||
handler([ht](std::string s) {
|
||||
*ht = parseHashType(s);
|
||||
if (*ht == htUnknown) throw UsageError("unknown hash type '%1%'", s);
|
||||
if (*ht == htUnknown) {
|
||||
throw UsageError("unknown hash type '%1%'", s);
|
||||
}
|
||||
});
|
||||
return *this;
|
||||
}
|
||||
|
|
|
|||
12
third_party/nix/src/libutil/compression.cc
vendored
12
third_party/nix/src/libutil/compression.cc
vendored
|
|
@ -138,7 +138,9 @@ struct BrotliDecompressionSink : ChunkedCompressionSink {
|
|||
|
||||
BrotliDecompressionSink(Sink& nextSink) : nextSink(nextSink) {
|
||||
state = BrotliDecoderCreateInstance(nullptr, nullptr, nullptr);
|
||||
if (!state) throw CompressionError("unable to initialize brotli decoder");
|
||||
if (!state) {
|
||||
throw CompressionError("unable to initialize brotli decoder");
|
||||
}
|
||||
}
|
||||
|
||||
~BrotliDecompressionSink() { BrotliDecoderDestroyInstance(state); }
|
||||
|
|
@ -214,7 +216,9 @@ struct XzCompressionSink : CompressionSink {
|
|||
mt_options.check = LZMA_CHECK_CRC64;
|
||||
mt_options.threads = lzma_cputhreads();
|
||||
mt_options.block_size = 0;
|
||||
if (mt_options.threads == 0) mt_options.threads = 1;
|
||||
if (mt_options.threads == 0) {
|
||||
mt_options.threads = 1;
|
||||
}
|
||||
// FIXME: maybe use lzma_stream_encoder_mt_memusage() to control the
|
||||
// number of threads.
|
||||
ret = lzma_stream_encoder_mt(&strm, &mt_options);
|
||||
|
|
@ -322,7 +326,9 @@ struct BrotliCompressionSink : ChunkedCompressionSink {
|
|||
|
||||
BrotliCompressionSink(Sink& nextSink) : nextSink(nextSink) {
|
||||
state = BrotliEncoderCreateInstance(nullptr, nullptr, nullptr);
|
||||
if (!state) throw CompressionError("unable to initialise brotli encoder");
|
||||
if (!state) {
|
||||
throw CompressionError("unable to initialise brotli encoder");
|
||||
}
|
||||
}
|
||||
|
||||
~BrotliCompressionSink() { BrotliEncoderDestroyInstance(state); }
|
||||
|
|
|
|||
24
third_party/nix/src/libutil/config.cc
vendored
24
third_party/nix/src/libutil/config.cc
vendored
|
|
@ -11,7 +11,9 @@ namespace nix {
|
|||
|
||||
bool Config::set(const std::string& name, const std::string& value) {
|
||||
auto i = _settings.find(name);
|
||||
if (i == _settings.end()) return false;
|
||||
if (i == _settings.end()) {
|
||||
return false;
|
||||
}
|
||||
i->second.setting->set(value);
|
||||
i->second.setting->overriden = true;
|
||||
return true;
|
||||
|
|
@ -84,10 +86,14 @@ void AbstractConfig::applyConfigFile(const Path& path) {
|
|||
pos++;
|
||||
|
||||
string::size_type hash = line.find('#');
|
||||
if (hash != string::npos) line = string(line, 0, hash);
|
||||
if (hash != string::npos) {
|
||||
line = string(line, 0, hash);
|
||||
}
|
||||
|
||||
vector<string> tokens = tokenizeString<vector<string> >(line);
|
||||
if (tokens.empty()) continue;
|
||||
if (tokens.empty()) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (tokens.size() < 2)
|
||||
throw UsageError("illegal configuration line '%1%' in '%2%'", line,
|
||||
|
|
@ -147,7 +153,9 @@ void Config::toJSON(JSONObject& out) {
|
|||
|
||||
void Config::convertToArgs(Args& args, const std::string& category) {
|
||||
for (auto& s : _settings)
|
||||
if (!s.second.isAlias) s.second.setting->convertToArg(args, category);
|
||||
if (!s.second.isAlias) {
|
||||
s.second.setting->convertToArg(args, category);
|
||||
}
|
||||
}
|
||||
|
||||
AbstractSetting::AbstractSetting(const std::string& name,
|
||||
|
|
@ -284,7 +292,9 @@ void PathSetting::set(const std::string& str) {
|
|||
|
||||
bool GlobalConfig::set(const std::string& name, const std::string& value) {
|
||||
for (auto& config : *configRegistrations)
|
||||
if (config->set(name, value)) return true;
|
||||
if (config->set(name, value)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
unknownSettings.emplace(name, value);
|
||||
|
||||
|
|
@ -315,7 +325,9 @@ GlobalConfig globalConfig;
|
|||
GlobalConfig::ConfigRegistrations* GlobalConfig::configRegistrations;
|
||||
|
||||
GlobalConfig::Register::Register(Config* config) {
|
||||
if (!configRegistrations) configRegistrations = new ConfigRegistrations;
|
||||
if (!configRegistrations) {
|
||||
configRegistrations = new ConfigRegistrations;
|
||||
}
|
||||
configRegistrations->emplace_back(config);
|
||||
}
|
||||
|
||||
|
|
|
|||
24
third_party/nix/src/libutil/hash.cc
vendored
24
third_party/nix/src/libutil/hash.cc
vendored
|
|
@ -139,7 +139,9 @@ Hash::Hash(const std::string& s, HashType type) : type(type) {
|
|||
if (sep != string::npos) {
|
||||
string hts = string(s, 0, sep);
|
||||
this->type = parseHashType(hts);
|
||||
if (this->type == htUnknown) throw BadHash("unknown hash type '%s'", hts);
|
||||
if (this->type == htUnknown) {
|
||||
throw BadHash("unknown hash type '%s'", hts);
|
||||
}
|
||||
if (type != htUnknown && type != this->type)
|
||||
throw BadHash("hash '%s' should have type '%s'", s, printHashType(type));
|
||||
pos = sep + 1;
|
||||
|
|
@ -174,8 +176,12 @@ Hash::Hash(const std::string& s, HashType type) : type(type) {
|
|||
char c = s[pos + size - n - 1];
|
||||
unsigned char digit;
|
||||
for (digit = 0; digit < base32Chars.size(); ++digit) /* !!! slow */
|
||||
if (base32Chars[digit] == c) break;
|
||||
if (digit >= 32) throw BadHash("invalid base-32 hash '%s'", s);
|
||||
if (base32Chars[digit] == c) {
|
||||
break;
|
||||
}
|
||||
if (digit >= 32) {
|
||||
throw BadHash("invalid base-32 hash '%s'", s);
|
||||
}
|
||||
unsigned int b = n * 5;
|
||||
unsigned int i = b / 8;
|
||||
unsigned int j = b % 8;
|
||||
|
|
@ -184,7 +190,9 @@ Hash::Hash(const std::string& s, HashType type) : type(type) {
|
|||
if (i < hashSize - 1) {
|
||||
hash[i + 1] |= digit >> (8 - j);
|
||||
} else {
|
||||
if (digit >> (8 - j)) throw BadHash("invalid base-32 hash '%s'", s);
|
||||
if (digit >> (8 - j)) {
|
||||
throw BadHash("invalid base-32 hash '%s'", s);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -258,13 +266,17 @@ Hash hashFile(HashType ht, const Path& path) {
|
|||
start(ht, ctx);
|
||||
|
||||
AutoCloseFD fd = open(path.c_str(), O_RDONLY | O_CLOEXEC);
|
||||
if (!fd) throw SysError(format("opening file '%1%'") % path);
|
||||
if (!fd) {
|
||||
throw SysError(format("opening file '%1%'") % path);
|
||||
}
|
||||
|
||||
std::vector<unsigned char> buf(8192);
|
||||
ssize_t n;
|
||||
while ((n = read(fd.get(), buf.data(), buf.size()))) {
|
||||
checkInterrupt();
|
||||
if (n == -1) throw SysError(format("reading file '%1%'") % path);
|
||||
if (n == -1) {
|
||||
throw SysError(format("reading file '%1%'") % path);
|
||||
}
|
||||
update(ht, ctx, buf.data(), n);
|
||||
}
|
||||
|
||||
|
|
|
|||
8
third_party/nix/src/libutil/json.cc
vendored
8
third_party/nix/src/libutil/json.cc
vendored
|
|
@ -91,7 +91,9 @@ JSONWriter::~JSONWriter() {
|
|||
if (state) {
|
||||
assertActive();
|
||||
state->stack--;
|
||||
if (state->stack == 0) delete state;
|
||||
if (state->stack == 0) {
|
||||
delete state;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -158,7 +160,9 @@ void JSONObject::attr(const std::string& s) {
|
|||
comma();
|
||||
toJSON(state->str, s);
|
||||
state->str << ':';
|
||||
if (state->indent) state->str << ' ';
|
||||
if (state->indent) {
|
||||
state->str << ' ';
|
||||
}
|
||||
}
|
||||
|
||||
JSONList JSONObject::list(const std::string& name) {
|
||||
|
|
|
|||
4
third_party/nix/src/libutil/lazy.hh
vendored
4
third_party/nix/src/libutil/lazy.hh
vendored
|
|
@ -35,7 +35,9 @@ class Lazy {
|
|||
ex = std::current_exception();
|
||||
}
|
||||
});
|
||||
if (ex) std::rethrow_exception(ex);
|
||||
if (ex) {
|
||||
std::rethrow_exception(ex);
|
||||
}
|
||||
return value;
|
||||
}
|
||||
};
|
||||
|
|
|
|||
12
third_party/nix/src/libutil/lru-cache.hh
vendored
12
third_party/nix/src/libutil/lru-cache.hh
vendored
|
|
@ -31,7 +31,9 @@ class LRUCache {
|
|||
|
||||
/* Insert or upsert an item in the cache. */
|
||||
void upsert(const Key& key, const Value& value) {
|
||||
if (capacity == 0) return;
|
||||
if (capacity == 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
erase(key);
|
||||
|
||||
|
|
@ -53,7 +55,9 @@ class LRUCache {
|
|||
|
||||
bool erase(const Key& key) {
|
||||
auto i = data.find(key);
|
||||
if (i == data.end()) return false;
|
||||
if (i == data.end()) {
|
||||
return false;
|
||||
}
|
||||
lru.erase(i->second.first.it);
|
||||
data.erase(i);
|
||||
return true;
|
||||
|
|
@ -63,7 +67,9 @@ class LRUCache {
|
|||
recently used item. */
|
||||
std::optional<Value> get(const Key& key) {
|
||||
auto i = data.find(key);
|
||||
if (i == data.end()) return {};
|
||||
if (i == data.end()) {
|
||||
return {};
|
||||
}
|
||||
|
||||
/* Move this item to the back of the LRU list. */
|
||||
lru.erase(i->second.first.it);
|
||||
|
|
|
|||
8
third_party/nix/src/libutil/monitor-fd.hh
vendored
8
third_party/nix/src/libutil/monitor-fd.hh
vendored
|
|
@ -28,7 +28,9 @@ class MonitorFdHup {
|
|||
*/
|
||||
fds[0].events = POLLHUP;
|
||||
auto count = poll(fds, 1, -1);
|
||||
if (count == -1) abort(); // can't happen
|
||||
if (count == -1) {
|
||||
abort();
|
||||
} // can't happen
|
||||
/* This shouldn't happen, but can on macOS due to a bug.
|
||||
See rdar://37550628.
|
||||
|
||||
|
|
@ -36,7 +38,9 @@ class MonitorFdHup {
|
|||
coordination with the main thread if spinning proves
|
||||
too harmful.
|
||||
*/
|
||||
if (count == 0) continue;
|
||||
if (count == 0) {
|
||||
continue;
|
||||
}
|
||||
assert(fds[0].revents & POLLHUP);
|
||||
triggerInterrupt();
|
||||
break;
|
||||
|
|
|
|||
12
third_party/nix/src/libutil/pool.hh
vendored
12
third_party/nix/src/libutil/pool.hh
vendored
|
|
@ -99,10 +99,14 @@ class Pool {
|
|||
Handle(const Handle& l) = delete;
|
||||
|
||||
~Handle() {
|
||||
if (!r) return;
|
||||
if (!r) {
|
||||
return;
|
||||
}
|
||||
{
|
||||
auto state_(pool.state.lock());
|
||||
if (!bad) state_->idle.push_back(ref<R>(r));
|
||||
if (!bad) {
|
||||
state_->idle.push_back(ref<R>(r));
|
||||
}
|
||||
assert(state_->inUse);
|
||||
state_->inUse--;
|
||||
}
|
||||
|
|
@ -160,7 +164,9 @@ class Pool {
|
|||
auto state_(state.lock());
|
||||
std::vector<ref<R>> left;
|
||||
for (auto& p : state_->idle)
|
||||
if (validator(p)) left.push_back(p);
|
||||
if (validator(p)) {
|
||||
left.push_back(p);
|
||||
}
|
||||
std::swap(state_->idle, left);
|
||||
}
|
||||
};
|
||||
|
|
|
|||
8
third_party/nix/src/libutil/ref.hh
vendored
8
third_party/nix/src/libutil/ref.hh
vendored
|
|
@ -17,11 +17,15 @@ class ref {
|
|||
ref<T>(const ref<T>& r) : p(r.p) {}
|
||||
|
||||
explicit ref<T>(const std::shared_ptr<T>& p) : p(p) {
|
||||
if (!p) throw std::invalid_argument("null pointer cast to ref");
|
||||
if (!p) {
|
||||
throw std::invalid_argument("null pointer cast to ref");
|
||||
}
|
||||
}
|
||||
|
||||
explicit ref<T>(T* p) : p(p) {
|
||||
if (!p) throw std::invalid_argument("null pointer cast to ref");
|
||||
if (!p) {
|
||||
throw std::invalid_argument("null pointer cast to ref");
|
||||
}
|
||||
}
|
||||
|
||||
T* operator->() const { return &*p; }
|
||||
|
|
|
|||
44
third_party/nix/src/libutil/serialise.cc
vendored
44
third_party/nix/src/libutil/serialise.cc
vendored
|
|
@ -11,7 +11,9 @@
|
|||
namespace nix {
|
||||
|
||||
void BufferedSink::operator()(const unsigned char* data, size_t len) {
|
||||
if (!buffer) buffer = decltype(buffer)(new unsigned char[bufSize]);
|
||||
if (!buffer) {
|
||||
buffer = decltype(buffer)(new unsigned char[bufSize]);
|
||||
}
|
||||
|
||||
while (len) {
|
||||
/* Optimisation: bypass the buffer if the data exceeds the
|
||||
|
|
@ -28,12 +30,16 @@ void BufferedSink::operator()(const unsigned char* data, size_t len) {
|
|||
data += n;
|
||||
bufPos += n;
|
||||
len -= n;
|
||||
if (bufPos == bufSize) flush();
|
||||
if (bufPos == bufSize) {
|
||||
flush();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void BufferedSink::flush() {
|
||||
if (bufPos == 0) return;
|
||||
if (bufPos == 0) {
|
||||
return;
|
||||
}
|
||||
size_t n = bufPos;
|
||||
bufPos = 0; // don't trigger the assert() in ~BufferedSink()
|
||||
write(buffer.get(), n);
|
||||
|
|
@ -97,15 +103,21 @@ std::string Source::drain() {
|
|||
}
|
||||
|
||||
size_t BufferedSource::read(unsigned char* data, size_t len) {
|
||||
if (!buffer) buffer = decltype(buffer)(new unsigned char[bufSize]);
|
||||
if (!buffer) {
|
||||
buffer = decltype(buffer)(new unsigned char[bufSize]);
|
||||
}
|
||||
|
||||
if (!bufPosIn) bufPosIn = readUnbuffered(buffer.get(), bufSize);
|
||||
if (!bufPosIn) {
|
||||
bufPosIn = readUnbuffered(buffer.get(), bufSize);
|
||||
}
|
||||
|
||||
/* Copy out the data in the buffer. */
|
||||
size_t n = len > bufPosIn - bufPosOut ? bufPosIn - bufPosOut : len;
|
||||
memcpy(data, buffer.get() + bufPosOut, n);
|
||||
bufPosOut += n;
|
||||
if (bufPosIn == bufPosOut) bufPosIn = bufPosOut = 0;
|
||||
if (bufPosIn == bufPosOut) {
|
||||
bufPosIn = bufPosOut = 0;
|
||||
}
|
||||
return n;
|
||||
}
|
||||
|
||||
|
|
@ -132,7 +144,9 @@ size_t FdSource::readUnbuffered(unsigned char* data, size_t len) {
|
|||
bool FdSource::good() { return _good; }
|
||||
|
||||
size_t StringSource::read(unsigned char* data, size_t len) {
|
||||
if (pos == s.size()) throw EndOfFile("end of string reached");
|
||||
if (pos == s.size()) {
|
||||
throw EndOfFile("end of string reached");
|
||||
}
|
||||
size_t n = s.copy((char*)data, len, pos);
|
||||
pos += n;
|
||||
return n;
|
||||
|
|
@ -162,7 +176,9 @@ std::unique_ptr<Source> sinkToSource(std::function<void(Sink&)> fun,
|
|||
if (!coro)
|
||||
coro = coro_t::pull_type([&](coro_t::push_type& yield) {
|
||||
LambdaSink sink([&](const unsigned char* data, size_t len) {
|
||||
if (len) yield(std::string((const char*)data, len));
|
||||
if (len) {
|
||||
yield(std::string((const char*)data, len));
|
||||
}
|
||||
});
|
||||
fun(sink);
|
||||
});
|
||||
|
|
@ -232,13 +248,17 @@ void readPadding(size_t len, Source& source) {
|
|||
size_t n = 8 - (len % 8);
|
||||
source(zero, n);
|
||||
for (unsigned int i = 0; i < n; i++)
|
||||
if (zero[i]) throw SerialisationError("non-zero padding");
|
||||
if (zero[i]) {
|
||||
throw SerialisationError("non-zero padding");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
size_t readString(unsigned char* buf, size_t max, Source& source) {
|
||||
auto len = readNum<size_t>(source);
|
||||
if (len > max) throw SerialisationError("string is too long");
|
||||
if (len > max) {
|
||||
throw SerialisationError("string is too long");
|
||||
}
|
||||
source(buf, len);
|
||||
readPadding(len, source);
|
||||
return len;
|
||||
|
|
@ -246,7 +266,9 @@ size_t readString(unsigned char* buf, size_t max, Source& source) {
|
|||
|
||||
string readString(Source& source, size_t max) {
|
||||
auto len = readNum<size_t>(source);
|
||||
if (len > max) throw SerialisationError("string is too long");
|
||||
if (len > max) {
|
||||
throw SerialisationError("string is too long");
|
||||
}
|
||||
std::string res(len, 0);
|
||||
source((unsigned char*)res.data(), len);
|
||||
readPadding(len, source);
|
||||
|
|
|
|||
24
third_party/nix/src/libutil/thread-pool.cc
vendored
24
third_party/nix/src/libutil/thread-pool.cc
vendored
|
|
@ -10,7 +10,9 @@ ThreadPool::ThreadPool(size_t _maxThreads) : maxThreads(_maxThreads) {
|
|||
|
||||
if (!maxThreads) {
|
||||
maxThreads = std::thread::hardware_concurrency();
|
||||
if (!maxThreads) maxThreads = 1;
|
||||
if (!maxThreads) {
|
||||
maxThreads = 1;
|
||||
}
|
||||
}
|
||||
|
||||
DLOG(INFO) << "starting pool of " << maxThreads - 1 << " threads";
|
||||
|
|
@ -26,7 +28,9 @@ void ThreadPool::shutdown() {
|
|||
std::swap(workers, state->workers);
|
||||
}
|
||||
|
||||
if (workers.empty()) return;
|
||||
if (workers.empty()) {
|
||||
return;
|
||||
}
|
||||
|
||||
DLOG(INFO) << "reaping " << workers.size() << " worker threads";
|
||||
|
||||
|
|
@ -62,7 +66,9 @@ void ThreadPool::process() {
|
|||
|
||||
assert(quit);
|
||||
|
||||
if (state->exception) std::rethrow_exception(state->exception);
|
||||
if (state->exception) {
|
||||
std::rethrow_exception(state->exception);
|
||||
}
|
||||
|
||||
} catch (...) {
|
||||
/* In the exceptional case, some workers may still be
|
||||
|
|
@ -76,7 +82,9 @@ void ThreadPool::process() {
|
|||
}
|
||||
|
||||
void ThreadPool::doWork(bool mainThread) {
|
||||
if (!mainThread) interruptCheck = [&]() { return (bool)quit; };
|
||||
if (!mainThread) {
|
||||
interruptCheck = [&]() { return (bool)quit; };
|
||||
}
|
||||
|
||||
bool didWork = false;
|
||||
std::exception_ptr exc;
|
||||
|
|
@ -114,9 +122,13 @@ void ThreadPool::doWork(bool mainThread) {
|
|||
/* Wait until a work item is available or we're asked to
|
||||
quit. */
|
||||
while (true) {
|
||||
if (quit) return;
|
||||
if (quit) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (!state->pending.empty()) break;
|
||||
if (!state->pending.empty()) {
|
||||
break;
|
||||
}
|
||||
|
||||
/* If there are no active or pending items, and the
|
||||
main thread is running process(), then no new items
|
||||
|
|
|
|||
12
third_party/nix/src/libutil/thread-pool.hh
vendored
12
third_party/nix/src/libutil/thread-pool.hh
vendored
|
|
@ -78,7 +78,9 @@ void processGraph(ThreadPool& pool, const std::set<T>& nodes,
|
|||
{
|
||||
auto graph(graph_.lock());
|
||||
auto i = graph->refs.find(node);
|
||||
if (i == graph->refs.end()) goto getRefs;
|
||||
if (i == graph->refs.end()) {
|
||||
goto getRefs;
|
||||
}
|
||||
goto doWork;
|
||||
}
|
||||
|
||||
|
|
@ -93,7 +95,9 @@ void processGraph(ThreadPool& pool, const std::set<T>& nodes,
|
|||
graph->refs[node].insert(ref);
|
||||
graph->rrefs[ref].insert(node);
|
||||
}
|
||||
if (graph->refs[node].empty()) goto doWork;
|
||||
if (graph->refs[node].empty()) {
|
||||
goto doWork;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -111,7 +115,9 @@ void processGraph(ThreadPool& pool, const std::set<T>& nodes,
|
|||
auto i = refs.find(node);
|
||||
assert(i != refs.end());
|
||||
refs.erase(i);
|
||||
if (refs.empty()) pool.enqueue(std::bind(worker, rref));
|
||||
if (refs.empty()) {
|
||||
pool.enqueue(std::bind(worker, rref));
|
||||
}
|
||||
}
|
||||
graph->left.erase(node);
|
||||
graph->refs.erase(node);
|
||||
|
|
|
|||
256
third_party/nix/src/libutil/util.cc
vendored
256
third_party/nix/src/libutil/util.cc
vendored
|
|
@ -107,7 +107,9 @@ Path canonPath(const Path& path, bool resolveSymlinks) {
|
|||
|
||||
string s;
|
||||
|
||||
if (path[0] != '/') throw Error(format("not an absolute path: '%1%'") % path);
|
||||
if (path[0] != '/') {
|
||||
throw Error(format("not an absolute path: '%1%'") % path);
|
||||
}
|
||||
|
||||
string::const_iterator i = path.begin(), end = path.end();
|
||||
string temp;
|
||||
|
|
@ -119,15 +121,21 @@ Path canonPath(const Path& path, bool resolveSymlinks) {
|
|||
while (1) {
|
||||
/* Skip slashes. */
|
||||
while (i != end && *i == '/') i++;
|
||||
if (i == end) break;
|
||||
if (i == end) {
|
||||
break;
|
||||
}
|
||||
|
||||
/* Ignore `.'. */
|
||||
if (*i == '.' && (i + 1 == end || i[1] == '/')) i++;
|
||||
if (*i == '.' && (i + 1 == end || i[1] == '/')) {
|
||||
i++;
|
||||
}
|
||||
|
||||
/* If `..', delete the last component. */
|
||||
else if (*i == '.' && i + 1 < end && i[1] == '.' &&
|
||||
(i + 2 == end || i[2] == '/')) {
|
||||
if (!s.empty()) s.erase(s.rfind('/'));
|
||||
if (!s.empty()) {
|
||||
s.erase(s.rfind('/'));
|
||||
}
|
||||
i += 2;
|
||||
}
|
||||
|
||||
|
|
@ -155,15 +163,21 @@ Path canonPath(const Path& path, bool resolveSymlinks) {
|
|||
|
||||
Path dirOf(const Path& path) {
|
||||
Path::size_type pos = path.rfind('/');
|
||||
if (pos == string::npos) return ".";
|
||||
if (pos == string::npos) {
|
||||
return ".";
|
||||
}
|
||||
return pos == 0 ? "/" : Path(path, 0, pos);
|
||||
}
|
||||
|
||||
string baseNameOf(const Path& path) {
|
||||
if (path.empty()) return "";
|
||||
if (path.empty()) {
|
||||
return "";
|
||||
}
|
||||
|
||||
Path::size_type last = path.length() - 1;
|
||||
if (path[last] == '/' && last > 0) last -= 1;
|
||||
if (path[last] == '/' && last > 0) {
|
||||
last -= 1;
|
||||
}
|
||||
|
||||
Path::size_type pos = path.rfind('/', last);
|
||||
if (pos == string::npos)
|
||||
|
|
@ -228,13 +242,17 @@ DirEntries readDirectory(const Path& path) {
|
|||
entries.reserve(64);
|
||||
|
||||
AutoCloseDir dir(opendir(path.c_str()));
|
||||
if (!dir) throw SysError(format("opening directory '%1%'") % path);
|
||||
if (!dir) {
|
||||
throw SysError(format("opening directory '%1%'") % path);
|
||||
}
|
||||
|
||||
struct dirent* dirent;
|
||||
while (errno = 0, dirent = readdir(dir.get())) { /* sic */
|
||||
checkInterrupt();
|
||||
string name = dirent->d_name;
|
||||
if (name == "." || name == "..") continue;
|
||||
if (name == "." || name == "..") {
|
||||
continue;
|
||||
}
|
||||
entries.emplace_back(name, dirent->d_ino,
|
||||
#ifdef HAVE_STRUCT_DIRENT_D_TYPE
|
||||
dirent->d_type
|
||||
|
|
@ -243,22 +261,32 @@ DirEntries readDirectory(const Path& path) {
|
|||
#endif
|
||||
);
|
||||
}
|
||||
if (errno) throw SysError(format("reading directory '%1%'") % path);
|
||||
if (errno) {
|
||||
throw SysError(format("reading directory '%1%'") % path);
|
||||
}
|
||||
|
||||
return entries;
|
||||
}
|
||||
|
||||
unsigned char getFileType(const Path& path) {
|
||||
struct stat st = lstat(path);
|
||||
if (S_ISDIR(st.st_mode)) return DT_DIR;
|
||||
if (S_ISLNK(st.st_mode)) return DT_LNK;
|
||||
if (S_ISREG(st.st_mode)) return DT_REG;
|
||||
if (S_ISDIR(st.st_mode)) {
|
||||
return DT_DIR;
|
||||
}
|
||||
if (S_ISLNK(st.st_mode)) {
|
||||
return DT_LNK;
|
||||
}
|
||||
if (S_ISREG(st.st_mode)) {
|
||||
return DT_REG;
|
||||
}
|
||||
return DT_UNKNOWN;
|
||||
}
|
||||
|
||||
string readFile(int fd) {
|
||||
struct stat st;
|
||||
if (fstat(fd, &st) == -1) throw SysError("statting file");
|
||||
if (fstat(fd, &st) == -1) {
|
||||
throw SysError("statting file");
|
||||
}
|
||||
|
||||
std::vector<unsigned char> buf(st.st_size);
|
||||
readFull(fd, buf.data(), st.st_size);
|
||||
|
|
@ -268,27 +296,35 @@ string readFile(int fd) {
|
|||
|
||||
string readFile(const Path& path, bool drain) {
|
||||
AutoCloseFD fd = open(path.c_str(), O_RDONLY | O_CLOEXEC);
|
||||
if (!fd) throw SysError(format("opening file '%1%'") % path);
|
||||
if (!fd) {
|
||||
throw SysError(format("opening file '%1%'") % path);
|
||||
}
|
||||
return drain ? drainFD(fd.get()) : readFile(fd.get());
|
||||
}
|
||||
|
||||
void readFile(const Path& path, Sink& sink) {
|
||||
AutoCloseFD fd = open(path.c_str(), O_RDONLY | O_CLOEXEC);
|
||||
if (!fd) throw SysError("opening file '%s'", path);
|
||||
if (!fd) {
|
||||
throw SysError("opening file '%s'", path);
|
||||
}
|
||||
drainFD(fd.get(), sink);
|
||||
}
|
||||
|
||||
void writeFile(const Path& path, const string& s, mode_t mode) {
|
||||
AutoCloseFD fd =
|
||||
open(path.c_str(), O_WRONLY | O_TRUNC | O_CREAT | O_CLOEXEC, mode);
|
||||
if (!fd) throw SysError(format("opening file '%1%'") % path);
|
||||
if (!fd) {
|
||||
throw SysError(format("opening file '%1%'") % path);
|
||||
}
|
||||
writeFull(fd.get(), s);
|
||||
}
|
||||
|
||||
void writeFile(const Path& path, Source& source, mode_t mode) {
|
||||
AutoCloseFD fd =
|
||||
open(path.c_str(), O_WRONLY | O_TRUNC | O_CREAT | O_CLOEXEC, mode);
|
||||
if (!fd) throw SysError(format("opening file '%1%'") % path);
|
||||
if (!fd) {
|
||||
throw SysError(format("opening file '%1%'") % path);
|
||||
}
|
||||
|
||||
std::vector<unsigned char> buf(64 * 1024);
|
||||
|
||||
|
|
@ -310,11 +346,15 @@ string readLine(int fd) {
|
|||
// FIXME: inefficient
|
||||
ssize_t rd = read(fd, &ch, 1);
|
||||
if (rd == -1) {
|
||||
if (errno != EINTR) throw SysError("reading a line");
|
||||
if (errno != EINTR) {
|
||||
throw SysError("reading a line");
|
||||
}
|
||||
} else if (rd == 0)
|
||||
throw EndOfFile("unexpected EOF reading a line");
|
||||
else {
|
||||
if (ch == '\n') return s;
|
||||
if (ch == '\n') {
|
||||
return s;
|
||||
}
|
||||
s += ch;
|
||||
}
|
||||
}
|
||||
|
|
@ -330,11 +370,15 @@ static void _deletePath(const Path& path, unsigned long long& bytesFreed) {
|
|||
|
||||
struct stat st;
|
||||
if (lstat(path.c_str(), &st) == -1) {
|
||||
if (errno == ENOENT) return;
|
||||
if (errno == ENOENT) {
|
||||
return;
|
||||
}
|
||||
throw SysError(format("getting status of '%1%'") % path);
|
||||
}
|
||||
|
||||
if (!S_ISDIR(st.st_mode) && st.st_nlink == 1) bytesFreed += st.st_size;
|
||||
if (!S_ISDIR(st.st_mode) && st.st_nlink == 1) {
|
||||
bytesFreed += st.st_size;
|
||||
}
|
||||
|
||||
if (S_ISDIR(st.st_mode)) {
|
||||
/* Make the directory accessible. */
|
||||
|
|
@ -349,7 +393,9 @@ static void _deletePath(const Path& path, unsigned long long& bytesFreed) {
|
|||
}
|
||||
|
||||
if (remove(path.c_str()) == -1) {
|
||||
if (errno == ENOENT) return;
|
||||
if (errno == ENOENT) {
|
||||
return;
|
||||
}
|
||||
throw SysError(format("cannot unlink '%1%'") % path);
|
||||
}
|
||||
}
|
||||
|
|
@ -409,7 +455,9 @@ Path createTempDir(const Path& tmpRoot, const Path& prefix, bool includePid,
|
|||
std::string getUserName() {
|
||||
auto pw = getpwuid(geteuid());
|
||||
std::string name = pw ? pw->pw_name : getEnv("USER", "");
|
||||
if (name.empty()) throw Error("cannot figure out user name");
|
||||
if (name.empty()) {
|
||||
throw Error("cannot figure out user name");
|
||||
}
|
||||
return name;
|
||||
}
|
||||
|
||||
|
|
@ -431,13 +479,17 @@ Path getHome() { return getHome2(); }
|
|||
|
||||
Path getCacheDir() {
|
||||
Path cacheDir = getEnv("XDG_CACHE_HOME");
|
||||
if (cacheDir.empty()) cacheDir = getHome() + "/.cache";
|
||||
if (cacheDir.empty()) {
|
||||
cacheDir = getHome() + "/.cache";
|
||||
}
|
||||
return cacheDir;
|
||||
}
|
||||
|
||||
Path getConfigDir() {
|
||||
Path configDir = getEnv("XDG_CONFIG_HOME");
|
||||
if (configDir.empty()) configDir = getHome() + "/.config";
|
||||
if (configDir.empty()) {
|
||||
configDir = getHome() + "/.config";
|
||||
}
|
||||
return configDir;
|
||||
}
|
||||
|
||||
|
|
@ -452,13 +504,17 @@ std::vector<Path> getConfigDirs() {
|
|||
|
||||
Path getDataDir() {
|
||||
Path dataDir = getEnv("XDG_DATA_HOME");
|
||||
if (dataDir.empty()) dataDir = getHome() + "/.local/share";
|
||||
if (dataDir.empty()) {
|
||||
dataDir = getHome() + "/.local/share";
|
||||
}
|
||||
return dataDir;
|
||||
}
|
||||
|
||||
Paths createDirs(const Path& path) {
|
||||
Paths created;
|
||||
if (path == "/") return created;
|
||||
if (path == "/") {
|
||||
return created;
|
||||
}
|
||||
|
||||
struct stat st;
|
||||
if (lstat(path.c_str(), &st) == -1) {
|
||||
|
|
@ -491,7 +547,9 @@ void replaceSymlink(const Path& target, const Path& link) {
|
|||
try {
|
||||
createSymlink(target, tmp);
|
||||
} catch (SysError& e) {
|
||||
if (e.errNo == EEXIST) continue;
|
||||
if (e.errNo == EEXIST) {
|
||||
continue;
|
||||
}
|
||||
throw;
|
||||
}
|
||||
|
||||
|
|
@ -507,10 +565,14 @@ void readFull(int fd, unsigned char* buf, size_t count) {
|
|||
checkInterrupt();
|
||||
ssize_t res = read(fd, (char*)buf, count);
|
||||
if (res == -1) {
|
||||
if (errno == EINTR) continue;
|
||||
if (errno == EINTR) {
|
||||
continue;
|
||||
}
|
||||
throw SysError("reading from file");
|
||||
}
|
||||
if (res == 0) throw EndOfFile("unexpected end-of-file");
|
||||
if (res == 0) {
|
||||
throw EndOfFile("unexpected end-of-file");
|
||||
}
|
||||
count -= res;
|
||||
buf += res;
|
||||
}
|
||||
|
|
@ -519,9 +581,13 @@ void readFull(int fd, unsigned char* buf, size_t count) {
|
|||
void writeFull(int fd, const unsigned char* buf, size_t count,
|
||||
bool allowInterrupts) {
|
||||
while (count) {
|
||||
if (allowInterrupts) checkInterrupt();
|
||||
if (allowInterrupts) {
|
||||
checkInterrupt();
|
||||
}
|
||||
ssize_t res = write(fd, (char*)buf, count);
|
||||
if (res == -1 && errno != EINTR) throw SysError("writing to file");
|
||||
if (res == -1 && errno != EINTR) {
|
||||
throw SysError("writing to file");
|
||||
}
|
||||
if (res > 0) {
|
||||
count -= res;
|
||||
buf += res;
|
||||
|
|
@ -560,8 +626,12 @@ void drainFD(int fd, Sink& sink, bool block) {
|
|||
checkInterrupt();
|
||||
ssize_t rd = read(fd, buf.data(), buf.size());
|
||||
if (rd == -1) {
|
||||
if (!block && (errno == EAGAIN || errno == EWOULDBLOCK)) break;
|
||||
if (errno != EINTR) throw SysError("reading from file");
|
||||
if (!block && (errno == EAGAIN || errno == EWOULDBLOCK)) {
|
||||
break;
|
||||
}
|
||||
if (errno != EINTR) {
|
||||
throw SysError("reading from file");
|
||||
}
|
||||
} else if (rd == 0)
|
||||
break;
|
||||
else
|
||||
|
|
@ -644,9 +714,13 @@ int AutoCloseFD::release() {
|
|||
void Pipe::create() {
|
||||
int fds[2];
|
||||
#if HAVE_PIPE2
|
||||
if (pipe2(fds, O_CLOEXEC) != 0) throw SysError("creating pipe");
|
||||
if (pipe2(fds, O_CLOEXEC) != 0) {
|
||||
throw SysError("creating pipe");
|
||||
}
|
||||
#else
|
||||
if (pipe(fds) != 0) throw SysError("creating pipe");
|
||||
if (pipe(fds) != 0) {
|
||||
throw SysError("creating pipe");
|
||||
}
|
||||
closeOnExec(fds[0]);
|
||||
closeOnExec(fds[1]);
|
||||
#endif
|
||||
|
|
@ -661,11 +735,15 @@ Pid::Pid() {}
|
|||
Pid::Pid(pid_t pid) : pid(pid) {}
|
||||
|
||||
Pid::~Pid() {
|
||||
if (pid != -1) kill();
|
||||
if (pid != -1) {
|
||||
kill();
|
||||
}
|
||||
}
|
||||
|
||||
void Pid::operator=(pid_t pid) {
|
||||
if (this->pid != -1 && this->pid != pid) kill();
|
||||
if (this->pid != -1 && this->pid != pid) {
|
||||
kill();
|
||||
}
|
||||
this->pid = pid;
|
||||
killSignal = SIGKILL; // reset signal to default
|
||||
}
|
||||
|
|
@ -744,11 +822,17 @@ void killUser(uid_t uid) {
|
|||
calling process. In the OSX libc, it's set to true,
|
||||
which means "follow POSIX", which we don't want here
|
||||
*/
|
||||
if (syscall(SYS_kill, -1, SIGKILL, false) == 0) break;
|
||||
if (syscall(SYS_kill, -1, SIGKILL, false) == 0) {
|
||||
break;
|
||||
}
|
||||
#else
|
||||
if (kill(-1, SIGKILL) == 0) break;
|
||||
if (kill(-1, SIGKILL) == 0) {
|
||||
break;
|
||||
}
|
||||
#endif
|
||||
if (errno == ESRCH) break; /* no more processes */
|
||||
if (errno == ESRCH) {
|
||||
break;
|
||||
} /* no more processes */
|
||||
if (errno != EINTR)
|
||||
throw SysError(format("cannot kill processes for uid '%1%'") % uid);
|
||||
}
|
||||
|
|
@ -780,7 +864,9 @@ static pid_t doFork(bool allowVfork, std::function<void()> fun) {
|
|||
#else
|
||||
pid_t pid = fork();
|
||||
#endif
|
||||
if (pid != 0) return pid;
|
||||
if (pid != 0) {
|
||||
return pid;
|
||||
}
|
||||
fun();
|
||||
abort();
|
||||
}
|
||||
|
|
@ -808,7 +894,9 @@ pid_t startProcess(std::function<void()> fun, const ProcessOptions& options) {
|
|||
};
|
||||
|
||||
pid_t pid = doFork(options.allowVfork, wrapper);
|
||||
if (pid == -1) throw SysError("unable to fork");
|
||||
if (pid == -1) {
|
||||
throw SysError("unable to fork");
|
||||
}
|
||||
|
||||
return pid;
|
||||
}
|
||||
|
|
@ -866,19 +954,27 @@ void runProgram2(const RunOptions& options) {
|
|||
|
||||
/* Create a pipe. */
|
||||
Pipe out, in;
|
||||
if (options.standardOut) out.create();
|
||||
if (source) in.create();
|
||||
if (options.standardOut) {
|
||||
out.create();
|
||||
}
|
||||
if (source) {
|
||||
in.create();
|
||||
}
|
||||
|
||||
ProcessOptions processOptions;
|
||||
// vfork implies that the environment of the main process and the fork will
|
||||
// be shared (technically this is undefined, but in practice that's the
|
||||
// case), so we can't use it if we alter the environment
|
||||
if (options.environment) processOptions.allowVfork = false;
|
||||
if (options.environment) {
|
||||
processOptions.allowVfork = false;
|
||||
}
|
||||
|
||||
/* Fork. */
|
||||
Pid pid = startProcess(
|
||||
[&]() {
|
||||
if (options.environment) replaceEnv(*options.environment);
|
||||
if (options.environment) {
|
||||
replaceEnv(*options.environment);
|
||||
}
|
||||
if (options.standardOut &&
|
||||
dup2(out.writeSide.get(), STDOUT_FILENO) == -1)
|
||||
throw SysError("dupping stdout");
|
||||
|
|
@ -919,7 +1015,9 @@ void runProgram2(const RunOptions& options) {
|
|||
std::promise<void> promise;
|
||||
|
||||
Finally doJoin([&]() {
|
||||
if (writerThread.joinable()) writerThread.join();
|
||||
if (writerThread.joinable()) {
|
||||
writerThread.join();
|
||||
}
|
||||
});
|
||||
|
||||
if (source) {
|
||||
|
|
@ -944,13 +1042,17 @@ void runProgram2(const RunOptions& options) {
|
|||
});
|
||||
}
|
||||
|
||||
if (options.standardOut) drainFD(out.readSide.get(), *options.standardOut);
|
||||
if (options.standardOut) {
|
||||
drainFD(out.readSide.get(), *options.standardOut);
|
||||
}
|
||||
|
||||
/* Wait for the child to finish. */
|
||||
int status = pid.wait();
|
||||
|
||||
/* Wait for the writer thread to finish. */
|
||||
if (source) promise.get_future().get();
|
||||
if (source) {
|
||||
promise.get_future().get();
|
||||
}
|
||||
|
||||
if (status)
|
||||
throw ExecError(status, fmt("program '%1%' %2%", options.program,
|
||||
|
|
@ -975,7 +1077,9 @@ void closeMostFDs(const set<int>& exceptions) {
|
|||
int maxFD = 0;
|
||||
maxFD = sysconf(_SC_OPEN_MAX);
|
||||
for (int fd = 0; fd < maxFD; ++fd)
|
||||
if (!exceptions.count(fd)) close(fd); /* ignore result */
|
||||
if (!exceptions.count(fd)) {
|
||||
close(fd);
|
||||
} /* ignore result */
|
||||
}
|
||||
|
||||
void closeOnExec(int fd) {
|
||||
|
|
@ -1012,7 +1116,9 @@ C tokenizeString(const string& s, const string& separators) {
|
|||
string::size_type pos = s.find_first_not_of(separators, 0);
|
||||
while (pos != string::npos) {
|
||||
string::size_type end = s.find_first_of(separators, pos + 1);
|
||||
if (end == string::npos) end = s.size();
|
||||
if (end == string::npos) {
|
||||
end = s.size();
|
||||
}
|
||||
string token(s, pos, end - pos);
|
||||
result.insert(result.end(), token);
|
||||
pos = s.find_first_not_of(separators, end);
|
||||
|
|
@ -1028,7 +1134,9 @@ template vector<string> tokenizeString(const string& s,
|
|||
string concatStringsSep(const string& sep, const Strings& ss) {
|
||||
string s;
|
||||
for (auto& i : ss) {
|
||||
if (s.size() != 0) s += sep;
|
||||
if (s.size() != 0) {
|
||||
s += sep;
|
||||
}
|
||||
s += i;
|
||||
}
|
||||
return s;
|
||||
|
|
@ -1037,7 +1145,9 @@ string concatStringsSep(const string& sep, const Strings& ss) {
|
|||
string concatStringsSep(const string& sep, const StringSet& ss) {
|
||||
string s;
|
||||
for (auto& i : ss) {
|
||||
if (s.size() != 0) s += sep;
|
||||
if (s.size() != 0) {
|
||||
s += sep;
|
||||
}
|
||||
s += i;
|
||||
}
|
||||
return s;
|
||||
|
|
@ -1050,14 +1160,18 @@ string chomp(const string& s) {
|
|||
|
||||
string trim(const string& s, const string& whitespace) {
|
||||
auto i = s.find_first_not_of(whitespace);
|
||||
if (i == string::npos) return "";
|
||||
if (i == string::npos) {
|
||||
return "";
|
||||
}
|
||||
auto j = s.find_last_not_of(whitespace);
|
||||
return string(s, i, j == string::npos ? j : j - i + 1);
|
||||
}
|
||||
|
||||
string replaceStrings(const std::string& s, const std::string& from,
|
||||
const std::string& to) {
|
||||
if (from.empty()) return s;
|
||||
if (from.empty()) {
|
||||
return s;
|
||||
}
|
||||
string res = s;
|
||||
size_t pos = 0;
|
||||
while ((pos = res.find(from, pos)) != std::string::npos) {
|
||||
|
|
@ -1143,12 +1257,18 @@ std::string filterANSIEscapes(const std::string& s, bool filterAll,
|
|||
// eat intermediate bytes
|
||||
while (i != s.end() && *i >= 0x20 && *i <= 0x2f) e += *i++;
|
||||
// eat final byte
|
||||
if (i != s.end() && *i >= 0x40 && *i <= 0x7e) e += last = *i++;
|
||||
if (i != s.end() && *i >= 0x40 && *i <= 0x7e) {
|
||||
e += last = *i++;
|
||||
}
|
||||
} else {
|
||||
if (i != s.end() && *i >= 0x40 && *i <= 0x5f) e += *i++;
|
||||
if (i != s.end() && *i >= 0x40 && *i <= 0x5f) {
|
||||
e += *i++;
|
||||
}
|
||||
}
|
||||
|
||||
if (!filterAll && last == 'm') t += e;
|
||||
if (!filterAll && last == 'm') {
|
||||
t += e;
|
||||
}
|
||||
}
|
||||
|
||||
else if (*i == '\t') {
|
||||
|
|
@ -1190,7 +1310,9 @@ string base64Encode(const string& s) {
|
|||
}
|
||||
}
|
||||
|
||||
if (nbits) res.push_back(base64Chars[data << (6 - nbits) & 0x3f]);
|
||||
if (nbits) {
|
||||
res.push_back(base64Chars[data << (6 - nbits) & 0x3f]);
|
||||
}
|
||||
while (res.size() % 4) res.push_back('=');
|
||||
|
||||
return res;
|
||||
|
|
@ -1212,11 +1334,17 @@ string base64Decode(const string& s) {
|
|||
unsigned int d = 0, bits = 0;
|
||||
|
||||
for (char c : s) {
|
||||
if (c == '=') break;
|
||||
if (c == '\n') continue;
|
||||
if (c == '=') {
|
||||
break;
|
||||
}
|
||||
if (c == '\n') {
|
||||
continue;
|
||||
}
|
||||
|
||||
char digit = decode[(unsigned char)c];
|
||||
if (digit == -1) throw Error("invalid character in Base64 string");
|
||||
if (digit == -1) {
|
||||
throw Error("invalid character in Base64 string");
|
||||
}
|
||||
|
||||
bits += 6;
|
||||
d = d << 6 | digit;
|
||||
|
|
|
|||
4
third_party/nix/src/libutil/util.hh
vendored
4
third_party/nix/src/libutil/util.hh
vendored
|
|
@ -416,7 +416,9 @@ class Callback {
|
|||
|
||||
Callback(Callback&& callback) : fun(std::move(callback.fun)) {
|
||||
auto prev = callback.done.test_and_set();
|
||||
if (prev) done.test_and_set();
|
||||
if (prev) {
|
||||
done.test_and_set();
|
||||
}
|
||||
}
|
||||
|
||||
void operator()(T&& t) noexcept {
|
||||
|
|
|
|||
16
third_party/nix/src/libutil/xml-writer.cc
vendored
16
third_party/nix/src/libutil/xml-writer.cc
vendored
|
|
@ -33,7 +33,9 @@ void XMLWriter::openElement(const string& name, const XMLAttrs& attrs) {
|
|||
output << "<" << name;
|
||||
writeAttrs(attrs);
|
||||
output << ">";
|
||||
if (indent) output << std::endl;
|
||||
if (indent) {
|
||||
output << std::endl;
|
||||
}
|
||||
pendingElems.push_back(name);
|
||||
}
|
||||
|
||||
|
|
@ -41,9 +43,13 @@ void XMLWriter::closeElement() {
|
|||
assert(!pendingElems.empty());
|
||||
indent_(pendingElems.size() - 1);
|
||||
output << "</" << pendingElems.back() << ">";
|
||||
if (indent) output << std::endl;
|
||||
if (indent) {
|
||||
output << std::endl;
|
||||
}
|
||||
pendingElems.pop_back();
|
||||
if (pendingElems.empty()) closed = true;
|
||||
if (pendingElems.empty()) {
|
||||
closed = true;
|
||||
}
|
||||
}
|
||||
|
||||
void XMLWriter::writeEmptyElement(const string& name, const XMLAttrs& attrs) {
|
||||
|
|
@ -52,7 +58,9 @@ void XMLWriter::writeEmptyElement(const string& name, const XMLAttrs& attrs) {
|
|||
output << "<" << name;
|
||||
writeAttrs(attrs);
|
||||
output << " />";
|
||||
if (indent) output << std::endl;
|
||||
if (indent) {
|
||||
output << std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void XMLWriter::writeAttrs(const XMLAttrs& attrs) {
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue