utf.c.svn-base
上传用户:sunhongbo
上传日期:2022-01-25
资源大小:3010k
文件大小:17k
源码类别:

数据库系统

开发平台:

C/C++

  1. /*
  2. ** 2004 April 13
  3. **
  4. ** The author disclaims copyright to this source code.  In place of
  5. ** a legal notice, here is a blessing:
  6. **
  7. **    May you do good and not evil.
  8. **    May you find forgiveness for yourself and forgive others.
  9. **    May you share freely, never taking more than you give.
  10. **
  11. *************************************************************************
  12. ** This file contains routines used to translate between UTF-8, 
  13. ** UTF-16, UTF-16BE, and UTF-16LE.
  14. **
  15. ** $Id: utf.c,v 1.61 2008/03/28 15:44:10 danielk1977 Exp $
  16. **
  17. ** Notes on UTF-8:
  18. **
  19. **   Byte-0    Byte-1    Byte-2    Byte-3    Value
  20. **  0xxxxxxx                                 00000000 00000000 0xxxxxxx
  21. **  110yyyyy  10xxxxxx                       00000000 00000yyy yyxxxxxx
  22. **  1110zzzz  10yyyyyy  10xxxxxx             00000000 zzzzyyyy yyxxxxxx
  23. **  11110uuu  10uuzzzz  10yyyyyy  10xxxxxx   000uuuuu zzzzyyyy yyxxxxxx
  24. **
  25. **
  26. ** Notes on UTF-16:  (with wwww+1==uuuuu)
  27. **
  28. **      Word-0               Word-1          Value
  29. **  110110ww wwzzzzyy   110111yy yyxxxxxx    000uuuuu zzzzyyyy yyxxxxxx
  30. **  zzzzyyyy yyxxxxxx                        00000000 zzzzyyyy yyxxxxxx
  31. **
  32. **
  33. ** BOM or Byte Order Mark:
  34. **     0xff 0xfe   little-endian utf-16 follows
  35. **     0xfe 0xff   big-endian utf-16 follows
  36. **
  37. */
  38. #include "sqliteInt.h"
  39. #include <assert.h>
  40. #include "vdbeInt.h"
  41. /*
  42. ** The following constant value is used by the SQLITE_BIGENDIAN and
  43. ** SQLITE_LITTLEENDIAN macros.
  44. */
  45. const int sqlite3one = 1;
  46. /*
  47. ** This lookup table is used to help decode the first byte of
  48. ** a multi-byte UTF8 character.
  49. */
  50. static const unsigned char sqlite3UtfTrans1[] = {
  51.   0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
  52.   0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
  53.   0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
  54.   0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
  55.   0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
  56.   0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
  57.   0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
  58.   0x00, 0x01, 0x02, 0x03, 0x00, 0x01, 0x00, 0x00,
  59. };
  60. #define WRITE_UTF8(zOut, c) {                          
  61.   if( c<0x00080 ){                                     
  62.     *zOut++ = (c&0xFF);                                
  63.   }                                                    
  64.   else if( c<0x00800 ){                                
  65.     *zOut++ = 0xC0 + ((c>>6)&0x1F);                    
  66.     *zOut++ = 0x80 + (c & 0x3F);                       
  67.   }                                                    
  68.   else if( c<0x10000 ){                                
  69.     *zOut++ = 0xE0 + ((c>>12)&0x0F);                   
  70.     *zOut++ = 0x80 + ((c>>6) & 0x3F);                  
  71.     *zOut++ = 0x80 + (c & 0x3F);                       
  72.   }else{                                               
  73.     *zOut++ = 0xF0 + ((c>>18) & 0x07);                 
  74.     *zOut++ = 0x80 + ((c>>12) & 0x3F);                 
  75.     *zOut++ = 0x80 + ((c>>6) & 0x3F);                  
  76.     *zOut++ = 0x80 + (c & 0x3F);                       
  77.   }                                                    
  78. }
  79. #define WRITE_UTF16LE(zOut, c) {                                
  80.   if( c<=0xFFFF ){                                              
  81.     *zOut++ = (c&0x00FF);                                       
  82.     *zOut++ = ((c>>8)&0x00FF);                                  
  83.   }else{                                                        
  84.     *zOut++ = (((c>>10)&0x003F) + (((c-0x10000)>>10)&0x00C0));  
  85.     *zOut++ = (0x00D8 + (((c-0x10000)>>18)&0x03));              
  86.     *zOut++ = (c&0x00FF);                                       
  87.     *zOut++ = (0x00DC + ((c>>8)&0x03));                         
  88.   }                                                             
  89. }
  90. #define WRITE_UTF16BE(zOut, c) {                                
  91.   if( c<=0xFFFF ){                                              
  92.     *zOut++ = ((c>>8)&0x00FF);                                  
  93.     *zOut++ = (c&0x00FF);                                       
  94.   }else{                                                        
  95.     *zOut++ = (0x00D8 + (((c-0x10000)>>18)&0x03));              
  96.     *zOut++ = (((c>>10)&0x003F) + (((c-0x10000)>>10)&0x00C0));  
  97.     *zOut++ = (0x00DC + ((c>>8)&0x03));                         
  98.     *zOut++ = (c&0x00FF);                                       
  99.   }                                                             
  100. }
  101. #define READ_UTF16LE(zIn, c){                                         
  102.   c = (*zIn++);                                                       
  103.   c += ((*zIn++)<<8);                                                 
  104.   if( c>=0xD800 && c<0xE000 ){                                       
  105.     int c2 = (*zIn++);                                                
  106.     c2 += ((*zIn++)<<8);                                              
  107.     c = (c2&0x03FF) + ((c&0x003F)<<10) + (((c&0x03C0)+0x0040)<<10);   
  108.     if( (c & 0xFFFF0000)==0 ) c = 0xFFFD;                             
  109.   }                                                                   
  110. }
  111. #define READ_UTF16BE(zIn, c){                                         
  112.   c = ((*zIn++)<<8);                                                  
  113.   c += (*zIn++);                                                      
  114.   if( c>=0xD800 && c<0xE000 ){                                       
  115.     int c2 = ((*zIn++)<<8);                                           
  116.     c2 += (*zIn++);                                                   
  117.     c = (c2&0x03FF) + ((c&0x003F)<<10) + (((c&0x03C0)+0x0040)<<10);   
  118.     if( (c & 0xFFFF0000)==0 ) c = 0xFFFD;                             
  119.   }                                                                   
  120. }
  121. /*
  122. ** Translate a single UTF-8 character.  Return the unicode value.
  123. **
  124. ** During translation, assume that the byte that zTerm points
  125. ** is a 0x00.
  126. **
  127. ** Write a pointer to the next unread byte back into *pzNext.
  128. **
  129. ** Notes On Invalid UTF-8:
  130. **
  131. **  *  This routine never allows a 7-bit character (0x00 through 0x7f) to
  132. **     be encoded as a multi-byte character.  Any multi-byte character that
  133. **     attempts to encode a value between 0x00 and 0x7f is rendered as 0xfffd.
  134. **
  135. **  *  This routine never allows a UTF16 surrogate value to be encoded.
  136. **     If a multi-byte character attempts to encode a value between
  137. **     0xd800 and 0xe000 then it is rendered as 0xfffd.
  138. **
  139. **  *  Bytes in the range of 0x80 through 0xbf which occur as the first
  140. **     byte of a character are interpreted as single-byte characters
  141. **     and rendered as themselves even though they are technically
  142. **     invalid characters.
  143. **
  144. **  *  This routine accepts an infinite number of different UTF8 encodings
  145. **     for unicode values 0x80 and greater.  It do not change over-length
  146. **     encodings to 0xfffd as some systems recommend.
  147. */
  148. int sqlite3Utf8Read(
  149.   const unsigned char *z,         /* First byte of UTF-8 character */
  150.   const unsigned char *zTerm,     /* Pretend this byte is 0x00 */
  151.   const unsigned char **pzNext    /* Write first byte past UTF-8 char here */
  152. ){
  153.   int c = *(z++);
  154.   if( c>=0xc0 ){
  155.     c = sqlite3UtfTrans1[c-0xc0];
  156.     while( z!=zTerm && (*z & 0xc0)==0x80 ){
  157.       c = (c<<6) + (0x3f & *(z++));
  158.     }
  159.     if( c<0x80
  160.         || (c&0xFFFFF800)==0xD800
  161.         || (c&0xFFFFFFFE)==0xFFFE ){  c = 0xFFFD; }
  162.   }
  163.   *pzNext = z;
  164.   return c;
  165. }
  166. /*
  167. ** If the TRANSLATE_TRACE macro is defined, the value of each Mem is
  168. ** printed on stderr on the way into and out of sqlite3VdbeMemTranslate().
  169. */ 
  170. /* #define TRANSLATE_TRACE 1 */
  171. #ifndef SQLITE_OMIT_UTF16
  172. /*
  173. ** This routine transforms the internal text encoding used by pMem to
  174. ** desiredEnc. It is an error if the string is already of the desired
  175. ** encoding, or if *pMem does not contain a string value.
  176. */
  177. int sqlite3VdbeMemTranslate(Mem *pMem, u8 desiredEnc){
  178.   int len;                    /* Maximum length of output string in bytes */
  179.   unsigned char *zOut;                  /* Output buffer */
  180.   unsigned char *zIn;                   /* Input iterator */
  181.   unsigned char *zTerm;                 /* End of input */
  182.   unsigned char *z;                     /* Output iterator */
  183.   unsigned int c;
  184.   assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
  185.   assert( pMem->flags&MEM_Str );
  186.   assert( pMem->enc!=desiredEnc );
  187.   assert( pMem->enc!=0 );
  188.   assert( pMem->n>=0 );
  189. #if defined(TRANSLATE_TRACE) && defined(SQLITE_DEBUG)
  190.   {
  191.     char zBuf[100];
  192.     sqlite3VdbeMemPrettyPrint(pMem, zBuf);
  193.     fprintf(stderr, "INPUT:  %sn", zBuf);
  194.   }
  195. #endif
  196.   /* If the translation is between UTF-16 little and big endian, then 
  197.   ** all that is required is to swap the byte order. This case is handled
  198.   ** differently from the others.
  199.   */
  200.   if( pMem->enc!=SQLITE_UTF8 && desiredEnc!=SQLITE_UTF8 ){
  201.     u8 temp;
  202.     int rc;
  203.     rc = sqlite3VdbeMemMakeWriteable(pMem);
  204.     if( rc!=SQLITE_OK ){
  205.       assert( rc==SQLITE_NOMEM );
  206.       return SQLITE_NOMEM;
  207.     }
  208.     zIn = (u8*)pMem->z;
  209.     zTerm = &zIn[pMem->n];
  210.     while( zIn<zTerm ){
  211.       temp = *zIn;
  212.       *zIn = *(zIn+1);
  213.       zIn++;
  214.       *zIn++ = temp;
  215.     }
  216.     pMem->enc = desiredEnc;
  217.     goto translate_out;
  218.   }
  219.   /* Set len to the maximum number of bytes required in the output buffer. */
  220.   if( desiredEnc==SQLITE_UTF8 ){
  221.     /* When converting from UTF-16, the maximum growth results from
  222.     ** translating a 2-byte character to a 4-byte UTF-8 character.
  223.     ** A single byte is required for the output string
  224.     ** nul-terminator.
  225.     */
  226.     len = pMem->n * 2 + 1;
  227.   }else{
  228.     /* When converting from UTF-8 to UTF-16 the maximum growth is caused
  229.     ** when a 1-byte UTF-8 character is translated into a 2-byte UTF-16
  230.     ** character. Two bytes are required in the output buffer for the
  231.     ** nul-terminator.
  232.     */
  233.     len = pMem->n * 2 + 2;
  234.   }
  235.   /* Set zIn to point at the start of the input buffer and zTerm to point 1
  236.   ** byte past the end.
  237.   **
  238.   ** Variable zOut is set to point at the output buffer, space obtained
  239.   ** from sqlite3_malloc().
  240.   */
  241.   zIn = (u8*)pMem->z;
  242.   zTerm = &zIn[pMem->n];
  243.   zOut = sqlite3DbMallocRaw(pMem->db, len);
  244.   if( !zOut ){
  245.     return SQLITE_NOMEM;
  246.   }
  247.   z = zOut;
  248.   if( pMem->enc==SQLITE_UTF8 ){
  249.     if( desiredEnc==SQLITE_UTF16LE ){
  250.       /* UTF-8 -> UTF-16 Little-endian */
  251.       while( zIn<zTerm ){
  252.         c = sqlite3Utf8Read(zIn, zTerm, (const u8**)&zIn);
  253.         WRITE_UTF16LE(z, c);
  254.       }
  255.     }else{
  256.       assert( desiredEnc==SQLITE_UTF16BE );
  257.       /* UTF-8 -> UTF-16 Big-endian */
  258.       while( zIn<zTerm ){
  259.         c = sqlite3Utf8Read(zIn, zTerm, (const u8**)&zIn);
  260.         WRITE_UTF16BE(z, c);
  261.       }
  262.     }
  263.     pMem->n = z - zOut;
  264.     *z++ = 0;
  265.   }else{
  266.     assert( desiredEnc==SQLITE_UTF8 );
  267.     if( pMem->enc==SQLITE_UTF16LE ){
  268.       /* UTF-16 Little-endian -> UTF-8 */
  269.       while( zIn<zTerm ){
  270.         READ_UTF16LE(zIn, c); 
  271.         WRITE_UTF8(z, c);
  272.       }
  273.     }else{
  274.       /* UTF-16 Little-endian -> UTF-8 */
  275.       while( zIn<zTerm ){
  276.         READ_UTF16BE(zIn, c); 
  277.         WRITE_UTF8(z, c);
  278.       }
  279.     }
  280.     pMem->n = z - zOut;
  281.   }
  282.   *z = 0;
  283.   assert( (pMem->n+(desiredEnc==SQLITE_UTF8?1:2))<=len );
  284.   sqlite3VdbeMemRelease(pMem);
  285.   pMem->flags &= ~(MEM_Static|MEM_Dyn|MEM_Ephem);
  286.   pMem->enc = desiredEnc;
  287.   pMem->flags |= (MEM_Term|MEM_Dyn);
  288.   pMem->z = (char*)zOut;
  289.   pMem->zMalloc = pMem->z;
  290. translate_out:
  291. #if defined(TRANSLATE_TRACE) && defined(SQLITE_DEBUG)
  292.   {
  293.     char zBuf[100];
  294.     sqlite3VdbeMemPrettyPrint(pMem, zBuf);
  295.     fprintf(stderr, "OUTPUT: %sn", zBuf);
  296.   }
  297. #endif
  298.   return SQLITE_OK;
  299. }
  300. /*
  301. ** This routine checks for a byte-order mark at the beginning of the 
  302. ** UTF-16 string stored in *pMem. If one is present, it is removed and
  303. ** the encoding of the Mem adjusted. This routine does not do any
  304. ** byte-swapping, it just sets Mem.enc appropriately.
  305. **
  306. ** The allocation (static, dynamic etc.) and encoding of the Mem may be
  307. ** changed by this function.
  308. */
  309. int sqlite3VdbeMemHandleBom(Mem *pMem){
  310.   int rc = SQLITE_OK;
  311.   u8 bom = 0;
  312.   if( pMem->n<0 || pMem->n>1 ){
  313.     u8 b1 = *(u8 *)pMem->z;
  314.     u8 b2 = *(((u8 *)pMem->z) + 1);
  315.     if( b1==0xFE && b2==0xFF ){
  316.       bom = SQLITE_UTF16BE;
  317.     }
  318.     if( b1==0xFF && b2==0xFE ){
  319.       bom = SQLITE_UTF16LE;
  320.     }
  321.   }
  322.   
  323.   if( bom ){
  324.     rc = sqlite3VdbeMemMakeWriteable(pMem);
  325.     if( rc==SQLITE_OK ){
  326.       pMem->n -= 2;
  327.       memmove(pMem->z, &pMem->z[2], pMem->n);
  328.       pMem->z[pMem->n] = '';
  329.       pMem->z[pMem->n+1] = '';
  330.       pMem->flags |= MEM_Term;
  331.       pMem->enc = bom;
  332.     }
  333.   }
  334.   return rc;
  335. }
  336. #endif /* SQLITE_OMIT_UTF16 */
  337. /*
  338. ** pZ is a UTF-8 encoded unicode string. If nByte is less than zero,
  339. ** return the number of unicode characters in pZ up to (but not including)
  340. ** the first 0x00 byte. If nByte is not less than zero, return the
  341. ** number of unicode characters in the first nByte of pZ (or up to 
  342. ** the first 0x00, whichever comes first).
  343. */
  344. int sqlite3Utf8CharLen(const char *zIn, int nByte){
  345.   int r = 0;
  346.   const u8 *z = (const u8*)zIn;
  347.   const u8 *zTerm;
  348.   if( nByte>=0 ){
  349.     zTerm = &z[nByte];
  350.   }else{
  351.     zTerm = (const u8*)(-1);
  352.   }
  353.   assert( z<=zTerm );
  354.   while( *z!=0 && z<zTerm ){
  355.     SQLITE_SKIP_UTF8(z);
  356.     r++;
  357.   }
  358.   return r;
  359. }
  360. /* This test function is not currently used by the automated test-suite. 
  361. ** Hence it is only available in debug builds.
  362. */
  363. #if defined(SQLITE_TEST) && defined(SQLITE_DEBUG)
  364. /*
  365. ** Translate UTF-8 to UTF-8.
  366. **
  367. ** This has the effect of making sure that the string is well-formed
  368. ** UTF-8.  Miscoded characters are removed.
  369. **
  370. ** The translation is done in-place (since it is impossible for the
  371. ** correct UTF-8 encoding to be longer than a malformed encoding).
  372. */
  373. int sqlite3Utf8To8(unsigned char *zIn){
  374.   unsigned char *zOut = zIn;
  375.   unsigned char *zStart = zIn;
  376.   unsigned char *zTerm;
  377.   u32 c;
  378.   while( zIn[0] ){
  379.     c = sqlite3Utf8Read(zIn, zTerm, (const u8**)&zIn);
  380.     if( c!=0xfffd ){
  381.       WRITE_UTF8(zOut, c);
  382.     }
  383.   }
  384.   *zOut = 0;
  385.   return zOut - zStart;
  386. }
  387. #endif
  388. #ifndef SQLITE_OMIT_UTF16
  389. /*
  390. ** Convert a UTF-16 string in the native encoding into a UTF-8 string.
  391. ** Memory to hold the UTF-8 string is obtained from sqlite3_malloc and must
  392. ** be freed by the calling function.
  393. **
  394. ** NULL is returned if there is an allocation error.
  395. */
  396. char *sqlite3Utf16to8(sqlite3 *db, const void *z, int nByte){
  397.   Mem m;
  398.   memset(&m, 0, sizeof(m));
  399.   m.db = db;
  400.   sqlite3VdbeMemSetStr(&m, z, nByte, SQLITE_UTF16NATIVE, SQLITE_STATIC);
  401.   sqlite3VdbeChangeEncoding(&m, SQLITE_UTF8);
  402.   if( db->mallocFailed ){
  403.     sqlite3VdbeMemRelease(&m);
  404.     m.z = 0;
  405.   }
  406.   assert( (m.flags & MEM_Term)!=0 || db->mallocFailed );
  407.   assert( (m.flags & MEM_Str)!=0 || db->mallocFailed );
  408.   return (m.flags & MEM_Dyn)!=0 ? m.z : sqlite3DbStrDup(db, m.z);
  409. }
  410. /*
  411. ** pZ is a UTF-16 encoded unicode string. If nChar is less than zero,
  412. ** return the number of bytes up to (but not including), the first pair
  413. ** of consecutive 0x00 bytes in pZ. If nChar is not less than zero,
  414. ** then return the number of bytes in the first nChar unicode characters
  415. ** in pZ (or up until the first pair of 0x00 bytes, whichever comes first).
  416. */
  417. int sqlite3Utf16ByteLen(const void *zIn, int nChar){
  418.   unsigned int c = 1;
  419.   char const *z = zIn;
  420.   int n = 0;
  421.   if( SQLITE_UTF16NATIVE==SQLITE_UTF16BE ){
  422.     /* Using an "if (SQLITE_UTF16NATIVE==SQLITE_UTF16BE)" construct here
  423.     ** and in other parts of this file means that at one branch will
  424.     ** not be covered by coverage testing on any single host. But coverage
  425.     ** will be complete if the tests are run on both a little-endian and 
  426.     ** big-endian host. Because both the UTF16NATIVE and SQLITE_UTF16BE
  427.     ** macros are constant at compile time the compiler can determine
  428.     ** which branch will be followed. It is therefore assumed that no runtime
  429.     ** penalty is paid for this "if" statement.
  430.     */
  431.     while( c && ((nChar<0) || n<nChar) ){
  432.       READ_UTF16BE(z, c);
  433.       n++;
  434.     }
  435.   }else{
  436.     while( c && ((nChar<0) || n<nChar) ){
  437.       READ_UTF16LE(z, c);
  438.       n++;
  439.     }
  440.   }
  441.   return (z-(char const *)zIn)-((c==0)?2:0);
  442. }
  443. #if defined(SQLITE_TEST)
  444. /*
  445. ** This routine is called from the TCL test function "translate_selftest".
  446. ** It checks that the primitives for serializing and deserializing
  447. ** characters in each encoding are inverses of each other.
  448. */
  449. void sqlite3UtfSelfTest(){
  450.   unsigned int i, t;
  451.   unsigned char zBuf[20];
  452.   unsigned char *z;
  453.   unsigned char *zTerm;
  454.   int n;
  455.   unsigned int c;
  456.   for(i=0; i<0x00110000; i++){
  457.     z = zBuf;
  458.     WRITE_UTF8(z, i);
  459.     n = z-zBuf;
  460.     z[0] = 0;
  461.     zTerm = z;
  462.     z = zBuf;
  463.     c = sqlite3Utf8Read(z, zTerm, (const u8**)&z);
  464.     t = i;
  465.     if( i>=0xD800 && i<=0xDFFF ) t = 0xFFFD;
  466.     if( (i&0xFFFFFFFE)==0xFFFE ) t = 0xFFFD;
  467.     assert( c==t );
  468.     assert( (z-zBuf)==n );
  469.   }
  470.   for(i=0; i<0x00110000; i++){
  471.     if( i>=0xD800 && i<0xE000 ) continue;
  472.     z = zBuf;
  473.     WRITE_UTF16LE(z, i);
  474.     n = z-zBuf;
  475.     z[0] = 0;
  476.     z = zBuf;
  477.     READ_UTF16LE(z, c);
  478.     assert( c==i );
  479.     assert( (z-zBuf)==n );
  480.   }
  481.   for(i=0; i<0x00110000; i++){
  482.     if( i>=0xD800 && i<0xE000 ) continue;
  483.     z = zBuf;
  484.     WRITE_UTF16BE(z, i);
  485.     n = z-zBuf;
  486.     z[0] = 0;
  487.     z = zBuf;
  488.     READ_UTF16BE(z, c);
  489.     assert( c==i );
  490.     assert( (z-zBuf)==n );
  491.   }
  492. }
  493. #endif /* SQLITE_TEST */
  494. #endif /* SQLITE_OMIT_UTF16 */