Fix risky signature of `wchar_to_utf8chars()`. Add `ll_convert()` alias.

`wchar_to_utf8chars()` used to require a `char*` output buffer with no length,
assuming that its caller knew enough to provide a buffer of sufficient length.
In fact a `char[8]` buffer suffices, but nothing in the header indicated that.
Eliminate the output parameter and return `std::string`. Fix the few existing
callers.

Also set an `ll_convert_alias` so that `ll_convert_to<std::string>(llwchar)`
directly calls `wchar_to_utf8chars()`. Replace instances of the workaround
`wstring_to_utf8str(LLWString(1, llwchar))`.

2 files changed, 13 insertions, 13 deletions

diff --git a/indra/llcommon/llstring.cpp b/indra/llcommon/llstring.cpp
index 505789f9ea..4d7cf90310 100644
--- a/indra/llcommon/llstring.cpp
+++ b/indra/llcommon/llstring.cpp
@@ -141,10 +141,10 @@ std::string rawstr_to_utf8(const std::string& raw)
     return wstring_to_utf8str(wstr);
 }
 
-std::ptrdiff_t wchar_to_utf8chars(llwchar in_char, char* outchars)
+std::string wchar_to_utf8chars(llwchar in_char)
 {
-    U32 cur_char = (U32)in_char;
-    char* base = outchars;
+    U32 cur_char(in_char);
+    char buff[8], *outchars = buff;
     if (cur_char < 0x80)
     {
         *outchars++ = (U8)cur_char;
@@ -189,7 +189,7 @@ std::ptrdiff_t wchar_to_utf8chars(llwchar in_char, char* outchars)
         LL_WARNS() << "Invalid Unicode character " << cur_char << "!" << LL_ENDL;
         *outchars++ = LL_UNKNOWN_CHAR;
     }
-    return outchars - base;
+    return { buff, std::string::size_type(outchars - buff) };
 }
 
 auto utf16chars_to_wchar(const U16* inchars, llwchar* outchar)
@@ -367,13 +367,12 @@ std::string wchar_utf8_preview(const llwchar wc)
     std::ostringstream oss;
     oss << std::hex << std::uppercase << (U32)wc;
 
-    U8 out_bytes[8];
-    U32 size = (U32)wchar_to_utf8chars(wc, (char*)out_bytes);
+    auto out_bytes = wchar_to_utf8chars(wc);
 
-    if (size > 1)
+    if (out_bytes.length() > 1)
     {
         oss << " [";
-        for (U32 i = 0; i < size; ++i)
+        for (U32 i = 0; i < out_bytes.length(); ++i)
         {
             if (i)
             {
@@ -492,10 +491,7 @@ std::string wstring_to_utf8str(const llwchar* utf32str, size_t len)
     S32 i = 0;
     while (i < len)
     {
-        char tchars[8];     /* Flawfinder: ignore */
-        auto n = wchar_to_utf8chars(utf32str[i], tchars);
-        tchars[n] = 0;
-        out += tchars;
+        out += wchar_to_utf8chars(utf32str[i]);
         i++;
     }
     return out;
diff --git a/indra/llcommon/llstring.h b/indra/llcommon/llstring.h
index e4be1efaed..b552aede82 100644
--- a/indra/llcommon/llstring.h
+++ b/indra/llcommon/llstring.h
@@ -707,7 +707,11 @@ ll_convert_forms(ll_convert_alias,     LLWString,     std::string,   utf8str_to_
 // Same function, better name. JC
 inline LLWString utf8string_to_wstring(const std::string& utf8_string) { return utf8str_to_wstring(utf8_string); }
 
-LL_COMMON_API std::ptrdiff_t wchar_to_utf8chars(llwchar inchar, char* outchars);
+// return a UTF-8 string representation of a single llwchar, which we
+// occasionally require:
+// cheaper than ll_convert_to<std::string>(LLWString(1, inchar))
+LL_COMMON_API std::string wchar_to_utf8chars(llwchar inchar);
+ll_convert_alias(std::string, llwchar, wchar_to_utf8chars(in));
 
 ll_convert_forms(ll_convert_alias,     std::string, LLWString,     wstring_to_utf8str);
 ll_convert_forms(ll_convert_u16_alias, std::string, llutf16string, utf16str_to_utf8str);