Use append_ instead of parse_ for String methods.
This commit is contained in:
Lukas Tenbrink
parent
594d64ec24
commit
ffa6ef220b
62 changed files with 245 additions and 274 deletions
|
|
@ -254,7 +254,7 @@ StringName OptimizedTranslation::get_message(const StringName &p_src_text, const
|
|||
|
||||
if (bucket.elem[idx].comp_size == bucket.elem[idx].uncomp_size) {
|
||||
String rstr;
|
||||
rstr.parse_utf8(&sptr[bucket.elem[idx].str_offset], bucket.elem[idx].uncomp_size);
|
||||
rstr.append_utf8(&sptr[bucket.elem[idx].str_offset], bucket.elem[idx].uncomp_size);
|
||||
|
||||
return rstr;
|
||||
} else {
|
||||
|
|
@ -262,7 +262,7 @@ StringName OptimizedTranslation::get_message(const StringName &p_src_text, const
|
|||
uncomp.resize(bucket.elem[idx].uncomp_size + 1);
|
||||
smaz_decompress(&sptr[bucket.elem[idx].str_offset], bucket.elem[idx].comp_size, uncomp.ptrw(), bucket.elem[idx].uncomp_size);
|
||||
String rstr;
|
||||
rstr.parse_utf8(uncomp.get_data());
|
||||
rstr.append_utf8(uncomp.get_data());
|
||||
return rstr;
|
||||
}
|
||||
}
|
||||
|
|
@ -284,14 +284,14 @@ Vector<String> OptimizedTranslation::get_translated_message_list() const {
|
|||
for (int j = 0; j < bucket.size; j++) {
|
||||
if (bucket.elem[j].comp_size == bucket.elem[j].uncomp_size) {
|
||||
String rstr;
|
||||
rstr.parse_utf8(&sptr[bucket.elem[j].str_offset], bucket.elem[j].uncomp_size);
|
||||
rstr.append_utf8(&sptr[bucket.elem[j].str_offset], bucket.elem[j].uncomp_size);
|
||||
msgs.push_back(rstr);
|
||||
} else {
|
||||
CharString uncomp;
|
||||
uncomp.resize(bucket.elem[j].uncomp_size + 1);
|
||||
smaz_decompress(&sptr[bucket.elem[j].str_offset], bucket.elem[j].comp_size, uncomp.ptrw(), bucket.elem[j].uncomp_size);
|
||||
String rstr;
|
||||
rstr.parse_utf8(uncomp.get_data());
|
||||
rstr.append_utf8(uncomp.get_data());
|
||||
msgs.push_back(rstr);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -299,17 +299,17 @@ Error String::parse_url(String &r_scheme, String &r_host, int &r_port, String &r
|
|||
return OK;
|
||||
}
|
||||
|
||||
void String::parse_latin1(const Span<char> &p_cstr) {
|
||||
if (p_cstr.size() == 0) {
|
||||
resize(0);
|
||||
void String::append_latin1(const Span<char> &p_cstr) {
|
||||
if (p_cstr.is_empty()) {
|
||||
return;
|
||||
}
|
||||
|
||||
resize(p_cstr.size() + 1); // include 0
|
||||
const int prev_length = length();
|
||||
resize(prev_length + p_cstr.size() + 1); // include 0
|
||||
|
||||
const char *src = p_cstr.ptr();
|
||||
const char *end = src + p_cstr.size();
|
||||
char32_t *dst = ptrw();
|
||||
char32_t *dst = ptrw() + prev_length;
|
||||
|
||||
for (; src < end; ++src, ++dst) {
|
||||
// If char is int8_t, a set sign bit will be reinterpreted as 256 - val implicitly.
|
||||
|
|
@ -318,16 +318,16 @@ void String::parse_latin1(const Span<char> &p_cstr) {
|
|||
*dst = 0;
|
||||
}
|
||||
|
||||
void String::parse_utf32(const Span<char32_t> &p_cstr) {
|
||||
if (p_cstr.size() == 0) {
|
||||
resize(0);
|
||||
void String::append_utf32(const Span<char32_t> &p_cstr) {
|
||||
if (p_cstr.is_empty()) {
|
||||
return;
|
||||
}
|
||||
|
||||
resize(p_cstr.size() + 1);
|
||||
const int prev_length = length();
|
||||
resize(prev_length + p_cstr.size() + 1);
|
||||
const char32_t *src = p_cstr.ptr();
|
||||
const char32_t *end = p_cstr.ptr() + p_cstr.size();
|
||||
char32_t *dst = ptrw();
|
||||
char32_t *dst = ptrw() + prev_length;
|
||||
|
||||
// Copy the string, and check for UTF-32 problems.
|
||||
for (; src < end; ++src, ++dst) {
|
||||
|
|
@ -412,55 +412,16 @@ String operator+(char32_t p_chr, const String &p_str) {
|
|||
}
|
||||
|
||||
String &String::operator+=(const String &p_str) {
|
||||
const int lhs_len = length();
|
||||
if (lhs_len == 0) {
|
||||
if (is_empty()) {
|
||||
*this = p_str;
|
||||
return *this;
|
||||
}
|
||||
|
||||
const int rhs_len = p_str.length();
|
||||
if (rhs_len == 0) {
|
||||
return *this;
|
||||
}
|
||||
|
||||
resize(lhs_len + rhs_len + 1);
|
||||
|
||||
const char32_t *src = p_str.ptr();
|
||||
char32_t *dst = ptrw() + lhs_len;
|
||||
|
||||
// Don't copy the terminating null with `memcpy` to avoid undefined behavior when string is being added to itself (it would overlap the destination).
|
||||
memcpy(dst, src, rhs_len * sizeof(char32_t));
|
||||
*(dst + rhs_len) = _null;
|
||||
|
||||
append_utf32(p_str);
|
||||
return *this;
|
||||
}
|
||||
|
||||
String &String::operator+=(const char *p_str) {
|
||||
if (!p_str || p_str[0] == 0) {
|
||||
return *this;
|
||||
}
|
||||
|
||||
const int lhs_len = length();
|
||||
const size_t rhs_len = strlen(p_str);
|
||||
|
||||
resize(lhs_len + rhs_len + 1);
|
||||
|
||||
char32_t *dst = ptrw() + lhs_len;
|
||||
|
||||
for (size_t i = 0; i <= rhs_len; i++) {
|
||||
#if CHAR_MIN == 0
|
||||
uint8_t c = p_str[i];
|
||||
#else
|
||||
uint8_t c = p_str[i] >= 0 ? p_str[i] : uint8_t(256 + p_str[i]);
|
||||
#endif
|
||||
if (c == 0 && i < rhs_len) {
|
||||
print_unicode_error("NUL character", true);
|
||||
dst[i] = _replacement_char;
|
||||
} else {
|
||||
dst[i] = c;
|
||||
}
|
||||
}
|
||||
|
||||
append_latin1(p_str);
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
|
@ -476,32 +437,12 @@ String &String::operator+=(const wchar_t *p_str) {
|
|||
}
|
||||
|
||||
String &String::operator+=(const char32_t *p_str) {
|
||||
*this += String(p_str);
|
||||
append_utf32(Span(p_str, strlen(p_str)));
|
||||
return *this;
|
||||
}
|
||||
|
||||
String &String::operator+=(char32_t p_char) {
|
||||
if (p_char == 0) {
|
||||
print_unicode_error("NUL character", true);
|
||||
return *this;
|
||||
}
|
||||
|
||||
const int lhs_len = length();
|
||||
resize(lhs_len + 2);
|
||||
char32_t *dst = ptrw();
|
||||
|
||||
if ((p_char & 0xfffff800) == 0xd800) {
|
||||
print_unicode_error(vformat("Unpaired surrogate (%x)", (uint32_t)p_char));
|
||||
dst[lhs_len] = _replacement_char;
|
||||
} else if (p_char > 0x10ffff) {
|
||||
print_unicode_error(vformat("Invalid unicode codepoint (%x)", (uint32_t)p_char));
|
||||
dst[lhs_len] = _replacement_char;
|
||||
} else {
|
||||
dst[lhs_len] = p_char;
|
||||
}
|
||||
|
||||
dst[lhs_len + 1] = 0;
|
||||
|
||||
append_utf32(Span(&p_char, 1));
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
|
@ -1921,17 +1862,17 @@ CharString String::ascii(bool p_allow_extended) const {
|
|||
return cs;
|
||||
}
|
||||
|
||||
Error String::parse_ascii(const Span<char> &p_range) {
|
||||
if (p_range.size() == 0) {
|
||||
resize(0);
|
||||
Error String::append_ascii(const Span<char> &p_range) {
|
||||
if (p_range.is_empty()) {
|
||||
return OK;
|
||||
}
|
||||
|
||||
resize(p_range.size() + 1); // Include \0
|
||||
const int prev_length = length();
|
||||
resize(prev_length + p_range.size() + 1); // Include \0
|
||||
|
||||
const char *src = p_range.ptr();
|
||||
const char *end = src + p_range.size();
|
||||
char32_t *dst = ptrw();
|
||||
char32_t *dst = ptrw() + prev_length;
|
||||
bool decode_failed = false;
|
||||
|
||||
for (; src < end; ++src, ++dst) {
|
||||
|
|
@ -1951,12 +1892,12 @@ Error String::parse_ascii(const Span<char> &p_range) {
|
|||
|
||||
String String::utf8(const char *p_utf8, int p_len) {
|
||||
String ret;
|
||||
ret.parse_utf8(p_utf8, p_len);
|
||||
ret.append_utf8(p_utf8, p_len);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
Error String::parse_utf8(const char *p_utf8, int p_len, bool p_skip_cr) {
|
||||
Error String::append_utf8(const char *p_utf8, int p_len, bool p_skip_cr) {
|
||||
if (!p_utf8) {
|
||||
return ERR_INVALID_DATA;
|
||||
}
|
||||
|
|
@ -1977,9 +1918,10 @@ Error String::parse_utf8(const char *p_utf8, int p_len, bool p_skip_cr) {
|
|||
p_len = strlen(p_utf8);
|
||||
}
|
||||
|
||||
const int prev_length = length();
|
||||
// If all utf8 characters maps to ASCII, then the max size will be p_len, and we add +1 for the null termination.
|
||||
resize(p_len + 1);
|
||||
char32_t *dst = ptrw();
|
||||
resize(prev_length + p_len + 1);
|
||||
char32_t *dst = ptrw() + prev_length;
|
||||
|
||||
Error result = Error::OK;
|
||||
|
||||
|
|
@ -2124,7 +2066,7 @@ Error String::parse_utf8(const char *p_utf8, int p_len, bool p_skip_cr) {
|
|||
}
|
||||
|
||||
(*dst++) = 0;
|
||||
resize(dst - ptr());
|
||||
resize(prev_length + dst - ptr());
|
||||
|
||||
return result;
|
||||
}
|
||||
|
|
@ -2215,12 +2157,12 @@ CharString String::utf8() const {
|
|||
|
||||
String String::utf16(const char16_t *p_utf16, int p_len) {
|
||||
String ret;
|
||||
ret.parse_utf16(p_utf16, p_len, true);
|
||||
ret.append_utf16(p_utf16, p_len, true);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
Error String::parse_utf16(const char16_t *p_utf16, int p_len, bool p_default_little_endian) {
|
||||
Error String::append_utf16(const char16_t *p_utf16, int p_len, bool p_default_little_endian) {
|
||||
if (!p_utf16) {
|
||||
return ERR_INVALID_DATA;
|
||||
}
|
||||
|
|
@ -2297,8 +2239,9 @@ Error String::parse_utf16(const char16_t *p_utf16, int p_len, bool p_default_lit
|
|||
return OK; // empty string
|
||||
}
|
||||
|
||||
resize(str_size + 1);
|
||||
char32_t *dst = ptrw();
|
||||
const int prev_length = length();
|
||||
resize(prev_length + str_size + 1);
|
||||
char32_t *dst = ptrw() + prev_length;
|
||||
dst[str_size] = 0;
|
||||
|
||||
bool skip = false;
|
||||
|
|
|
|||
|
|
@ -249,30 +249,30 @@ class String {
|
|||
void copy_from_unchecked(const char32_t *p_char, int p_length);
|
||||
|
||||
// NULL-terminated c string copy - automatically parse the string to find the length.
|
||||
void parse_latin1(const char *p_cstr) {
|
||||
parse_latin1(Span(p_cstr, p_cstr ? strlen(p_cstr) : 0));
|
||||
void append_latin1(const char *p_cstr) {
|
||||
append_latin1(Span(p_cstr, p_cstr ? strlen(p_cstr) : 0));
|
||||
}
|
||||
void parse_utf32(const char32_t *p_cstr) {
|
||||
parse_utf32(Span(p_cstr, p_cstr ? strlen(p_cstr) : 0));
|
||||
void append_utf32(const char32_t *p_cstr) {
|
||||
append_utf32(Span(p_cstr, p_cstr ? strlen(p_cstr) : 0));
|
||||
}
|
||||
|
||||
// wchar_t copy_from depends on the platform.
|
||||
void parse_wstring(const Span<wchar_t> &p_cstr) {
|
||||
void append_wstring(const Span<wchar_t> &p_cstr) {
|
||||
#ifdef WINDOWS_ENABLED
|
||||
// wchar_t is 16-bit, parse as UTF-16
|
||||
parse_utf16((const char16_t *)p_cstr.ptr(), p_cstr.size());
|
||||
append_utf16((const char16_t *)p_cstr.ptr(), p_cstr.size());
|
||||
#else
|
||||
// wchar_t is 32-bit, copy directly
|
||||
parse_utf32((Span<char32_t> &)p_cstr);
|
||||
append_utf32((Span<char32_t> &)p_cstr);
|
||||
#endif
|
||||
}
|
||||
void parse_wstring(const wchar_t *p_cstr) {
|
||||
void append_wstring(const wchar_t *p_cstr) {
|
||||
#ifdef WINDOWS_ENABLED
|
||||
// wchar_t is 16-bit, parse as UTF-16
|
||||
parse_utf16((const char16_t *)p_cstr);
|
||||
append_utf16((const char16_t *)p_cstr);
|
||||
#else
|
||||
// wchar_t is 32-bit, copy directly
|
||||
parse_utf32((const char32_t *)p_cstr);
|
||||
append_utf32((const char32_t *)p_cstr);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
|
@ -424,7 +424,7 @@ public:
|
|||
static String num_uint64(uint64_t p_num, int base = 10, bool capitalize_hex = false);
|
||||
static String chr(char32_t p_char) {
|
||||
String string;
|
||||
string.parse_utf32(Span(&p_char, 1));
|
||||
string.append_utf32(Span(&p_char, 1));
|
||||
return string;
|
||||
}
|
||||
static String md5(const uint8_t *p_md5);
|
||||
|
|
@ -497,40 +497,40 @@ public:
|
|||
CharString ascii(bool p_allow_extended = false) const;
|
||||
// Parse an ascii string.
|
||||
// If any character is > 127, an error will be logged, and 0xfffd will be inserted.
|
||||
Error parse_ascii(const Span<char> &p_range);
|
||||
Error append_ascii(const Span<char> &p_range);
|
||||
static String ascii(const Span<char> &p_range) {
|
||||
String s;
|
||||
s.parse_ascii(p_range);
|
||||
s.append_ascii(p_range);
|
||||
return s;
|
||||
}
|
||||
CharString latin1() const { return ascii(true); }
|
||||
void parse_latin1(const Span<char> &p_cstr);
|
||||
void append_latin1(const Span<char> &p_cstr);
|
||||
static String latin1(const Span<char> &p_string) {
|
||||
String string;
|
||||
string.parse_latin1(p_string);
|
||||
string.append_latin1(p_string);
|
||||
return string;
|
||||
}
|
||||
|
||||
CharString utf8() const;
|
||||
Error parse_utf8(const char *p_utf8, int p_len = -1, bool p_skip_cr = false);
|
||||
Error parse_utf8(const Span<char> &p_range, bool p_skip_cr = false) {
|
||||
return parse_utf8(p_range.ptr(), p_range.size(), p_skip_cr);
|
||||
Error append_utf8(const char *p_utf8, int p_len = -1, bool p_skip_cr = false);
|
||||
Error append_utf8(const Span<char> &p_range, bool p_skip_cr = false) {
|
||||
return append_utf8(p_range.ptr(), p_range.size(), p_skip_cr);
|
||||
}
|
||||
static String utf8(const char *p_utf8, int p_len = -1);
|
||||
static String utf8(const Span<char> &p_range) { return utf8(p_range.ptr(), p_range.size()); }
|
||||
|
||||
Char16String utf16() const;
|
||||
Error parse_utf16(const char16_t *p_utf16, int p_len = -1, bool p_default_little_endian = true);
|
||||
Error parse_utf16(const Span<char16_t> p_range, bool p_skip_cr = false) {
|
||||
return parse_utf16(p_range.ptr(), p_range.size(), p_skip_cr);
|
||||
Error append_utf16(const char16_t *p_utf16, int p_len = -1, bool p_default_little_endian = true);
|
||||
Error append_utf16(const Span<char16_t> p_range, bool p_skip_cr = false) {
|
||||
return append_utf16(p_range.ptr(), p_range.size(), p_skip_cr);
|
||||
}
|
||||
static String utf16(const char16_t *p_utf16, int p_len = -1);
|
||||
static String utf16(const Span<char16_t> &p_range) { return utf16(p_range.ptr(), p_range.size()); }
|
||||
|
||||
void parse_utf32(const Span<char32_t> &p_cstr);
|
||||
void append_utf32(const Span<char32_t> &p_cstr);
|
||||
static String utf32(const Span<char32_t> &p_span) {
|
||||
String string;
|
||||
string.parse_utf32(p_span);
|
||||
string.append_utf32(p_span);
|
||||
return string;
|
||||
}
|
||||
|
||||
|
|
@ -621,24 +621,27 @@ public:
|
|||
|
||||
// Constructors for NULL terminated C strings.
|
||||
String(const char *p_cstr) {
|
||||
parse_latin1(p_cstr);
|
||||
append_latin1(p_cstr);
|
||||
}
|
||||
String(const wchar_t *p_cstr) {
|
||||
parse_wstring(p_cstr);
|
||||
append_wstring(p_cstr);
|
||||
}
|
||||
String(const char32_t *p_cstr) {
|
||||
parse_utf32(p_cstr);
|
||||
append_utf32(p_cstr);
|
||||
}
|
||||
|
||||
// Copy assignment for NULL terminated C strings.
|
||||
void operator=(const char *p_cstr) {
|
||||
parse_latin1(p_cstr);
|
||||
clear();
|
||||
append_latin1(p_cstr);
|
||||
}
|
||||
void operator=(const wchar_t *p_cstr) {
|
||||
parse_wstring(p_cstr);
|
||||
clear();
|
||||
append_wstring(p_cstr);
|
||||
}
|
||||
void operator=(const char32_t *p_cstr) {
|
||||
parse_utf32(p_cstr);
|
||||
clear();
|
||||
append_utf32(p_cstr);
|
||||
}
|
||||
};
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue