Annotation of embedaddon/sqlite3/src/utf.c, revision 1.1
1.1 ! misho 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