Changeset 67334 in vbox for trunk/src/VBox/Runtime/common/string

Timestamp:

Jun 12, 2017 9:48:11 AM (8 years ago)

Author:

vboxsync

Message:

IPRT: Added RTStrToUtf16BigEx and RTStrToUtf16Big for turning UTF-8 into UTF-16BE (big endian).

File:

• trunk/src/VBox/Runtime/common/string/utf-8.cpp (modified) (5 diffs)

trunk/src/VBox/Runtime/common/string/utf-8.cpp

@@ -33 +33 @@
 
 #include <iprt/uni.h>
+#include <iprt/asm.h>
 #include <iprt/alloc.h>
 #include <iprt/assert.h>
@@ -829 +830 @@
  * @param   pwsz    Where to store the UTF-16 string.
  * @param   cwc     The number of RTUTF16 items the pwsz buffer can hold, excluding the terminator ('\\0').
+ *
+ * @note    rtUtf8RecodeAsUtf16Big is a duplicate with RT_H2BE_U16 applied.
  */
 static int rtUtf8RecodeAsUtf16(const char *psz, size_t cch, PRTUTF16 pwsz, size_t cwc)
@@ -907 +910 @@
 
 
+/**
+ * Recodes a valid UTF-8 string as UTF-16BE.
+ *
+ * Since we know the input is valid, we do *not* perform encoding or length checks.
+ *
+ * @returns iprt status code.
+ * @param   psz     The UTF-8 string to recode. This is a valid encoding.
+ * @param   cch     The number of chars (the type char, so bytes if you like) to process of the UTF-8 string.
+ *                  The recoding will stop when cch or '\\0' is reached. Pass RTSTR_MAX to process up to '\\0'.
+ * @param   pwsz    Where to store the UTF-16BE string.
+ * @param   cwc     The number of RTUTF16 items the pwsz buffer can hold, excluding the terminator ('\\0').
+ *
+ * @note    This is a copy of rtUtf8RecodeAsUtf16 with RT_H2BE_U16 applied.
+ */
+static int rtUtf8RecodeAsUtf16Big(const char *psz, size_t cch, PRTUTF16 pwsz, size_t cwc)
+{
+    int                     rc   = VINF_SUCCESS;
+    const unsigned char    *puch = (const unsigned char *)psz;
+    PRTUTF16                pwc  = pwsz;
+    while (cch > 0)
+    {
+        /* read the next char and check for terminator. */
+        const unsigned char uch = *puch;
+        if (uch)
+        { /* we only break once, so consider this the likely branch. */ }
+        else
+            break;
+
+        /* check for output overflow */
+        if (RT_LIKELY(cwc >= 1))
+        { /* likely */ }
+        else
+        {
+            rc = VERR_BUFFER_OVERFLOW;
+            break;
+        }
+        cwc--;
+
+        /* decode and recode the code point */
+        if (!(uch & RT_BIT(7)))
+        {
+            *pwc++ = RT_H2BE_U16((RTUTF16)uch);
+            puch++;
+            cch--;
+        }
+        else if ((uch & (RT_BIT(7) | RT_BIT(6) | RT_BIT(5))) == (RT_BIT(7) | RT_BIT(6)))
+        {
+            uint16_t uc = (puch[1] & 0x3f)
+                    | ((uint16_t)(uch     & 0x1f) << 6);
+            *pwc++ = RT_H2BE_U16(uc);
+            puch += 2;
+            cch -= 2;
+        }
+        else if ((uch & (RT_BIT(7) | RT_BIT(6) | RT_BIT(5) | RT_BIT(4))) == (RT_BIT(7) | RT_BIT(6) | RT_BIT(5)))
+        {
+            uint16_t uc = (puch[2] & 0x3f)
+                    | ((uint16_t)(puch[1] & 0x3f) << 6)
+                    | ((uint16_t)(uch     & 0x0f) << 12);
+            *pwc++ = RT_H2BE_U16(uc);
+            puch += 3;
+            cch -= 3;
+        }
+        else
+        {
+            /* generate surrogate pair */
+            Assert((uch & (RT_BIT(7) | RT_BIT(6) | RT_BIT(5) | RT_BIT(4) | RT_BIT(3))) == (RT_BIT(7) | RT_BIT(6) | RT_BIT(5) | RT_BIT(4)));
+            RTUNICP uc =           (puch[3] & 0x3f)
+                       | ((RTUNICP)(puch[2] & 0x3f) << 6)
+                       | ((RTUNICP)(puch[1] & 0x3f) << 12)
+                       | ((RTUNICP)(uch     & 0x07) << 18);
+            if (RT_UNLIKELY(cwc < 1))
+            {
+                rc = VERR_BUFFER_OVERFLOW;
+                break;
+            }
+            cwc--;
+
+            uc -= 0x10000;
+            *pwc++ = RT_H2BE_U16(0xd800 | (uc >> 10));
+            *pwc++ = RT_H2BE_U16(0xdc00 | (uc & 0x3ff));
+            puch += 4;
+            cch -= 4;
+        }
+    }
+
+    /* done */
+    *pwc = '\0';
+    return rc;
+}
+
+
 RTDECL(int) RTStrToUtf16Tag(const char *pszString, PRTUTF16 *ppwszString, const char *pszTag)
 {
@@ -946 +1040 @@
 }
 RT_EXPORT_SYMBOL(RTStrToUtf16Tag);
+
+
+RTDECL(int) RTStrToUtf16BigTag(const char *pszString, PRTUTF16 *ppwszString, const char *pszTag)
+{
+    /*
+     * Validate input.
+     */
+    Assert(VALID_PTR(ppwszString));
+    Assert(VALID_PTR(pszString));
+    *ppwszString = NULL;
+
+    /*
+     * Validate the UTF-8 input and calculate the length of the UTF-16 string.
+     */
+    size_t cwc;
+    int rc = rtUtf8CalcUtf16Length(pszString, &cwc);
+    if (RT_SUCCESS(rc))
+    {
+        /*
+         * Allocate buffer.
+         */
+        PRTUTF16 pwsz = (PRTUTF16)RTMemAllocTag((cwc + 1) * sizeof(RTUTF16), pszTag);
+        if (pwsz)
+        {
+            /*
+             * Encode the UTF-16 string.
+             */
+            rc = rtUtf8RecodeAsUtf16Big(pszString, RTSTR_MAX, pwsz, cwc);
+            if (RT_SUCCESS(rc))
+            {
+                *ppwszString = pwsz;
+                return rc;
+            }
+            RTMemFree(pwsz);
+        }
+        else
+            rc = VERR_NO_UTF16_MEMORY;
+    }
+    return rc;
+}
+RT_EXPORT_SYMBOL(RTStrToUtf16TagBig);
 
 
@@ -1011 +1146 @@
 }
 RT_EXPORT_SYMBOL(RTStrToUtf16ExTag);
+
+
+RTDECL(int)  RTStrToUtf16BigExTag(const char *pszString, size_t cchString,
+                                  PRTUTF16 *ppwsz, size_t cwc, size_t *pcwc, const char *pszTag)
+{
+    /*
+     * Validate input.
+     */
+    Assert(VALID_PTR(pszString));
+    Assert(VALID_PTR(ppwsz));
+    Assert(!pcwc || VALID_PTR(pcwc));
+
+    /*
+     * Validate the UTF-8 input and calculate the length of the UTF-16 string.
+     */
+    size_t cwcResult;
+    int rc;
+    if (cchString != RTSTR_MAX)
+        rc = rtUtf8CalcUtf16LengthN(pszString, cchString, &cwcResult);
+    else
+        rc = rtUtf8CalcUtf16Length(pszString, &cwcResult);
+    if (RT_SUCCESS(rc))
+    {
+        if (pcwc)
+            *pcwc = cwcResult;
+
+        /*
+         * Check buffer size / Allocate buffer.
+         */
+        bool fShouldFree;
+        PRTUTF16 pwszResult;
+        if (cwc > 0 && *ppwsz)
+        {
+            fShouldFree = false;
+            if (cwc <= cwcResult)
+                return VERR_BUFFER_OVERFLOW;
+            pwszResult = *ppwsz;
+        }
+        else
+        {
+            *ppwsz = NULL;
+            fShouldFree = true;
+            cwc = RT_MAX(cwcResult + 1, cwc);
+            pwszResult = (PRTUTF16)RTMemAllocTag(cwc * sizeof(RTUTF16), pszTag);
+        }
+        if (pwszResult)
+        {
+            /*
+             * Encode the UTF-16BE string.
+             */
+            rc = rtUtf8RecodeAsUtf16Big(pszString, cchString, pwszResult, cwc - 1);
+            if (RT_SUCCESS(rc))
+            {
+                *ppwsz = pwszResult;
+                return rc;
+            }
+            if (fShouldFree)
+                RTMemFree(pwszResult);
+        }
+        else
+            rc = VERR_NO_UTF16_MEMORY;
+    }
+    return rc;
+}
+RT_EXPORT_SYMBOL(RTStrToUtf16BigExTag);