From 32d54c943f8fb2489f8dfef34a24ada5ecc43572 Mon Sep 17 00:00:00 2001 From: Nikola Matic Date: Thu, 17 Aug 2023 15:53:20 +0200 Subject: [PATCH] Purge using namespace std from libsolutil --- libsolutil/CommonData.cpp | 43 ++++++++++--------- libsolutil/CommonIO.cpp | 25 ++++++----- libsolutil/Exceptions.cpp | 11 +++-- libsolutil/IndentedWriter.cpp | 13 +++--- libsolutil/IpfsHash.cpp | 15 ++++--- libsolutil/JSON.cpp | 28 ++++++------- libsolutil/Keccak256.cpp | 2 - libsolutil/StringUtils.cpp | 47 +++++++++++---------- libsolutil/SwarmHash.cpp | 5 +-- libsolutil/TemporaryDirectory.cpp | 11 +++-- libsolutil/Whiskers.cpp | 69 +++++++++++++++---------------- scripts/check_style.sh | 1 + 12 files changed, 129 insertions(+), 141 deletions(-) diff --git a/libsolutil/CommonData.cpp b/libsolutil/CommonData.cpp index 437a090c2c28..0614abaf3090 100644 --- a/libsolutil/CommonData.cpp +++ b/libsolutil/CommonData.cpp @@ -29,7 +29,6 @@ #include -using namespace std; using namespace solidity; using namespace solidity::util; @@ -41,7 +40,7 @@ static char const* lowerHexChars = "0123456789abcdef"; } -string solidity::util::toHex(uint8_t _data, HexCase _case) +std::string solidity::util::toHex(uint8_t _data, HexCase _case) { assertThrow(_case != HexCase::Mixed, BadHexCase, "Mixed case can only be used for byte arrays."); @@ -53,7 +52,7 @@ string solidity::util::toHex(uint8_t _data, HexCase _case) }; } -string solidity::util::toHex(bytes const& _data, HexPrefix _prefix, HexCase _case) +std::string solidity::util::toHex(bytes const& _data, HexPrefix _prefix, HexCase _case) { std::string ret(_data.size() * 2 + (_prefix == HexPrefix::Add ? 2 : 0), 0); @@ -90,7 +89,7 @@ int solidity::util::fromHex(char _i, WhenError _throw) if (_i >= 'A' && _i <= 'F') return _i - 'A' + 10; if (_throw == WhenError::Throw) - assertThrow(false, BadHexCharacter, to_string(_i)); + assertThrow(false, BadHexCharacter, std::to_string(_i)); else return -1; } @@ -125,31 +124,31 @@ bytes solidity::util::fromHex(std::string const& _s, WhenError _throw) } -bool solidity::util::passesAddressChecksum(string const& _str, bool _strict) +bool solidity::util::passesAddressChecksum(std::string const& _str, bool _strict) { - string s = _str.substr(0, 2) == "0x" ? _str : "0x" + _str; + std::string s = _str.substr(0, 2) == "0x" ? _str : "0x" + _str; if (s.length() != 42) return false; if (!_strict && ( - s.find_first_of("abcdef") == string::npos || - s.find_first_of("ABCDEF") == string::npos + s.find_first_of("abcdef") == std::string::npos || + s.find_first_of("ABCDEF") == std::string::npos )) return true; return s == solidity::util::getChecksummedAddress(s); } -string solidity::util::getChecksummedAddress(string const& _addr) +std::string solidity::util::getChecksummedAddress(std::string const& _addr) { - string s = _addr.substr(0, 2) == "0x" ? _addr.substr(2) : _addr; + std::string s = _addr.substr(0, 2) == "0x" ? _addr.substr(2) : _addr; assertThrow(s.length() == 40, InvalidAddress, ""); - assertThrow(s.find_first_not_of("0123456789abcdefABCDEF") == string::npos, InvalidAddress, ""); + assertThrow(s.find_first_not_of("0123456789abcdefABCDEF") == std::string::npos, InvalidAddress, ""); h256 hash = keccak256(boost::algorithm::to_lower_copy(s, std::locale::classic())); - string ret = "0x"; + std::string ret = "0x"; for (unsigned i = 0; i < 40; ++i) { char addressCharacter = s[i]; @@ -162,16 +161,16 @@ string solidity::util::getChecksummedAddress(string const& _addr) return ret; } -bool solidity::util::isValidHex(string const& _string) +bool solidity::util::isValidHex(std::string const& _string) { if (_string.substr(0, 2) != "0x") return false; - if (_string.find_first_not_of("0123456789abcdefABCDEF", 2) != string::npos) + if (_string.find_first_not_of("0123456789abcdefABCDEF", 2) != std::string::npos) return false; return true; } -bool solidity::util::isValidDecimal(string const& _string) +bool solidity::util::isValidDecimal(std::string const& _string) { if (_string.empty()) return false; @@ -180,14 +179,14 @@ bool solidity::util::isValidDecimal(string const& _string) // No leading zeros if (_string.front() == '0') return false; - if (_string.find_first_not_of("0123456789") != string::npos) + if (_string.find_first_not_of("0123456789") != std::string::npos) return false; return true; } -string solidity::util::formatAsStringOrNumber(string const& _value) +std::string solidity::util::formatAsStringOrNumber(std::string const& _value) { - assertThrow(_value.length() <= 32, StringTooLong, "String to be formatted longer than 32 bytes."); + assertThrow(_value.length() <= 32, StringTooLong, "std::string to be formatted longer than 32 bytes."); for (auto const& c: _value) if (c <= 0x1f || c >= 0x7f || c == '"') @@ -197,9 +196,9 @@ string solidity::util::formatAsStringOrNumber(string const& _value) } -string solidity::util::escapeAndQuoteString(string const& _input) +std::string solidity::util::escapeAndQuoteString(std::string const& _input) { - string out; + std::string out; for (char c: _input) if (c == '\\') @@ -214,8 +213,8 @@ string solidity::util::escapeAndQuoteString(string const& _input) out += "\\t"; else if (!isPrint(c)) { - ostringstream o; - o << "\\x" << std::hex << setfill('0') << setw(2) << (unsigned)(unsigned char)(c); + std::ostringstream o; + o << "\\x" << std::hex << std::setfill('0') << std::setw(2) << (unsigned)(unsigned char)(c); out += o.str(); } else diff --git a/libsolutil/CommonIO.cpp b/libsolutil/CommonIO.cpp index 6089f4db66c0..06ce23a02401 100644 --- a/libsolutil/CommonIO.cpp +++ b/libsolutil/CommonIO.cpp @@ -31,7 +31,6 @@ #include #endif -using namespace std; using namespace solidity::util; namespace @@ -55,35 +54,35 @@ inline T readFile(boost::filesystem::path const& _file) // get length of file: is.seekg(0, is.end); - streamoff length = is.tellg(); + std::streamoff length = is.tellg(); if (length == 0) return ret; // do not read empty file (MSVC does not like it) is.seekg(0, is.beg); ret.resize((static_cast(length) + c_elementSize - 1) / c_elementSize); - is.read(const_cast(reinterpret_cast(ret.data())), static_cast(length)); + is.read(const_cast(reinterpret_cast(ret.data())), static_cast(length)); return ret; } } -string solidity::util::readFileAsString(boost::filesystem::path const& _file) +std::string solidity::util::readFileAsString(boost::filesystem::path const& _file) { - return readFile(_file); + return readFile(_file); } -string solidity::util::readUntilEnd(istream& _stdin) +std::string solidity::util::readUntilEnd(std::istream& _stdin) { - ostringstream ss; + std::ostringstream ss; ss << _stdin.rdbuf(); return ss.str(); } -string solidity::util::readBytes(istream& _input, size_t _length) +std::string solidity::util::readBytes(std::istream& _input, size_t _length) { - string output; + std::string output; output.resize(_length); - _input.read(output.data(), static_cast(_length)); + _input.read(output.data(), static_cast(_length)); // If read() reads fewer bytes it sets failbit in addition to eofbit. if (_input.fail()) output.resize(static_cast(_input.gcount())); @@ -135,10 +134,10 @@ class DisableConsoleBuffering int solidity::util::readStandardInputChar() { DisableConsoleBuffering disableConsoleBuffering; - return cin.get(); + return std::cin.get(); } -string solidity::util::absolutePath(string const& _path, string const& _reference) +std::string solidity::util::absolutePath(std::string const& _path, std::string const& _reference) { boost::filesystem::path p(_path); // Anything that does not start with `.` is an absolute path. @@ -158,6 +157,6 @@ string solidity::util::absolutePath(string const& _path, string const& _referenc return result.generic_string(); } -string solidity::util::sanitizePath(string const& _path) { +std::string solidity::util::sanitizePath(std::string const& _path) { return boost::filesystem::path(_path).generic_string(); } diff --git a/libsolutil/Exceptions.cpp b/libsolutil/Exceptions.cpp index fa4021d3be7b..00fe3e26ce92 100644 --- a/libsolutil/Exceptions.cpp +++ b/libsolutil/Exceptions.cpp @@ -18,13 +18,12 @@ #include -using namespace std; using namespace solidity::util; char const* Exception::what() const noexcept { // Return the comment if available. - if (string const* cmt = comment()) + if (std::string const* cmt = comment()) return cmt->data(); // Fallback to base what(). @@ -33,20 +32,20 @@ char const* Exception::what() const noexcept return std::exception::what(); } -string Exception::lineInfo() const +std::string Exception::lineInfo() const { char const* const* file = boost::get_error_info(*this); int const* line = boost::get_error_info(*this); - string ret; + std::string ret; if (file) ret += *file; ret += ':'; if (line) - ret += to_string(*line); + ret += std::to_string(*line); return ret; } -string const* Exception::comment() const noexcept +std::string const* Exception::comment() const noexcept { return boost::get_error_info(*this); } diff --git a/libsolutil/IndentedWriter.cpp b/libsolutil/IndentedWriter.cpp index 0e0aded3ccb2..b2a3c06c93c0 100644 --- a/libsolutil/IndentedWriter.cpp +++ b/libsolutil/IndentedWriter.cpp @@ -23,21 +23,20 @@ #include #include -using namespace std; using namespace solidity::util; -string IndentedWriter::format() const +std::string IndentedWriter::format() const { - string result; + std::string result; for (auto const& line: m_lines) - result += string(line.indentation * 4, ' ') + line.contents + "\n"; + result += std::string(line.indentation * 4, ' ') + line.contents + "\n"; return result; } void IndentedWriter::newLine() { if (!m_lines.back().contents.empty()) - m_lines.emplace_back(Line{string(), m_lines.back().indentation}); + m_lines.emplace_back(Line{std::string(), m_lines.back().indentation}); } void IndentedWriter::indent() @@ -53,12 +52,12 @@ void IndentedWriter::unindent() m_lines.back().indentation--; } -void IndentedWriter::add(string const& _str) +void IndentedWriter::add(std::string const& _str) { m_lines.back().contents += _str; } -void IndentedWriter::addLine(string const& _line) +void IndentedWriter::addLine(std::string const& _line) { newLine(); add(_line); diff --git a/libsolutil/IpfsHash.cpp b/libsolutil/IpfsHash.cpp index dbf411dc783d..3599b7121830 100644 --- a/libsolutil/IpfsHash.cpp +++ b/libsolutil/IpfsHash.cpp @@ -23,7 +23,6 @@ #include #include -using namespace std; using namespace solidity; using namespace solidity::util; @@ -56,11 +55,11 @@ bytes encodeLinkData(bytes const& _data) return bytes{0x12} + varintEncoding(_data.size()) + _data; } -string base58Encode(bytes const& _data) +std::string base58Encode(bytes const& _data) { - static string const alphabet{"123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"}; + static std::string const alphabet{"123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"}; bigint data(util::toHex(_data, HexPrefix::Add)); - string output; + std::string output; while (data) { output += alphabet[static_cast(data % alphabet.size())]; @@ -84,7 +83,7 @@ struct Chunk size_t blockSize = 0; }; -using Chunks = vector; +using Chunks = std::vector; Chunk combineLinks(Chunks& _links) { @@ -153,7 +152,7 @@ bytes groupChunksBottomUp(Chunks _currentLevel) } } -bytes solidity::util::ipfsHash(string _data) +bytes solidity::util::ipfsHash(std::string _data) { size_t const maxChunkSize = 1024 * 256; size_t chunkCount = _data.length() / maxChunkSize + (_data.length() % maxChunkSize > 0 ? 1 : 0); @@ -164,7 +163,7 @@ bytes solidity::util::ipfsHash(string _data) for (size_t chunkIndex = 0; chunkIndex < chunkCount; chunkIndex++) { bytes chunkBytes = asBytes( - _data.substr(chunkIndex * maxChunkSize, min(maxChunkSize, _data.length() - chunkIndex * maxChunkSize)) + _data.substr(chunkIndex * maxChunkSize, std::min(maxChunkSize, _data.length() - chunkIndex * maxChunkSize)) ); bytes lengthAsVarint = varintEncoding(chunkBytes.size()); @@ -197,7 +196,7 @@ bytes solidity::util::ipfsHash(string _data) return groupChunksBottomUp(std::move(allChunks)); } -string solidity::util::ipfsHashBase58(string _data) +std::string solidity::util::ipfsHashBase58(std::string _data) { return base58Encode(ipfsHash(std::move(_data))); } diff --git a/libsolutil/JSON.cpp b/libsolutil/JSON.cpp index d27982acb364..27dcf677f299 100644 --- a/libsolutil/JSON.cpp +++ b/libsolutil/JSON.cpp @@ -30,8 +30,6 @@ #include #include -using namespace std; - static_assert( (JSONCPP_VERSION_MAJOR == 1) && (JSONCPP_VERSION_MINOR == 9) && (JSONCPP_VERSION_PATCH == 3), "Unexpected jsoncpp version: " JSONCPP_VERSION_STRING ". Expecting 1.9.3." @@ -47,7 +45,7 @@ namespace class StreamWriterBuilder: public Json::StreamWriterBuilder { public: - explicit StreamWriterBuilder(map const& _settings) + explicit StreamWriterBuilder(std::map const& _settings) { for (auto const& iter: _settings) this->settings_[iter.first] = iter.second; @@ -68,10 +66,10 @@ class StrictModeCharReaderBuilder: public Json::CharReaderBuilder /// \param _input JSON input string /// \param _builder StreamWriterBuilder that is used to create new Json::StreamWriter /// \return serialized json object -string print(Json::Value const& _input, Json::StreamWriterBuilder const& _builder) +std::string print(Json::Value const& _input, Json::StreamWriterBuilder const& _builder) { - stringstream stream; - unique_ptr writer(_builder.newStreamWriter()); + std::stringstream stream; + std::unique_ptr writer(_builder.newStreamWriter()); writer->write(_input, &stream); return stream.str(); } @@ -82,9 +80,9 @@ string print(Json::Value const& _input, Json::StreamWriterBuilder const& _builde /// \param _json [out] resulting JSON object /// \param _errs [out] Formatted error messages /// \return \c true if the document was successfully parsed, \c false if an error occurred. -bool parse(Json::CharReaderBuilder& _builder, string const& _input, Json::Value& _json, string* _errs) +bool parse(Json::CharReaderBuilder& _builder, std::string const& _input, Json::Value& _json, std::string* _errs) { - unique_ptr reader(_builder.newCharReader()); + std::unique_ptr reader(_builder.newCharReader()); return reader->parse(_input.c_str(), _input.c_str() + _input.length(), &_json, _errs); } @@ -113,34 +111,34 @@ Json::Value removeNullMembers(Json::Value _json) return _json; } -string jsonPrettyPrint(Json::Value const& _input) +std::string jsonPrettyPrint(Json::Value const& _input) { return jsonPrint(_input, JsonFormat{ JsonFormat::Pretty }); } -string jsonCompactPrint(Json::Value const& _input) +std::string jsonCompactPrint(Json::Value const& _input) { return jsonPrint(_input, JsonFormat{ JsonFormat::Compact }); } -string jsonPrint(Json::Value const& _input, JsonFormat const& _format) +std::string jsonPrint(Json::Value const& _input, JsonFormat const& _format) { - map settings; + std::map settings; if (_format.format == JsonFormat::Pretty) { - settings["indentation"] = string(_format.indent, ' '); + settings["indentation"] = std::string(_format.indent, ' '); settings["enableYAMLCompatibility"] = true; } else settings["indentation"] = ""; StreamWriterBuilder writerBuilder(settings); - string result = print(_input, writerBuilder); + std::string result = print(_input, writerBuilder); if (_format.format == JsonFormat::Pretty) boost::replace_all(result, " \n", "\n"); return result; } -bool jsonParseStrict(string const& _input, Json::Value& _json, string* _errs /* = nullptr */) +bool jsonParseStrict(std::string const& _input, Json::Value& _json, std::string* _errs /* = nullptr */) { static StrictModeCharReaderBuilder readerBuilder; return parse(readerBuilder, _input, _json, _errs); diff --git a/libsolutil/Keccak256.cpp b/libsolutil/Keccak256.cpp index 212804904974..c54dedabeb8f 100644 --- a/libsolutil/Keccak256.cpp +++ b/libsolutil/Keccak256.cpp @@ -25,8 +25,6 @@ #include #include -using namespace std; - namespace solidity::util { diff --git a/libsolutil/StringUtils.cpp b/libsolutil/StringUtils.cpp index d1c96fb2e227..de3a95668d32 100644 --- a/libsolutil/StringUtils.cpp +++ b/libsolutil/StringUtils.cpp @@ -19,18 +19,17 @@ * @author Balajiganapathi S * @date 2017 * - * String routines + * std::string routines */ #include #include #include -using namespace std; using namespace solidity; using namespace solidity::util; -bool solidity::util::stringWithinDistance(string const& _str1, string const& _str2, size_t _maxDistance, size_t _lenThreshold) +bool solidity::util::stringWithinDistance(std::string const& _str1, std::string const& _str2, size_t _maxDistance, size_t _lenThreshold) { if (_str1 == _str2) return true; @@ -47,13 +46,13 @@ bool solidity::util::stringWithinDistance(string const& _str1, string const& _st return distance <= _maxDistance && distance < n1 && distance < n2; } -size_t solidity::util::stringDistance(string const& _str1, string const& _str2) +size_t solidity::util::stringDistance(std::string const& _str1, std::string const& _str2) { size_t n1 = _str1.size(); size_t n2 = _str2.size(); // Optimize by storing only last 2 rows and current row. So first index is considered modulo 3 // This is a two-dimensional array of size 3 x (n2 + 1). - vector dp(3 * (n2 + 1)); + std::vector dp(3 * (n2 + 1)); // In this dp formulation of Damerau–Levenshtein distance we are assuming that the strings are 1-based to make base case storage easier. // So index accesser to _name1 and _name2 have to be adjusted accordingly @@ -61,25 +60,25 @@ size_t solidity::util::stringDistance(string const& _str1, string const& _str2) for (size_t i2 = 0; i2 <= n2; ++i2) { size_t x = 0; - if (min(i1, i2) == 0) // base case - x = max(i1, i2); + if (std::min(i1, i2) == 0) // base case + x = std::max(i1, i2); else { size_t left = dp[(i1 - 1) % 3 + i2 * 3]; size_t up = dp[(i1 % 3) + (i2 - 1) * 3]; size_t upleft = dp[((i1 - 1) % 3) + (i2 - 1) * 3]; // deletion and insertion - x = min(left + 1, up + 1); + x = std::min(left + 1, up + 1); if (_str1[i1-1] == _str2[i2-1]) // same chars, can skip - x = min(x, upleft); + x = std::min(x, upleft); else // different chars so try substitution - x = min(x, upleft + 1); + x = std::min(x, upleft + 1); // transposing if (i1 > 1 && i2 > 1 && _str1[i1 - 1] == _str2[i2 - 2] && _str1[i1 - 2] == _str2[i2 - 1]) - x = min(x, dp[((i1 - 2) % 3) + (i2 - 2) * 3] + 1); + x = std::min(x, dp[((i1 - 2) % 3) + (i2 - 2) * 3] + 1); } dp[(i1 % 3) + i2 * 3] = x; } @@ -87,9 +86,9 @@ size_t solidity::util::stringDistance(string const& _str1, string const& _str2) return dp[(n1 % 3) + n2 * 3]; } -string solidity::util::quotedAlternativesList(vector const& suggestions) +std::string solidity::util::quotedAlternativesList(std::vector const& suggestions) { - vector quotedSuggestions; + std::vector quotedSuggestions; for (auto& suggestion: suggestions) quotedSuggestions.emplace_back("\"" + suggestion + "\""); @@ -97,20 +96,20 @@ string solidity::util::quotedAlternativesList(vector const& suggestions) return joinHumanReadable(quotedSuggestions, ", ", " or "); } -string solidity::util::suffixedVariableNameList(string const& _baseName, size_t _startSuffix, size_t _endSuffix) +std::string solidity::util::suffixedVariableNameList(std::string const& _baseName, size_t _startSuffix, size_t _endSuffix) { - string result; + std::string result; if (_startSuffix < _endSuffix) { - result = _baseName + to_string(_startSuffix++); + result = _baseName + std::to_string(_startSuffix++); while (_startSuffix < _endSuffix) - result += ", " + _baseName + to_string(_startSuffix++); + result += ", " + _baseName + std::to_string(_startSuffix++); } else if (_endSuffix < _startSuffix) { - result = _baseName + to_string(_endSuffix++); + result = _baseName + std::to_string(_endSuffix++); while (_endSuffix < _startSuffix) - result = _baseName + to_string(_endSuffix++) + ", " + result; + result = _baseName + std::to_string(_endSuffix++) + ", " + result; } return result; } @@ -119,7 +118,7 @@ namespace { /// Try to format as N * 2**x -optional tryFormatPowerOfTwo(bigint const& _value) +std::optional tryFormatPowerOfTwo(bigint const& _value) { bigint prefix = _value; @@ -128,7 +127,7 @@ optional tryFormatPowerOfTwo(bigint const& _value) for (; (prefix & 0xff) == 0; prefix >>= 8) ++i; if (i <= 2) - return nullopt; + return std::nullopt; // 0x100 yields 2**8 (N is 1 and redundant) if (prefix == 1) @@ -150,11 +149,11 @@ optional tryFormatPowerOfTwo(bigint const& _value) } -string solidity::util::formatNumberReadable(bigint const& _value, bool _useTruncation) +std::string solidity::util::formatNumberReadable(bigint const& _value, bool _useTruncation) { bool const isNegative = _value < 0; bigint const absValue = isNegative ? (bigint(-1) * _value) : bigint(_value); - string const sign = isNegative ? "-" : ""; + std::string const sign = isNegative ? "-" : ""; // smaller numbers return as decimal if (absValue <= 0x1000000) @@ -165,7 +164,7 @@ string solidity::util::formatNumberReadable(bigint const& _value, bool _useTrunc else if (auto result = tryFormatPowerOfTwo(absValue + 1)) return {sign + *result + (isNegative ? " + 1" : " - 1")}; - string str = toHex(toCompactBigEndian(absValue), HexPrefix::Add, HexCase::Mixed); + std::string str = toHex(toCompactBigEndian(absValue), HexPrefix::Add, HexCase::Mixed); if (_useTruncation) { diff --git a/libsolutil/SwarmHash.cpp b/libsolutil/SwarmHash.cpp index 32e798d160d1..cf47cb15935b 100644 --- a/libsolutil/SwarmHash.cpp +++ b/libsolutil/SwarmHash.cpp @@ -22,7 +22,6 @@ #include -using namespace std; using namespace solidity; using namespace solidity::util; @@ -42,7 +41,7 @@ h256 swarmHashSimple(bytesConstRef _data, size_t _size) return keccak256(toLittleEndian(_size) + _data.toBytes()); } -h256 swarmHashIntermediate(string const& _input, size_t _offset, size_t _length) +h256 swarmHashIntermediate(std::string const& _input, size_t _offset, size_t _length) { bytesConstRef ref; bytes innerNodes; @@ -104,7 +103,7 @@ h256 chunkHash(bytesConstRef const _data, bool _forceHigherLevel = false) } -h256 solidity::util::bzzr0Hash(string const& _input) +h256 solidity::util::bzzr0Hash(std::string const& _input) { return swarmHashIntermediate(_input, 0, _input.size()); } diff --git a/libsolutil/TemporaryDirectory.cpp b/libsolutil/TemporaryDirectory.cpp index e82d87cf21ac..ff4504794156 100644 --- a/libsolutil/TemporaryDirectory.cpp +++ b/libsolutil/TemporaryDirectory.cpp @@ -26,7 +26,6 @@ #include #include -using namespace std; using namespace solidity; using namespace solidity::util; @@ -42,8 +41,8 @@ TemporaryDirectory::TemporaryDirectory(std::string const& _prefix): } TemporaryDirectory::TemporaryDirectory( - vector const& _subdirectories, - string const& _prefix + std::vector const& _subdirectories, + std::string const& _prefix ): TemporaryDirectory(_prefix) { @@ -71,9 +70,9 @@ TemporaryDirectory::~TemporaryDirectory() uintmax_t numRemoved = fs::remove_all(m_path, errorCode); if (errorCode.value() != boost::system::errc::success) { - cerr << "Failed to completely remove temporary directory '" << m_path << "'. "; - cerr << "Only " << numRemoved << " files were actually removed." << endl; - cerr << "Reason: " << errorCode.message() << endl; + std::cerr << "Failed to completely remove temporary directory '" << m_path << "'. "; + std::cerr << "Only " << numRemoved << " files were actually removed." << std::endl; + std::cerr << "Reason: " << errorCode.message() << std::endl; } } diff --git a/libsolutil/Whiskers.cpp b/libsolutil/Whiskers.cpp index b6d3ebde0cd6..1f026d9464a7 100644 --- a/libsolutil/Whiskers.cpp +++ b/libsolutil/Whiskers.cpp @@ -28,16 +28,15 @@ #include -using namespace std; using namespace solidity::util; -Whiskers::Whiskers(string _template): +Whiskers::Whiskers(std::string _template): m_template(std::move(_template)) { checkTemplateValid(); } -Whiskers& Whiskers::operator()(string _parameter, string _value) +Whiskers& Whiskers::operator()(std::string _parameter, std::string _value) { checkParameterValid(_parameter); checkParameterUnknown(_parameter); @@ -46,7 +45,7 @@ Whiskers& Whiskers::operator()(string _parameter, string _value) return *this; } -Whiskers& Whiskers::operator()(string _parameter, bool _value) +Whiskers& Whiskers::operator()(std::string _parameter, bool _value) { checkParameterValid(_parameter); checkParameterUnknown(_parameter); @@ -56,8 +55,8 @@ Whiskers& Whiskers::operator()(string _parameter, bool _value) } Whiskers& Whiskers::operator()( - string _listParameter, - vector> _values + std::string _listParameter, + std::vector> _values ) { checkParameterValid(_listParameter); @@ -70,15 +69,15 @@ Whiskers& Whiskers::operator()( return *this; } -string Whiskers::render() const +std::string Whiskers::render() const { return replace(m_template, m_parameters, m_conditions, m_listParameters); } void Whiskers::checkTemplateValid() const { - regex validTemplate("<[#?!\\/]\\+{0,1}[a-zA-Z0-9_$-]+(?:[^a-zA-Z0-9_$>-]|$)"); - smatch match; + std::regex validTemplate("<[#?!\\/]\\+{0,1}[a-zA-Z0-9_$-]+(?:[^a-zA-Z0-9_$>-]|$)"); + std::smatch match; assertThrow( !regex_search(m_template, match, validTemplate), WhiskersError, @@ -86,9 +85,9 @@ void Whiskers::checkTemplateValid() const ); } -void Whiskers::checkParameterValid(string const& _parameter) const +void Whiskers::checkParameterValid(std::string const& _parameter) const { - static regex validParam("^" + paramRegex() + "$"); + static std::regex validParam("^" + paramRegex() + "$"); assertThrow( regex_match(_parameter, validParam), WhiskersError, @@ -96,7 +95,7 @@ void Whiskers::checkParameterValid(string const& _parameter) const ); } -void Whiskers::checkParameterUnknown(string const& _parameter) const +void Whiskers::checkParameterUnknown(std::string const& _parameter) const { assertThrow( !m_parameters.count(_parameter), @@ -115,13 +114,13 @@ void Whiskers::checkParameterUnknown(string const& _parameter) const ); } -void Whiskers::checkTemplateContainsTags(string const& _parameter, vector const& _prefixes) const +void Whiskers::checkTemplateContainsTags(std::string const& _parameter, std::vector const& _prefixes) const { for (auto const& prefix: _prefixes) { - string tag{"<" + prefix + _parameter + ">"}; + std::string tag{"<" + prefix + _parameter + ">"}; assertThrow( - m_template.find(tag) != string::npos, + m_template.find(tag) != std::string::npos, WhiskersError, "Tag '" + tag + "' not found in template:\n" + m_template ); @@ -131,17 +130,17 @@ void Whiskers::checkTemplateContainsTags(string const& _parameter, vector -string regex_replace( - string const& _source, - regex const& _pattern, +std::string regex_replace( + std::string const& _source, + std::regex const& _pattern, ReplaceCallback _replace, - regex_constants::match_flag_type _flags = regex_constants::match_default + std::regex_constants::match_flag_type _flags = std::regex_constants::match_default ) { - sregex_iterator curMatch(_source.begin(), _source.end(), _pattern, _flags); - sregex_iterator matchEnd; - string::const_iterator lastMatchedPos(_source.cbegin()); - string result; + std::sregex_iterator curMatch(_source.begin(), _source.end(), _pattern, _flags); + std::sregex_iterator matchEnd; + std::string::const_iterator lastMatchedPos(_source.cbegin()); + std::string result; while (curMatch != matchEnd) { result.append(curMatch->prefix().first, curMatch->prefix().second); @@ -154,23 +153,23 @@ string regex_replace( } } -string Whiskers::replace( - string const& _template, +std::string Whiskers::replace( + std::string const& _template, StringMap const& _parameters, - map const& _conditions, - map> const& _listParameters + std::map const& _conditions, + std::map> const& _listParameters ) { - static regex listOrTag( + static std::regex listOrTag( "<(" + paramRegex() + ")>|" "<#(" + paramRegex() + ")>((?:.|\\r|\\n)*?)|" "<\\?(\\+?" + paramRegex() + ")>((?:.|\\r|\\n)*?)(((?:.|\\r|\\n)*?))?" ); - return regex_replace(_template, listOrTag, [&](match_results _match) -> string + return regex_replace(_template, listOrTag, [&](std::match_results _match) -> std::string { - string tagName(_match[1]); - string listName(_match[2]); - string conditionName(_match[4]); + std::string tagName(_match[1]); + std::string listName(_match[2]); + std::string conditionName(_match[4]); if (!tagName.empty()) { assertThrow( @@ -184,12 +183,12 @@ string Whiskers::replace( } else if (!listName.empty()) { - string templ(_match[3]); + std::string templ(_match[3]); assertThrow( _listParameters.count(listName), WhiskersError, "List parameter " + listName + " not set." ); - string replacement; + std::string replacement; for (auto const& parameters: _listParameters.at(listName)) replacement += replace(templ, joinMaps(_parameters, parameters), _conditions); return replacement; @@ -200,7 +199,7 @@ string Whiskers::replace( bool conditionValue = false; if (conditionName[0] == '+') { - string tag = conditionName.substr(1); + std::string tag = conditionName.substr(1); if (_parameters.count(tag)) conditionValue = !_parameters.at(tag).empty(); diff --git a/scripts/check_style.sh b/scripts/check_style.sh index 7c1167490a58..5288cb9a5c6a 100755 --- a/scripts/check_style.sh +++ b/scripts/check_style.sh @@ -33,6 +33,7 @@ NAMESPACE_STD_FREE_FILES=( libsolidity/interface/* libsolidity/lsp/* libsolidity/parsing/* + libsolutil/* ) (