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: u32 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_STAT3
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 */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to utf.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / src