CrystalSpace

Public API Reference

csutil/csuctransform.h

Go to the documentation of this file.
00001 /*
00002     Copyright (C) 2003 by Frank Richter
00003 
00004     This library is free software; you can redistribute it and/or
00005     modify it under the terms of the GNU Library General Public
00006     License as published by the Free Software Foundation; either
00007     version 2 of the License, or (at your option) any later version.
00008 
00009     This library is distributed in the hope that it will be useful,
00010     but WITHOUT ANY WARRANTY; without even the implied warranty of
00011     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00012     Library General Public License for more details.
00013 
00014     You should have received a copy of the GNU Library General Public
00015     License along with this library; if not, write to the Free
00016     Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
00017 */
00018 
00019 #ifndef __CS_CSUCTRANSFORM_H__
00020 #define __CS_CSUCTRANSFORM_H__
00021 
00022 #include "csunicode.h"
00023 
00035 #define CS_UC_MAX_UTF8_ENCODED          4  /* 6 to encode 32 bit */
00036 
00040 #define CS_UC_MAX_UTF16_ENCODED         2
00041 
00045 #define CS_UC_MAX_UTF32_ENCODED         1
00046 #if (CS_WCHAR_T_SIZE == 1)
00047 #define CS_UC_MAX_WCHAR_T_ENCODED       CS_UC_MAX_UTF8_ENCODED
00048 #elif (CS_WCHAR_T_SIZE == 2)
00049 
00053 #define CS_UC_MAX_WCHAR_T_ENCODED       CS_UC_MAX_UTF16_ENCODED
00054 #else
00055 #define CS_UC_MAX_WCHAR_T_ENCODED       CS_UC_MAX_UTF32_ENCODED
00056 #endif
00057 
00061 #define CS_UC_MAX_MAPPED                3
00062 
00066 enum
00067 {
00073   csUcMapSimple = (1 << 0)
00074 };
00075 
00079 class CS_CRYSTALSPACE_EXPORT csUnicodeTransform
00080 {
00081 public:
00082 #define FAIL(ret)                               \
00083   {                                             \
00084     if (isValid) *isValid = false;              \
00085     ch = CS_UC_CHAR_REPLACER;                   \
00086     return ret;                                 \
00087   }
00088 
00089 #define SUCCEED                                 \
00090     if (isValid) *isValid = true;               \
00091     return chUsed;
00092   
00093 #define GET_NEXT(next)  \
00094   if ((size_t)chUsed == strlen)                 \
00095   {                                             \
00096     FAIL(chUsed);                               \
00097   }                                             \
00098   next = *str++;                                \
00099   if (next == 0)                                \
00100   {                                             \
00101     FAIL(chUsed);                               \
00102   }                                             \
00103   chUsed++;                                     
00104   
00123   inline static int UTF8Decode (const utf8_char* str, size_t strlen, 
00124     utf32_char& ch, bool* isValid = 0, bool returnNonChar = false)
00125   {
00126     if (str == 0)
00127     {
00128       FAIL(0);
00129     }
00130     int chUsed = 0;
00131     
00132     utf8_char curCh;
00133     GET_NEXT(curCh);
00134     if ((curCh & 0x80) == 0)
00135     {
00136       // easy case
00137       ch = curCh;
00138       SUCCEED;
00139     }
00140     else
00141     {
00142       // Count with how many bytes this char is encoded.
00143       int n = 0;
00144       while ((n < 7) && ((curCh & (1 << (7 - n))) != 0)) { n++; }
00145 
00146       if ((n < 2) || (n > 6))
00147       {
00148         // Invalid code: first char of a "sequence" must have
00149         // at least two and at most six MSBs set
00150         FAIL(1);
00151       }
00152 
00153       ch = (curCh & ((1 << (8 - n)) - 1));
00154       
00155       for (int i = 1; i < n; i++)
00156       {
00157         GET_NEXT(curCh);
00158         if ((curCh & 0xc0) != 0x80)
00159         {
00160           FAIL(chUsed);
00161         }
00162         else
00163         {
00164           ch <<= 6;
00165           ch |= (curCh & 0x3f);
00166         }
00167       }
00168       
00169       // Check if in Unicode range.
00170       if (ch > CS_UC_LAST_CHAR)
00171       {
00172         FAIL(chUsed);
00173       }
00174 
00175       // Check for "overlong" codes.
00176       if ((ch < 0x80) && (n > 0))
00177       {
00178         FAIL(chUsed);
00179       }
00180       else if ((ch < 0x800) && (n > 2))
00181       {
00182         FAIL(chUsed);
00183       }
00184       else if ((ch < 0x10000) && (n > 3))
00185       {
00186         FAIL(chUsed);
00187       }
00188       else if ((ch < 0x200000) && (n > 4))
00189       {
00190         FAIL(chUsed);
00191       }
00192       /* 
00193       else if ((ch < 0x4000000) && (n > 5))
00194       {
00195         FAIL(chUsed);
00196       }
00197       else if ((ch < 0x80000000) && (n > 6))
00198       {
00199         FAIL(chUsed);
00200       }
00201       */
00202       
00203       if (!returnNonChar && (CS_UC_IS_NONCHARACTER(ch) 
00204         || CS_UC_IS_SURROGATE(ch)))
00205         FAIL(chUsed);
00206       SUCCEED;
00207     }
00208   }
00209   
00214   inline static int UTF16Decode (const utf16_char* str, size_t strlen, 
00215     utf32_char& ch, bool* isValid = 0, bool returnNonChar = false)
00216   {
00217     if (str == 0)
00218     {
00219       FAIL(0);
00220     }
00221     int chUsed = 0;
00222     
00223     utf16_char curCh;
00224     GET_NEXT(curCh);
00225     // Decode surrogate
00226     if (CS_UC_IS_SURROGATE (curCh))
00227     {
00228       // Invalid code
00229       if (!CS_UC_IS_HIGH_SURROGATE (curCh))
00230       {
00231         FAIL(chUsed);
00232       }
00233       ch = 0x10000 + ((curCh & 0x03ff) << 10);
00234       GET_NEXT(curCh);
00235       // Invalid code
00236       if (!CS_UC_IS_LOW_SURROGATE (curCh))
00237       {
00238         // Fail with 1 so the char is handled upon the next Decode.
00239         FAIL(1);
00240       }
00241       ch |= (curCh & 0x3ff);
00242     }
00243     else
00244     {
00245       ch = curCh;
00246     }
00247     if (!returnNonChar && (CS_UC_IS_NONCHARACTER(ch) 
00248       || CS_UC_IS_SURROGATE(ch)))
00249       FAIL(chUsed);
00250     SUCCEED;
00251   }
00252   
00257   inline static int UTF32Decode (const utf32_char* str, size_t strlen, 
00258     utf32_char& ch, bool* isValid = 0, bool returnNonChar = false)
00259   {
00260     if (str == 0)
00261     {
00262       FAIL(0);
00263     }
00264     int chUsed = 0;
00265     
00266     GET_NEXT(ch);
00267     if ((!returnNonChar && (CS_UC_IS_NONCHARACTER(ch) 
00268       || CS_UC_IS_SURROGATE(ch))) || (ch > CS_UC_LAST_CHAR))
00269       FAIL(chUsed);
00270     SUCCEED;
00271   }
00272 
00277   inline static int Decode (const utf8_char* str, size_t strlen, 
00278     utf32_char& ch, bool* isValid = 0, bool returnNonChar = false)
00279   {
00280     return UTF8Decode (str, strlen, ch, isValid, returnNonChar);
00281   }
00286   inline static int Decode (const utf16_char* str, size_t strlen, 
00287     utf32_char& ch, bool* isValid = 0, bool returnNonChar = false)
00288   {
00289     return UTF16Decode (str, strlen, ch, isValid, returnNonChar);
00290   }
00295   inline static int Decode (const utf32_char* str, size_t strlen, 
00296     utf32_char& ch, bool* isValid = 0, bool returnNonChar = false)
00297   {
00298     return UTF32Decode (str, strlen, ch, isValid, returnNonChar);
00299   }
00300 
00302 #undef FAIL
00303 #undef SUCCEED
00304 #undef GET_NEXT
00305 
00308 #define _OUTPUT_CHAR(buf, chr)                          \
00309   if (bufRemaining > 0)                                 \
00310   {                                                     \
00311     if(buf) *buf++ = chr;                               \
00312     bufRemaining--;                                     \
00313   }                                                     \
00314   encodedLen++;
00315 
00316 #define OUTPUT_CHAR(chr) _OUTPUT_CHAR(buf, chr)
00317   
00331   inline static int EncodeUTF8 (const utf32_char ch, utf8_char* buf, 
00332     size_t bufsize, bool allowNonchars = false)
00333   {
00334     if ((!allowNonchars && ((CS_UC_IS_NONCHARACTER(ch)) 
00335       || (CS_UC_IS_SURROGATE(ch)))) || (ch > CS_UC_LAST_CHAR))
00336       return 0;
00337     size_t bufRemaining = bufsize;
00338     int encodedLen = 0;
00339     
00340     if (ch < 0x80)
00341     {
00342       OUTPUT_CHAR ((utf8_char)ch);
00343     }
00344     else if (ch < 0x800)
00345     {
00346       OUTPUT_CHAR ((utf8_char)(0xc0 | (ch >> 6)));
00347       OUTPUT_CHAR ((utf8_char)(0x80 | (ch & 0x3f)));
00348     }
00349     else if (ch < 0x10000)
00350     {
00351       OUTPUT_CHAR ((utf8_char)(0xe0 | (ch >> 12)));
00352       OUTPUT_CHAR ((utf8_char)(0x80 | ((ch >> 6) & 0x3f)));
00353       OUTPUT_CHAR ((utf8_char)(0x80 | (ch & 0x3f)));
00354     }
00355     else if (ch < 0x200000)
00356     {
00357       OUTPUT_CHAR ((utf8_char)(0xf0 | (ch >> 18)));
00358       OUTPUT_CHAR ((utf8_char)(0x80 | ((ch >> 12) & 0x3f)));
00359       OUTPUT_CHAR ((utf8_char)(0x80 | ((ch >> 6) & 0x3f)));
00360       OUTPUT_CHAR ((utf8_char)(0x80 | (ch & 0x3f)));
00361     }
00362     /*
00363     else if (ch < 0x4000000)
00364     {
00365       OUTPUT_CHAR ((utf8_char)(0xf8 | (ch >> 24)));
00366       OUTPUT_CHAR ((utf8_char)(0x80 | ((ch >> 18) & 0x3f)));
00367       OUTPUT_CHAR ((utf8_char)(0x80 | ((ch >> 12) & 0x3f)));
00368       OUTPUT_CHAR ((utf8_char)(0x80 | ((ch >> 6) & 0x3f)));
00369       OUTPUT_CHAR ((utf8_char)(0x80 | (ch & 0x3f)));
00370     }
00371     else if (ch < 0x80000000)
00372     {
00373       OUTPUT_CHAR ((utf8_char)(0xfc | (ch >> 30)));
00374       OUTPUT_CHAR ((utf8_char)(0x80 | ((ch >> 24) & 0x3f)));
00375       OUTPUT_CHAR ((utf8_char)(0x80 | ((ch >> 18) & 0x3f)));
00376       OUTPUT_CHAR ((utf8_char)(0x80 | ((ch >> 12) & 0x3f)));
00377       OUTPUT_CHAR ((utf8_char)(0x80 | ((ch >> 6) & 0x3f)));
00378       OUTPUT_CHAR ((utf8_char)(0x80 | (ch & 0x3f)));
00379     }
00380     */
00381     return encodedLen;
00382   }
00383     
00388   inline static int EncodeUTF16 (const utf32_char ch, utf16_char* buf, 
00389     size_t bufsize, bool allowNonchars = false)
00390   {
00391     if ((!allowNonchars && ((CS_UC_IS_NONCHARACTER(ch)) 
00392       || (CS_UC_IS_SURROGATE(ch)))) || (ch > CS_UC_LAST_CHAR))
00393       return 0;
00394     size_t bufRemaining = bufsize;
00395     int encodedLen = 0;
00396     
00397     if (ch < 0x10000)
00398     {
00399       OUTPUT_CHAR((utf16_char)ch);
00400     }
00401     else if (ch < 0x100000)
00402     {
00403       utf32_char ch_shifted = ch - 0x10000;
00404       OUTPUT_CHAR((utf16_char)((ch_shifted >> 10) 
00405         | CS_UC_CHAR_HIGH_SURROGATE_FIRST));
00406       OUTPUT_CHAR((utf16_char)((ch_shifted & 0x3ff) 
00407         | CS_UC_CHAR_LOW_SURROGATE_FIRST));
00408     }
00409     else
00410       return 0;
00411     
00412     return encodedLen;
00413   }
00414 
00419   inline static int EncodeUTF32 (const utf32_char ch, utf32_char* buf, 
00420     size_t bufsize, bool allowNonchars = false)
00421   {
00422     if ((!allowNonchars && ((CS_UC_IS_NONCHARACTER(ch)) 
00423       || (CS_UC_IS_SURROGATE(ch)))) || (ch > CS_UC_LAST_CHAR))
00424       return 0;
00425     size_t bufRemaining = bufsize;
00426     int encodedLen = 0;
00427     
00428     OUTPUT_CHAR(ch);
00429     
00430     return encodedLen;
00431   }
00432 
00437   inline static int Encode (const utf32_char ch, utf8_char* buf, 
00438     size_t bufsize, bool allowNonchars = false)
00439   {
00440     return EncodeUTF8 (ch, buf, bufsize, allowNonchars);
00441   }
00446   inline static int Encode (const utf32_char ch, utf16_char* buf, 
00447     size_t bufsize, bool allowNonchars = false)
00448   {
00449     return EncodeUTF16 (ch, buf, bufsize, allowNonchars);
00450   }
00455   inline static int Encode (const utf32_char ch, utf32_char* buf, 
00456     size_t bufsize, bool allowNonchars = false)
00457   {
00458     return EncodeUTF32 (ch, buf, bufsize, allowNonchars);
00459   }
00461 #undef OUTPUT_CHAR
00462   
00465 #define OUTPUT_CHAR(chr) _OUTPUT_CHAR(dest, chr)
00466   
00467 #define UCTF_CONVERTER(funcName, fromType, decoder, toType, encoder)    \
00468   inline static size_t funcName (toType* dest, size_t destSize,         \
00469     const fromType* source, size_t srcSize = (size_t)-1)                \
00470   {                                                                     \
00471     if ((srcSize == 0) || (source == 0))                                \
00472       return 0;                                                         \
00473                                                                         \
00474     size_t bufRemaining = (destSize > 0) ? destSize - 1 : 0;            \
00475     size_t encodedLen = 0;                                              \
00476                                                                         \
00477     size_t srcChars = srcSize;                                          \
00478                                                                         \
00479     if (srcSize == (size_t)-1)                                          \
00480     {                                                                   \
00481       srcChars = 0;                                                     \
00482       const fromType* sptr = source;                                    \
00483       while (*sptr++ != 0) srcChars++;                                  \
00484     }                                                                   \
00485                                                                         \
00486     while (srcChars > 0)                                                \
00487     {                                                                   \
00488       utf32_char ch;                                                    \
00489       int scnt = decoder (source, srcChars, ch, 0);                     \
00490       if (scnt == 0) break;                                             \
00491       int dcnt = encoder (ch, dest, bufRemaining);                      \
00492       if (dcnt == 0)                                                    \
00493       {                                                                 \
00494         dcnt = encoder (CS_UC_CHAR_REPLACER, dest, bufRemaining);       \
00495       }                                                                 \
00496                                                                         \
00497       if ((size_t)dcnt >= bufRemaining)                                 \
00498       {                                                                 \
00499         if (dest && (destSize > 0)) dest += bufRemaining;               \
00500         bufRemaining = 0;                                               \
00501       }                                                                 \
00502       else                                                              \
00503       {                                                                 \
00504         bufRemaining -= dcnt;                                           \
00505         if (dest && (destSize > 0)) dest += dcnt;                       \
00506       }                                                                 \
00507       encodedLen += dcnt;                                               \
00508       if ((size_t)scnt >= srcChars) break;                              \
00509       srcChars -= scnt;                                                 \
00510       source += scnt;                                                   \
00511     }                                                                   \
00512                                                                         \
00513     if (dest) *dest = 0;                                                \
00514                                                                         \
00515     return encodedLen + 1;                                              \
00516   }
00517 
00533   UCTF_CONVERTER (UTF8to16, utf8_char, UTF8Decode, utf16_char, EncodeUTF16);
00538   UCTF_CONVERTER (UTF8to32, utf8_char, UTF8Decode, utf32_char, EncodeUTF32);
00539 
00544   UCTF_CONVERTER (UTF16to8, utf16_char, UTF16Decode, utf8_char, EncodeUTF8);
00549   UCTF_CONVERTER (UTF16to32, utf16_char, UTF16Decode, utf32_char, EncodeUTF32);
00550   
00555   UCTF_CONVERTER (UTF32to8, utf32_char, UTF32Decode, utf8_char, EncodeUTF8);
00560   UCTF_CONVERTER (UTF32to16, utf32_char, UTF32Decode, utf16_char, EncodeUTF16);
00563 #undef UCTF_CONVERTER
00564 #undef OUTPUT_CHAR
00565 #undef _OUTPUT_CHAR
00566 
00567 #if (CS_WCHAR_T_SIZE == 1)
00568   inline static size_t UTF8toWC (wchar_t* dest, size_t destSize, 
00569     const utf8_char* source, size_t srcSize)
00570   {
00571     size_t srcChars = srcSize;                                          
00572     if (srcSize == (size_t)-1)                                          
00573     {                                                                   
00574       srcChars = 0;                                                     
00575       const utf8_char* sptr = source;                                   
00576       while (*sptr++ != 0) srcChars++;                                  
00577     }                           
00578     if ((dest != 0) && (destSize != 0))
00579     {
00580       size_t len = MIN (destSize - 1, srcChars);
00581       memcpy (dest, source, size * sizeof (wchar_t));
00582       *(dest + len) = 0;
00583     }
00584     return srcChars + 1;
00585   };
00586 
00587   inline static size_t UTF16toWC (wchar_t* dest, size_t destSize, 
00588     const utf16_char* source, size_t srcSize)
00589   {
00590     return UTF16to8 ((utf8_char*)dest, destSize, source, srcSize);
00591   };
00592 
00593   inline static size_t UTF32toWC (wchar_t* dest, size_t destSize, 
00594     const utf32_char* source, size_t srcSize)
00595   {
00596     return UTF32to8 ((utf8_char*)dest, destSize, source, srcSize);
00597   };
00598   
00599   inline static size_t WCtoUTF8 (utf8_char* dest, size_t destSize, 
00600     const wchar_t* source, size_t srcSize)
00601   {
00602     size_t srcChars = srcSize;                                          
00603     if (srcSize == (size_t)-1)                                          
00604     {                                                                   
00605       srcChars = 0;                                                     
00606       const wchar_t* sptr = source;                                     
00607       while (*sptr++ != 0) srcChars++;                                  
00608     }                           
00609     if ((dest != 0) && (destSize != 0))
00610     {
00611       size_t len = MIN (destSize - 1, srcChars);
00612       memcpy (dest, source, len * sizeof (wchar_t));
00613       *(dest + len) = 0;
00614     }
00615     return srcChars + 1;
00616   };
00617 
00618   inline static size_t WCtoUTF16 (utf16_char* dest, size_t destSize, 
00619     const wchar_t* source, size_t srcSize)
00620   {
00621     return UTF8to16 (dest, destSize, source, srcSize);
00622   };
00623 
00624   inline static size_t WCtoUTF32 (utf32_char* dest, size_t destSize, 
00625     const wchar_t* source, size_t srcSize)
00626   {
00627     return UTF8to32 (dest, destSize, source, srcSize);
00628   };
00629 
00630   inline static int Decode (const wchar_t* str, size_t strlen, 
00631     utf32_char& ch, bool* isValid = 0, bool returnNonChar = false)
00632   {
00633     return UTF8Decode ((utf8_char*)str, strlen, ch, isValid, returnNonChar);
00634   }
00635   inline static int Encode (const utf32_char ch, wchar_t* buf, 
00636     size_t bufsize, bool allowNonchars = false)
00637   {
00638     return EncodeUTF8 (ch, (utf8_char*)buf, bufsize, allowNonchars);
00639   }
00640 #elif (CS_WCHAR_T_SIZE == 2)
00641   // Methods below for doxygen documentation are here as the size '2' is 
00642   // default.
00643   
00650   inline static size_t UTF8toWC (wchar_t* dest, size_t destSize, 
00651     const utf8_char* source, size_t srcSize)
00652   {
00653     return UTF8to16 ((utf16_char*)dest, destSize, source, srcSize);
00654   };
00655 
00660   inline static size_t UTF16toWC (wchar_t* dest, size_t destSize, 
00661     const utf16_char* source, size_t srcSize)
00662   {
00663     size_t srcChars = srcSize;                                          
00664     if (srcSize == (size_t)-1)                                          
00665     {                                                                   
00666       srcChars = 0;                                                     
00667       const utf16_char* sptr = source;                                  
00668       while (*sptr++ != 0) srcChars++;                                  
00669     }                           
00670     if ((dest != 0) && (destSize != 0))
00671     {
00672       size_t len = MIN (destSize - 1, srcChars);
00673       memcpy (dest, source, len * sizeof (wchar_t));
00674       *(dest + len) = 0;
00675     }
00676     return srcChars + 1;
00677   };
00678 
00683   inline static size_t UTF32toWC (wchar_t* dest, size_t destSize, 
00684     const utf32_char* source, size_t srcSize)
00685   {
00686     return UTF32to16 ((utf16_char*)dest, destSize, source, srcSize);
00687   };
00688   
00693   inline static size_t WCtoUTF8 (utf8_char* dest, size_t destSize, 
00694     const wchar_t* source, size_t srcSize)
00695   {
00696     return UTF16to8 (dest, destSize, (utf16_char*)source, srcSize);
00697   };
00698 
00703   inline static size_t WCtoUTF16 (utf16_char* dest, size_t destSize, 
00704     const wchar_t* source, size_t srcSize)
00705   {
00706     size_t srcChars = srcSize;                                          
00707     if (srcSize == (size_t)-1)                                          
00708     {                                                                   
00709       srcChars = 0;                                                     
00710       const wchar_t* sptr = source;                                     
00711       while (*sptr++ != 0) srcChars++;                                  
00712     }                           
00713     if ((dest != 0) && (destSize != 0))
00714     {
00715       size_t len = MIN (destSize - 1, srcChars);
00716       memcpy (dest, source, len * sizeof (wchar_t));
00717       *(dest + len) = 0;
00718     }
00719     return srcChars + 1;
00720   };
00721 
00726   inline static size_t WCtoUTF32 (utf32_char* dest, size_t destSize, 
00727     const wchar_t* source, size_t srcSize)
00728   {
00729     return UTF16to32 (dest, destSize, (utf16_char*)source, srcSize);
00730   };
00731 
00732   /* Decode()/Encode() overloads for wchar_t.
00733    * - On VC7+, wchar_t may be an unsigned short or the special type __wchar_t.
00734    * - On VC6 wchar_t is always an unsigned short. __wchar_t does not exist.
00735    * Now there may be conflicts with the utf16_char overloads if wchar_t is
00736    * an unsigned short. On the other hand, we would like to support VC7+'s
00737    * built-in wchar_t as well.
00738    * So: on VC7+, provide overloads for __wchar_t, on VC6, don't compile this
00739    * code at all, on other compilers, provide overloads for wchar_t instead
00740    * (by re#definining __wchar_t). 
00741    */
00742 #if !defined(CS_COMPILER_MSVC) || (_MSC_VER > 1300)
00743 #if !defined(CS_COMPILER_MSVC)
00744   #define __wchar_t wchar_t
00745 #endif  
00746 
00750   inline static int Decode (const __wchar_t* str, size_t strlen, 
00751     utf32_char& ch, bool* isValid = 0, bool returnNonChar = false)
00752   {
00753     return UTF16Decode ((utf16_char*)str, strlen, ch, isValid, returnNonChar);
00754   }
00759   inline static int Encode (const utf32_char ch, __wchar_t* buf, 
00760     size_t bufsize, bool allowNonchars = false)
00761   {
00762     return EncodeUTF16 (ch, (utf16_char*)buf, bufsize, allowNonchars);
00763   }
00764 #ifdef __wchar_t
00765   #undef __wchar_t
00766 #endif
00767 #endif
00768 
00769 #elif (CS_WCHAR_T_SIZE == 4)
00770   inline static size_t UTF8toWC (wchar_t* dest, size_t destSize, 
00771     const utf8_char* source, size_t srcSize)
00772   {
00773     return UTF8to32 ((utf32_char*)dest, destSize, source, srcSize);
00774   };
00775 
00776   inline static size_t UTF16toWC (wchar_t* dest, size_t destSize, 
00777     const utf16_char* source, size_t srcSize)
00778   {
00779     return UTF16to32 ((utf32_char*)dest, destSize, source, srcSize);
00780   };
00781 
00782   inline static size_t UTF32toWC (wchar_t* dest, size_t destSize, 
00783     const utf32_char* source,  size_t srcSize)
00784   {
00785     size_t srcChars = srcSize;                                          
00786     if (srcSize == (size_t)-1)                                          
00787     {                                                                   
00788       srcChars = 0;                                                     
00789       const utf32_char* sptr = source;                                  
00790       while (*sptr++ != 0) srcChars++;                                  
00791     }                           
00792     if ((dest != 0) && (destSize != 0))
00793     {
00794       size_t len = MIN (destSize - 1, srcChars);
00795       memcpy (dest, source, len * sizeof (wchar_t));
00796       *(dest + len) = 0;
00797     }
00798     return srcChars + 1;
00799   };
00800   
00801   inline static size_t WCtoUTF8 (utf8_char* dest, size_t destSize, 
00802     const wchar_t* source, size_t srcSize)
00803   {
00804     return UTF32to8 (dest, destSize, (utf32_char*)source, srcSize);
00805   };
00806 
00807   inline static size_t WCtoUTF16 (utf16_char* dest, size_t destSize, 
00808     const wchar_t* source, size_t srcSize)
00809   {
00810     return UTF32to16 (dest, destSize, (utf32_char*)source, srcSize);
00811   };
00812 
00813   inline static size_t WCtoUTF32 (utf32_char* dest, size_t destSize, 
00814     const wchar_t* source, size_t srcSize)
00815   {
00816     size_t srcChars = srcSize;                                          
00817     if (srcSize == (size_t)-1)                                          
00818     {                                                                   
00819       srcChars = 0;                                                     
00820       const wchar_t* sptr = source;                                     
00821       while (*sptr++ != 0) srcChars++;                                  
00822     }                           
00823     if ((dest != 0) && (destSize != 0))
00824     {
00825       size_t len = MIN (destSize - 1, srcChars);
00826       memcpy (dest, source, len * sizeof (wchar_t));
00827       *(dest + len) = 0;
00828     }
00829     return srcChars + 1;
00830   };
00831 
00832   inline static int Decode (const wchar_t* str, size_t strlen, 
00833     utf32_char& ch, bool* isValid = 0, bool returnNonChar = false)
00834   {
00835     return UTF32Decode ((utf32_char*)str, strlen, ch, isValid, returnNonChar);
00836   }
00837   inline static int Encode (const utf32_char ch, wchar_t* buf, 
00838     size_t bufsize, bool allowNonchars = false)
00839   {
00840     return EncodeUTF32 (ch, (utf32_char*)buf, bufsize, allowNonchars);
00841   }
00842 #else
00843   #error Odd-sized, unsupported wchar_t!
00844 #endif
00845 
00858   inline static int UTF8Skip (const utf8_char* str, size_t maxSkip)
00859   {
00860     if (maxSkip < 1) return 0;
00861   
00862     if ((*str & 0x80) == 0)
00863     {
00864       return 1;
00865     }
00866     else
00867     {
00868       int n = 0;
00869       while ((n < 7) && ((*str & (1 << (7 - n))) != 0)) { n++; }
00870 
00871       if ((n < 2) || (n > 6))
00872       {
00873         return 1;
00874       }
00875 
00876       int skip = 1;
00877       
00878       for (; skip < n; skip++)
00879       {
00880         if (((str[skip] & 0xc0) != 0x80) || ((size_t)skip > maxSkip))
00881         {
00882           break;
00883         }
00884       }
00885       return skip;
00886     }
00887   }
00888   
00899   inline static int UTF8Rewind (const utf8_char* str, size_t maxRew)
00900   {
00901     if (maxRew < 1) return 0;
00902     
00903     const utf8_char* pos = str - 1;
00904     
00905     if ((*pos & 0x80) == 0)
00906     {
00907       return 1;
00908     }
00909     
00910     // Skip backward to the first byte of the sequence.
00911     int skip = 1;
00912     while (((*pos & 0xc0) == 0x80) && ((size_t)skip < maxRew))
00913     {
00914       skip++;
00915       pos--;
00916     }
00917     
00918     return skip;
00919   }
00920   
00926   inline static int UTF16Skip (const utf16_char* str, size_t maxSkip)
00927   {
00928     if (CS_UC_IS_HIGH_SURROGATE (*str))
00929       return (int)(MIN(maxSkip, 2));
00930     else
00931       return (int)(MIN(maxSkip, 1));
00932   }
00933   
00939   inline static int UTF16Rewind (const utf16_char* str, size_t maxRew)
00940   {
00941     if (maxRew < 1) return 0;
00942     
00943     const utf16_char* pos = str - 1;
00944     if (!CS_UC_IS_SURROGATE(*pos)) 
00945       return 1;
00946     else
00947     {
00948       if ((maxRew > 1) && (CS_UC_IS_HIGH_SURROGATE(*(pos - 1))))
00949         return 2;
00950       else
00951         return 1;
00952     }
00953   }
00954   
00960   inline static int UTF32Skip (const utf32_char* str, size_t maxSkip)
00961   {
00962     (void)str; // silence gcc
00963     return (int)(MIN(maxSkip, 1));
00964   }
00965 
00971   inline static int UTF32Rewind (const utf32_char* str, size_t maxRew)
00972   {
00973     (void)str; // silence gcc
00974     if (maxRew < 1) return 0;
00975     return 1;
00976   }
00991   static size_t MapToUpper (const utf32_char ch, utf32_char* dest, 
00992     size_t destSize, uint flags = 0);
00997   static size_t MapToLower (const utf32_char ch, utf32_char* dest, 
00998     size_t destSize, uint flags = 0);
01004   static size_t MapToFold (const utf32_char ch, utf32_char* dest, 
01005     size_t destSize, uint flags = 0);
01007 };
01008 
01011 #endif
01012 

Generated for Crystal Space 1.0.2 by doxygen 1.4.7