Public API Reference

csutil/csuctransform.h

Go to the documentation of this file.

/*
    Copyright (C) 2003 by Frank Richter

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the Free
    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#ifndef __CS_CSUCTRANSFORM_H__
#define __CS_CSUCTRANSFORM_H__

#include "csunicode.h"

#define CS_UC_MAX_UTF8_ENCODED          4  /* 6 to encode 32 bit */

#define CS_UC_MAX_UTF16_ENCODED         2

#define CS_UC_MAX_UTF32_ENCODED         1
#if (CS_WCHAR_T_SIZE == 1)
#define CS_UC_MAX_WCHAR_T_ENCODED       CS_UC_MAX_UTF8_ENCODED
#elif (CS_WCHAR_T_SIZE == 2)

#define CS_UC_MAX_WCHAR_T_ENCODED       CS_UC_MAX_UTF16_ENCODED
#else
#define CS_UC_MAX_WCHAR_T_ENCODED       CS_UC_MAX_UTF32_ENCODED
#endif

#define CS_UC_MAX_MAPPED                3

enum
{
  csUcMapSimple = (1 << 0)
};

class CS_CRYSTALSPACE_EXPORT csUnicodeTransform
{
public:
#define FAIL(ret)                               \
  {                                             \
    if (isValid) *isValid = false;              \
    ch = CS_UC_CHAR_REPLACER;                   \
    return ret;                                 \
  }

#define SUCCEED                                 \
    if (isValid) *isValid = true;               \
    return chUsed;
  
#define GET_NEXT(next)  \
  if ((size_t)chUsed == strlen)                 \
  {                                             \
    FAIL(chUsed);                               \
  }                                             \
  next = *str++;                                \
  if (next == 0)                                \
  {                                             \
    FAIL(chUsed);                               \
  }                                             \
  chUsed++;                                     
  
  inline static int UTF8Decode (const utf8_char* str, size_t strlen, 
    utf32_char& ch, bool* isValid = 0, bool returnNonChar = false)
  {
    if (str == 0)
    {
      FAIL(0);
    }
    int chUsed = 0;
    
    utf8_char curCh;
    GET_NEXT(curCh);
    if ((curCh & 0x80) == 0)
    {
      // easy case
      ch = curCh;
      SUCCEED;
    }
    else
    {
      // Count with how many bytes this char is encoded.
      int n = 0;
      while ((n < 7) && ((curCh & (1 << (7 - n))) != 0)) { n++; }

      if ((n < 2) || (n > 6))
      {
        // Invalid code: first char of a "sequence" must have
        // at least two and at most six MSBs set
        FAIL(1);
      }

      ch = (curCh & ((1 << (8 - n)) - 1));
      
      for (int i = 1; i < n; i++)
      {
        GET_NEXT(curCh);
        if ((curCh & 0xc0) != 0x80)
        {
          FAIL(chUsed);
        }
        else
        {
          ch <<= 6;
          ch |= (curCh & 0x3f);
        }
      }
      
      // Check if in Unicode range.
      if (ch > CS_UC_LAST_CHAR)
      {
        FAIL(chUsed);
      }

      // Check for "overlong" codes.
      if ((ch < 0x80) && (n > 0))
      {
        FAIL(chUsed);
      }
      else if ((ch < 0x800) && (n > 2))
      {
        FAIL(chUsed);
      }
      else if ((ch < 0x10000) && (n > 3))
      {
        FAIL(chUsed);
      }
      else if ((ch < 0x200000) && (n > 4))
      {
        FAIL(chUsed);
      }
      /* 
      else if ((ch < 0x4000000) && (n > 5))
      {
        FAIL(chUsed);
      }
      else if ((ch < 0x80000000) && (n > 6))
      {
        FAIL(chUsed);
      }
      */
      
      if (!returnNonChar && (CS_UC_IS_NONCHARACTER(ch) 
        || CS_UC_IS_SURROGATE(ch)))
        FAIL(chUsed);
      SUCCEED;
    }
  }
  
  inline static int UTF16Decode (const utf16_char* str, size_t strlen, 
    utf32_char& ch, bool* isValid = 0, bool returnNonChar = false)
  {
    if (str == 0)
    {
      FAIL(0);
    }
    int chUsed = 0;
    
    utf16_char curCh;
    GET_NEXT(curCh);
    // Decode surrogate
    if (CS_UC_IS_SURROGATE (curCh))
    {
      // Invalid code
      if (!CS_UC_IS_HIGH_SURROGATE (curCh))
      {
        FAIL(chUsed);
      }
      ch = 0x10000 + ((curCh & 0x03ff) << 10);
      GET_NEXT(curCh);
      // Invalid code
      if (!CS_UC_IS_LOW_SURROGATE (curCh))
      {
        // Fail with 1 so the char is handled upon the next Decode.
        FAIL(1);
      }
      ch |= (curCh & 0x3ff);
    }
    else
    {
      ch = curCh;
    }
    if (!returnNonChar && (CS_UC_IS_NONCHARACTER(ch) 
      || CS_UC_IS_SURROGATE(ch)))
      FAIL(chUsed);
    SUCCEED;
  }
  
  inline static int UTF32Decode (const utf32_char* str, size_t strlen, 
    utf32_char& ch, bool* isValid = 0, bool returnNonChar = false)
  {
    if (str == 0)
    {
      FAIL(0);
    }
    int chUsed = 0;
    
    GET_NEXT(ch);
    if ((!returnNonChar && (CS_UC_IS_NONCHARACTER(ch) 
      || CS_UC_IS_SURROGATE(ch))) || (ch > CS_UC_LAST_CHAR))
      FAIL(chUsed);
    SUCCEED;
  }

  inline static int Decode (const utf8_char* str, size_t strlen, 
    utf32_char& ch, bool* isValid = 0, bool returnNonChar = false)
  {
    return UTF8Decode (str, strlen, ch, isValid, returnNonChar);
  }
  inline static int Decode (const utf16_char* str, size_t strlen, 
    utf32_char& ch, bool* isValid = 0, bool returnNonChar = false)
  {
    return UTF16Decode (str, strlen, ch, isValid, returnNonChar);
  }
  inline static int Decode (const utf32_char* str, size_t strlen, 
    utf32_char& ch, bool* isValid = 0, bool returnNonChar = false)
  {
    return UTF32Decode (str, strlen, ch, isValid, returnNonChar);
  }

#undef FAIL
#undef SUCCEED
#undef GET_NEXT

#define _OUTPUT_CHAR(buf, chr)                          \
  if (bufRemaining > 0)                                 \
  {                                                     \
    if(buf) *buf++ = chr;                               \
    bufRemaining--;                                     \
  }                                                     \
  encodedLen++;

#define OUTPUT_CHAR(chr) _OUTPUT_CHAR(buf, chr)
  
  inline static int EncodeUTF8 (const utf32_char ch, utf8_char* buf, 
    size_t bufsize, bool allowNonchars = false)
  {
    if ((!allowNonchars && ((CS_UC_IS_NONCHARACTER(ch)) 
      || (CS_UC_IS_SURROGATE(ch)))) || (ch > CS_UC_LAST_CHAR))
      return 0;
    size_t bufRemaining = bufsize;
    int encodedLen = 0;
    
    if (ch < 0x80)
    {
      OUTPUT_CHAR ((utf8_char)ch);
    }
    else if (ch < 0x800)
    {
      OUTPUT_CHAR ((utf8_char)(0xc0 | (ch >> 6)));
      OUTPUT_CHAR ((utf8_char)(0x80 | (ch & 0x3f)));
    }
    else if (ch < 0x10000)
    {
      OUTPUT_CHAR ((utf8_char)(0xe0 | (ch >> 12)));
      OUTPUT_CHAR ((utf8_char)(0x80 | ((ch >> 6) & 0x3f)));
      OUTPUT_CHAR ((utf8_char)(0x80 | (ch & 0x3f)));
    }
    else if (ch < 0x200000)
    {
      OUTPUT_CHAR ((utf8_char)(0xf0 | (ch >> 18)));
      OUTPUT_CHAR ((utf8_char)(0x80 | ((ch >> 12) & 0x3f)));
      OUTPUT_CHAR ((utf8_char)(0x80 | ((ch >> 6) & 0x3f)));
      OUTPUT_CHAR ((utf8_char)(0x80 | (ch & 0x3f)));
    }
    /*
    else if (ch < 0x4000000)
    {
      OUTPUT_CHAR ((utf8_char)(0xf8 | (ch >> 24)));
      OUTPUT_CHAR ((utf8_char)(0x80 | ((ch >> 18) & 0x3f)));
      OUTPUT_CHAR ((utf8_char)(0x80 | ((ch >> 12) & 0x3f)));
      OUTPUT_CHAR ((utf8_char)(0x80 | ((ch >> 6) & 0x3f)));
      OUTPUT_CHAR ((utf8_char)(0x80 | (ch & 0x3f)));
    }
    else if (ch < 0x80000000)
    {
      OUTPUT_CHAR ((utf8_char)(0xfc | (ch >> 30)));
      OUTPUT_CHAR ((utf8_char)(0x80 | ((ch >> 24) & 0x3f)));
      OUTPUT_CHAR ((utf8_char)(0x80 | ((ch >> 18) & 0x3f)));
      OUTPUT_CHAR ((utf8_char)(0x80 | ((ch >> 12) & 0x3f)));
      OUTPUT_CHAR ((utf8_char)(0x80 | ((ch >> 6) & 0x3f)));
      OUTPUT_CHAR ((utf8_char)(0x80 | (ch & 0x3f)));
    }
    */
    return encodedLen;
  }
    
  inline static int EncodeUTF16 (const utf32_char ch, utf16_char* buf, 
    size_t bufsize, bool allowNonchars = false)
  {
    if ((!allowNonchars && ((CS_UC_IS_NONCHARACTER(ch)) 
      || (CS_UC_IS_SURROGATE(ch)))) || (ch > CS_UC_LAST_CHAR))
      return 0;
    size_t bufRemaining = bufsize;
    int encodedLen = 0;
    
    if (ch < 0x10000)
    {
      OUTPUT_CHAR((utf16_char)ch);
    }
    else if (ch < 0x100000)
    {
      utf32_char ch_shifted = ch - 0x10000;
      OUTPUT_CHAR((utf16_char)((ch_shifted >> 10) 
        | CS_UC_CHAR_HIGH_SURROGATE_FIRST));
      OUTPUT_CHAR((utf16_char)((ch_shifted & 0x3ff) 
        | CS_UC_CHAR_LOW_SURROGATE_FIRST));
    }
    else
      return 0;
    
    return encodedLen;
  }

  inline static int EncodeUTF32 (const utf32_char ch, utf32_char* buf, 
    size_t bufsize, bool allowNonchars = false)
  {
    if ((!allowNonchars && ((CS_UC_IS_NONCHARACTER(ch)) 
      || (CS_UC_IS_SURROGATE(ch)))) || (ch > CS_UC_LAST_CHAR))
      return 0;
    size_t bufRemaining = bufsize;
    int encodedLen = 0;
    
    OUTPUT_CHAR(ch);
    
    return encodedLen;
  }

  inline static int Encode (const utf32_char ch, utf8_char* buf, 
    size_t bufsize, bool allowNonchars = false)
  {
    return EncodeUTF8 (ch, buf, bufsize, allowNonchars);
  }
  inline static int Encode (const utf32_char ch, utf16_char* buf, 
    size_t bufsize, bool allowNonchars = false)
  {
    return EncodeUTF16 (ch, buf, bufsize, allowNonchars);
  }
  inline static int Encode (const utf32_char ch, utf32_char* buf, 
    size_t bufsize, bool allowNonchars = false)
  {
    return EncodeUTF32 (ch, buf, bufsize, allowNonchars);
  }
#undef OUTPUT_CHAR
  
#define OUTPUT_CHAR(chr) _OUTPUT_CHAR(dest, chr)
  
#define UCTF_CONVERTER(funcName, fromType, decoder, toType, encoder)    \
  inline static size_t funcName (toType* dest, size_t destSize,         \
    const fromType* source, size_t srcSize = (size_t)-1)                \
  {                                                                     \
    if ((srcSize == 0) || (source == 0))                                \
      return 0;                                                         \
                                                                        \
    size_t bufRemaining = (destSize > 0) ? destSize - 1 : 0;            \
    size_t encodedLen = 0;                                              \
                                                                        \
    size_t srcChars = srcSize;                                          \
                                                                        \
    if (srcSize == (size_t)-1)                                          \
    {                                                                   \
      srcChars = 0;                                                     \
      const fromType* sptr = source;                                    \
      while (*sptr++ != 0) srcChars++;                                  \
    }                                                                   \
                                                                        \
    while (srcChars > 0)                                                \
    {                                                                   \
      utf32_char ch;                                                    \
      int scnt = decoder (source, srcChars, ch, 0);                     \
      if (scnt == 0) break;                                             \
      int dcnt = encoder (ch, dest, bufRemaining);                      \
      if (dcnt == 0)                                                    \
      {                                                                 \
        dcnt = encoder (CS_UC_CHAR_REPLACER, dest, bufRemaining);       \
      }                                                                 \
                                                                        \
      if ((size_t)dcnt >= bufRemaining)                                 \
      {                                                                 \
        if (dest && (destSize > 0)) dest += bufRemaining;               \
        bufRemaining = 0;                                               \
      }                                                                 \
      else                                                              \
      {                                                                 \
        bufRemaining -= dcnt;                                           \
        if (dest && (destSize > 0)) dest += dcnt;                       \
      }                                                                 \
      encodedLen += dcnt;                                               \
      if ((size_t)scnt >= srcChars) break;                              \
      srcChars -= scnt;                                                 \
      source += scnt;                                                   \
    }                                                                   \
                                                                        \
    if (dest) *dest = 0;                                                \
                                                                        \
    return encodedLen + 1;                                              \
  }

  UCTF_CONVERTER (UTF8to16, utf8_char, UTF8Decode, utf16_char, EncodeUTF16);
  UCTF_CONVERTER (UTF8to32, utf8_char, UTF8Decode, utf32_char, EncodeUTF32);

  UCTF_CONVERTER (UTF16to8, utf16_char, UTF16Decode, utf8_char, EncodeUTF8);
  UCTF_CONVERTER (UTF16to32, utf16_char, UTF16Decode, utf32_char, EncodeUTF32);
  
  UCTF_CONVERTER (UTF32to8, utf32_char, UTF32Decode, utf8_char, EncodeUTF8);
  UCTF_CONVERTER (UTF32to16, utf32_char, UTF32Decode, utf16_char, EncodeUTF16);
#undef UCTF_CONVERTER
#undef OUTPUT_CHAR
#undef _OUTPUT_CHAR

#if (CS_WCHAR_T_SIZE == 1)
  inline static size_t UTF8toWC (wchar_t* dest, size_t destSize, 
    const utf8_char* source, size_t srcSize)
  {
    size_t srcChars = srcSize;                                          
    if (srcSize == (size_t)-1)                                          
    {                                                                   
      srcChars = 0;                                                     
      const utf8_char* sptr = source;                                   
      while (*sptr++ != 0) srcChars++;                                  
    }                           
    if ((dest != 0) && (destSize != 0))
    {
      size_t len = MIN (destSize - 1, srcChars);
      memcpy (dest, source, size * sizeof (wchar_t));
      *(dest + len) = 0;
    }
    return srcChars + 1;
  };

  inline static size_t UTF16toWC (wchar_t* dest, size_t destSize, 
    const utf16_char* source, size_t srcSize)
  {
    return UTF16to8 ((utf8_char*)dest, destSize, source, srcSize);
  };

  inline static size_t UTF32toWC (wchar_t* dest, size_t destSize, 
    const utf32_char* source, size_t srcSize)
  {
    return UTF32to8 ((utf8_char*)dest, destSize, source, srcSize);
  };
  
  inline static size_t WCtoUTF8 (utf8_char* dest, size_t destSize, 
    const wchar_t* source, size_t srcSize)
  {
    size_t srcChars = srcSize;                                          
    if (srcSize == (size_t)-1)                                          
    {                                                                   
      srcChars = 0;                                                     
      const wchar_t* sptr = source;                                     
      while (*sptr++ != 0) srcChars++;                                  
    }                           
    if ((dest != 0) && (destSize != 0))
    {
      size_t len = MIN (destSize - 1, srcChars);
      memcpy (dest, source, len * sizeof (wchar_t));
      *(dest + len) = 0;
    }
    return srcChars + 1;
  };

  inline static size_t WCtoUTF16 (utf16_char* dest, size_t destSize, 
    const wchar_t* source, size_t srcSize)
  {
    return UTF8to16 (dest, destSize, source, srcSize);
  };

  inline static size_t WCtoUTF32 (utf32_char* dest, size_t destSize, 
    const wchar_t* source, size_t srcSize)
  {
    return UTF8to32 (dest, destSize, source, srcSize);
  };

  inline static int Decode (const wchar_t* str, size_t strlen, 
    utf32_char& ch, bool* isValid = 0, bool returnNonChar = false)
  {
    return UTF8Decode ((utf8_char*)str, strlen, ch, isValid, returnNonChar);
  }
  inline static int Encode (const utf32_char ch, wchar_t* buf, 
    size_t bufsize, bool allowNonchars = false)
  {
    return EncodeUTF8 (ch, (utf8_char*)buf, bufsize, allowNonchars);
  }
#elif (CS_WCHAR_T_SIZE == 2)
  // Methods below for doxygen documentation are here as the size '2' is 
  // default.
  
  inline static size_t UTF8toWC (wchar_t* dest, size_t destSize, 
    const utf8_char* source, size_t srcSize)
  {
    return UTF8to16 ((utf16_char*)dest, destSize, source, srcSize);
  };

  inline static size_t UTF16toWC (wchar_t* dest, size_t destSize, 
    const utf16_char* source, size_t srcSize)
  {
    size_t srcChars = srcSize;                                          
    if (srcSize == (size_t)-1)                                          
    {                                                                   
      srcChars = 0;                                                     
      const utf16_char* sptr = source;                                  
      while (*sptr++ != 0) srcChars++;                                  
    }                           
    if ((dest != 0) && (destSize != 0))
    {
      size_t len = MIN (destSize - 1, srcChars);
      memcpy (dest, source, len * sizeof (wchar_t));
      *(dest + len) = 0;
    }
    return srcChars + 1;
  };

  inline static size_t UTF32toWC (wchar_t* dest, size_t destSize, 
    const utf32_char* source, size_t srcSize)
  {
    return UTF32to16 ((utf16_char*)dest, destSize, source, srcSize);
  };
  
  inline static size_t WCtoUTF8 (utf8_char* dest, size_t destSize, 
    const wchar_t* source, size_t srcSize)
  {
    return UTF16to8 (dest, destSize, (utf16_char*)source, srcSize);
  };

  inline static size_t WCtoUTF16 (utf16_char* dest, size_t destSize, 
    const wchar_t* source, size_t srcSize)
  {
    size_t srcChars = srcSize;                                          
    if (srcSize == (size_t)-1)                                          
    {                                                                   
      srcChars = 0;                                                     
      const wchar_t* sptr = source;                                     
      while (*sptr++ != 0) srcChars++;                                  
    }                           
    if ((dest != 0) && (destSize != 0))
    {
      size_t len = MIN (destSize - 1, srcChars);
      memcpy (dest, source, len * sizeof (wchar_t));
      *(dest + len) = 0;
    }
    return srcChars + 1;
  };

  inline static size_t WCtoUTF32 (utf32_char* dest, size_t destSize, 
    const wchar_t* source, size_t srcSize)
  {
    return UTF16to32 (dest, destSize, (utf16_char*)source, srcSize);
  };

  /* Decode()/Encode() overloads for wchar_t.
   * - On VC7+, wchar_t may be an unsigned short or the special type __wchar_t.
   * - On VC6 wchar_t is always an unsigned short. __wchar_t does not exist.
   * Now there may be conflicts with the utf16_char overloads if wchar_t is
   * an unsigned short. On the other hand, we would like to support VC7+'s
   * built-in wchar_t as well.
   * So: on VC7+, provide overloads for __wchar_t, on VC6, don't compile this
   * code at all, on other compilers, provide overloads for wchar_t instead
   * (by re#definining __wchar_t). 
   */
#if !defined(CS_COMPILER_MSVC) || (_MSC_VER > 1300)
#if !defined(CS_COMPILER_MSVC)
  #define __wchar_t wchar_t
#endif  

  inline static int Decode (const __wchar_t* str, size_t strlen, 
    utf32_char& ch, bool* isValid = 0, bool returnNonChar = false)
  {
    return UTF16Decode ((utf16_char*)str, strlen, ch, isValid, returnNonChar);
  }
  inline static int Encode (const utf32_char ch, __wchar_t* buf, 
    size_t bufsize, bool allowNonchars = false)
  {
    return EncodeUTF16 (ch, (utf16_char*)buf, bufsize, allowNonchars);
  }
#ifdef __wchar_t
  #undef __wchar_t
#endif
#endif

#elif (CS_WCHAR_T_SIZE == 4)
  inline static size_t UTF8toWC (wchar_t* dest, size_t destSize, 
    const utf8_char* source, size_t srcSize)
  {
    return UTF8to32 ((utf32_char*)dest, destSize, source, srcSize);
  };

  inline static size_t UTF16toWC (wchar_t* dest, size_t destSize, 
    const utf16_char* source, size_t srcSize)
  {
    return UTF16to32 ((utf32_char*)dest, destSize, source, srcSize);
  };

  inline static size_t UTF32toWC (wchar_t* dest, size_t destSize, 
    const utf32_char* source,  size_t srcSize)
  {
    size_t srcChars = srcSize;                                          
    if (srcSize == (size_t)-1)                                          
    {                                                                   
      srcChars = 0;                                                     
      const utf32_char* sptr = source;                                  
      while (*sptr++ != 0) srcChars++;                                  
    }                           
    if ((dest != 0) && (destSize != 0))
    {
      size_t len = MIN (destSize - 1, srcChars);
      memcpy (dest, source, len * sizeof (wchar_t));
      *(dest + len) = 0;
    }
    return srcChars + 1;
  };
  
  inline static size_t WCtoUTF8 (utf8_char* dest, size_t destSize, 
    const wchar_t* source, size_t srcSize)
  {
    return UTF32to8 (dest, destSize, (utf32_char*)source, srcSize);
  };

  inline static size_t WCtoUTF16 (utf16_char* dest, size_t destSize, 
    const wchar_t* source, size_t srcSize)
  {
    return UTF32to16 (dest, destSize, (utf32_char*)source, srcSize);
  };

  inline static size_t WCtoUTF32 (utf32_char* dest, size_t destSize, 
    const wchar_t* source, size_t srcSize)
  {
    size_t srcChars = srcSize;                                          
    if (srcSize == (size_t)-1)                                          
    {                                                                   
      srcChars = 0;                                                     
      const wchar_t* sptr = source;                                     
      while (*sptr++ != 0) srcChars++;                                  
    }                           
    if ((dest != 0) && (destSize != 0))
    {
      size_t len = MIN (destSize - 1, srcChars);
      memcpy (dest, source, len * sizeof (wchar_t));
      *(dest + len) = 0;
    }
    return srcChars + 1;
  };

  inline static int Decode (const wchar_t* str, size_t strlen, 
    utf32_char& ch, bool* isValid = 0, bool returnNonChar = false)
  {
    return UTF32Decode ((utf32_char*)str, strlen, ch, isValid, returnNonChar);
  }
  inline static int Encode (const utf32_char ch, wchar_t* buf, 
    size_t bufsize, bool allowNonchars = false)
  {
    return EncodeUTF32 (ch, (utf32_char*)buf, bufsize, allowNonchars);
  }
#else
  #error Odd-sized, unsupported wchar_t!
#endif

  inline static int UTF8Skip (const utf8_char* str, size_t maxSkip)
  {
    if (maxSkip < 1) return 0;
  
    if ((*str & 0x80) == 0)
    {
      return 1;
    }
    else
    {
      int n = 0;
      while ((n < 7) && ((*str & (1 << (7 - n))) != 0)) { n++; }

      if ((n < 2) || (n > 6))
      {
        return 1;
      }

      int skip = 1;
      
      for (; skip < n; skip++)
      {
        if (((str[skip] & 0xc0) != 0x80) || ((size_t)skip > maxSkip))
        {
          break;
        }
      }
      return skip;
    }
  }
  
  inline static int UTF8Rewind (const utf8_char* str, size_t maxRew)
  {
    if (maxRew < 1) return 0;
    
    const utf8_char* pos = str - 1;
    
    if ((*pos & 0x80) == 0)
    {
      return 1;
    }
    
    // Skip backward to the first byte of the sequence.
    int skip = 1;
    while (((*pos & 0xc0) == 0x80) && ((size_t)skip < maxRew))
    {
      skip++;
      pos--;
    }
    
    return skip;
  }
  
  inline static int UTF16Skip (const utf16_char* str, size_t maxSkip)
  {
    if (CS_UC_IS_HIGH_SURROGATE (*str))
      return (int)(MIN(maxSkip, 2));
    else
      return (int)(MIN(maxSkip, 1));
  }
  
  inline static int UTF16Rewind (const utf16_char* str, size_t maxRew)
  {
    if (maxRew < 1) return 0;
    
    const utf16_char* pos = str - 1;
    if (!CS_UC_IS_SURROGATE(*pos)) 
      return 1;
    else
    {
      if ((maxRew > 1) && (CS_UC_IS_HIGH_SURROGATE(*(pos - 1))))
        return 2;
      else
        return 1;
    }
  }
  
  inline static int UTF32Skip (const utf32_char* str, size_t maxSkip)
  {
    (void)str; // silence gcc
    return (int)(MIN(maxSkip, 1));
  }

  inline static int UTF32Rewind (const utf32_char* str, size_t maxRew)
  {
    (void)str; // silence gcc
    if (maxRew < 1) return 0;
    return 1;
  }
  static size_t MapToUpper (const utf32_char ch, utf32_char* dest, 
    size_t destSize, uint flags = 0);
  static size_t MapToLower (const utf32_char ch, utf32_char* dest, 
    size_t destSize, uint flags = 0);
  static size_t MapToFold (const utf32_char ch, utf32_char* dest, 
    size_t destSize, uint flags = 0);
};

#endif

---