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 }
sqlite3Utf8Read(const unsigned char * zIn,const unsigned char ** pzNext)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 */
sqlite3VdbeMemTranslate(Mem * pMem,u8 desiredEnc)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 */
sqlite3VdbeMemHandleBom(Mem * pMem)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 */
sqlite3Utf8CharLen(const char * zIn,int nByte)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 */
sqlite3Utf8To8(unsigned char * zIn)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 */
sqlite3Utf16to8(sqlite3 * db,const void * z,int nByte,u8 enc)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
sqlite3Utf8to16(sqlite3 * db,u8 enc,char * z,int n,int * pnOut)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 */
sqlite3Utf16ByteLen(const void * zIn,int nChar)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 */
sqlite3UtfSelfTest(void)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 */
561