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