sl@0: /*
sl@0: ** 2004 April 13
sl@0: **
sl@0: ** The author disclaims copyright to this source code.  In place of
sl@0: ** a legal notice, here is a blessing:
sl@0: **
sl@0: **    May you do good and not evil.
sl@0: **    May you find forgiveness for yourself and forgive others.
sl@0: **    May you share freely, never taking more than you give.
sl@0: **
sl@0: *************************************************************************
sl@0: ** This file contains routines used to translate between UTF-8, 
sl@0: ** UTF-16, UTF-16BE, and UTF-16LE.
sl@0: **
sl@0: ** $Id: utf.c,v 1.65 2008/08/12 15:04:59 danielk1977 Exp $
sl@0: **
sl@0: ** Notes on UTF-8:
sl@0: **
sl@0: **   Byte-0    Byte-1    Byte-2    Byte-3    Value
sl@0: **  0xxxxxxx                                 00000000 00000000 0xxxxxxx
sl@0: **  110yyyyy  10xxxxxx                       00000000 00000yyy yyxxxxxx
sl@0: **  1110zzzz  10yyyyyy  10xxxxxx             00000000 zzzzyyyy yyxxxxxx
sl@0: **  11110uuu  10uuzzzz  10yyyyyy  10xxxxxx   000uuuuu zzzzyyyy yyxxxxxx
sl@0: **
sl@0: **
sl@0: ** Notes on UTF-16:  (with wwww+1==uuuuu)
sl@0: **
sl@0: **      Word-0               Word-1          Value
sl@0: **  110110ww wwzzzzyy   110111yy yyxxxxxx    000uuuuu zzzzyyyy yyxxxxxx
sl@0: **  zzzzyyyy yyxxxxxx                        00000000 zzzzyyyy yyxxxxxx
sl@0: **
sl@0: **
sl@0: ** BOM or Byte Order Mark:
sl@0: **     0xff 0xfe   little-endian utf-16 follows
sl@0: **     0xfe 0xff   big-endian utf-16 follows
sl@0: **
sl@0: */
sl@0: #include "sqliteInt.h"
sl@0: #include <assert.h>
sl@0: #include "vdbeInt.h"
sl@0: 
sl@0: /*
sl@0: ** The following constant value is used by the SQLITE_BIGENDIAN and
sl@0: ** SQLITE_LITTLEENDIAN macros.
sl@0: */
sl@0: const int sqlite3one = 1;
sl@0: 
sl@0: /*
sl@0: ** This lookup table is used to help decode the first byte of
sl@0: ** a multi-byte UTF8 character.
sl@0: */
sl@0: static const unsigned char sqlite3UtfTrans1[] = {
sl@0:   0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
sl@0:   0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
sl@0:   0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
sl@0:   0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
sl@0:   0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
sl@0:   0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
sl@0:   0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
sl@0:   0x00, 0x01, 0x02, 0x03, 0x00, 0x01, 0x00, 0x00,
sl@0: };
sl@0: 
sl@0: 
sl@0: #define WRITE_UTF8(zOut, c) {                          \
sl@0:   if( c<0x00080 ){                                     \
sl@0:     *zOut++ = (c&0xFF);                                \
sl@0:   }                                                    \
sl@0:   else if( c<0x00800 ){                                \
sl@0:     *zOut++ = 0xC0 + ((c>>6)&0x1F);                    \
sl@0:     *zOut++ = 0x80 + (c & 0x3F);                       \
sl@0:   }                                                    \
sl@0:   else if( c<0x10000 ){                                \
sl@0:     *zOut++ = 0xE0 + ((c>>12)&0x0F);                   \
sl@0:     *zOut++ = 0x80 + ((c>>6) & 0x3F);                  \
sl@0:     *zOut++ = 0x80 + (c & 0x3F);                       \
sl@0:   }else{                                               \
sl@0:     *zOut++ = 0xF0 + ((c>>18) & 0x07);                 \
sl@0:     *zOut++ = 0x80 + ((c>>12) & 0x3F);                 \
sl@0:     *zOut++ = 0x80 + ((c>>6) & 0x3F);                  \
sl@0:     *zOut++ = 0x80 + (c & 0x3F);                       \
sl@0:   }                                                    \
sl@0: }
sl@0: 
sl@0: #define WRITE_UTF16LE(zOut, c) {                                \
sl@0:   if( c<=0xFFFF ){                                              \
sl@0:     *zOut++ = (c&0x00FF);                                       \
sl@0:     *zOut++ = ((c>>8)&0x00FF);                                  \
sl@0:   }else{                                                        \
sl@0:     *zOut++ = (((c>>10)&0x003F) + (((c-0x10000)>>10)&0x00C0));  \
sl@0:     *zOut++ = (0x00D8 + (((c-0x10000)>>18)&0x03));              \
sl@0:     *zOut++ = (c&0x00FF);                                       \
sl@0:     *zOut++ = (0x00DC + ((c>>8)&0x03));                         \
sl@0:   }                                                             \
sl@0: }
sl@0: 
sl@0: #define WRITE_UTF16BE(zOut, c) {                                \
sl@0:   if( c<=0xFFFF ){                                              \
sl@0:     *zOut++ = ((c>>8)&0x00FF);                                  \
sl@0:     *zOut++ = (c&0x00FF);                                       \
sl@0:   }else{                                                        \
sl@0:     *zOut++ = (0x00D8 + (((c-0x10000)>>18)&0x03));              \
sl@0:     *zOut++ = (((c>>10)&0x003F) + (((c-0x10000)>>10)&0x00C0));  \
sl@0:     *zOut++ = (0x00DC + ((c>>8)&0x03));                         \
sl@0:     *zOut++ = (c&0x00FF);                                       \
sl@0:   }                                                             \
sl@0: }
sl@0: 
sl@0: #define READ_UTF16LE(zIn, c){                                         \
sl@0:   c = (*zIn++);                                                       \
sl@0:   c += ((*zIn++)<<8);                                                 \
sl@0:   if( c>=0xD800 && c<0xE000 ){                                       \
sl@0:     int c2 = (*zIn++);                                                \
sl@0:     c2 += ((*zIn++)<<8);                                              \
sl@0:     c = (c2&0x03FF) + ((c&0x003F)<<10) + (((c&0x03C0)+0x0040)<<10);   \
sl@0:     if( (c & 0xFFFF0000)==0 ) c = 0xFFFD;                             \
sl@0:   }                                                                   \
sl@0: }
sl@0: 
sl@0: #define READ_UTF16BE(zIn, c){                                         \
sl@0:   c = ((*zIn++)<<8);                                                  \
sl@0:   c += (*zIn++);                                                      \
sl@0:   if( c>=0xD800 && c<0xE000 ){                                       \
sl@0:     int c2 = ((*zIn++)<<8);                                           \
sl@0:     c2 += (*zIn++);                                                   \
sl@0:     c = (c2&0x03FF) + ((c&0x003F)<<10) + (((c&0x03C0)+0x0040)<<10);   \
sl@0:     if( (c & 0xFFFF0000)==0 ) c = 0xFFFD;                             \
sl@0:   }                                                                   \
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Translate a single UTF-8 character.  Return the unicode value.
sl@0: **
sl@0: ** During translation, assume that the byte that zTerm points
sl@0: ** is a 0x00.
sl@0: **
sl@0: ** Write a pointer to the next unread byte back into *pzNext.
sl@0: **
sl@0: ** Notes On Invalid UTF-8:
sl@0: **
sl@0: **  *  This routine never allows a 7-bit character (0x00 through 0x7f) to
sl@0: **     be encoded as a multi-byte character.  Any multi-byte character that
sl@0: **     attempts to encode a value between 0x00 and 0x7f is rendered as 0xfffd.
sl@0: **
sl@0: **  *  This routine never allows a UTF16 surrogate value to be encoded.
sl@0: **     If a multi-byte character attempts to encode a value between
sl@0: **     0xd800 and 0xe000 then it is rendered as 0xfffd.
sl@0: **
sl@0: **  *  Bytes in the range of 0x80 through 0xbf which occur as the first
sl@0: **     byte of a character are interpreted as single-byte characters
sl@0: **     and rendered as themselves even though they are technically
sl@0: **     invalid characters.
sl@0: **
sl@0: **  *  This routine accepts an infinite number of different UTF8 encodings
sl@0: **     for unicode values 0x80 and greater.  It do not change over-length
sl@0: **     encodings to 0xfffd as some systems recommend.
sl@0: */
sl@0: #define READ_UTF8(zIn, zTerm, c)                           \
sl@0:   c = *(zIn++);                                            \
sl@0:   if( c>=0xc0 ){                                           \
sl@0:     c = sqlite3UtfTrans1[c-0xc0];                          \
sl@0:     while( zIn!=zTerm && (*zIn & 0xc0)==0x80 ){            \
sl@0:       c = (c<<6) + (0x3f & *(zIn++));                      \
sl@0:     }                                                      \
sl@0:     if( c<0x80                                             \
sl@0:         || (c&0xFFFFF800)==0xD800                          \
sl@0:         || (c&0xFFFFFFFE)==0xFFFE ){  c = 0xFFFD; }        \
sl@0:   }
sl@0: int sqlite3Utf8Read(
sl@0:   const unsigned char *z,         /* First byte of UTF-8 character */
sl@0:   const unsigned char *zTerm,     /* Pretend this byte is 0x00 */
sl@0:   const unsigned char **pzNext    /* Write first byte past UTF-8 char here */
sl@0: ){
sl@0:   int c;
sl@0:   READ_UTF8(z, zTerm, c);
sl@0:   *pzNext = z;
sl@0:   return c;
sl@0: }
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: /*
sl@0: ** If the TRANSLATE_TRACE macro is defined, the value of each Mem is
sl@0: ** printed on stderr on the way into and out of sqlite3VdbeMemTranslate().
sl@0: */ 
sl@0: /* #define TRANSLATE_TRACE 1 */
sl@0: 
sl@0: #ifndef SQLITE_OMIT_UTF16
sl@0: /*
sl@0: ** This routine transforms the internal text encoding used by pMem to
sl@0: ** desiredEnc. It is an error if the string is already of the desired
sl@0: ** encoding, or if *pMem does not contain a string value.
sl@0: */
sl@0: int sqlite3VdbeMemTranslate(Mem *pMem, u8 desiredEnc){
sl@0:   int len;                    /* Maximum length of output string in bytes */
sl@0:   unsigned char *zOut;                  /* Output buffer */
sl@0:   unsigned char *zIn;                   /* Input iterator */
sl@0:   unsigned char *zTerm;                 /* End of input */
sl@0:   unsigned char *z;                     /* Output iterator */
sl@0:   unsigned int c;
sl@0: 
sl@0:   assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
sl@0:   assert( pMem->flags&MEM_Str );
sl@0:   assert( pMem->enc!=desiredEnc );
sl@0:   assert( pMem->enc!=0 );
sl@0:   assert( pMem->n>=0 );
sl@0: 
sl@0: #if defined(TRANSLATE_TRACE) && defined(SQLITE_DEBUG)
sl@0:   {
sl@0:     char zBuf[100];
sl@0:     sqlite3VdbeMemPrettyPrint(pMem, zBuf);
sl@0:     fprintf(stderr, "INPUT:  %s\n", zBuf);
sl@0:   }
sl@0: #endif
sl@0: 
sl@0:   /* If the translation is between UTF-16 little and big endian, then 
sl@0:   ** all that is required is to swap the byte order. This case is handled
sl@0:   ** differently from the others.
sl@0:   */
sl@0:   if( pMem->enc!=SQLITE_UTF8 && desiredEnc!=SQLITE_UTF8 ){
sl@0:     u8 temp;
sl@0:     int rc;
sl@0:     rc = sqlite3VdbeMemMakeWriteable(pMem);
sl@0:     if( rc!=SQLITE_OK ){
sl@0:       assert( rc==SQLITE_NOMEM );
sl@0:       return SQLITE_NOMEM;
sl@0:     }
sl@0:     zIn = (u8*)pMem->z;
sl@0:     zTerm = &zIn[pMem->n];
sl@0:     while( zIn<zTerm ){
sl@0:       temp = *zIn;
sl@0:       *zIn = *(zIn+1);
sl@0:       zIn++;
sl@0:       *zIn++ = temp;
sl@0:     }
sl@0:     pMem->enc = desiredEnc;
sl@0:     goto translate_out;
sl@0:   }
sl@0: 
sl@0:   /* Set len to the maximum number of bytes required in the output buffer. */
sl@0:   if( desiredEnc==SQLITE_UTF8 ){
sl@0:     /* When converting from UTF-16, the maximum growth results from
sl@0:     ** translating a 2-byte character to a 4-byte UTF-8 character.
sl@0:     ** A single byte is required for the output string
sl@0:     ** nul-terminator.
sl@0:     */
sl@0:     len = pMem->n * 2 + 1;
sl@0:   }else{
sl@0:     /* When converting from UTF-8 to UTF-16 the maximum growth is caused
sl@0:     ** when a 1-byte UTF-8 character is translated into a 2-byte UTF-16
sl@0:     ** character. Two bytes are required in the output buffer for the
sl@0:     ** nul-terminator.
sl@0:     */
sl@0:     len = pMem->n * 2 + 2;
sl@0:   }
sl@0: 
sl@0:   /* Set zIn to point at the start of the input buffer and zTerm to point 1
sl@0:   ** byte past the end.
sl@0:   **
sl@0:   ** Variable zOut is set to point at the output buffer, space obtained
sl@0:   ** from sqlite3_malloc().
sl@0:   */
sl@0:   zIn = (u8*)pMem->z;
sl@0:   zTerm = &zIn[pMem->n];
sl@0:   zOut = sqlite3DbMallocRaw(pMem->db, len);
sl@0:   if( !zOut ){
sl@0:     return SQLITE_NOMEM;
sl@0:   }
sl@0:   z = zOut;
sl@0: 
sl@0:   if( pMem->enc==SQLITE_UTF8 ){
sl@0:     if( desiredEnc==SQLITE_UTF16LE ){
sl@0:       /* UTF-8 -> UTF-16 Little-endian */
sl@0:       while( zIn<zTerm ){
sl@0:         /* c = sqlite3Utf8Read(zIn, zTerm, (const u8**)&zIn); */
sl@0:         READ_UTF8(zIn, zTerm, c);
sl@0:         WRITE_UTF16LE(z, c);
sl@0:       }
sl@0:     }else{
sl@0:       assert( desiredEnc==SQLITE_UTF16BE );
sl@0:       /* UTF-8 -> UTF-16 Big-endian */
sl@0:       while( zIn<zTerm ){
sl@0:         /* c = sqlite3Utf8Read(zIn, zTerm, (const u8**)&zIn); */
sl@0:         READ_UTF8(zIn, zTerm, c);
sl@0:         WRITE_UTF16BE(z, c);
sl@0:       }
sl@0:     }
sl@0:     pMem->n = z - zOut;
sl@0:     *z++ = 0;
sl@0:   }else{
sl@0:     assert( desiredEnc==SQLITE_UTF8 );
sl@0:     if( pMem->enc==SQLITE_UTF16LE ){
sl@0:       /* UTF-16 Little-endian -> UTF-8 */
sl@0:       while( zIn<zTerm ){
sl@0:         READ_UTF16LE(zIn, c); 
sl@0:         WRITE_UTF8(z, c);
sl@0:       }
sl@0:     }else{
sl@0:       /* UTF-16 Big-endian -> UTF-8 */
sl@0:       while( zIn<zTerm ){
sl@0:         READ_UTF16BE(zIn, c); 
sl@0:         WRITE_UTF8(z, c);
sl@0:       }
sl@0:     }
sl@0:     pMem->n = z - zOut;
sl@0:   }
sl@0:   *z = 0;
sl@0:   assert( (pMem->n+(desiredEnc==SQLITE_UTF8?1:2))<=len );
sl@0: 
sl@0:   sqlite3VdbeMemRelease(pMem);
sl@0:   pMem->flags &= ~(MEM_Static|MEM_Dyn|MEM_Ephem);
sl@0:   pMem->enc = desiredEnc;
sl@0:   pMem->flags |= (MEM_Term|MEM_Dyn);
sl@0:   pMem->z = (char*)zOut;
sl@0:   pMem->zMalloc = pMem->z;
sl@0: 
sl@0: translate_out:
sl@0: #if defined(TRANSLATE_TRACE) && defined(SQLITE_DEBUG)
sl@0:   {
sl@0:     char zBuf[100];
sl@0:     sqlite3VdbeMemPrettyPrint(pMem, zBuf);
sl@0:     fprintf(stderr, "OUTPUT: %s\n", zBuf);
sl@0:   }
sl@0: #endif
sl@0:   return SQLITE_OK;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** This routine checks for a byte-order mark at the beginning of the 
sl@0: ** UTF-16 string stored in *pMem. If one is present, it is removed and
sl@0: ** the encoding of the Mem adjusted. This routine does not do any
sl@0: ** byte-swapping, it just sets Mem.enc appropriately.
sl@0: **
sl@0: ** The allocation (static, dynamic etc.) and encoding of the Mem may be
sl@0: ** changed by this function.
sl@0: */
sl@0: int sqlite3VdbeMemHandleBom(Mem *pMem){
sl@0:   int rc = SQLITE_OK;
sl@0:   u8 bom = 0;
sl@0: 
sl@0:   if( pMem->n<0 || pMem->n>1 ){
sl@0:     u8 b1 = *(u8 *)pMem->z;
sl@0:     u8 b2 = *(((u8 *)pMem->z) + 1);
sl@0:     if( b1==0xFE && b2==0xFF ){
sl@0:       bom = SQLITE_UTF16BE;
sl@0:     }
sl@0:     if( b1==0xFF && b2==0xFE ){
sl@0:       bom = SQLITE_UTF16LE;
sl@0:     }
sl@0:   }
sl@0:   
sl@0:   if( bom ){
sl@0:     rc = sqlite3VdbeMemMakeWriteable(pMem);
sl@0:     if( rc==SQLITE_OK ){
sl@0:       pMem->n -= 2;
sl@0:       memmove(pMem->z, &pMem->z[2], pMem->n);
sl@0:       pMem->z[pMem->n] = '\0';
sl@0:       pMem->z[pMem->n+1] = '\0';
sl@0:       pMem->flags |= MEM_Term;
sl@0:       pMem->enc = bom;
sl@0:     }
sl@0:   }
sl@0:   return rc;
sl@0: }
sl@0: #endif /* SQLITE_OMIT_UTF16 */
sl@0: 
sl@0: /*
sl@0: ** pZ is a UTF-8 encoded unicode string. If nByte is less than zero,
sl@0: ** return the number of unicode characters in pZ up to (but not including)
sl@0: ** the first 0x00 byte. If nByte is not less than zero, return the
sl@0: ** number of unicode characters in the first nByte of pZ (or up to 
sl@0: ** the first 0x00, whichever comes first).
sl@0: */
sl@0: int sqlite3Utf8CharLen(const char *zIn, int nByte){
sl@0:   int r = 0;
sl@0:   const u8 *z = (const u8*)zIn;
sl@0:   const u8 *zTerm;
sl@0:   if( nByte>=0 ){
sl@0:     zTerm = &z[nByte];
sl@0:   }else{
sl@0:     zTerm = (const u8*)(-1);
sl@0:   }
sl@0:   assert( z<=zTerm );
sl@0:   while( *z!=0 && z<zTerm ){
sl@0:     SQLITE_SKIP_UTF8(z);
sl@0:     r++;
sl@0:   }
sl@0:   return r;
sl@0: }
sl@0: 
sl@0: /* This test function is not currently used by the automated test-suite. 
sl@0: ** Hence it is only available in debug builds.
sl@0: */
sl@0: #if defined(SQLITE_TEST) && defined(SQLITE_DEBUG)
sl@0: /*
sl@0: ** Translate UTF-8 to UTF-8.
sl@0: **
sl@0: ** This has the effect of making sure that the string is well-formed
sl@0: ** UTF-8.  Miscoded characters are removed.
sl@0: **
sl@0: ** The translation is done in-place (since it is impossible for the
sl@0: ** correct UTF-8 encoding to be longer than a malformed encoding).
sl@0: */
sl@0: int sqlite3Utf8To8(unsigned char *zIn){
sl@0:   unsigned char *zOut = zIn;
sl@0:   unsigned char *zStart = zIn;
sl@0:   unsigned char *zTerm = &zIn[strlen((char *)zIn)];
sl@0:   u32 c;
sl@0: 
sl@0:   while( zIn[0] ){
sl@0:     c = sqlite3Utf8Read(zIn, zTerm, (const u8**)&zIn);
sl@0:     if( c!=0xfffd ){
sl@0:       WRITE_UTF8(zOut, c);
sl@0:     }
sl@0:   }
sl@0:   *zOut = 0;
sl@0:   return zOut - zStart;
sl@0: }
sl@0: #endif
sl@0: 
sl@0: #ifndef SQLITE_OMIT_UTF16
sl@0: /*
sl@0: ** Convert a UTF-16 string in the native encoding into a UTF-8 string.
sl@0: ** Memory to hold the UTF-8 string is obtained from sqlite3_malloc and must
sl@0: ** be freed by the calling function.
sl@0: **
sl@0: ** NULL is returned if there is an allocation error.
sl@0: */
sl@0: char *sqlite3Utf16to8(sqlite3 *db, const void *z, int nByte){
sl@0:   Mem m;
sl@0:   memset(&m, 0, sizeof(m));
sl@0:   m.db = db;
sl@0:   sqlite3VdbeMemSetStr(&m, z, nByte, SQLITE_UTF16NATIVE, SQLITE_STATIC);
sl@0:   sqlite3VdbeChangeEncoding(&m, SQLITE_UTF8);
sl@0:   if( db->mallocFailed ){
sl@0:     sqlite3VdbeMemRelease(&m);
sl@0:     m.z = 0;
sl@0:   }
sl@0:   assert( (m.flags & MEM_Term)!=0 || db->mallocFailed );
sl@0:   assert( (m.flags & MEM_Str)!=0 || db->mallocFailed );
sl@0:   return (m.flags & MEM_Dyn)!=0 ? m.z : sqlite3DbStrDup(db, m.z);
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** pZ is a UTF-16 encoded unicode string. If nChar is less than zero,
sl@0: ** return the number of bytes up to (but not including), the first pair
sl@0: ** of consecutive 0x00 bytes in pZ. If nChar is not less than zero,
sl@0: ** then return the number of bytes in the first nChar unicode characters
sl@0: ** in pZ (or up until the first pair of 0x00 bytes, whichever comes first).
sl@0: */
sl@0: int sqlite3Utf16ByteLen(const void *zIn, int nChar){
sl@0:   unsigned int c = 1;
sl@0:   char const *z = zIn;
sl@0:   int n = 0;
sl@0:   if( SQLITE_UTF16NATIVE==SQLITE_UTF16BE ){
sl@0:     /* Using an "if (SQLITE_UTF16NATIVE==SQLITE_UTF16BE)" construct here
sl@0:     ** and in other parts of this file means that at one branch will
sl@0:     ** not be covered by coverage testing on any single host. But coverage
sl@0:     ** will be complete if the tests are run on both a little-endian and 
sl@0:     ** big-endian host. Because both the UTF16NATIVE and SQLITE_UTF16BE
sl@0:     ** macros are constant at compile time the compiler can determine
sl@0:     ** which branch will be followed. It is therefore assumed that no runtime
sl@0:     ** penalty is paid for this "if" statement.
sl@0:     */
sl@0:     while( c && ((nChar<0) || n<nChar) ){
sl@0:       READ_UTF16BE(z, c);
sl@0:       n++;
sl@0:     }
sl@0:   }else{
sl@0:     while( c && ((nChar<0) || n<nChar) ){
sl@0:       READ_UTF16LE(z, c);
sl@0:       n++;
sl@0:     }
sl@0:   }
sl@0:   return (z-(char const *)zIn)-((c==0)?2:0);
sl@0: }
sl@0: 
sl@0: #if defined(SQLITE_TEST)
sl@0: /*
sl@0: ** This routine is called from the TCL test function "translate_selftest".
sl@0: ** It checks that the primitives for serializing and deserializing
sl@0: ** characters in each encoding are inverses of each other.
sl@0: */
sl@0: void sqlite3UtfSelfTest(void){
sl@0:   unsigned int i, t;
sl@0:   unsigned char zBuf[20];
sl@0:   unsigned char *z;
sl@0:   unsigned char *zTerm;
sl@0:   int n;
sl@0:   unsigned int c;
sl@0: 
sl@0:   for(i=0; i<0x00110000; i++){
sl@0:     z = zBuf;
sl@0:     WRITE_UTF8(z, i);
sl@0:     n = z-zBuf;
sl@0:     z[0] = 0;
sl@0:     zTerm = z;
sl@0:     z = zBuf;
sl@0:     c = sqlite3Utf8Read(z, zTerm, (const u8**)&z);
sl@0:     t = i;
sl@0:     if( i>=0xD800 && i<=0xDFFF ) t = 0xFFFD;
sl@0:     if( (i&0xFFFFFFFE)==0xFFFE ) t = 0xFFFD;
sl@0:     assert( c==t );
sl@0:     assert( (z-zBuf)==n );
sl@0:   }
sl@0:   for(i=0; i<0x00110000; i++){
sl@0:     if( i>=0xD800 && i<0xE000 ) continue;
sl@0:     z = zBuf;
sl@0:     WRITE_UTF16LE(z, i);
sl@0:     n = z-zBuf;
sl@0:     z[0] = 0;
sl@0:     z = zBuf;
sl@0:     READ_UTF16LE(z, c);
sl@0:     assert( c==i );
sl@0:     assert( (z-zBuf)==n );
sl@0:   }
sl@0:   for(i=0; i<0x00110000; i++){
sl@0:     if( i>=0xD800 && i<0xE000 ) continue;
sl@0:     z = zBuf;
sl@0:     WRITE_UTF16BE(z, i);
sl@0:     n = z-zBuf;
sl@0:     z[0] = 0;
sl@0:     z = zBuf;
sl@0:     READ_UTF16BE(z, c);
sl@0:     assert( c==i );
sl@0:     assert( (z-zBuf)==n );
sl@0:   }
sl@0: }
sl@0: #endif /* SQLITE_TEST */
sl@0: #endif /* SQLITE_OMIT_UTF16 */