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*/ 45const 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*/ 52static 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 } 166int 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*/ 204int 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 328translate_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*/ 348int 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*/ 386int 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*/ 416int 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*/ 440char *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 468char *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*/ 488int 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*/ 513void 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 */ 561