Chiebot-Mirror
/
protobuf
mirror of https://github.com/protocolbuffers/protobuf.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

Revert all changes to strutil.{h,cc} from this PR

Browse Source
pull/10148/head
Jorg Brown 2 years ago
parent a075d2fb14
commit 24d0a3bed1
2 changed files with 77 additions and 73 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 84
      src/google/protobuf/stubs/strutil.cc
  2. 66
      src/google/protobuf/stubs/strutil.h

84
src/google/protobuf/stubs/strutil.cc
Unescape View File

@ -43,8 +43,6 @@
#include <google/protobuf/stubs/logging.h> #include <google/protobuf/stubs/logging.h>
#include <google/protobuf/stubs/stl_util.h> #include <google/protobuf/stubs/stl_util.h>
#undef StringReplace
#ifdef _WIN32 #ifdef _WIN32
// MSVC has only _snprintf, not snprintf. // MSVC has only _snprintf, not snprintf.
// //
@ -131,15 +129,11 @@ void StripWhitespace(std::string *str) {
// it only replaces the first instance of "old." // it only replaces the first instance of "old."
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
#define DONOTCHECKIN_GOOGLE_DCHECK_NO_OVERLAP(dest, src) \ void StringReplace(const std::string &s, const std::string &oldsub,
GOOGLE_DCHECK_GT(uintptr_t((src).data() - (dest).data()), \ const std::string &newsub, bool replace_all,
uintptr_t((dest).size())) std::string *res) {
void StringReplace(StringPiece s, StringPiece oldsub, StringPiece newsub,
bool replace_all, std::string *res, const char *filename, int linenum) {
if (oldsub.empty()) { if (oldsub.empty()) {
DONOTCHECKIN_GOOGLE_DCHECK_NO_OVERLAP(*res, s); res->append(s); // if empty, append the given string.
StrAppend(res, s); // if empty, append the given string.
return; return;
} }
@ -150,15 +144,11 @@ void StringReplace(StringPiece s, StringPiece oldsub, StringPiece newsub,
if (pos == std::string::npos) { if (pos == std::string::npos) {
break; break;
} }
DONOTCHECKIN_GOOGLE_DCHECK_NO_OVERLAP(*res, s); res->append(s, start_pos, pos - start_pos);
StrAppend(res, s.substr(start_pos, pos - start_pos)); res->append(newsub);
DONOTCHECKIN_GOOGLE_DCHECK_NO_OVERLAP(*res, newsub);
StrAppend(res, newsub);
start_pos = pos + oldsub.size(); // start searching again after the "old" start_pos = pos + oldsub.size(); // start searching again after the "old"
} while (replace_all); } while (replace_all);
DONOTCHECKIN_GOOGLE_DCHECK_NO_OVERLAP(*res, s) res->append(s, start_pos, s.length() - start_pos);
<< " file=" << (filename ? filename : "") << " line=" << linenum;
StrAppend(res, s.substr(start_pos, s.length() - start_pos));
} }
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
@ -170,10 +160,10 @@ void StringReplace(StringPiece s, StringPiece oldsub, StringPiece newsub,
// happened or not. // happened or not.
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
std::string StringReplaceImpl(StringPiece s, StringPiece oldsub, StringPiece newsub, std::string StringReplace(const std::string &s, const std::string &oldsub,
bool replace_all, const char *filename, int linenum) { const std::string &newsub, bool replace_all) {
std::string ret; std::string ret;
StringReplace(s, oldsub, newsub, replace_all, &ret, filename, linenum); StringReplace(s, oldsub, newsub, replace_all, &ret);
return ret; return ret;
} }
@ -455,24 +445,22 @@ int UnescapeCEscapeSequences(const char *source, char *dest,
// In the first and second calls, the length of dest is returned. In the // In the first and second calls, the length of dest is returned. In the
// the third call, the new string is returned. // the third call, the new string is returned.
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
int UnescapeCEscapeString(StringPiece src, std::string *dest) { int UnescapeCEscapeString(const std::string &src, std::string *dest) {
return UnescapeCEscapeString(src, dest, nullptr); return UnescapeCEscapeString(src, dest, nullptr);
} }
int UnescapeCEscapeString(StringPiece src, std::string *dest, int UnescapeCEscapeString(const std::string &src, std::string *dest,
std::vector<std::string> *errors) { std::vector<std::string> *errors) {
std::unique_ptr<char[]> unescaped(new char[src.size() + 1]); std::unique_ptr<char[]> unescaped(new char[src.size() + 1]);
int len = UnescapeCEscapeSequences(std::string(src).c_str(), unescaped.get(), int len = UnescapeCEscapeSequences(src.c_str(), unescaped.get(), errors);
errors);
GOOGLE_CHECK(dest); GOOGLE_CHECK(dest);
dest->assign(unescaped.get(), len); dest->assign(unescaped.get(), len);
return len; return len;
} }
std::string UnescapeCEscapeString(StringPiece src) { std::string UnescapeCEscapeString(const std::string &src) {
std::unique_ptr<char[]> unescaped(new char[src.size() + 1]); std::unique_ptr<char[]> unescaped(new char[src.size() + 1]);
int len = UnescapeCEscapeSequences(std::string(src).c_str(), unescaped.get(), int len = UnescapeCEscapeSequences(src.c_str(), unescaped.get(), nullptr);
nullptr);
return std::string(unescaped.get(), len); return std::string(unescaped.get(), len);
} }
@ -513,11 +501,9 @@ int CEscapeInternal(const char* src, int src_len, char* dest,
if ((!utf8_safe || static_cast<uint8_t>(*src) < 0x80) && if ((!utf8_safe || static_cast<uint8_t>(*src) < 0x80) &&
(!isprint(*src) || (!isprint(*src) ||
(last_hex_escape && isxdigit(*src)))) { (last_hex_escape && isxdigit(*src)))) {
// need space for 4 letter escape and the trailing '\0' to if (dest_len - used < 4) // need space for 4 letter escape
// be written by snprintf.
if (dest_len - used < 5)
return -1; return -1;
snprintf(dest + used, 5, (use_hex ? "\\x%02x" : "\\%03o"), sprintf(dest + used, (use_hex ? "\\x%02x" : "\\%03o"),
static_cast<uint8_t>(*src)); static_cast<uint8_t>(*src));
is_hex_escape = use_hex; is_hex_escape = use_hex;
used += 4; used += 4;
@ -606,7 +592,7 @@ void CEscapeAndAppend(StringPiece src, std::string *dest) {
} }
} }
std::string CEscape(StringPiece src) { std::string CEscape(const std::string &src) {
std::string dest; std::string dest;
CEscapeAndAppend(src, &dest); CEscapeAndAppend(src, &dest);
return dest; return dest;
@ -614,7 +600,7 @@ std::string CEscape(StringPiece src) {
namespace strings { namespace strings {
std::string Utf8SafeCEscape(StringPiece src) { std::string Utf8SafeCEscape(const std::string &src) {
const int dest_length = src.size() * 4 + 1; // Maximum possible expansion const int dest_length = src.size() * 4 + 1; // Maximum possible expansion
std::unique_ptr<char[]> dest(new char[dest_length]); std::unique_ptr<char[]> dest(new char[dest_length]);
const int len = CEscapeInternal(src.data(), src.size(), const int len = CEscapeInternal(src.data(), src.size(),
@ -623,7 +609,7 @@ std::string Utf8SafeCEscape(StringPiece src) {
return std::string(dest.get(), len); return std::string(dest.get(), len);
} }
std::string CHexEscape(StringPiece src) { std::string CHexEscape(const std::string &src) {
const int dest_length = src.size() * 4 + 1; // Maximum possible expansion const int dest_length = src.size() * 4 + 1; // Maximum possible expansion
std::unique_ptr<char[]> dest(new char[dest_length]); std::unique_ptr<char[]> dest(new char[dest_length]);
const int len = CEscapeInternal(src.data(), src.size(), const int len = CEscapeInternal(src.data(), src.size(),
@ -677,7 +663,7 @@ uint32_t strtou32_adaptor(const char *nptr, char **endptr, int base) {
return static_cast<uint32_t>(result); return static_cast<uint32_t>(result);
} }
inline bool safe_parse_sign(StringPiece *text /*inout*/, inline bool safe_parse_sign(std::string *text /*inout*/,
bool *negative_ptr /*output*/) { bool *negative_ptr /*output*/) {
const char* start = text->data(); const char* start = text->data();
const char* end = start + text->size(); const char* end = start + text->size();
@ -706,7 +692,7 @@ inline bool safe_parse_sign(StringPiece *text /*inout*/,
} }
template <typename IntType> template <typename IntType>
bool safe_parse_positive_int(StringPiece text, IntType *value_p) { bool safe_parse_positive_int(std::string text, IntType *value_p) {
int base = 10; int base = 10;
IntType value = 0; IntType value = 0;
const IntType vmax = std::numeric_limits<IntType>::max(); const IntType vmax = std::numeric_limits<IntType>::max();
@ -739,7 +725,7 @@ bool safe_parse_positive_int(StringPiece text, IntType *value_p) {
} }
template <typename IntType> template <typename IntType>
bool safe_parse_negative_int(StringPiece text, IntType *value_p) { bool safe_parse_negative_int(const std::string &text, IntType *value_p) {
int base = 10; int base = 10;
IntType value = 0; IntType value = 0;
const IntType vmin = std::numeric_limits<IntType>::min(); const IntType vmin = std::numeric_limits<IntType>::min();
@ -779,7 +765,7 @@ bool safe_parse_negative_int(StringPiece text, IntType *value_p) {
} }
template <typename IntType> template <typename IntType>
bool safe_int_internal(StringPiece text, IntType *value_p) { bool safe_int_internal(std::string text, IntType *value_p) {
*value_p = 0; *value_p = 0;
bool negative; bool negative;
if (!safe_parse_sign(&text, &negative)) { if (!safe_parse_sign(&text, &negative)) {
@ -793,7 +779,7 @@ bool safe_int_internal(StringPiece text, IntType *value_p) {
} }
template <typename IntType> template <typename IntType>
bool safe_uint_internal(StringPiece text, IntType *value_p) { bool safe_uint_internal(std::string text, IntType *value_p) {
*value_p = 0; *value_p = 0;
bool negative; bool negative;
if (!safe_parse_sign(&text, &negative) || negative) { if (!safe_parse_sign(&text, &negative) || negative) {
@ -1355,19 +1341,19 @@ bool safe_strtod(const char* str, double* value) {
return *str != '\0' && *endptr == '\0'; return *str != '\0' && *endptr == '\0';
} }
bool safe_strto32(StringPiece str, int32_t *value) { bool safe_strto32(const std::string &str, int32_t *value) {
return safe_int_internal(str, value); return safe_int_internal(str, value);
} }
bool safe_strtou32(StringPiece str, uint32_t *value) { bool safe_strtou32(const std::string &str, uint32_t *value) {
return safe_uint_internal(str, value); return safe_uint_internal(str, value);
} }
bool safe_strto64(StringPiece str, int64_t *value) { bool safe_strto64(const std::string &str, int64_t *value) {
return safe_int_internal(str, value); return safe_int_internal(str, value);
} }
bool safe_strtou64(StringPiece str, uint64_t *value) { bool safe_strtou64(const std::string &str, uint64_t *value) {
return safe_uint_internal(str, value); return safe_uint_internal(str, value);
} }
@ -1625,8 +1611,8 @@ void StrAppend(std::string *result, const AlphaNum &a, const AlphaNum &b,
GOOGLE_DCHECK_EQ(out, begin + result->size()); GOOGLE_DCHECK_EQ(out, begin + result->size());
} }
int GlobalReplaceSubstring(StringPiece substring, StringPiece replacement, int GlobalReplaceSubstring(const std::string &substring,
std::string *s) { const std::string &replacement, std::string *s) {
GOOGLE_CHECK(s != nullptr); GOOGLE_CHECK(s != nullptr);
if (s->empty() || substring.empty()) if (s->empty() || substring.empty())
return 0; return 0;
@ -2346,15 +2332,15 @@ int UTF8FirstLetterNumBytes(const char* src, int len) {
// (1) determines the presence of LF (first one is ok) // (1) determines the presence of LF (first one is ok)
// (2) if yes, removes any CR, else convert every CR to LF // (2) if yes, removes any CR, else convert every CR to LF
void CleanStringLineEndings(StringPiece src, std::string *dst, void CleanStringLineEndings(const std::string &src, std::string *dst,
bool auto_end_last_line) { bool auto_end_last_line) {
if (dst->empty()) { if (dst->empty()) {
StrAppend(dst, src); dst->append(src);
CleanStringLineEndings(dst, auto_end_last_line); CleanStringLineEndings(dst, auto_end_last_line);
} else { } else {
std::string tmp(src); std::string tmp = src;
CleanStringLineEndings(&tmp, auto_end_last_line); CleanStringLineEndings(&tmp, auto_end_last_line);
StrAppend(dst, tmp); dst->append(tmp);
} }
} }

66
src/google/protobuf/stubs/strutil.h
Unescape View File

@ -118,11 +118,12 @@ inline bool HasPrefixString(StringPiece str, StringPiece prefix) {
memcmp(str.data(), prefix.data(), prefix.size()) == 0; memcmp(str.data(), prefix.data(), prefix.size()) == 0;
} }
inline std::string StripPrefixString(StringPiece str, StringPiece prefix) { inline std::string StripPrefixString(const std::string& str,
const std::string& prefix) {
if (HasPrefixString(str, prefix)) { if (HasPrefixString(str, prefix)) {
return str.substr(prefix.size()).ToString(); return str.substr(prefix.size());
} else { } else {
return str.ToString(); return str;
} }
} }
@ -140,11 +141,12 @@ inline bool HasSuffixString(StringPiece str, StringPiece suffix) {
suffix.size()) == 0; suffix.size()) == 0;
} }
inline std::string StripSuffixString(StringPiece str, StringPiece suffix) { inline std::string StripSuffixString(const std::string& str,
const std::string& suffix) {
if (HasSuffixString(str, suffix)) { if (HasSuffixString(str, suffix)) {
return str.substr(0, str.size() - suffix.size()).ToString(); return str.substr(0, str.size() - suffix.size());
} else { } else {
return str.ToString(); return str;
} }
} }
@ -190,8 +192,8 @@ inline void UpperString(std::string* s) {
inline void ToUpper(std::string* s) { UpperString(s); } inline void ToUpper(std::string* s) { UpperString(s); }
inline std::string ToUpper(StringPiece s) { inline std::string ToUpper(const std::string& s) {
std::string out(s); std::string out = s;
UpperString(&out); UpperString(&out);
return out; return out;
} }
@ -204,9 +206,10 @@ inline std::string ToUpper(StringPiece s) {
// happened or not. // happened or not.
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
PROTOBUF_EXPORT std::string StringReplaceImpl(StringPiece s, StringPiece oldsub, PROTOBUF_EXPORT std::string StringReplace(const std::string& s,
StringPiece newsub, bool replace_all, const char *filename = nullptr, int linenum = 0); const std::string& oldsub,
#define StringReplace(s,o,n,all) StringReplaceImpl(s,o,n,all,__FILE__, __LINE__) const std::string& newsub,
bool replace_all);
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
// SplitStringUsing() // SplitStringUsing()
@ -311,10 +314,12 @@ PROTOBUF_EXPORT int UnescapeCEscapeSequences(const char* source, char* dest,
// the third call, the new string is returned. // the third call, the new string is returned.
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
PROTOBUF_EXPORT int UnescapeCEscapeString(StringPiece src, std::string* dest); PROTOBUF_EXPORT int UnescapeCEscapeString(const std::string& src,
PROTOBUF_EXPORT int UnescapeCEscapeString(StringPiece src, std::string* dest, std::string* dest);
PROTOBUF_EXPORT int UnescapeCEscapeString(const std::string& src,
std::string* dest,
std::vector<std::string>* errors); std::vector<std::string>* errors);
PROTOBUF_EXPORT std::string UnescapeCEscapeString(StringPiece src); PROTOBUF_EXPORT std::string UnescapeCEscapeString(const std::string& src);
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
// CEscape() // CEscape()
@ -323,7 +328,7 @@ PROTOBUF_EXPORT std::string UnescapeCEscapeString(StringPiece src);
// //
// Escaped chars: \n, \r, \t, ", ', \, and !isprint(). // Escaped chars: \n, \r, \t, ", ', \, and !isprint().
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
PROTOBUF_EXPORT std::string CEscape(StringPiece src); PROTOBUF_EXPORT std::string CEscape(const std::string& src);
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
// CEscapeAndAppend() // CEscapeAndAppend()
@ -334,10 +339,10 @@ PROTOBUF_EXPORT void CEscapeAndAppend(StringPiece src, std::string* dest);
namespace strings { namespace strings {
// Like CEscape() but does not escape bytes with the upper bit set. // Like CEscape() but does not escape bytes with the upper bit set.
PROTOBUF_EXPORT std::string Utf8SafeCEscape(StringPiece src); PROTOBUF_EXPORT std::string Utf8SafeCEscape(const std::string& src);
// Like CEscape() but uses hex (\x) escapes instead of octals. // Like CEscape() but uses hex (\x) escapes instead of octals.
PROTOBUF_EXPORT std::string CHexEscape(StringPiece src); PROTOBUF_EXPORT std::string CHexEscape(const std::string& src);
} // namespace strings } // namespace strings
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
@ -394,23 +399,35 @@ inline uint64_t strtou64(const char *nptr, char **endptr, int base) {
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
PROTOBUF_EXPORT bool safe_strtob(StringPiece str, bool* value); PROTOBUF_EXPORT bool safe_strtob(StringPiece str, bool* value);
PROTOBUF_EXPORT bool safe_strto32(StringPiece str, int32_t* value); PROTOBUF_EXPORT bool safe_strto32(const std::string& str, int32_t* value);
PROTOBUF_EXPORT bool safe_strtou32(StringPiece str, uint32_t* value); PROTOBUF_EXPORT bool safe_strtou32(const std::string& str, uint32_t* value);
inline bool safe_strto32(const char* str, int32_t* value) { inline bool safe_strto32(const char* str, int32_t* value) {
return safe_strto32(std::string(str), value); return safe_strto32(std::string(str), value);
} }
inline bool safe_strto32(StringPiece str, int32_t* value) {
return safe_strto32(str.ToString(), value);
}
inline bool safe_strtou32(const char* str, uint32_t* value) { inline bool safe_strtou32(const char* str, uint32_t* value) {
return safe_strtou32(std::string(str), value); return safe_strtou32(std::string(str), value);
} }
inline bool safe_strtou32(StringPiece str, uint32_t* value) {
return safe_strtou32(str.ToString(), value);
}
PROTOBUF_EXPORT bool safe_strto64(StringPiece str, int64_t* value); PROTOBUF_EXPORT bool safe_strto64(const std::string& str, int64_t* value);
PROTOBUF_EXPORT bool safe_strtou64(StringPiece str, uint64_t* value); PROTOBUF_EXPORT bool safe_strtou64(const std::string& str, uint64_t* value);
inline bool safe_strto64(const char* str, int64_t* value) { inline bool safe_strto64(const char* str, int64_t* value) {
return safe_strto64(std::string(str), value); return safe_strto64(std::string(str), value);
} }
inline bool safe_strto64(StringPiece str, int64_t* value) {
return safe_strto64(str.ToString(), value);
}
inline bool safe_strtou64(const char* str, uint64_t* value) { inline bool safe_strtou64(const char* str, uint64_t* value) {
return safe_strtou64(std::string(str), value); return safe_strtou64(std::string(str), value);
} }
inline bool safe_strtou64(StringPiece str, uint64_t* value) {
return safe_strtou64(str.ToString(), value);
}
PROTOBUF_EXPORT bool safe_strtof(const char* str, float* value); PROTOBUF_EXPORT bool safe_strtof(const char* str, float* value);
PROTOBUF_EXPORT bool safe_strtod(const char* str, double* value); PROTOBUF_EXPORT bool safe_strtod(const char* str, double* value);
@ -781,8 +798,8 @@ PROTOBUF_EXPORT std::string ToHex(uint64_t num);
// //
// NOTE: The string pieces must not overlap s. // NOTE: The string pieces must not overlap s.
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
PROTOBUF_EXPORT int GlobalReplaceSubstring(StringPiece substring, PROTOBUF_EXPORT int GlobalReplaceSubstring(const std::string& substring,
StringPiece replacement, const std::string& replacement,
std::string* s); std::string* s);
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
@ -900,7 +917,8 @@ PROTOBUF_EXPORT int UTF8FirstLetterNumBytes(const char* src, int len);
// //
// (1) determines the presence of LF (first one is ok) // (1) determines the presence of LF (first one is ok)
// (2) if yes, removes any CR, else convert every CR to LF // (2) if yes, removes any CR, else convert every CR to LF
PROTOBUF_EXPORT void CleanStringLineEndings(StringPiece src, std::string* dst, PROTOBUF_EXPORT void CleanStringLineEndings(const std::string& src,
std::string* dst,
bool auto_end_last_line); bool auto_end_last_line);
// Same as above, but transforms the argument in place. // Same as above, but transforms the argument in place.

Write Preview
Loading…
Cancel
Save