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 #if !defined(SQLITE_AMALGAMATION) && SQLITE_BYTEORDER==0 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 && SQLITE_BYTEORDER==0 */ 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 /* 109 ** Translate a single UTF-8 character. Return the unicode value. 110 ** 111 ** During translation, assume that the byte that zTerm points 112 ** is a 0x00. 113 ** 114 ** Write a pointer to the next unread byte back into *pzNext. 115 ** 116 ** Notes On Invalid UTF-8: 117 ** 118 ** * This routine never allows a 7-bit character (0x00 through 0x7f) to 119 ** be encoded as a multi-byte character. Any multi-byte character that 120 ** attempts to encode a value between 0x00 and 0x7f is rendered as 0xfffd. 121 ** 122 ** * This routine never allows a UTF16 surrogate value to be encoded. 123 ** If a multi-byte character attempts to encode a value between 124 ** 0xd800 and 0xe000 then it is rendered as 0xfffd. 125 ** 126 ** * Bytes in the range of 0x80 through 0xbf which occur as the first 127 ** byte of a character are interpreted as single-byte characters 128 ** and rendered as themselves even though they are technically 129 ** invalid characters. 130 ** 131 ** * This routine accepts over-length UTF8 encodings 132 ** for unicode values 0x80 and greater. It does not change over-length 133 ** encodings to 0xfffd as some systems recommend. 134 */ 135 #define READ_UTF8(zIn, zTerm, c) \ 136 c = *(zIn++); \ 137 if( c>=0xc0 ){ \ 138 c = sqlite3Utf8Trans1[c-0xc0]; \ 139 while( zIn!=zTerm && (*zIn & 0xc0)==0x80 ){ \ 140 c = (c<<6) + (0x3f & *(zIn++)); \ 141 } \ 142 if( c<0x80 \ 143 || (c&0xFFFFF800)==0xD800 \ 144 || (c&0xFFFFFFFE)==0xFFFE ){ c = 0xFFFD; } \ 145 } 146 u32 sqlite3Utf8Read( 147 const unsigned char **pz /* Pointer to string from which to read char */ 148 ){ 149 unsigned int c; 150 151 /* Same as READ_UTF8() above but without the zTerm parameter. 152 ** For this routine, we assume the UTF8 string is always zero-terminated. 153 */ 154 c = *((*pz)++); 155 if( c>=0xc0 ){ 156 c = sqlite3Utf8Trans1[c-0xc0]; 157 while( (*(*pz) & 0xc0)==0x80 ){ 158 c = (c<<6) + (0x3f & *((*pz)++)); 159 } 160 if( c<0x80 161 || (c&0xFFFFF800)==0xD800 162 || (c&0xFFFFFFFE)==0xFFFE ){ c = 0xFFFD; } 163 } 164 return c; 165 } 166 167 168 169 170 /* 171 ** If the TRANSLATE_TRACE macro is defined, the value of each Mem is 172 ** printed on stderr on the way into and out of sqlite3VdbeMemTranslate(). 173 */ 174 /* #define TRANSLATE_TRACE 1 */ 175 176 #ifndef SQLITE_OMIT_UTF16 177 /* 178 ** This routine transforms the internal text encoding used by pMem to 179 ** desiredEnc. It is an error if the string is already of the desired 180 ** encoding, or if *pMem does not contain a string value. 181 */ 182 SQLITE_NOINLINE int sqlite3VdbeMemTranslate(Mem *pMem, u8 desiredEnc){ 183 sqlite3_int64 len; /* Maximum length of output string in bytes */ 184 unsigned char *zOut; /* Output buffer */ 185 unsigned char *zIn; /* Input iterator */ 186 unsigned char *zTerm; /* End of input */ 187 unsigned char *z; /* Output iterator */ 188 unsigned int c; 189 190 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) ); 191 assert( pMem->flags&MEM_Str ); 192 assert( pMem->enc!=desiredEnc ); 193 assert( pMem->enc!=0 ); 194 assert( pMem->n>=0 ); 195 196 #if defined(TRANSLATE_TRACE) && defined(SQLITE_DEBUG) 197 { 198 StrAccum acc; 199 char zBuf[1000]; 200 sqlite3StrAccumInit(&acc, 0, zBuf, sizeof(zBuf), 0); 201 sqlite3VdbeMemPrettyPrint(pMem, &acc); 202 fprintf(stderr, "INPUT: %s\n", sqlite3StrAccumFinish(&acc)); 203 } 204 #endif 205 206 /* If the translation is between UTF-16 little and big endian, then 207 ** all that is required is to swap the byte order. This case is handled 208 ** differently from the others. 209 */ 210 if( pMem->enc!=SQLITE_UTF8 && desiredEnc!=SQLITE_UTF8 ){ 211 u8 temp; 212 int rc; 213 rc = sqlite3VdbeMemMakeWriteable(pMem); 214 if( rc!=SQLITE_OK ){ 215 assert( rc==SQLITE_NOMEM ); 216 return SQLITE_NOMEM_BKPT; 217 } 218 zIn = (u8*)pMem->z; 219 zTerm = &zIn[pMem->n&~1]; 220 while( zIn<zTerm ){ 221 temp = *zIn; 222 *zIn = *(zIn+1); 223 zIn++; 224 *zIn++ = temp; 225 } 226 pMem->enc = desiredEnc; 227 goto translate_out; 228 } 229 230 /* Set len to the maximum number of bytes required in the output buffer. */ 231 if( desiredEnc==SQLITE_UTF8 ){ 232 /* When converting from UTF-16, the maximum growth results from 233 ** translating a 2-byte character to a 4-byte UTF-8 character. 234 ** A single byte is required for the output string 235 ** nul-terminator. 236 */ 237 pMem->n &= ~1; 238 len = 2 * (sqlite3_int64)pMem->n + 1; 239 }else{ 240 /* When converting from UTF-8 to UTF-16 the maximum growth is caused 241 ** when a 1-byte UTF-8 character is translated into a 2-byte UTF-16 242 ** character. Two bytes are required in the output buffer for the 243 ** nul-terminator. 244 */ 245 len = 2 * (sqlite3_int64)pMem->n + 2; 246 } 247 248 /* Set zIn to point at the start of the input buffer and zTerm to point 1 249 ** byte past the end. 250 ** 251 ** Variable zOut is set to point at the output buffer, space obtained 252 ** from sqlite3_malloc(). 253 */ 254 zIn = (u8*)pMem->z; 255 zTerm = &zIn[pMem->n]; 256 zOut = sqlite3DbMallocRaw(pMem->db, len); 257 if( !zOut ){ 258 return SQLITE_NOMEM_BKPT; 259 } 260 z = zOut; 261 262 if( pMem->enc==SQLITE_UTF8 ){ 263 if( desiredEnc==SQLITE_UTF16LE ){ 264 /* UTF-8 -> UTF-16 Little-endian */ 265 while( zIn<zTerm ){ 266 READ_UTF8(zIn, zTerm, c); 267 WRITE_UTF16LE(z, c); 268 } 269 }else{ 270 assert( desiredEnc==SQLITE_UTF16BE ); 271 /* UTF-8 -> UTF-16 Big-endian */ 272 while( zIn<zTerm ){ 273 READ_UTF8(zIn, zTerm, c); 274 WRITE_UTF16BE(z, c); 275 } 276 } 277 pMem->n = (int)(z - zOut); 278 *z++ = 0; 279 }else{ 280 assert( desiredEnc==SQLITE_UTF8 ); 281 if( pMem->enc==SQLITE_UTF16LE ){ 282 /* UTF-16 Little-endian -> UTF-8 */ 283 while( zIn<zTerm ){ 284 c = *(zIn++); 285 c += (*(zIn++))<<8; 286 if( c>=0xd800 && c<0xe000 ){ 287 #ifdef SQLITE_REPLACE_INVALID_UTF 288 if( c>=0xdc00 || zIn>=zTerm ){ 289 c = 0xfffd; 290 }else{ 291 int c2 = *(zIn++); 292 c2 += (*(zIn++))<<8; 293 if( c2<0xdc00 || c2>=0xe000 ){ 294 zIn -= 2; 295 c = 0xfffd; 296 }else{ 297 c = ((c&0x3ff)<<10) + (c2&0x3ff) + 0x10000; 298 } 299 } 300 #else 301 if( zIn<zTerm ){ 302 int c2 = (*zIn++); 303 c2 += ((*zIn++)<<8); 304 c = (c2&0x03FF) + ((c&0x003F)<<10) + (((c&0x03C0)+0x0040)<<10); 305 } 306 #endif 307 } 308 WRITE_UTF8(z, c); 309 } 310 }else{ 311 /* UTF-16 Big-endian -> UTF-8 */ 312 while( zIn<zTerm ){ 313 c = (*(zIn++))<<8; 314 c += *(zIn++); 315 if( c>=0xd800 && c<0xe000 ){ 316 #ifdef SQLITE_REPLACE_INVALID_UTF 317 if( c>=0xdc00 || zIn>=zTerm ){ 318 c = 0xfffd; 319 }else{ 320 int c2 = (*(zIn++))<<8; 321 c2 += *(zIn++); 322 if( c2<0xdc00 || c2>=0xe000 ){ 323 zIn -= 2; 324 c = 0xfffd; 325 }else{ 326 c = ((c&0x3ff)<<10) + (c2&0x3ff) + 0x10000; 327 } 328 } 329 #else 330 if( zIn<zTerm ){ 331 int c2 = ((*zIn++)<<8); 332 c2 += (*zIn++); 333 c = (c2&0x03FF) + ((c&0x003F)<<10) + (((c&0x03C0)+0x0040)<<10); 334 } 335 #endif 336 } 337 WRITE_UTF8(z, c); 338 } 339 } 340 pMem->n = (int)(z - zOut); 341 } 342 *z = 0; 343 assert( (pMem->n+(desiredEnc==SQLITE_UTF8?1:2))<=len ); 344 345 c = MEM_Str|MEM_Term|(pMem->flags&(MEM_AffMask|MEM_Subtype)); 346 sqlite3VdbeMemRelease(pMem); 347 pMem->flags = c; 348 pMem->enc = desiredEnc; 349 pMem->z = (char*)zOut; 350 pMem->zMalloc = pMem->z; 351 pMem->szMalloc = sqlite3DbMallocSize(pMem->db, pMem->z); 352 353 translate_out: 354 #if defined(TRANSLATE_TRACE) && defined(SQLITE_DEBUG) 355 { 356 StrAccum acc; 357 char zBuf[1000]; 358 sqlite3StrAccumInit(&acc, 0, zBuf, sizeof(zBuf), 0); 359 sqlite3VdbeMemPrettyPrint(pMem, &acc); 360 fprintf(stderr, "OUTPUT: %s\n", sqlite3StrAccumFinish(&acc)); 361 } 362 #endif 363 return SQLITE_OK; 364 } 365 #endif /* SQLITE_OMIT_UTF16 */ 366 367 #ifndef SQLITE_OMIT_UTF16 368 /* 369 ** This routine checks for a byte-order mark at the beginning of the 370 ** UTF-16 string stored in *pMem. If one is present, it is removed and 371 ** the encoding of the Mem adjusted. This routine does not do any 372 ** byte-swapping, it just sets Mem.enc appropriately. 373 ** 374 ** The allocation (static, dynamic etc.) and encoding of the Mem may be 375 ** changed by this function. 376 */ 377 int sqlite3VdbeMemHandleBom(Mem *pMem){ 378 int rc = SQLITE_OK; 379 u8 bom = 0; 380 381 assert( pMem->n>=0 ); 382 if( pMem->n>1 ){ 383 u8 b1 = *(u8 *)pMem->z; 384 u8 b2 = *(((u8 *)pMem->z) + 1); 385 if( b1==0xFE && b2==0xFF ){ 386 bom = SQLITE_UTF16BE; 387 } 388 if( b1==0xFF && b2==0xFE ){ 389 bom = SQLITE_UTF16LE; 390 } 391 } 392 393 if( bom ){ 394 rc = sqlite3VdbeMemMakeWriteable(pMem); 395 if( rc==SQLITE_OK ){ 396 pMem->n -= 2; 397 memmove(pMem->z, &pMem->z[2], pMem->n); 398 pMem->z[pMem->n] = '\0'; 399 pMem->z[pMem->n+1] = '\0'; 400 pMem->flags |= MEM_Term; 401 pMem->enc = bom; 402 } 403 } 404 return rc; 405 } 406 #endif /* SQLITE_OMIT_UTF16 */ 407 408 /* 409 ** pZ is a UTF-8 encoded unicode string. If nByte is less than zero, 410 ** return the number of unicode characters in pZ up to (but not including) 411 ** the first 0x00 byte. If nByte is not less than zero, return the 412 ** number of unicode characters in the first nByte of pZ (or up to 413 ** the first 0x00, whichever comes first). 414 */ 415 int sqlite3Utf8CharLen(const char *zIn, int nByte){ 416 int r = 0; 417 const u8 *z = (const u8*)zIn; 418 const u8 *zTerm; 419 if( nByte>=0 ){ 420 zTerm = &z[nByte]; 421 }else{ 422 zTerm = (const u8*)(-1); 423 } 424 assert( z<=zTerm ); 425 while( *z!=0 && z<zTerm ){ 426 SQLITE_SKIP_UTF8(z); 427 r++; 428 } 429 return r; 430 } 431 432 /* This test function is not currently used by the automated test-suite. 433 ** Hence it is only available in debug builds. 434 */ 435 #if defined(SQLITE_TEST) && defined(SQLITE_DEBUG) 436 /* 437 ** Translate UTF-8 to UTF-8. 438 ** 439 ** This has the effect of making sure that the string is well-formed 440 ** UTF-8. Miscoded characters are removed. 441 ** 442 ** The translation is done in-place and aborted if the output 443 ** overruns the input. 444 */ 445 int sqlite3Utf8To8(unsigned char *zIn){ 446 unsigned char *zOut = zIn; 447 unsigned char *zStart = zIn; 448 u32 c; 449 450 while( zIn[0] && zOut<=zIn ){ 451 c = sqlite3Utf8Read((const u8**)&zIn); 452 if( c!=0xfffd ){ 453 WRITE_UTF8(zOut, c); 454 } 455 } 456 *zOut = 0; 457 return (int)(zOut - zStart); 458 } 459 #endif 460 461 #ifndef SQLITE_OMIT_UTF16 462 /* 463 ** Convert a UTF-16 string in the native encoding into a UTF-8 string. 464 ** Memory to hold the UTF-8 string is obtained from sqlite3_malloc and must 465 ** be freed by the calling function. 466 ** 467 ** NULL is returned if there is an allocation error. 468 */ 469 char *sqlite3Utf16to8(sqlite3 *db, const void *z, int nByte, u8 enc){ 470 Mem m; 471 memset(&m, 0, sizeof(m)); 472 m.db = db; 473 sqlite3VdbeMemSetStr(&m, z, nByte, enc, SQLITE_STATIC); 474 sqlite3VdbeChangeEncoding(&m, SQLITE_UTF8); 475 if( db->mallocFailed ){ 476 sqlite3VdbeMemRelease(&m); 477 m.z = 0; 478 } 479 assert( (m.flags & MEM_Term)!=0 || db->mallocFailed ); 480 assert( (m.flags & MEM_Str)!=0 || db->mallocFailed ); 481 assert( m.z || db->mallocFailed ); 482 return m.z; 483 } 484 485 /* 486 ** zIn is a UTF-16 encoded unicode string at least nChar characters long. 487 ** Return the number of bytes in the first nChar unicode characters 488 ** in pZ. nChar must be non-negative. 489 */ 490 int sqlite3Utf16ByteLen(const void *zIn, int nChar){ 491 int c; 492 unsigned char const *z = zIn; 493 int n = 0; 494 495 if( SQLITE_UTF16NATIVE==SQLITE_UTF16LE ) z++; 496 while( n<nChar ){ 497 c = z[0]; 498 z += 2; 499 if( c>=0xd8 && c<0xdc && z[0]>=0xdc && z[0]<0xe0 ) z += 2; 500 n++; 501 } 502 return (int)(z-(unsigned char const *)zIn) 503 - (SQLITE_UTF16NATIVE==SQLITE_UTF16LE); 504 } 505 506 #if defined(SQLITE_TEST) 507 /* 508 ** This routine is called from the TCL test function "translate_selftest". 509 ** It checks that the primitives for serializing and deserializing 510 ** characters in each encoding are inverses of each other. 511 */ 512 void sqlite3UtfSelfTest(void){ 513 unsigned int i, t; 514 unsigned char zBuf[20]; 515 unsigned char *z; 516 int n; 517 unsigned int c; 518 519 for(i=0; i<0x00110000; i++){ 520 z = zBuf; 521 WRITE_UTF8(z, i); 522 n = (int)(z-zBuf); 523 assert( n>0 && n<=4 ); 524 z[0] = 0; 525 z = zBuf; 526 c = sqlite3Utf8Read((const u8**)&z); 527 t = i; 528 if( i>=0xD800 && i<=0xDFFF ) t = 0xFFFD; 529 if( (i&0xFFFFFFFE)==0xFFFE ) t = 0xFFFD; 530 assert( c==t ); 531 assert( (z-zBuf)==n ); 532 } 533 } 534 #endif /* SQLITE_TEST */ 535 #endif /* SQLITE_OMIT_UTF16 */ 536