CharsetBOCU1.java
// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*
*******************************************************************************
* Copyright (C) 2008-2011, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
package com.ibm.icu.charset;
import com.ibm.icu.lang.UCharacter;
import com.ibm.icu.text.UTF16;
import com.ibm.icu.text.UnicodeSet;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.IntBuffer;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CharsetEncoder;
import java.nio.charset.CoderResult;
/**
* @author krajwade
*/
class CharsetBOCU1 extends CharsetICU {
/* BOCU constants and macros */
/* initial value for "prev": middle of the ASCII range */
private static final byte BOCU1_ASCII_PREV = 0x40;
/* bounding byte values for differences */
private static final int BOCU1_MIN = 0x21;
private static final int BOCU1_MIDDLE = 0x90;
// private static final int BOCU1_MAX_LEAD = 0xfe;
private static final int BOCU1_MAX_TRAIL = 0xff;
private static final int BOCU1_RESET = 0xff;
/* number of lead bytes */
// private static final int BOCU1_COUNT = (BOCU1_MAX_LEAD-BOCU1_MIN+1);
/* adjust trail byte counts for the use of some C0 control byte values */
private static final int BOCU1_TRAIL_CONTROLS_COUNT = 20;
private static final int BOCU1_TRAIL_BYTE_OFFSET = (BOCU1_MIN - BOCU1_TRAIL_CONTROLS_COUNT);
/* number of trail bytes */
private static final int 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)
*/
private static final int BOCU1_SINGLE = 64;
/* number of lead bytes for positive and negative 2/3/4-byte sequences */
private static final int BOCU1_LEAD_2 = 43;
private static final int BOCU1_LEAD_3 = 3;
// private static final int BOCU1_LEAD_4 = 1;
/* The difference value range for single-byters. */
private static final int BOCU1_REACH_POS_1 = (BOCU1_SINGLE - 1);
private static final int BOCU1_REACH_NEG_1 = (-BOCU1_SINGLE);
/* The difference value range for double-byters. */
private static final int BOCU1_REACH_POS_2 =
(BOCU1_REACH_POS_1 + BOCU1_LEAD_2 * BOCU1_TRAIL_COUNT);
private static final int BOCU1_REACH_NEG_2 =
(BOCU1_REACH_NEG_1 - BOCU1_LEAD_2 * BOCU1_TRAIL_COUNT);
/* The difference value range for 3-byters. */
private static final int BOCU1_REACH_POS_3 =
(BOCU1_REACH_POS_2 + BOCU1_LEAD_3 * BOCU1_TRAIL_COUNT * BOCU1_TRAIL_COUNT);
private static final int BOCU1_REACH_NEG_3 =
(BOCU1_REACH_NEG_2 - BOCU1_LEAD_3 * BOCU1_TRAIL_COUNT * BOCU1_TRAIL_COUNT);
/* The lead byte start values. */
private static final int BOCU1_START_POS_2 = (BOCU1_MIDDLE + BOCU1_REACH_POS_1 + 1);
private static final int BOCU1_START_POS_3 = (BOCU1_START_POS_2 + BOCU1_LEAD_2);
private static final int BOCU1_START_POS_4 = (BOCU1_START_POS_3 + BOCU1_LEAD_3);
/* ==BOCU1_MAX_LEAD */
private static final int BOCU1_START_NEG_2 = (BOCU1_MIDDLE + BOCU1_REACH_NEG_1);
private static final int BOCU1_START_NEG_3 = (BOCU1_START_NEG_2 - BOCU1_LEAD_2);
// private static final int 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). */
/* private static int BOCU1_LENGTH_FROM_LEAD(int lead) {
return ((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. */
private static int BOCU1_LENGTH_FROM_PACKED(int packed) {
return (((packed) & UConverterConstants.UNSIGNED_INT_MASK) < 0x04000000
? (packed) >> 24
: 4);
}
/*
* 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.
*/
private static final int[] bocu1ByteToTrail = {
/* 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.
*/
private static final int[] bocu1TrailToByte = {
/* 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
};
/*
* 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).
*/
private static int BOCU1_TRAIL_TO_BYTE(int trail) {
return ((trail) >= BOCU1_TRAIL_CONTROLS_COUNT
? (trail) + BOCU1_TRAIL_BYTE_OFFSET
: bocu1TrailToByte[trail]);
}
/* BOCU-1 implementation functions ------------------------------------------ */
private static int BOCU1_SIMPLE_PREV(int c) {
return (((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
*/
private static int bocu1Prev(int 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. */
private static int BOCU1_PREV(int c) {
return ((c) < 0x3040 || (c) > 0xd7a3 ? BOCU1_SIMPLE_PREV(c) : bocu1Prev(c));
}
protected byte[] fromUSubstitution = new byte[] {(byte) 0x1A};
/* Faster versions of packDiff() for single-byte-encoded diff values. */
/** Is a diff value encodable in a single byte? */
private static boolean DIFF_IS_SINGLE(int diff) {
return (BOCU1_REACH_NEG_1 <= (diff) && (diff) <= BOCU1_REACH_POS_1);
}
/** Encode a diff value in a single byte. */
private static int PACK_SINGLE_DIFF(int diff) {
return (BOCU1_MIDDLE + (diff));
}
/** Is a diff value encodable in two bytes? */
private static boolean DIFF_IS_DOUBLE(int diff) {
return (BOCU1_REACH_NEG_2 <= (diff) && (diff) <= BOCU1_REACH_POS_2);
}
public CharsetBOCU1(String icuCanonicalName, String javaCanonicalName, String[] aliases) {
super(icuCanonicalName, javaCanonicalName, aliases);
maxBytesPerChar = 4;
minBytesPerChar = 1;
maxCharsPerByte = 1;
}
class CharsetEncoderBOCU extends CharsetEncoderICU {
public CharsetEncoderBOCU(CharsetICU cs) {
super(cs, fromUSubstitution);
}
int sourceIndex, nextSourceIndex;
int prev, c, diff;
boolean checkNegative;
boolean LoopAfterTrail;
int targetCapacity;
CoderResult cr;
/* label values for supporting behavior similar to goto in C */
private static final int fastSingle = 0;
private static final int getTrail = 1;
private static final int regularLoop = 2;
private boolean LabelLoop; // used to break the while loop
private int labelType =
fastSingle; // labeType is set to fastSingle to start the code from fastSingle:
/**
* 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.
*
* <p>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).
*/
private int NEGDIVMOD(int n, int d, int m) {
diff = n;
(m) = (diff) % (d);
(diff) /= (d);
if ((m) < 0) {
--(diff);
(m) += (d);
}
return m;
}
/**
* Encode a difference -0x10ffff..0x10ffff in 1..4 bytes and return a packed integer with
* them.
*
* <p>The encoding favors small absolute differences with short encodings to compress runs
* of same-script characters.
*
* <p>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)
*/
private int packDiff(int n) {
int result, m = 0;
diff = n;
if (diff >= BOCU1_REACH_NEG_1) {
/* mostly positive differences, and single-byte negative ones */
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 |= ((BOCU1_START_POS_4 & UConverterConstants.UNSIGNED_INT_MASK)) << 24;
}
} else {
/* two- to four-byte negative differences */
if (diff >= BOCU1_REACH_NEG_2) {
/* two bytes */
diff -= BOCU1_REACH_NEG_1;
result = 0x02000000;
m = 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;
m = NEGDIVMOD(diff, BOCU1_TRAIL_COUNT, m);
result |= BOCU1_TRAIL_TO_BYTE(m);
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;
m = NEGDIVMOD(diff, BOCU1_TRAIL_COUNT, m);
result = BOCU1_TRAIL_TO_BYTE(m);
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;
}
@Override
protected CoderResult encodeLoop(
CharBuffer source, ByteBuffer target, IntBuffer offsets, boolean flush) {
cr = CoderResult.UNDERFLOW;
LabelLoop = true; // used to break the while loop
checkNegative = false; // its value is set to true to get out of while loop when c = -c
LoopAfterTrail = false; // its value is set to true to ignore code before getTrail:
/*set up the local pointers*/
targetCapacity = target.limit() - target.position();
c = fromUChar32;
prev = 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) {
labelType = getTrail;
}
while (LabelLoop) {
switch (labelType) {
case fastSingle:
labelType = fastSingle(source, target, offsets);
break;
case getTrail:
labelType = getTrail(source, target, offsets);
break;
case regularLoop:
labelType = regularLoop(source, target, offsets);
break;
}
}
return cr;
}
private int fastSingle(CharBuffer source, ByteBuffer target, IntBuffer offsets) {
// fastSingle:
/*fast loop for single-byte differences*/
/*use only one loop counter variable , targetCapacity, not also source*/
diff = source.limit() - source.position();
if (targetCapacity > diff) {
targetCapacity = diff;
}
while (targetCapacity > 0 && (c = source.get(source.position())) < 0x3000) {
if (c <= 0x20) {
if (c != 0x20) {
prev = BOCU1_ASCII_PREV;
}
target.put((byte) c);
if (offsets != null) {
offsets.put(nextSourceIndex++);
}
source.position(source.position() + 1);
--targetCapacity;
} else {
diff = c - prev;
if (DIFF_IS_SINGLE(diff)) {
prev = BOCU1_SIMPLE_PREV(c);
target.put((byte) PACK_SINGLE_DIFF(diff));
if (offsets != null) {
offsets.put(nextSourceIndex++);
}
source.position(source.position() + 1);
--targetCapacity;
} else {
break;
}
}
}
return regularLoop;
}
private int getTrail(CharBuffer source, ByteBuffer target, IntBuffer offsets) {
if (source.hasRemaining()) {
/*test the following code unit*/
char trail = source.get(source.position());
if (UTF16.isTrailSurrogate(trail)) {
source.position(source.position() + 1);
++nextSourceIndex;
c = UCharacter.getCodePoint(c, trail);
}
} else {
/*no more input*/
c =
-c; /*negative lead surrogate as "incomplete" indicator to avoid c=0 everywhere else*/
checkNegative = true;
}
LoopAfterTrail = true;
return regularLoop;
}
@SuppressWarnings("fallthrough")
private int regularLoop(CharBuffer source, ByteBuffer target, IntBuffer offsets) {
if (!LoopAfterTrail) {
/*restore real values*/
targetCapacity = target.limit() - target.position();
sourceIndex = nextSourceIndex; /*wrong if offsets==null but does not matter*/
}
/*regular loop for all classes*/
while (LoopAfterTrail || source.hasRemaining()) {
if (LoopAfterTrail || targetCapacity > 0) {
if (!LoopAfterTrail) {
c = source.get();
++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.put((byte) c);
if (offsets != null) {
offsets.put(sourceIndex++);
}
--targetCapacity;
sourceIndex = nextSourceIndex;
continue;
}
if (UTF16.isLeadSurrogate(c)) {
getTrail(source, target, offsets);
if (checkNegative) {
break;
}
}
}
if (LoopAfterTrail) {
LoopAfterTrail = false;
}
/*
* 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.put((byte) PACK_SINGLE_DIFF(diff));
if (offsets != null) {
offsets.put(sourceIndex++);
}
--targetCapacity;
sourceIndex = nextSourceIndex;
if (c < 0x3000) {
labelType = fastSingle;
return labelType;
}
} else if (DIFF_IS_DOUBLE(diff) && 2 <= targetCapacity) {
/*optimize 2 byte case*/
int m = 0;
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;
m = NEGDIVMOD(diff, BOCU1_TRAIL_COUNT, m);
diff += BOCU1_START_NEG_2;
}
target.put((byte) diff);
target.put((byte) BOCU1_TRAIL_TO_BYTE(m));
if (offsets != null) {
offsets.put(sourceIndex);
offsets.put(sourceIndex);
}
targetCapacity -= 2;
sourceIndex = nextSourceIndex;
} else {
int 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 the next one*/
case 4:
target.put((byte) (diff >> 24));
if (offsets != null) {
offsets.put(sourceIndex);
}
case 3:
target.put((byte) (diff >> 16));
if (offsets != null) {
offsets.put(sourceIndex);
}
case 2:
target.put((byte) (diff >> 8));
if (offsets != null) {
offsets.put(sourceIndex);
}
/*case 1 handled above*/
target.put((byte) diff);
if (offsets != null) {
offsets.put(sourceIndex);
}
default:
/*will never occur*/
break;
}
targetCapacity -= length;
sourceIndex = nextSourceIndex;
} else {
ByteBuffer error = ByteBuffer.wrap(errorBuffer);
/*
* 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;
switch (length) {
/* each branch falls through to the next one */
case 3:
error.put((byte) (diff >> 16));
case 2:
error.put((byte) (diff >> 8));
case 1:
error.put((byte) diff);
default:
/* will never occur */
break;
}
errorBufferLength = 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.put((byte) (diff >> 16));
if (offsets != null) {
offsets.put(sourceIndex);
}
case 2:
target.put((byte) (diff >> 8));
if (offsets != null) {
offsets.put(sourceIndex);
}
case 1:
target.put((byte) diff);
if (offsets != null) {
offsets.put(sourceIndex);
}
default:
/* will never occur */
break;
}
/* target overflow */
targetCapacity = 0;
cr = CoderResult.OVERFLOW;
break;
}
}
} else {
/*target is full*/
cr = CoderResult.OVERFLOW;
break;
}
}
/*set the converter state back into UConverter*/
fromUChar32 = c < 0 ? -c : 0;
fromUnicodeStatus = prev;
LabelLoop = false;
labelType = fastSingle;
return labelType;
}
}
static class CharsetDecoderBOCU extends CharsetDecoderICU {
public CharsetDecoderBOCU(CharsetICU cs) {
super(cs);
}
int byteIndex;
int sourceIndex, nextSourceIndex;
int prev, c, diff, count;
byte[] bytes;
CoderResult cr;
/* label values for supporting behavior similar to goto in C */
private static final int fastSingle = 0;
private static final int getTrail = 1;
private static final int regularLoop = 2;
private static final int endLoop = 3;
private boolean LabelLoop; // used to break the while loop
private boolean afterTrail; // its value is set to true to ignore code after getTrail:
private int labelType;
/*
* 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 --------------------------------- */
/**
* 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
*/
private int decodeBocu1LeadByte(int b) {
int diffValue, countValue;
if (b >= BOCU1_START_NEG_2) {
/* positive difference */
if (b < BOCU1_START_POS_3) {
/* two bytes */
diffValue = (b - BOCU1_START_POS_2) * BOCU1_TRAIL_COUNT + BOCU1_REACH_POS_1 + 1;
countValue = 1;
} else if (b < BOCU1_START_POS_4) {
/* three bytes */
diffValue =
(b - BOCU1_START_POS_3) * BOCU1_TRAIL_COUNT * BOCU1_TRAIL_COUNT
+ BOCU1_REACH_POS_2
+ 1;
countValue = 2;
} else {
/* four bytes */
diffValue = BOCU1_REACH_POS_3 + 1;
countValue = 3;
}
} else {
/* negative difference */
if (b >= BOCU1_START_NEG_3) {
/* two bytes */
diffValue = (b - BOCU1_START_NEG_2) * BOCU1_TRAIL_COUNT + BOCU1_REACH_NEG_1;
countValue = 1;
} else if (b > BOCU1_MIN) {
/* three bytes */
diffValue =
(b - BOCU1_START_NEG_3) * BOCU1_TRAIL_COUNT * BOCU1_TRAIL_COUNT
+ BOCU1_REACH_NEG_2;
countValue = 2;
} else {
/* four bytes */
diffValue =
-BOCU1_TRAIL_COUNT * BOCU1_TRAIL_COUNT * BOCU1_TRAIL_COUNT
+ BOCU1_REACH_NEG_3;
countValue = 3;
}
}
/* return the state for decoding the trail byte(s) */
return (diffValue << 2) | countValue;
}
/**
* 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
*/
private int decodeBocu1TrailByte(int countValue, int b) {
b = b & UConverterConstants.UNSIGNED_BYTE_MASK;
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 */
} else {
// b-= BOCU1_TRAIL_BYTE_OFFSET;
b = b - BOCU1_TRAIL_BYTE_OFFSET;
}
/* add trail byte into difference and decrement count */
if (countValue == 1) {
return b;
} else if (countValue == 2) {
return b * BOCU1_TRAIL_COUNT;
} else /* count==3 */ {
return b * (BOCU1_TRAIL_COUNT * BOCU1_TRAIL_COUNT);
}
}
@Override
protected CoderResult decodeLoop(
ByteBuffer source, CharBuffer target, IntBuffer offsets, boolean flush) {
cr = CoderResult.UNDERFLOW;
LabelLoop = true;
afterTrail = false;
labelType = fastSingle; // labelType is set to fastSingle so t
/*get the converter state*/
prev = toUnicodeStatus;
if (prev == 0) {
prev = BOCU1_ASCII_PREV;
}
diff = mode;
count = diff & 3;
diff >>= 2;
byteIndex = toULength;
bytes = toUBytesArray;
/* 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.position() < target.limit()) {
labelType = getTrail;
}
while (LabelLoop) {
switch (labelType) {
case fastSingle:
labelType = fastSingle(source, target, offsets);
break;
case getTrail:
labelType = getTrail(source, target, offsets);
break;
case regularLoop:
labelType = afterGetTrail(source, target, offsets);
break;
case endLoop:
endLoop(source, target, offsets);
break;
}
}
return cr;
}
private int fastSingle(ByteBuffer source, CharBuffer target, IntBuffer offsets) {
labelType = regularLoop;
/* fast loop for single-byte differences */
/* use count as the only loop counter variable */
diff = source.limit() - source.position();
count = target.limit() - target.position();
if (count > diff) {
count = diff;
}
while (count > 0) {
if (BOCU1_START_NEG_2
<= (c =
source.get(source.position())
& UConverterConstants.UNSIGNED_BYTE_MASK)
&& c < BOCU1_START_POS_2) {
c = prev + (c - BOCU1_MIDDLE);
if (c < 0x3000) {
target.put((char) c);
if (offsets != null) {
offsets.put(nextSourceIndex++);
}
prev = BOCU1_SIMPLE_PREV(c);
} else {
break;
}
} else if ((c & UConverterConstants.UNSIGNED_BYTE_MASK) <= 0x20) {
if ((c & UConverterConstants.UNSIGNED_BYTE_MASK) != 0x20) {
prev = BOCU1_ASCII_PREV;
}
target.put((char) c);
if (offsets != null) {
offsets.put(nextSourceIndex++);
}
} else {
break;
}
source.position(source.position() + 1);
--count;
}
sourceIndex = nextSourceIndex; /* wrong if offsets==NULL but does not matter */
return labelType;
}
private int getTrail(ByteBuffer source, CharBuffer target, IntBuffer offsets) {
labelType = regularLoop;
for (; ; ) {
if (source.position() >= source.limit()) {
labelType = endLoop;
return labelType;
}
++nextSourceIndex;
c = bytes[byteIndex++] = source.get();
/* trail byte in any position */
c = decodeBocu1TrailByte(count, c);
if (c < 0) {
cr = CoderResult.malformedForLength(1);
labelType = endLoop;
return labelType;
}
diff += c;
if (--count == 0) {
/* final trail byte, deliver a code point */
byteIndex = 0;
c = prev + diff;
if (c > 0x10ffff) {
cr = CoderResult.malformedForLength(1);
labelType = endLoop;
return labelType;
}
break;
}
}
afterTrail = true;
return labelType;
}
private int afterGetTrail(ByteBuffer source, CharBuffer target, IntBuffer offsets) {
/* decode a sequence of single and lead bytes */
while (afterTrail || source.hasRemaining()) {
if (!afterTrail) {
if (target.position() >= target.limit()) {
/* target is full */
cr = CoderResult.OVERFLOW;
break;
}
++nextSourceIndex;
c = source.get() & UConverterConstants.UNSIGNED_BYTE_MASK;
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.put((char) c);
if (offsets != null) {
offsets.put(sourceIndex);
}
prev = BOCU1_SIMPLE_PREV(c);
sourceIndex = nextSourceIndex;
labelType = fastSingle;
return labelType;
}
} 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.put((char) c);
if (offsets != null) {
offsets.put(sourceIndex);
}
sourceIndex = nextSourceIndex;
continue;
} else if (BOCU1_START_NEG_3 <= c
&& c < BOCU1_START_POS_3
&& source.hasRemaining()) {
/* Optimize two-byte case. */
if (c >= BOCU1_MIDDLE) {
diff =
(c - BOCU1_START_POS_2) * BOCU1_TRAIL_COUNT
+ BOCU1_REACH_POS_1
+ 1;
} else {
diff = (c - BOCU1_START_NEG_2) * BOCU1_TRAIL_COUNT + BOCU1_REACH_NEG_1;
}
/* trail byte */
++nextSourceIndex;
c = decodeBocu1TrailByte(1, source.get());
if (c < 0
|| ((c = prev + diff + c) & UConverterConstants.UNSIGNED_INT_MASK)
> 0x10ffff) {
bytes[0] = source.get(source.position() - 2);
bytes[1] = source.get(source.position() - 1);
byteIndex = 2;
cr = CoderResult.malformedForLength(2);
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] = (byte) c;
byteIndex = 1;
diff = decodeBocu1LeadByte(c);
count = diff & 3;
diff >>= 2;
getTrail(source, target, offsets);
if (labelType != regularLoop) {
return labelType;
}
}
}
if (afterTrail) {
afterTrail = false;
}
/* calculate the next prev and output c */
prev = BOCU1_PREV(c);
if (c <= 0xffff) {
target.put((char) c);
if (offsets != null) {
offsets.put(sourceIndex);
}
} else {
/* output surrogate pair */
target.put(UTF16.getLeadSurrogate(c));
if (target.hasRemaining()) {
target.put(UTF16.getTrailSurrogate(c));
if (offsets != null) {
offsets.put(sourceIndex);
offsets.put(sourceIndex);
}
} else {
/* target overflow */
if (offsets != null) {
offsets.put(sourceIndex);
}
charErrorBufferArray[0] = UTF16.getTrailSurrogate(c);
charErrorBufferLength = 1;
cr = CoderResult.OVERFLOW;
break;
}
}
sourceIndex = nextSourceIndex;
}
labelType = endLoop;
return labelType;
}
private void endLoop(ByteBuffer source, CharBuffer target, IntBuffer offsets) {
if (cr.isMalformed()) {
/* set the converter state in UConverter to deal with the next character */
toUnicodeStatus = BOCU1_ASCII_PREV;
mode = 0;
} else {
/* set the converter state back into UConverter */
toUnicodeStatus = prev;
mode = (diff << 2) | count;
}
toULength = byteIndex;
LabelLoop = false;
}
}
@Override
public CharsetDecoder newDecoder() {
return new CharsetDecoderBOCU(this);
}
@Override
public CharsetEncoder newEncoder() {
return new CharsetEncoderBOCU(this);
}
@Override
void getUnicodeSetImpl(UnicodeSet setFillIn, int which) {
CharsetICU.getCompleteUnicodeSet(setFillIn);
}
}