| /* |
| ****************************************************************************** |
| * |
| * Copyright (C) 2002-2011, International Business Machines |
| * Corporation and others. All Rights Reserved. |
| * |
| ****************************************************************************** |
| * file name: ucnvbocu.cpp |
| * encoding: US-ASCII |
| * tab size: 8 (not used) |
| * indentation:4 |
| * |
| * created on: 2002mar27 |
| * created by: Markus W. Scherer |
| * |
| * This is an implementation of the Binary Ordered Compression for Unicode, |
| * in its MIME-friendly form as defined in http://www.unicode.org/notes/tn6/ |
| */ |
| |
| #include "unicode/utypes.h" |
| |
| #if !UCONFIG_NO_CONVERSION |
| |
| #include "unicode/ucnv.h" |
| #include "unicode/ucnv_cb.h" |
| #include "unicode/utf16.h" |
| #include "putilimp.h" |
| #include "ucnv_bld.h" |
| #include "ucnv_cnv.h" |
| #include "uassert.h" |
| |
| /* BOCU-1 constants and macros ---------------------------------------------- */ |
| |
| /* |
| * BOCU-1 encodes the code points of a Unicode string as |
| * a sequence of byte-encoded differences (slope detection), |
| * preserving lexical order. |
| * |
| * Optimize the difference-taking for runs of Unicode text within |
| * small scripts: |
| * |
| * Most small scripts are allocated within aligned 128-blocks of Unicode |
| * code points. Lexical order is preserved if the "previous code point" state |
| * is always moved into the middle of such a block. |
| * |
| * Additionally, "prev" is moved from anywhere in the Unihan and Hangul |
| * areas into the middle of those areas. |
| * |
| * C0 control codes and space are encoded with their US-ASCII bytes. |
| * "prev" is reset for C0 controls but not for space. |
| */ |
| |
| /* initial value for "prev": middle of the ASCII range */ |
| #define BOCU1_ASCII_PREV 0x40 |
| |
| /* bounding byte values for differences */ |
| #define BOCU1_MIN 0x21 |
| #define BOCU1_MIDDLE 0x90 |
| #define BOCU1_MAX_LEAD 0xfe |
| #define BOCU1_MAX_TRAIL 0xff |
| #define BOCU1_RESET 0xff |
| |
| /* number of lead bytes */ |
| #define BOCU1_COUNT (BOCU1_MAX_LEAD-BOCU1_MIN+1) |
| |
| /* adjust trail byte counts for the use of some C0 control byte values */ |
| #define BOCU1_TRAIL_CONTROLS_COUNT 20 |
| #define BOCU1_TRAIL_BYTE_OFFSET (BOCU1_MIN-BOCU1_TRAIL_CONTROLS_COUNT) |
| |
| /* number of trail bytes */ |
| #define BOCU1_TRAIL_COUNT ((BOCU1_MAX_TRAIL-BOCU1_MIN+1)+BOCU1_TRAIL_CONTROLS_COUNT) |
| |
| /* |
| * number of positive and negative single-byte codes |
| * (counting 0==BOCU1_MIDDLE among the positive ones) |
| */ |
| #define BOCU1_SINGLE 64 |
| |
| /* number of lead bytes for positive and negative 2/3/4-byte sequences */ |
| #define BOCU1_LEAD_2 43 |
| #define BOCU1_LEAD_3 3 |
| #define BOCU1_LEAD_4 1 |
| |
| /* The difference value range for single-byters. */ |
| #define BOCU1_REACH_POS_1 (BOCU1_SINGLE-1) |
| #define BOCU1_REACH_NEG_1 (-BOCU1_SINGLE) |
| |
| /* The difference value range for double-byters. */ |
| #define BOCU1_REACH_POS_2 (BOCU1_REACH_POS_1+BOCU1_LEAD_2*BOCU1_TRAIL_COUNT) |
| #define BOCU1_REACH_NEG_2 (BOCU1_REACH_NEG_1-BOCU1_LEAD_2*BOCU1_TRAIL_COUNT) |
| |
| /* The difference value range for 3-byters. */ |
| #define BOCU1_REACH_POS_3 \ |
| (BOCU1_REACH_POS_2+BOCU1_LEAD_3*BOCU1_TRAIL_COUNT*BOCU1_TRAIL_COUNT) |
| |
| #define BOCU1_REACH_NEG_3 (BOCU1_REACH_NEG_2-BOCU1_LEAD_3*BOCU1_TRAIL_COUNT*BOCU1_TRAIL_COUNT) |
| |
| /* The lead byte start values. */ |
| #define BOCU1_START_POS_2 (BOCU1_MIDDLE+BOCU1_REACH_POS_1+1) |
| #define BOCU1_START_POS_3 (BOCU1_START_POS_2+BOCU1_LEAD_2) |
| #define BOCU1_START_POS_4 (BOCU1_START_POS_3+BOCU1_LEAD_3) |
| /* ==BOCU1_MAX_LEAD */ |
| |
| #define BOCU1_START_NEG_2 (BOCU1_MIDDLE+BOCU1_REACH_NEG_1) |
| #define BOCU1_START_NEG_3 (BOCU1_START_NEG_2-BOCU1_LEAD_2) |
| #define BOCU1_START_NEG_4 (BOCU1_START_NEG_3-BOCU1_LEAD_3) |
| /* ==BOCU1_MIN+1 */ |
| |
| /* The length of a byte sequence, according to the lead byte (!=BOCU1_RESET). */ |
| #define BOCU1_LENGTH_FROM_LEAD(lead) \ |
| ((BOCU1_START_NEG_2<=(lead) && (lead)<BOCU1_START_POS_2) ? 1 : \ |
| (BOCU1_START_NEG_3<=(lead) && (lead)<BOCU1_START_POS_3) ? 2 : \ |
| (BOCU1_START_NEG_4<=(lead) && (lead)<BOCU1_START_POS_4) ? 3 : 4) |
| |
| /* The length of a byte sequence, according to its packed form. */ |
| #define BOCU1_LENGTH_FROM_PACKED(packed) \ |
| ((uint32_t)(packed)<0x04000000 ? (packed)>>24 : 4) |
| |
| /* |
| * 12 commonly used C0 control codes (and space) are only used to encode |
| * themselves directly, |
| * which makes BOCU-1 MIME-usable and reasonably safe for |
| * ASCII-oriented software. |
| * |
| * These controls are |
| * 0 NUL |
| * |
| * 7 BEL |
| * 8 BS |
| * |
| * 9 TAB |
| * a LF |
| * b VT |
| * c FF |
| * d CR |
| * |
| * e SO |
| * f SI |
| * |
| * 1a SUB |
| * 1b ESC |
| * |
| * The other 20 C0 controls are also encoded directly (to preserve order) |
| * but are also used as trail bytes in difference encoding |
| * (for better compression). |
| */ |
| #define BOCU1_TRAIL_TO_BYTE(t) ((t)>=BOCU1_TRAIL_CONTROLS_COUNT ? (t)+BOCU1_TRAIL_BYTE_OFFSET : bocu1TrailToByte[t]) |
| |
| /* |
| * Byte value map for control codes, |
| * from external byte values 0x00..0x20 |
| * to trail byte values 0..19 (0..0x13) as used in the difference calculation. |
| * External byte values that are illegal as trail bytes are mapped to -1. |
| */ |
| static const int8_t |
| bocu1ByteToTrail[BOCU1_MIN]={ |
| /* 0 1 2 3 4 5 6 7 */ |
| -1, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, -1, |
| |
| /* 8 9 a b c d e f */ |
| -1, -1, -1, -1, -1, -1, -1, -1, |
| |
| /* 10 11 12 13 14 15 16 17 */ |
| 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, |
| |
| /* 18 19 1a 1b 1c 1d 1e 1f */ |
| 0x0e, 0x0f, -1, -1, 0x10, 0x11, 0x12, 0x13, |
| |
| /* 20 */ |
| -1 |
| }; |
| |
| /* |
| * Byte value map for control codes, |
| * from trail byte values 0..19 (0..0x13) as used in the difference calculation |
| * to external byte values 0x00..0x20. |
| */ |
| static const int8_t |
| bocu1TrailToByte[BOCU1_TRAIL_CONTROLS_COUNT]={ |
| /* 0 1 2 3 4 5 6 7 */ |
| 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x10, 0x11, |
| |
| /* 8 9 a b c d e f */ |
| 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, |
| |
| /* 10 11 12 13 */ |
| 0x1c, 0x1d, 0x1e, 0x1f |
| }; |
| |
| /** |
| * Integer division and modulo with negative numerators |
| * yields negative modulo results and quotients that are one more than |
| * what we need here. |
| * This macro adjust the results so that the modulo-value m is always >=0. |
| * |
| * For positive n, the if() condition is always FALSE. |
| * |
| * @param n Number to be split into quotient and rest. |
| * Will be modified to contain the quotient. |
| * @param d Divisor. |
| * @param m Output variable for the rest (modulo result). |
| */ |
| #define NEGDIVMOD(n, d, m) { \ |
| (m)=(n)%(d); \ |
| (n)/=(d); \ |
| if((m)<0) { \ |
| --(n); \ |
| (m)+=(d); \ |
| } \ |
| } |
| |
| /* Faster versions of packDiff() for single-byte-encoded diff values. */ |
| |
| /** Is a diff value encodable in a single byte? */ |
| #define DIFF_IS_SINGLE(diff) (BOCU1_REACH_NEG_1<=(diff) && (diff)<=BOCU1_REACH_POS_1) |
| |
| /** Encode a diff value in a single byte. */ |
| #define PACK_SINGLE_DIFF(diff) (BOCU1_MIDDLE+(diff)) |
| |
| /** Is a diff value encodable in two bytes? */ |
| #define DIFF_IS_DOUBLE(diff) (BOCU1_REACH_NEG_2<=(diff) && (diff)<=BOCU1_REACH_POS_2) |
| |
| /* BOCU-1 implementation functions ------------------------------------------ */ |
| |
| #define BOCU1_SIMPLE_PREV(c) (((c)&~0x7f)+BOCU1_ASCII_PREV) |
| |
| /** |
| * Compute the next "previous" value for differencing |
| * from the current code point. |
| * |
| * @param c current code point, 0x3040..0xd7a3 (rest handled by macro below) |
| * @return "previous code point" state value |
| */ |
| static inline int32_t |
| bocu1Prev(int32_t c) { |
| /* compute new prev */ |
| if(/* 0x3040<=c && */ c<=0x309f) { |
| /* Hiragana is not 128-aligned */ |
| return 0x3070; |
| } else if(0x4e00<=c && c<=0x9fa5) { |
| /* CJK Unihan */ |
| return 0x4e00-BOCU1_REACH_NEG_2; |
| } else if(0xac00<=c /* && c<=0xd7a3 */) { |
| /* Korean Hangul */ |
| return (0xd7a3+0xac00)/2; |
| } else { |
| /* mostly small scripts */ |
| return BOCU1_SIMPLE_PREV(c); |
| } |
| } |
| |
| /** Fast version of bocu1Prev() for most scripts. */ |
| #define BOCU1_PREV(c) ((c)<0x3040 || (c)>0xd7a3 ? BOCU1_SIMPLE_PREV(c) : bocu1Prev(c)) |
| |
| /* |
| * The BOCU-1 converter uses the standard setup code in ucnv.c/ucnv_bld.c. |
| * The UConverter fields are used as follows: |
| * |
| * fromUnicodeStatus encoder's prev (0 will be interpreted as BOCU1_ASCII_PREV) |
| * |
| * toUnicodeStatus decoder's prev (0 will be interpreted as BOCU1_ASCII_PREV) |
| * mode decoder's incomplete (diff<<2)|count (ignored when toULength==0) |
| */ |
| |
| /* BOCU-1-from-Unicode conversion functions --------------------------------- */ |
| |
| /** |
| * Encode a difference -0x10ffff..0x10ffff in 1..4 bytes |
| * and return a packed integer with them. |
| * |
| * The encoding favors small absolute differences with short encodings |
| * to compress runs of same-script characters. |
| * |
| * Optimized version with unrolled loops and fewer floating-point operations |
| * than the standard packDiff(). |
| * |
| * @param diff difference value -0x10ffff..0x10ffff |
| * @return |
| * 0x010000zz for 1-byte sequence zz |
| * 0x0200yyzz for 2-byte sequence yy zz |
| * 0x03xxyyzz for 3-byte sequence xx yy zz |
| * 0xwwxxyyzz for 4-byte sequence ww xx yy zz (ww>0x03) |
| */ |
| static int32_t |
| packDiff(int32_t diff) { |
| int32_t result, m; |
| |
| U_ASSERT(!DIFF_IS_SINGLE(diff)); /* assume we won't be called where diff==BOCU1_REACH_NEG_1=-64 */ |
| if(diff>=BOCU1_REACH_NEG_1) { |
| /* mostly positive differences, and single-byte negative ones */ |
| #if 0 /* single-byte case handled in macros, see below */ |
| if(diff<=BOCU1_REACH_POS_1) { |
| /* single byte */ |
| return 0x01000000|(BOCU1_MIDDLE+diff); |
| } else |
| #endif |
| if(diff<=BOCU1_REACH_POS_2) { |
| /* two bytes */ |
| diff-=BOCU1_REACH_POS_1+1; |
| result=0x02000000; |
| |
| m=diff%BOCU1_TRAIL_COUNT; |
| diff/=BOCU1_TRAIL_COUNT; |
| result|=BOCU1_TRAIL_TO_BYTE(m); |
| |
| result|=(BOCU1_START_POS_2+diff)<<8; |
| } else if(diff<=BOCU1_REACH_POS_3) { |
| /* three bytes */ |
| diff-=BOCU1_REACH_POS_2+1; |
| result=0x03000000; |
| |
| m=diff%BOCU1_TRAIL_COUNT; |
| diff/=BOCU1_TRAIL_COUNT; |
| result|=BOCU1_TRAIL_TO_BYTE(m); |
| |
| m=diff%BOCU1_TRAIL_COUNT; |
| diff/=BOCU1_TRAIL_COUNT; |
| result|=BOCU1_TRAIL_TO_BYTE(m)<<8; |
| |
| result|=(BOCU1_START_POS_3+diff)<<16; |
| } else { |
| /* four bytes */ |
| diff-=BOCU1_REACH_POS_3+1; |
| |
| m=diff%BOCU1_TRAIL_COUNT; |
| diff/=BOCU1_TRAIL_COUNT; |
| result=BOCU1_TRAIL_TO_BYTE(m); |
| |
| m=diff%BOCU1_TRAIL_COUNT; |
| diff/=BOCU1_TRAIL_COUNT; |
| result|=BOCU1_TRAIL_TO_BYTE(m)<<8; |
| |
| /* |
| * We know that / and % would deliver quotient 0 and rest=diff. |
| * Avoid division and modulo for performance. |
| */ |
| result|=BOCU1_TRAIL_TO_BYTE(diff)<<16; |
| |
| result|=((uint32_t)BOCU1_START_POS_4)<<24; |
| } |
| } else { |
| /* two- to four-byte negative differences */ |
| if(diff>=BOCU1_REACH_NEG_2) { |
| /* two bytes */ |
| diff-=BOCU1_REACH_NEG_1; |
| result=0x02000000; |
| |
| NEGDIVMOD(diff, BOCU1_TRAIL_COUNT, m); |
| result|=BOCU1_TRAIL_TO_BYTE(m); |
| |
| result|=(BOCU1_START_NEG_2+diff)<<8; |
| } else if(diff>=BOCU1_REACH_NEG_3) { |
| /* three bytes */ |
| diff-=BOCU1_REACH_NEG_2; |
| result=0x03000000; |
| |
| NEGDIVMOD(diff, BOCU1_TRAIL_COUNT, m); |
| result|=BOCU1_TRAIL_TO_BYTE(m); |
| |
| NEGDIVMOD(diff, BOCU1_TRAIL_COUNT, m); |
| result|=BOCU1_TRAIL_TO_BYTE(m)<<8; |
| |
| result|=(BOCU1_START_NEG_3+diff)<<16; |
| } else { |
| /* four bytes */ |
| diff-=BOCU1_REACH_NEG_3; |
| |
| NEGDIVMOD(diff, BOCU1_TRAIL_COUNT, m); |
| result=BOCU1_TRAIL_TO_BYTE(m); |
| |
| NEGDIVMOD(diff, BOCU1_TRAIL_COUNT, m); |
| result|=BOCU1_TRAIL_TO_BYTE(m)<<8; |
| |
| /* |
| * We know that NEGDIVMOD would deliver |
| * quotient -1 and rest=diff+BOCU1_TRAIL_COUNT. |
| * Avoid division and modulo for performance. |
| */ |
| m=diff+BOCU1_TRAIL_COUNT; |
| result|=BOCU1_TRAIL_TO_BYTE(m)<<16; |
| |
| result|=BOCU1_MIN<<24; |
| } |
| } |
| return result; |
| } |
| |
| |
| static void |
| _Bocu1FromUnicodeWithOffsets(UConverterFromUnicodeArgs *pArgs, |
| UErrorCode *pErrorCode) { |
| UConverter *cnv; |
| const UChar *source, *sourceLimit; |
| uint8_t *target; |
| int32_t targetCapacity; |
| int32_t *offsets; |
| |
| int32_t prev, c, diff; |
| |
| int32_t sourceIndex, nextSourceIndex; |
| |
| U_ALIGN_CODE(16) |
| |
| /* set up the local pointers */ |
| cnv=pArgs->converter; |
| source=pArgs->source; |
| sourceLimit=pArgs->sourceLimit; |
| target=(uint8_t *)pArgs->target; |
| targetCapacity=(int32_t)(pArgs->targetLimit-pArgs->target); |
| offsets=pArgs->offsets; |
| |
| /* get the converter state from UConverter */ |
| c=cnv->fromUChar32; |
| prev=(int32_t)cnv->fromUnicodeStatus; |
| if(prev==0) { |
| prev=BOCU1_ASCII_PREV; |
| } |
| |
| /* sourceIndex=-1 if the current character began in the previous buffer */ |
| sourceIndex= c==0 ? 0 : -1; |
| nextSourceIndex=0; |
| |
| /* conversion loop */ |
| if(c!=0 && targetCapacity>0) { |
| goto getTrail; |
| } |
| |
| fastSingle: |
| /* fast loop for single-byte differences */ |
| /* use only one loop counter variable, targetCapacity, not also source */ |
| diff=(int32_t)(sourceLimit-source); |
| if(targetCapacity>diff) { |
| targetCapacity=diff; |
| } |
| while(targetCapacity>0 && (c=*source)<0x3000) { |
| if(c<=0x20) { |
| if(c!=0x20) { |
| prev=BOCU1_ASCII_PREV; |
| } |
| *target++=(uint8_t)c; |
| *offsets++=nextSourceIndex++; |
| ++source; |
| --targetCapacity; |
| } else { |
| diff=c-prev; |
| if(DIFF_IS_SINGLE(diff)) { |
| prev=BOCU1_SIMPLE_PREV(c); |
| *target++=(uint8_t)PACK_SINGLE_DIFF(diff); |
| *offsets++=nextSourceIndex++; |
| ++source; |
| --targetCapacity; |
| } else { |
| break; |
| } |
| } |
| } |
| /* restore real values */ |
| targetCapacity=(int32_t)((const uint8_t *)pArgs->targetLimit-target); |
| sourceIndex=nextSourceIndex; /* wrong if offsets==NULL but does not matter */ |
| |
| /* regular loop for all cases */ |
| while(source<sourceLimit) { |
| if(targetCapacity>0) { |
| c=*source++; |
| ++nextSourceIndex; |
| |
| if(c<=0x20) { |
| /* |
| * ISO C0 control & space: |
| * Encode directly for MIME compatibility, |
| * and reset state except for space, to not disrupt compression. |
| */ |
| if(c!=0x20) { |
| prev=BOCU1_ASCII_PREV; |
| } |
| *target++=(uint8_t)c; |
| *offsets++=sourceIndex; |
| --targetCapacity; |
| |
| sourceIndex=nextSourceIndex; |
| continue; |
| } |
| |
| if(U16_IS_LEAD(c)) { |
| getTrail: |
| if(source<sourceLimit) { |
| /* test the following code unit */ |
| UChar trail=*source; |
| if(U16_IS_TRAIL(trail)) { |
| ++source; |
| ++nextSourceIndex; |
| c=U16_GET_SUPPLEMENTARY(c, trail); |
| } |
| } else { |
| /* no more input */ |
| c=-c; /* negative lead surrogate as "incomplete" indicator to avoid c=0 everywhere else */ |
| break; |
| } |
| } |
| |
| /* |
| * all other Unicode code points c==U+0021..U+10ffff |
| * are encoded with the difference c-prev |
| * |
| * a new prev is computed from c, |
| * placed in the middle of a 0x80-block (for most small scripts) or |
| * in the middle of the Unihan and Hangul blocks |
| * to statistically minimize the following difference |
| */ |
| diff=c-prev; |
| prev=BOCU1_PREV(c); |
| if(DIFF_IS_SINGLE(diff)) { |
| *target++=(uint8_t)PACK_SINGLE_DIFF(diff); |
| *offsets++=sourceIndex; |
| --targetCapacity; |
| sourceIndex=nextSourceIndex; |
| if(c<0x3000) { |
| goto fastSingle; |
| } |
| } else if(DIFF_IS_DOUBLE(diff) && 2<=targetCapacity) { |
| /* optimize 2-byte case */ |
| int32_t m; |
| |
| if(diff>=0) { |
| diff-=BOCU1_REACH_POS_1+1; |
| m=diff%BOCU1_TRAIL_COUNT; |
| diff/=BOCU1_TRAIL_COUNT; |
| diff+=BOCU1_START_POS_2; |
| } else { |
| diff-=BOCU1_REACH_NEG_1; |
| NEGDIVMOD(diff, BOCU1_TRAIL_COUNT, m); |
| diff+=BOCU1_START_NEG_2; |
| } |
| *target++=(uint8_t)diff; |
| *target++=(uint8_t)BOCU1_TRAIL_TO_BYTE(m); |
| *offsets++=sourceIndex; |
| *offsets++=sourceIndex; |
| targetCapacity-=2; |
| sourceIndex=nextSourceIndex; |
| } else { |
| int32_t length; /* will be 2..4 */ |
| |
| diff=packDiff(diff); |
| length=BOCU1_LENGTH_FROM_PACKED(diff); |
| |
| /* write the output character bytes from diff and length */ |
| /* from the first if in the loop we know that targetCapacity>0 */ |
| if(length<=targetCapacity) { |
| switch(length) { |
| /* each branch falls through to the next one */ |
| case 4: |
| *target++=(uint8_t)(diff>>24); |
| *offsets++=sourceIndex; |
| case 3: /*fall through*/ |
| *target++=(uint8_t)(diff>>16); |
| *offsets++=sourceIndex; |
| case 2: /*fall through*/ |
| *target++=(uint8_t)(diff>>8); |
| *offsets++=sourceIndex; |
| /* case 1: handled above */ |
| *target++=(uint8_t)diff; |
| *offsets++=sourceIndex; |
| default: |
| /* will never occur */ |
| break; |
| } |
| targetCapacity-=length; |
| sourceIndex=nextSourceIndex; |
| } else { |
| uint8_t *charErrorBuffer; |
| |
| /* |
| * We actually do this backwards here: |
| * In order to save an intermediate variable, we output |
| * first to the overflow buffer what does not fit into the |
| * regular target. |
| */ |
| /* we know that 1<=targetCapacity<length<=4 */ |
| length-=targetCapacity; |
| charErrorBuffer=(uint8_t *)cnv->charErrorBuffer; |
| switch(length) { |
| /* each branch falls through to the next one */ |
| case 3: |
| *charErrorBuffer++=(uint8_t)(diff>>16); |
| case 2: /*fall through*/ |
| *charErrorBuffer++=(uint8_t)(diff>>8); |
| case 1: /*fall through*/ |
| *charErrorBuffer=(uint8_t)diff; |
| default: |
| /* will never occur */ |
| break; |
| } |
| cnv->charErrorBufferLength=(int8_t)length; |
| |
| /* now output what fits into the regular target */ |
| diff>>=8*length; /* length was reduced by targetCapacity */ |
| switch(targetCapacity) { |
| /* each branch falls through to the next one */ |
| case 3: |
| *target++=(uint8_t)(diff>>16); |
| *offsets++=sourceIndex; |
| case 2: /*fall through*/ |
| *target++=(uint8_t)(diff>>8); |
| *offsets++=sourceIndex; |
| case 1: /*fall through*/ |
| *target++=(uint8_t)diff; |
| *offsets++=sourceIndex; |
| default: |
| /* will never occur */ |
| break; |
| } |
| |
| /* target overflow */ |
| targetCapacity=0; |
| *pErrorCode=U_BUFFER_OVERFLOW_ERROR; |
| break; |
| } |
| } |
| } else { |
| /* target is full */ |
| *pErrorCode=U_BUFFER_OVERFLOW_ERROR; |
| break; |
| } |
| } |
| |
| /* set the converter state back into UConverter */ |
| cnv->fromUChar32= c<0 ? -c : 0; |
| cnv->fromUnicodeStatus=(uint32_t)prev; |
| |
| /* write back the updated pointers */ |
| pArgs->source=source; |
| pArgs->target=(char *)target; |
| pArgs->offsets=offsets; |
| } |
| |
| /* |
| * Identical to _Bocu1FromUnicodeWithOffsets but without offset handling. |
| * If a change is made in the original function, then either |
| * change this function the same way or |
| * re-copy the original function and remove the variables |
| * offsets, sourceIndex, and nextSourceIndex. |
| */ |
| static void |
| _Bocu1FromUnicode(UConverterFromUnicodeArgs *pArgs, |
| UErrorCode *pErrorCode) { |
| UConverter *cnv; |
| const UChar *source, *sourceLimit; |
| uint8_t *target; |
| int32_t targetCapacity; |
| |
| int32_t prev, c, diff; |
| |
| /* set up the local pointers */ |
| cnv=pArgs->converter; |
| source=pArgs->source; |
| sourceLimit=pArgs->sourceLimit; |
| target=(uint8_t *)pArgs->target; |
| targetCapacity=(int32_t)(pArgs->targetLimit-pArgs->target); |
| |
| /* get the converter state from UConverter */ |
| c=cnv->fromUChar32; |
| prev=(int32_t)cnv->fromUnicodeStatus; |
| if(prev==0) { |
| prev=BOCU1_ASCII_PREV; |
| } |
| |
| /* conversion loop */ |
| if(c!=0 && targetCapacity>0) { |
| goto getTrail; |
| } |
| |
| fastSingle: |
| /* fast loop for single-byte differences */ |
| /* use only one loop counter variable, targetCapacity, not also source */ |
| diff=(int32_t)(sourceLimit-source); |
| if(targetCapacity>diff) { |
| targetCapacity=diff; |
| } |
| while(targetCapacity>0 && (c=*source)<0x3000) { |
| if(c<=0x20) { |
| if(c!=0x20) { |
| prev=BOCU1_ASCII_PREV; |
| } |
| *target++=(uint8_t)c; |
| } else { |
| diff=c-prev; |
| if(DIFF_IS_SINGLE(diff)) { |
| prev=BOCU1_SIMPLE_PREV(c); |
| *target++=(uint8_t)PACK_SINGLE_DIFF(diff); |
| } else { |
| break; |
| } |
| } |
| ++source; |
| --targetCapacity; |
| } |
| /* restore real values */ |
| targetCapacity=(int32_t)((const uint8_t *)pArgs->targetLimit-target); |
| |
| /* regular loop for all cases */ |
| while(source<sourceLimit) { |
| if(targetCapacity>0) { |
| c=*source++; |
| |
| if(c<=0x20) { |
| /* |
| * ISO C0 control & space: |
| * Encode directly for MIME compatibility, |
| * and reset state except for space, to not disrupt compression. |
| */ |
| if(c!=0x20) { |
| prev=BOCU1_ASCII_PREV; |
| } |
| *target++=(uint8_t)c; |
| --targetCapacity; |
| continue; |
| } |
| |
| if(U16_IS_LEAD(c)) { |
| getTrail: |
| if(source<sourceLimit) { |
| /* test the following code unit */ |
| UChar trail=*source; |
| if(U16_IS_TRAIL(trail)) { |
| ++source; |
| c=U16_GET_SUPPLEMENTARY(c, trail); |
| } |
| } else { |
| /* no more input */ |
| c=-c; /* negative lead surrogate as "incomplete" indicator to avoid c=0 everywhere else */ |
| break; |
| } |
| } |
| |
| /* |
| * all other Unicode code points c==U+0021..U+10ffff |
| * are encoded with the difference c-prev |
| * |
| * a new prev is computed from c, |
| * placed in the middle of a 0x80-block (for most small scripts) or |
| * in the middle of the Unihan and Hangul blocks |
| * to statistically minimize the following difference |
| */ |
| diff=c-prev; |
| prev=BOCU1_PREV(c); |
| if(DIFF_IS_SINGLE(diff)) { |
| *target++=(uint8_t)PACK_SINGLE_DIFF(diff); |
| --targetCapacity; |
| if(c<0x3000) { |
| goto fastSingle; |
| } |
| } else if(DIFF_IS_DOUBLE(diff) && 2<=targetCapacity) { |
| /* optimize 2-byte case */ |
| int32_t m; |
| |
| if(diff>=0) { |
| diff-=BOCU1_REACH_POS_1+1; |
| m=diff%BOCU1_TRAIL_COUNT; |
| diff/=BOCU1_TRAIL_COUNT; |
| diff+=BOCU1_START_POS_2; |
| } else { |
| diff-=BOCU1_REACH_NEG_1; |
| NEGDIVMOD(diff, BOCU1_TRAIL_COUNT, m); |
| diff+=BOCU1_START_NEG_2; |
| } |
| *target++=(uint8_t)diff; |
| *target++=(uint8_t)BOCU1_TRAIL_TO_BYTE(m); |
| targetCapacity-=2; |
| } else { |
| int32_t length; /* will be 2..4 */ |
| |
| diff=packDiff(diff); |
| length=BOCU1_LENGTH_FROM_PACKED(diff); |
| |
| /* write the output character bytes from diff and length */ |
| /* from the first if in the loop we know that targetCapacity>0 */ |
| if(length<=targetCapacity) { |
| switch(length) { |
| /* each branch falls through to the next one */ |
| case 4: |
| *target++=(uint8_t)(diff>>24); |
| case 3: /*fall through*/ |
| *target++=(uint8_t)(diff>>16); |
| /* case 2: handled above */ |
| *target++=(uint8_t)(diff>>8); |
| /* case 1: handled above */ |
| *target++=(uint8_t)diff; |
| default: |
| /* will never occur */ |
| break; |
| } |
| targetCapacity-=length; |
| } else { |
| uint8_t *charErrorBuffer; |
| |
| /* |
| * We actually do this backwards here: |
| * In order to save an intermediate variable, we output |
| * first to the overflow buffer what does not fit into the |
| * regular target. |
| */ |
| /* we know that 1<=targetCapacity<length<=4 */ |
| length-=targetCapacity; |
| charErrorBuffer=(uint8_t *)cnv->charErrorBuffer; |
| switch(length) { |
| /* each branch falls through to the next one */ |
| case 3: |
| *charErrorBuffer++=(uint8_t)(diff>>16); |
| case 2: /*fall through*/ |
| *charErrorBuffer++=(uint8_t)(diff>>8); |
| case 1: /*fall through*/ |
| *charErrorBuffer=(uint8_t)diff; |
| default: |
| /* will never occur */ |
| break; |
| } |
| cnv->charErrorBufferLength=(int8_t)length; |
| |
| /* now output what fits into the regular target */ |
| diff>>=8*length; /* length was reduced by targetCapacity */ |
| switch(targetCapacity) { |
| /* each branch falls through to the next one */ |
| case 3: |
| *target++=(uint8_t)(diff>>16); |
| case 2: /*fall through*/ |
| *target++=(uint8_t)(diff>>8); |
| case 1: /*fall through*/ |
| *target++=(uint8_t)diff; |
| default: |
| /* will never occur */ |
| break; |
| } |
| |
| /* target overflow */ |
| targetCapacity=0; |
| *pErrorCode=U_BUFFER_OVERFLOW_ERROR; |
| break; |
| } |
| } |
| } else { |
| /* target is full */ |
| *pErrorCode=U_BUFFER_OVERFLOW_ERROR; |
| break; |
| } |
| } |
| |
| /* set the converter state back into UConverter */ |
| cnv->fromUChar32= c<0 ? -c : 0; |
| cnv->fromUnicodeStatus=(uint32_t)prev; |
| |
| /* write back the updated pointers */ |
| pArgs->source=source; |
| pArgs->target=(char *)target; |
| } |
| |
| /* BOCU-1-to-Unicode conversion functions ----------------------------------- */ |
| |
| /** |
| * Function for BOCU-1 decoder; handles multi-byte lead bytes. |
| * |
| * @param b lead byte; |
| * BOCU1_MIN<=b<BOCU1_START_NEG_2 or BOCU1_START_POS_2<=b<BOCU1_MAX_LEAD |
| * @return (diff<<2)|count |
| */ |
| static inline int32_t |
| decodeBocu1LeadByte(int32_t b) { |
| int32_t diff, count; |
| |
| if(b>=BOCU1_START_NEG_2) { |
| /* positive difference */ |
| if(b<BOCU1_START_POS_3) { |
| /* two bytes */ |
| diff=((int32_t)b-BOCU1_START_POS_2)*BOCU1_TRAIL_COUNT+BOCU1_REACH_POS_1+1; |
| count=1; |
| } else if(b<BOCU1_START_POS_4) { |
| /* three bytes */ |
| diff=((int32_t)b-BOCU1_START_POS_3)*BOCU1_TRAIL_COUNT*BOCU1_TRAIL_COUNT+BOCU1_REACH_POS_2+1; |
| count=2; |
| } else { |
| /* four bytes */ |
| diff=BOCU1_REACH_POS_3+1; |
| count=3; |
| } |
| } else { |
| /* negative difference */ |
| if(b>=BOCU1_START_NEG_3) { |
| /* two bytes */ |
| diff=((int32_t)b-BOCU1_START_NEG_2)*BOCU1_TRAIL_COUNT+BOCU1_REACH_NEG_1; |
| count=1; |
| } else if(b>BOCU1_MIN) { |
| /* three bytes */ |
| diff=((int32_t)b-BOCU1_START_NEG_3)*BOCU1_TRAIL_COUNT*BOCU1_TRAIL_COUNT+BOCU1_REACH_NEG_2; |
| count=2; |
| } else { |
| /* four bytes */ |
| diff=-BOCU1_TRAIL_COUNT*BOCU1_TRAIL_COUNT*BOCU1_TRAIL_COUNT+BOCU1_REACH_NEG_3; |
| count=3; |
| } |
| } |
| |
| /* return the state for decoding the trail byte(s) */ |
| return (diff<<2)|count; |
| } |
| |
| /** |
| * Function for BOCU-1 decoder; handles multi-byte trail bytes. |
| * |
| * @param count number of remaining trail bytes including this one |
| * @param b trail byte |
| * @return new delta for diff including b - <0 indicates an error |
| * |
| * @see decodeBocu1 |
| */ |
| static inline int32_t |
| decodeBocu1TrailByte(int32_t count, int32_t b) { |
| if(b<=0x20) { |
| /* skip some C0 controls and make the trail byte range contiguous */ |
| b=bocu1ByteToTrail[b]; |
| /* b<0 for an illegal trail byte value will result in return<0 below */ |
| #if BOCU1_MAX_TRAIL<0xff |
| } else if(b>BOCU1_MAX_TRAIL) { |
| return -99; |
| #endif |
| } else { |
| b-=BOCU1_TRAIL_BYTE_OFFSET; |
| } |
| |
| /* add trail byte into difference and decrement count */ |
| if(count==1) { |
| return b; |
| } else if(count==2) { |
| return b*BOCU1_TRAIL_COUNT; |
| } else /* count==3 */ { |
| return b*(BOCU1_TRAIL_COUNT*BOCU1_TRAIL_COUNT); |
| } |
| } |
| |
| static void |
| _Bocu1ToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs, |
| UErrorCode *pErrorCode) { |
| UConverter *cnv; |
| const uint8_t *source, *sourceLimit; |
| UChar *target; |
| const UChar *targetLimit; |
| int32_t *offsets; |
| |
| int32_t prev, count, diff, c; |
| |
| int8_t byteIndex; |
| uint8_t *bytes; |
| |
| int32_t sourceIndex, nextSourceIndex; |
| |
| /* set up the local pointers */ |
| cnv=pArgs->converter; |
| source=(const uint8_t *)pArgs->source; |
| sourceLimit=(const uint8_t *)pArgs->sourceLimit; |
| target=pArgs->target; |
| targetLimit=pArgs->targetLimit; |
| offsets=pArgs->offsets; |
| |
| /* get the converter state from UConverter */ |
| prev=(int32_t)cnv->toUnicodeStatus; |
| if(prev==0) { |
| prev=BOCU1_ASCII_PREV; |
| } |
| diff=cnv->mode; /* mode may be set to UCNV_SI by ucnv_bld.c but then toULength==0 */ |
| count=diff&3; |
| diff>>=2; |
| |
| byteIndex=cnv->toULength; |
| bytes=cnv->toUBytes; |
| |
| /* sourceIndex=-1 if the current character began in the previous buffer */ |
| sourceIndex=byteIndex==0 ? 0 : -1; |
| nextSourceIndex=0; |
| |
| /* conversion "loop" similar to _SCSUToUnicodeWithOffsets() */ |
| if(count>0 && byteIndex>0 && target<targetLimit) { |
| goto getTrail; |
| } |
| |
| fastSingle: |
| /* fast loop for single-byte differences */ |
| /* use count as the only loop counter variable */ |
| diff=(int32_t)(sourceLimit-source); |
| count=(int32_t)(pArgs->targetLimit-target); |
| if(count>diff) { |
| count=diff; |
| } |
| while(count>0) { |
| if(BOCU1_START_NEG_2<=(c=*source) && c<BOCU1_START_POS_2) { |
| c=prev+(c-BOCU1_MIDDLE); |
| if(c<0x3000) { |
| *target++=(UChar)c; |
| *offsets++=nextSourceIndex++; |
| prev=BOCU1_SIMPLE_PREV(c); |
| } else { |
| break; |
| } |
| } else if(c<=0x20) { |
| if(c!=0x20) { |
| prev=BOCU1_ASCII_PREV; |
| } |
| *target++=(UChar)c; |
| *offsets++=nextSourceIndex++; |
| } else { |
| break; |
| } |
| ++source; |
| --count; |
| } |
| sourceIndex=nextSourceIndex; /* wrong if offsets==NULL but does not matter */ |
| |
| /* decode a sequence of single and lead bytes */ |
| while(source<sourceLimit) { |
| if(target>=targetLimit) { |
| /* target is full */ |
| *pErrorCode=U_BUFFER_OVERFLOW_ERROR; |
| break; |
| } |
| |
| ++nextSourceIndex; |
| c=*source++; |
| if(BOCU1_START_NEG_2<=c && c<BOCU1_START_POS_2) { |
| /* Write a code point directly from a single-byte difference. */ |
| c=prev+(c-BOCU1_MIDDLE); |
| if(c<0x3000) { |
| *target++=(UChar)c; |
| *offsets++=sourceIndex; |
| prev=BOCU1_SIMPLE_PREV(c); |
| sourceIndex=nextSourceIndex; |
| goto fastSingle; |
| } |
| } else if(c<=0x20) { |
| /* |
| * Direct-encoded C0 control code or space. |
| * Reset prev for C0 control codes but not for space. |
| */ |
| if(c!=0x20) { |
| prev=BOCU1_ASCII_PREV; |
| } |
| *target++=(UChar)c; |
| *offsets++=sourceIndex; |
| sourceIndex=nextSourceIndex; |
| continue; |
| } else if(BOCU1_START_NEG_3<=c && c<BOCU1_START_POS_3 && source<sourceLimit) { |
| /* Optimize two-byte case. */ |
| if(c>=BOCU1_MIDDLE) { |
| diff=((int32_t)c-BOCU1_START_POS_2)*BOCU1_TRAIL_COUNT+BOCU1_REACH_POS_1+1; |
| } else { |
| diff=((int32_t)c-BOCU1_START_NEG_2)*BOCU1_TRAIL_COUNT+BOCU1_REACH_NEG_1; |
| } |
| |
| /* trail byte */ |
| ++nextSourceIndex; |
| c=decodeBocu1TrailByte(1, *source++); |
| if(c<0 || (uint32_t)(c=prev+diff+c)>0x10ffff) { |
| bytes[0]=source[-2]; |
| bytes[1]=source[-1]; |
| byteIndex=2; |
| *pErrorCode=U_ILLEGAL_CHAR_FOUND; |
| break; |
| } |
| } else if(c==BOCU1_RESET) { |
| /* only reset the state, no code point */ |
| prev=BOCU1_ASCII_PREV; |
| sourceIndex=nextSourceIndex; |
| continue; |
| } else { |
| /* |
| * For multi-byte difference lead bytes, set the decoder state |
| * with the partial difference value from the lead byte and |
| * with the number of trail bytes. |
| */ |
| bytes[0]=(uint8_t)c; |
| byteIndex=1; |
| |
| diff=decodeBocu1LeadByte(c); |
| count=diff&3; |
| diff>>=2; |
| getTrail: |
| for(;;) { |
| if(source>=sourceLimit) { |
| goto endloop; |
| } |
| ++nextSourceIndex; |
| c=bytes[byteIndex++]=*source++; |
| |
| /* trail byte in any position */ |
| c=decodeBocu1TrailByte(count, c); |
| if(c<0) { |
| *pErrorCode=U_ILLEGAL_CHAR_FOUND; |
| goto endloop; |
| } |
| |
| diff+=c; |
| if(--count==0) { |
| /* final trail byte, deliver a code point */ |
| byteIndex=0; |
| c=prev+diff; |
| if((uint32_t)c>0x10ffff) { |
| *pErrorCode=U_ILLEGAL_CHAR_FOUND; |
| goto endloop; |
| } |
| break; |
| } |
| } |
| } |
| |
| /* calculate the next prev and output c */ |
| prev=BOCU1_PREV(c); |
| if(c<=0xffff) { |
| *target++=(UChar)c; |
| *offsets++=sourceIndex; |
| } else { |
| /* output surrogate pair */ |
| *target++=U16_LEAD(c); |
| if(target<targetLimit) { |
| *target++=U16_TRAIL(c); |
| *offsets++=sourceIndex; |
| *offsets++=sourceIndex; |
| } else { |
| /* target overflow */ |
| *offsets++=sourceIndex; |
| cnv->UCharErrorBuffer[0]=U16_TRAIL(c); |
| cnv->UCharErrorBufferLength=1; |
| *pErrorCode=U_BUFFER_OVERFLOW_ERROR; |
| break; |
| } |
| } |
| sourceIndex=nextSourceIndex; |
| } |
| endloop: |
| |
| if(*pErrorCode==U_ILLEGAL_CHAR_FOUND) { |
| /* set the converter state in UConverter to deal with the next character */ |
| cnv->toUnicodeStatus=BOCU1_ASCII_PREV; |
| cnv->mode=0; |
| } else { |
| /* set the converter state back into UConverter */ |
| cnv->toUnicodeStatus=(uint32_t)prev; |
| cnv->mode=(diff<<2)|count; |
| } |
| cnv->toULength=byteIndex; |
| |
| /* write back the updated pointers */ |
| pArgs->source=(const char *)source; |
| pArgs->target=target; |
| pArgs->offsets=offsets; |
| return; |
| } |
| |
| /* |
| * Identical to _Bocu1ToUnicodeWithOffsets but without offset handling. |
| * If a change is made in the original function, then either |
| * change this function the same way or |
| * re-copy the original function and remove the variables |
| * offsets, sourceIndex, and nextSourceIndex. |
| */ |
| static void |
| _Bocu1ToUnicode(UConverterToUnicodeArgs *pArgs, |
| UErrorCode *pErrorCode) { |
| UConverter *cnv; |
| const uint8_t *source, *sourceLimit; |
| UChar *target; |
| const UChar *targetLimit; |
| |
| int32_t prev, count, diff, c; |
| |
| int8_t byteIndex; |
| uint8_t *bytes; |
| |
| U_ALIGN_CODE(16) |
| |
| /* set up the local pointers */ |
| cnv=pArgs->converter; |
| source=(const uint8_t *)pArgs->source; |
| sourceLimit=(const uint8_t *)pArgs->sourceLimit; |
| target=pArgs->target; |
| targetLimit=pArgs->targetLimit; |
| |
| /* get the converter state from UConverter */ |
| prev=(int32_t)cnv->toUnicodeStatus; |
| if(prev==0) { |
| prev=BOCU1_ASCII_PREV; |
| } |
| diff=cnv->mode; /* mode may be set to UCNV_SI by ucnv_bld.c but then toULength==0 */ |
| count=diff&3; |
| diff>>=2; |
| |
| byteIndex=cnv->toULength; |
| bytes=cnv->toUBytes; |
| |
| /* conversion "loop" similar to _SCSUToUnicodeWithOffsets() */ |
| if(count>0 && byteIndex>0 && target<targetLimit) { |
| goto getTrail; |
| } |
| |
| fastSingle: |
| /* fast loop for single-byte differences */ |
| /* use count as the only loop counter variable */ |
| diff=(int32_t)(sourceLimit-source); |
| count=(int32_t)(pArgs->targetLimit-target); |
| if(count>diff) { |
| count=diff; |
| } |
| while(count>0) { |
| if(BOCU1_START_NEG_2<=(c=*source) && c<BOCU1_START_POS_2) { |
| c=prev+(c-BOCU1_MIDDLE); |
| if(c<0x3000) { |
| *target++=(UChar)c; |
| prev=BOCU1_SIMPLE_PREV(c); |
| } else { |
| break; |
| } |
| } else if(c<=0x20) { |
| if(c!=0x20) { |
| prev=BOCU1_ASCII_PREV; |
| } |
| *target++=(UChar)c; |
| } else { |
| break; |
| } |
| ++source; |
| --count; |
| } |
| |
| /* decode a sequence of single and lead bytes */ |
| while(source<sourceLimit) { |
| if(target>=targetLimit) { |
| /* target is full */ |
| *pErrorCode=U_BUFFER_OVERFLOW_ERROR; |
| break; |
| } |
| |
| c=*source++; |
| if(BOCU1_START_NEG_2<=c && c<BOCU1_START_POS_2) { |
| /* Write a code point directly from a single-byte difference. */ |
| c=prev+(c-BOCU1_MIDDLE); |
| if(c<0x3000) { |
| *target++=(UChar)c; |
| prev=BOCU1_SIMPLE_PREV(c); |
| goto fastSingle; |
| } |
| } else if(c<=0x20) { |
| /* |
| * Direct-encoded C0 control code or space. |
| * Reset prev for C0 control codes but not for space. |
| */ |
| if(c!=0x20) { |
| prev=BOCU1_ASCII_PREV; |
| } |
| *target++=(UChar)c; |
| continue; |
| } else if(BOCU1_START_NEG_3<=c && c<BOCU1_START_POS_3 && source<sourceLimit) { |
| /* Optimize two-byte case. */ |
| if(c>=BOCU1_MIDDLE) { |
| diff=((int32_t)c-BOCU1_START_POS_2)*BOCU1_TRAIL_COUNT+BOCU1_REACH_POS_1+1; |
| } else { |
| diff=((int32_t)c-BOCU1_START_NEG_2)*BOCU1_TRAIL_COUNT+BOCU1_REACH_NEG_1; |
| } |
| |
| /* trail byte */ |
| c=decodeBocu1TrailByte(1, *source++); |
| if(c<0 || (uint32_t)(c=prev+diff+c)>0x10ffff) { |
| bytes[0]=source[-2]; |
| bytes[1]=source[-1]; |
| byteIndex=2; |
| *pErrorCode=U_ILLEGAL_CHAR_FOUND; |
| break; |
| } |
| } else if(c==BOCU1_RESET) { |
| /* only reset the state, no code point */ |
| prev=BOCU1_ASCII_PREV; |
| continue; |
| } else { |
| /* |
| * For multi-byte difference lead bytes, set the decoder state |
| * with the partial difference value from the lead byte and |
| * with the number of trail bytes. |
| */ |
| bytes[0]=(uint8_t)c; |
| byteIndex=1; |
| |
| diff=decodeBocu1LeadByte(c); |
| count=diff&3; |
| diff>>=2; |
| getTrail: |
| for(;;) { |
| if(source>=sourceLimit) { |
| goto endloop; |
| } |
| c=bytes[byteIndex++]=*source++; |
| |
| /* trail byte in any position */ |
| c=decodeBocu1TrailByte(count, c); |
| if(c<0) { |
| *pErrorCode=U_ILLEGAL_CHAR_FOUND; |
| goto endloop; |
| } |
| |
| diff+=c; |
| if(--count==0) { |
| /* final trail byte, deliver a code point */ |
| byteIndex=0; |
| c=prev+diff; |
| if((uint32_t)c>0x10ffff) { |
| *pErrorCode=U_ILLEGAL_CHAR_FOUND; |
| goto endloop; |
| } |
| break; |
| } |
| } |
| } |
| |
| /* calculate the next prev and output c */ |
| prev=BOCU1_PREV(c); |
| if(c<=0xffff) { |
| *target++=(UChar)c; |
| } else { |
| /* output surrogate pair */ |
| *target++=U16_LEAD(c); |
| if(target<targetLimit) { |
| *target++=U16_TRAIL(c); |
| } else { |
| /* target overflow */ |
| cnv->UCharErrorBuffer[0]=U16_TRAIL(c); |
| cnv->UCharErrorBufferLength=1; |
| *pErrorCode=U_BUFFER_OVERFLOW_ERROR; |
| break; |
| } |
| } |
| } |
| endloop: |
| |
| if(*pErrorCode==U_ILLEGAL_CHAR_FOUND) { |
| /* set the converter state in UConverter to deal with the next character */ |
| cnv->toUnicodeStatus=BOCU1_ASCII_PREV; |
| cnv->mode=0; |
| } else { |
| /* set the converter state back into UConverter */ |
| cnv->toUnicodeStatus=(uint32_t)prev; |
| cnv->mode=(diff<<2)|count; |
| } |
| cnv->toULength=byteIndex; |
| |
| /* write back the updated pointers */ |
| pArgs->source=(const char *)source; |
| pArgs->target=target; |
| return; |
| } |
| |
| /* miscellaneous ------------------------------------------------------------ */ |
| |
| static const UConverterImpl _Bocu1Impl={ |
| UCNV_BOCU1, |
| |
| NULL, |
| NULL, |
| |
| NULL, |
| NULL, |
| NULL, |
| |
| _Bocu1ToUnicode, |
| _Bocu1ToUnicodeWithOffsets, |
| _Bocu1FromUnicode, |
| _Bocu1FromUnicodeWithOffsets, |
| NULL, |
| |
| NULL, |
| NULL, |
| NULL, |
| NULL, |
| ucnv_getCompleteUnicodeSet, |
| |
| NULL, |
| NULL |
| }; |
| |
| static const UConverterStaticData _Bocu1StaticData={ |
| sizeof(UConverterStaticData), |
| "BOCU-1", |
| 1214, /* CCSID for BOCU-1 */ |
| UCNV_IBM, UCNV_BOCU1, |
| 1, 4, /* one UChar generates at least 1 byte and at most 4 bytes */ |
| { 0x1a, 0, 0, 0 }, 1, /* BOCU-1 never needs to write a subchar */ |
| FALSE, FALSE, |
| 0, |
| 0, |
| { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 } /* reserved */ |
| }; |
| |
| const UConverterSharedData _Bocu1Data={ |
| sizeof(UConverterSharedData), ~((uint32_t)0), |
| NULL, NULL, &_Bocu1StaticData, FALSE, &_Bocu1Impl, |
| 0, |
| UCNV_MBCS_TABLE_INITIALIZER |
| }; |
| |
| #endif |
