nuclear@1: /**************************************************************************
nuclear@1: 
nuclear@1: Filename    :   OVR_UTF8Util.cpp
nuclear@1: Content     :   UTF8 Unicode character encoding/decoding support
nuclear@1: Created     :   September 19, 2012
nuclear@1: Notes       : 
nuclear@1: Notes       :   Much useful info at "UTF-8 and Unicode FAQ"
nuclear@1:                 http://www.cl.cam.ac.uk/~mgk25/unicode.html
nuclear@1: 
nuclear@1: Copyright   :   Copyright 2012 Oculus VR, Inc. All Rights reserved.
nuclear@1: 
nuclear@1: Use of this software is subject to the terms of the Oculus license
nuclear@1: agreement provided at the time of installation or download, or which
nuclear@1: otherwise accompanies this software in either electronic or hard copy form.
nuclear@1: 
nuclear@1: ************************************************************************************/
nuclear@1: 
nuclear@1: #include "OVR_UTF8Util.h"
nuclear@1: 
nuclear@1: namespace OVR { namespace UTF8Util {
nuclear@1: 
nuclear@1: SPInt OVR_STDCALL GetLength(const char* buf, SPInt buflen)
nuclear@1: {
nuclear@1:     const char* p = buf;
nuclear@1:     SPInt length = 0;
nuclear@1: 
nuclear@1:     if (buflen != -1)
nuclear@1:     {
nuclear@1:         while (p - buf < buflen)
nuclear@1:         {
nuclear@1:             // We should be able to have ASStrings with 0 in the middle.
nuclear@1:             UTF8Util::DecodeNextChar_Advance0(&p);
nuclear@1:             length++;
nuclear@1:         }
nuclear@1:     }
nuclear@1:     else
nuclear@1:     {
nuclear@1:         while (UTF8Util::DecodeNextChar_Advance0(&p))
nuclear@1:             length++;
nuclear@1:     }
nuclear@1:     
nuclear@1:     return length;
nuclear@1: }
nuclear@1: 
nuclear@1: UInt32 OVR_STDCALL GetCharAt(SPInt index, const char* putf8str, SPInt length)
nuclear@1: {
nuclear@1:     const char* buf = putf8str;
nuclear@1:     UInt32  c = 0;
nuclear@1: 
nuclear@1:     if (length != -1)
nuclear@1:     {
nuclear@1:         while (buf - putf8str < length)
nuclear@1:         {           
nuclear@1:             c = UTF8Util::DecodeNextChar_Advance0(&buf);
nuclear@1:             if (index == 0)
nuclear@1:                 return c;
nuclear@1:             index--;
nuclear@1:         }
nuclear@1: 
nuclear@1:         return c;
nuclear@1:     }
nuclear@1: 
nuclear@1:     do 
nuclear@1:     {
nuclear@1:         c = UTF8Util::DecodeNextChar_Advance0(&buf);
nuclear@1:         index--;
nuclear@1: 
nuclear@1:         if (c == 0)
nuclear@1:         {
nuclear@1:             // We've hit the end of the string; don't go further.
nuclear@1:             OVR_ASSERT(index == 0);
nuclear@1:             return c;
nuclear@1:         }
nuclear@1:     } while (index >= 0);
nuclear@1: 
nuclear@1:     return c;
nuclear@1: }
nuclear@1: 
nuclear@1: SPInt OVR_STDCALL GetByteIndex(SPInt index, const char *putf8str, SPInt length)
nuclear@1: {
nuclear@1:     const char* buf = putf8str;
nuclear@1: 
nuclear@1:     if (length != -1)
nuclear@1:     {
nuclear@1:         while ((buf - putf8str) < length && index > 0)
nuclear@1:         {
nuclear@1:             UTF8Util::DecodeNextChar_Advance0(&buf);
nuclear@1:             index--;
nuclear@1:         }
nuclear@1: 
nuclear@1:         return buf-putf8str;
nuclear@1:     }
nuclear@1: 
nuclear@1:     while (index > 0) 
nuclear@1:     {
nuclear@1:         UInt32 c = UTF8Util::DecodeNextChar_Advance0(&buf);
nuclear@1:         index--;
nuclear@1: 
nuclear@1:         if (c == 0)
nuclear@1:             return buf-putf8str;
nuclear@1:     };
nuclear@1: 
nuclear@1:     return buf-putf8str;
nuclear@1: }
nuclear@1: 
nuclear@1: int OVR_STDCALL GetEncodeCharSize(UInt32 ucs_character)
nuclear@1: {
nuclear@1:     if (ucs_character <= 0x7F)
nuclear@1:         return 1;
nuclear@1:     else if (ucs_character <= 0x7FF)
nuclear@1:         return 2;
nuclear@1:     else if (ucs_character <= 0xFFFF)
nuclear@1:         return 3;
nuclear@1:     else if (ucs_character <= 0x1FFFFF)
nuclear@1:         return 4;
nuclear@1:     else if (ucs_character <= 0x3FFFFFF)
nuclear@1:         return 5;
nuclear@1:     else if (ucs_character <= 0x7FFFFFFF)
nuclear@1:         return 6;
nuclear@1:     else
nuclear@1:         return 0;
nuclear@1: }
nuclear@1: 
nuclear@1: UInt32 OVR_STDCALL DecodeNextChar_Advance0(const char** putf8Buffer)
nuclear@1: {
nuclear@1:     UInt32  uc;
nuclear@1:     char    c;
nuclear@1:     
nuclear@1:     // Security considerations:
nuclear@1:     //
nuclear@1:     // Changed, this is now only the case for DecodeNextChar:
nuclear@1:     //  - If we hit a zero byte, we want to return 0 without stepping
nuclear@1:     //    the buffer pointer past the 0. th
nuclear@1:     //
nuclear@1:     // If we hit an "overlong sequence"; i.e. a character encoded
nuclear@1:     // in a longer multibyte string than is necessary, then we
nuclear@1:     // need to discard the character.  This is so attackers can't
nuclear@1:     // disguise dangerous characters or character sequences --
nuclear@1:     // there is only one valid encoding for each character.
nuclear@1:     //
nuclear@1:     // If we decode characters { 0xD800 .. 0xDFFF } or { 0xFFFE,
nuclear@1:     // 0xFFFF } then we ignore them; they are not valid in UTF-8.
nuclear@1:     
nuclear@1:     // This isn't actually an invalid character; it's a valid char that
nuclear@1:     // looks like an inverted question mark.
nuclear@1: #define INVALID_CHAR 0x0FFFD
nuclear@1:     
nuclear@1: #define FIRST_BYTE(mask, shift)     \
nuclear@1:     uc = (c & (mask)) << (shift);
nuclear@1:     
nuclear@1: #define NEXT_BYTE(shift) \
nuclear@1:     c = **putf8Buffer;   \
nuclear@1:     if (c == 0) return 0; /* end of buffer, do not advance */   \
nuclear@1:     if ((c & 0xC0) != 0x80) return INVALID_CHAR; /* standard check */  \
nuclear@1:     (*putf8Buffer)++;    \
nuclear@1:     uc |= (c & 0x3F) << shift;
nuclear@1:     
nuclear@1:     c = **putf8Buffer;
nuclear@1:     (*putf8Buffer)++;
nuclear@1:     if (c == 0)
nuclear@1:         return 0;   // End of buffer.
nuclear@1:     
nuclear@1:     if ((c & 0x80) == 0) return (UInt32) c; // Conventional 7-bit ASCII.
nuclear@1:     
nuclear@1:     // Multi-byte sequences.
nuclear@1:     if ((c & 0xE0) == 0xC0)
nuclear@1:     {
nuclear@1:         // Two-byte sequence.
nuclear@1:         FIRST_BYTE(0x1F, 6);
nuclear@1:         NEXT_BYTE(0);
nuclear@1:         if (uc < 0x80) return INVALID_CHAR;  // overlong
nuclear@1:         return uc;
nuclear@1:     }
nuclear@1:     else if ((c & 0xF0) == 0xE0)
nuclear@1:     {
nuclear@1:         // Three-byte sequence.
nuclear@1:         FIRST_BYTE(0x0F, 12);
nuclear@1:         NEXT_BYTE(6);
nuclear@1:         NEXT_BYTE(0);
nuclear@1:         if (uc < 0x800) return INVALID_CHAR; // overlong
nuclear@1:         // Not valid ISO 10646, but Flash requires these to work
nuclear@1:         // see AS3 test e15_5_3_2_3 for String.fromCharCode().charCodeAt(0)
nuclear@1:         // if (uc >= 0x0D800 && uc <= 0x0DFFF) return INVALID_CHAR;
nuclear@1:         // if (uc == 0x0FFFE || uc == 0x0FFFF) return INVALID_CHAR; // not valid ISO 10646
nuclear@1:         return uc;
nuclear@1:     }
nuclear@1:     else if ((c & 0xF8) == 0xF0)
nuclear@1:     {
nuclear@1:         // Four-byte sequence.
nuclear@1:         FIRST_BYTE(0x07, 18);
nuclear@1:         NEXT_BYTE(12);
nuclear@1:         NEXT_BYTE(6);
nuclear@1:         NEXT_BYTE(0);
nuclear@1:         if (uc < 0x010000) return INVALID_CHAR;  // overlong
nuclear@1:         return uc;
nuclear@1:     }
nuclear@1:     else if ((c & 0xFC) == 0xF8)
nuclear@1:     {
nuclear@1:         // Five-byte sequence.
nuclear@1:         FIRST_BYTE(0x03, 24);
nuclear@1:         NEXT_BYTE(18);
nuclear@1:         NEXT_BYTE(12);
nuclear@1:         NEXT_BYTE(6);
nuclear@1:         NEXT_BYTE(0);
nuclear@1:         if (uc < 0x0200000) return INVALID_CHAR; // overlong
nuclear@1:         return uc;
nuclear@1:     }
nuclear@1:     else if ((c & 0xFE) == 0xFC)
nuclear@1:     {
nuclear@1:         // Six-byte sequence.
nuclear@1:         FIRST_BYTE(0x01, 30);
nuclear@1:         NEXT_BYTE(24);
nuclear@1:         NEXT_BYTE(18);
nuclear@1:         NEXT_BYTE(12);
nuclear@1:         NEXT_BYTE(6);
nuclear@1:         NEXT_BYTE(0);
nuclear@1:         if (uc < 0x04000000) return INVALID_CHAR;    // overlong
nuclear@1:         return uc;
nuclear@1:     }
nuclear@1:     else
nuclear@1:     {
nuclear@1:         // Invalid.
nuclear@1:         return INVALID_CHAR;
nuclear@1:     }
nuclear@1: }
nuclear@1: 
nuclear@1: 
nuclear@1: void OVR_STDCALL EncodeChar(char* pbuffer, SPInt* pindex, UInt32 ucs_character)
nuclear@1: {
nuclear@1:     if (ucs_character <= 0x7F)
nuclear@1:     {
nuclear@1:         // Plain single-byte ASCII.
nuclear@1:         pbuffer[(*pindex)++] = (char) ucs_character;
nuclear@1:     }
nuclear@1:     else if (ucs_character <= 0x7FF)
nuclear@1:     {
nuclear@1:         // Two bytes.
nuclear@1:         pbuffer[(*pindex)++] = 0xC0 | (char)(ucs_character >> 6);
nuclear@1:         pbuffer[(*pindex)++] = 0x80 | (char)((ucs_character >> 0) & 0x3F);
nuclear@1:     }
nuclear@1:     else if (ucs_character <= 0xFFFF)
nuclear@1:     {
nuclear@1:         // Three bytes.
nuclear@1:         pbuffer[(*pindex)++] = 0xE0 | (char)(ucs_character >> 12);
nuclear@1:         pbuffer[(*pindex)++] = 0x80 | (char)((ucs_character >> 6) & 0x3F);
nuclear@1:         pbuffer[(*pindex)++] = 0x80 | (char)((ucs_character >> 0) & 0x3F);
nuclear@1:     }
nuclear@1:     else if (ucs_character <= 0x1FFFFF)
nuclear@1:     {
nuclear@1:         // Four bytes.
nuclear@1:         pbuffer[(*pindex)++] = 0xF0 | (char)(ucs_character >> 18);
nuclear@1:         pbuffer[(*pindex)++] = 0x80 | (char)((ucs_character >> 12) & 0x3F);
nuclear@1:         pbuffer[(*pindex)++] = 0x80 | (char)((ucs_character >> 6) & 0x3F);
nuclear@1:         pbuffer[(*pindex)++] = 0x80 | (char)((ucs_character >> 0) & 0x3F);
nuclear@1:     }
nuclear@1:     else if (ucs_character <= 0x3FFFFFF)
nuclear@1:     {
nuclear@1:         // Five bytes.
nuclear@1:         pbuffer[(*pindex)++] = 0xF8 | (char)(ucs_character >> 24);
nuclear@1:         pbuffer[(*pindex)++] = 0x80 | (char)((ucs_character >> 18) & 0x3F);
nuclear@1:         pbuffer[(*pindex)++] = 0x80 | (char)((ucs_character >> 12) & 0x3F);
nuclear@1:         pbuffer[(*pindex)++] = 0x80 | (char)((ucs_character >> 6) & 0x3F);
nuclear@1:         pbuffer[(*pindex)++] = 0x80 | (char)((ucs_character >> 0) & 0x3F);
nuclear@1:     }
nuclear@1:     else if (ucs_character <= 0x7FFFFFFF)
nuclear@1:     {
nuclear@1:         // Six bytes.
nuclear@1:         pbuffer[(*pindex)++] = 0xFC | (char)(ucs_character >> 30);
nuclear@1:         pbuffer[(*pindex)++] = 0x80 | (char)((ucs_character >> 24) & 0x3F);
nuclear@1:         pbuffer[(*pindex)++] = 0x80 | (char)((ucs_character >> 18) & 0x3F);
nuclear@1:         pbuffer[(*pindex)++] = 0x80 | (char)((ucs_character >> 12) & 0x3F);
nuclear@1:         pbuffer[(*pindex)++] = 0x80 | (char)((ucs_character >> 6) & 0x3F);
nuclear@1:         pbuffer[(*pindex)++] = 0x80 | (char)((ucs_character >> 0) & 0x3F);
nuclear@1:     }
nuclear@1:     else
nuclear@1:     {
nuclear@1:         // Invalid char; don't encode anything.
nuclear@1:     }
nuclear@1: }
nuclear@1: 
nuclear@1: SPInt OVR_STDCALL GetEncodeStringSize(const wchar_t* pchar, SPInt length)
nuclear@1: {
nuclear@1:     SPInt len = 0;
nuclear@1:     if (length != -1)
nuclear@1:         for (int i = 0; i < length; i++)
nuclear@1:         {
nuclear@1:             len += GetEncodeCharSize(pchar[i]);
nuclear@1:         }
nuclear@1:     else
nuclear@1:         for (int i = 0;; i++)
nuclear@1:         {
nuclear@1:             if (pchar[i] == 0)
nuclear@1:                 return len;
nuclear@1:             len += GetEncodeCharSize(pchar[i]);
nuclear@1:         }
nuclear@1:     return len;
nuclear@1: }
nuclear@1: 
nuclear@1: void OVR_STDCALL EncodeString(char *pbuff, const wchar_t* pchar, SPInt length)
nuclear@1: {
nuclear@1:     SPInt ofs = 0;
nuclear@1:     if (length != -1)
nuclear@1:     {
nuclear@1:         for (int i = 0; i < length; i++)
nuclear@1:         {            
nuclear@1:             EncodeChar(pbuff, &ofs, pchar[i]);
nuclear@1:         }
nuclear@1:     }
nuclear@1:     else
nuclear@1:     {
nuclear@1:         for (int i = 0;; i++)
nuclear@1:         {
nuclear@1:             if (pchar[i] == 0)
nuclear@1:                 break;
nuclear@1:             EncodeChar(pbuff, &ofs, pchar[i]);
nuclear@1:         }
nuclear@1:     }
nuclear@1:     pbuff[ofs] = 0;
nuclear@1: }
nuclear@1: 
nuclear@1: UPInt OVR_STDCALL DecodeString(wchar_t *pbuff, const char* putf8str, SPInt bytesLen)
nuclear@1: {
nuclear@1:     wchar_t *pbegin = pbuff;
nuclear@1:     if (bytesLen == -1)
nuclear@1:     {
nuclear@1:         while (1)
nuclear@1:         {
nuclear@1:             UInt32 ch = DecodeNextChar_Advance0(&putf8str);
nuclear@1:             if (ch == 0)
nuclear@1:                 break;
nuclear@1:             else if (ch >= 0xFFFF)
nuclear@1:                 ch = 0xFFFD;
nuclear@1:             *pbuff++ = wchar_t(ch);
nuclear@1:         }
nuclear@1:     }
nuclear@1:     else
nuclear@1:     {
nuclear@1:         const char* p = putf8str;
nuclear@1:         while ((p - putf8str) < bytesLen)
nuclear@1:         {
nuclear@1:             UInt32 ch = DecodeNextChar_Advance0(&p);
nuclear@1:             if (ch >= 0xFFFF)
nuclear@1:                 ch = 0xFFFD;
nuclear@1:             *pbuff++ = wchar_t(ch);
nuclear@1:         }
nuclear@1:     }
nuclear@1: 
nuclear@1:     *pbuff = 0;
nuclear@1:     return pbuff - pbegin;
nuclear@1: }
nuclear@1: 
nuclear@1: 
nuclear@1: #ifdef UTF8_UNIT_TEST
nuclear@1: 
nuclear@1: // Compile this test case with something like:
nuclear@1: //
nuclear@1: // gcc utf8.cpp -g -I.. -DUTF8_UNIT_TEST -lstdc++ -o utf8_test
nuclear@1: //
nuclear@1: //    or
nuclear@1: //
nuclear@1: // cl utf8.cpp -Zi -Od -DUTF8_UNIT_TEST -I..
nuclear@1: //
nuclear@1: // If possible, try running the test program with the first arg
nuclear@1: // pointing at the file:
nuclear@1: //
nuclear@1: // http://www.cl.cam.ac.uk/~mgk25/ucs/examples/UTF-8-test.txt
nuclear@1: // 
nuclear@1: // and examine the results by eye to make sure they are acceptable to
nuclear@1: // you.
nuclear@1: 
nuclear@1: 
nuclear@1: #include "base/utility.h"
nuclear@1: #include <stdio.h>
nuclear@1: 
nuclear@1: 
nuclear@1: bool    check_equal(const char* utf8_in, const UInt32* ucs_in)
nuclear@1: {
nuclear@1:     for (;;)
nuclear@1:     {
nuclear@1:         UInt32  next_ucs = *ucs_in++;
nuclear@1:         UInt32  next_ucs_from_utf8 = utf8::decode_next_unicode_character(&utf8_in);
nuclear@1:         if (next_ucs != next_ucs_from_utf8)
nuclear@1:         {
nuclear@1:             return false;
nuclear@1:         }
nuclear@1:         if (next_ucs == 0)
nuclear@1:         {
nuclear@1:             OVR_ASSERT(next_ucs_from_utf8 == 0);
nuclear@1:             break;
nuclear@1:         }
nuclear@1:     }
nuclear@1:     
nuclear@1:     return true;
nuclear@1: }
nuclear@1: 
nuclear@1: 
nuclear@1: void    log_ascii(const char* line)
nuclear@1: {
nuclear@1:     for (;;)
nuclear@1:     {
nuclear@1:         unsigned char   c = (unsigned char) *line++;
nuclear@1:         if (c == 0)
nuclear@1:         {
nuclear@1:             // End of line.
nuclear@1:             return;
nuclear@1:         }
nuclear@1:         else if (c != '\n'
nuclear@1:             && (c < 32 || c > 127))
nuclear@1:         {
nuclear@1:             // Non-printable as plain ASCII.
nuclear@1:             printf("<0x%02X>", (int) c);
nuclear@1:         }
nuclear@1:         else
nuclear@1:         {
nuclear@1:             printf("%c", c);
nuclear@1:         }
nuclear@1:     }
nuclear@1: }
nuclear@1: 
nuclear@1: 
nuclear@1: void    log_ucs(const UInt32* line)
nuclear@1: {
nuclear@1:     for (;;)
nuclear@1:     {
nuclear@1:         UInt32  uc = *line++;
nuclear@1:         if (uc == 0)
nuclear@1:         {
nuclear@1:             // End of line.
nuclear@1:             return;
nuclear@1:         }
nuclear@1:         else if (uc != '\n'
nuclear@1:             && (uc < 32 || uc > 127))
nuclear@1:         {
nuclear@1:             // Non-printable as plain ASCII.
nuclear@1:             printf("<U-%04X>", uc);
nuclear@1:         }
nuclear@1:         else
nuclear@1:         {
nuclear@1:             printf("%c", (char) uc);
nuclear@1:         }
nuclear@1:     }
nuclear@1: }
nuclear@1: 
nuclear@1: 
nuclear@1: // Simple canned test.
nuclear@1: int main(int argc, const char* argv[])
nuclear@1: {
nuclear@1:     {
nuclear@1:         const char* test8 = "Ignacio Castaño";
nuclear@1:         const UInt32    test32[] =
nuclear@1:         {
nuclear@1:             0x49, 0x67, 0x6E, 0x61, 0x63,
nuclear@1:                 0x69, 0x6F, 0x20, 0x43, 0x61,
nuclear@1:                 0x73, 0x74, 0x61, 0xF1, 0x6F,
nuclear@1:                 0x00
nuclear@1:         };
nuclear@1:         
nuclear@1:         OVR_ASSERT(check_equal(test8, test32));
nuclear@1:     }
nuclear@1:         
nuclear@1:         // If user passed an arg, try reading the file as UTF-8 encoded text.
nuclear@1:         if (argc > 1)
nuclear@1:         {
nuclear@1:             const char* filename = argv[1];
nuclear@1:             FILE*   fp = fopen(filename, "rb");
nuclear@1:             if (fp == NULL)
nuclear@1:             {
nuclear@1:                 printf("Can't open file '%s'\n", filename);
nuclear@1:                 return 1;
nuclear@1:             }
nuclear@1:             
nuclear@1:             // Read lines from the file, encode/decode them, and highlight discrepancies.
nuclear@1:             const int LINE_SIZE = 200;  // max line size
nuclear@1:             char    line_buffer_utf8[LINE_SIZE];
nuclear@1:             char    reencoded_utf8[6 * LINE_SIZE];
nuclear@1:             UInt32  line_buffer_ucs[LINE_SIZE];
nuclear@1:             
nuclear@1:             int byte_counter = 0;
nuclear@1:             for (;;)
nuclear@1:             {
nuclear@1:                 int c = fgetc(fp);
nuclear@1:                 if (c == EOF)
nuclear@1:                 {
nuclear@1:                     // Done.
nuclear@1:                     break;
nuclear@1:                 }
nuclear@1:                 line_buffer_utf8[byte_counter++] = c;
nuclear@1:                 if (c == '\n' || byte_counter >= LINE_SIZE - 2)
nuclear@1:                 {
nuclear@1:                     // End of line.  Process the line.
nuclear@1:                     line_buffer_utf8[byte_counter++] = 0;   // terminate.
nuclear@1:                     
nuclear@1:                     // Decode into UCS.
nuclear@1:                     const char* p = line_buffer_utf8;
nuclear@1:                     UInt32* q = line_buffer_ucs;
nuclear@1:                     for (;;)
nuclear@1:                     {
nuclear@1:                         UInt32  uc = UTF8Util::DecodeNextChar(&p);
nuclear@1:                         *q++ = uc;
nuclear@1:                         
nuclear@1:                         OVR_ASSERT(q < line_buffer_ucs + LINE_SIZE);
nuclear@1:                         OVR_ASSERT(p < line_buffer_utf8 + LINE_SIZE);
nuclear@1:                         
nuclear@1:                         if (uc == 0) break;
nuclear@1:                     }
nuclear@1:                     
nuclear@1:                     // Encode back into UTF-8.
nuclear@1:                     q = line_buffer_ucs;
nuclear@1:                     int index = 0;
nuclear@1:                     for (;;)
nuclear@1:                     {
nuclear@1:                         UInt32  uc = *q++;
nuclear@1:                         OVR_ASSERT(index < LINE_SIZE * 6 - 6);
nuclear@1:                         int last_index = index;
nuclear@1:                         UTF8Util::EncodeChar(reencoded_utf8, &index, uc);
nuclear@1:                         OVR_ASSERT(index <= last_index + 6);
nuclear@1:                         if (uc == 0) break;
nuclear@1:                     }
nuclear@1:                     
nuclear@1:                     // This can be useful for debugging.
nuclear@1: #if 0
nuclear@1:                     // Show the UCS and the re-encoded UTF-8.
nuclear@1:                     log_ucs(line_buffer_ucs);
nuclear@1:                     log_ascii(reencoded_utf8);
nuclear@1: #endif // 0
nuclear@1:                     
nuclear@1:                     OVR_ASSERT(check_equal(line_buffer_utf8, line_buffer_ucs));
nuclear@1:                     OVR_ASSERT(check_equal(reencoded_utf8, line_buffer_ucs));
nuclear@1:                     
nuclear@1:                     // Start next line.
nuclear@1:                     byte_counter = 0;
nuclear@1:                 }
nuclear@1:             }
nuclear@1:             
nuclear@1:             fclose(fp);
nuclear@1:         }
nuclear@1:         
nuclear@1:         return 0;
nuclear@1: }
nuclear@1: 
nuclear@1: 
nuclear@1: #endif // UTF8_UNIT_TEST
nuclear@1: 
nuclear@1: }} // namespace UTF8Util::OVR
nuclear@1: