package com.alibaba.fastjson.util;
import java.nio.Buffer;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CoderResult;
/* Legal UTF-8 Byte Sequences
*
* # Code Points Bits Bit/Byte pattern
* 1 7 0xxxxxxx
* U+0000..U+007F 00..7F
*
* 2 11 110xxxxx 10xxxxxx
* U+0080..U+07FF C2..DF 80..BF
*
* 3 16 1110xxxx 10xxxxxx 10xxxxxx
* U+0800..U+0FFF E0 A0..BF 80..BF
* U+1000..U+FFFF E1..EF 80..BF 80..BF
*
* 4 21 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
* U+10000..U+3FFFF F0 90..BF 80..BF 80..BF
* U+40000..U+FFFFF F1..F3 80..BF 80..BF 80..BF
* U+100000..U10FFFF F4 80..8F 80..BF 80..BF
*
*/
public class UTF8Decoder extends CharsetDecoder {
private final static Charset charset = Charset.forName("UTF-8");
public UTF8Decoder() {
super(charset, 1.0f, 1.0f);
}
private static boolean isNotContinuation(int b) {
return (b & 0xc0) != 0x80;
}
// [C2..DF] [80..BF]
private static final boolean isMalformed2(int b1, int b2) {
return (b1 & 0x1e) == 0x0 || (b2 & 0xc0) != 0x80;
}
// [E0] [A0..BF] [80..BF]
// [E1..EF] [80..BF] [80..BF]
private static boolean isMalformed3(int b1, int b2, int b3) {
return (b1 == (byte) 0xe0 && (b2 & 0xe0) == 0x80) || (b2 & 0xc0) != 0x80 || (b3 & 0xc0) != 0x80;
}
// [F0] [90..BF] [80..BF] [80..BF]
// [F1..F3] [80..BF] [80..BF] [80..BF]
// [F4] [80..8F] [80..BF] [80..BF]
// only check 80-be range here, the [0xf0,0x80...] and [0xf4,0x90-...]
// will be checked by Surrogate.neededFor(uc)
private static final boolean isMalformed4(int b2, int b3, int b4) {
return (b2 & 0xc0) != 0x80 || (b3 & 0xc0) != 0x80 || (b4 & 0xc0) != 0x80;
}
private static CoderResult lookupN(ByteBuffer src, int n) {
for (int i = 1; i < n; i++) {
if (isNotContinuation(src.get())) {
return CoderResult.malformedForLength(i);
}
}
return CoderResult.malformedForLength(n);
}
public static CoderResult malformedN(ByteBuffer src, int nb) {
switch (nb) {
case 1:
int b1 = src.get();
if ((b1 >> 2) == -2) {
// 5 bytes 111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
if (src.remaining() < 4) {
return CoderResult.UNDERFLOW;
}
return lookupN(src, 5);
}
if ((b1 >> 1) == -2) {
// 6 bytes 1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
if (src.remaining() < 5) {
return CoderResult.UNDERFLOW;
}
return lookupN(src, 6);
}
return CoderResult.malformedForLength(1);
case 2: // always 1
return CoderResult.malformedForLength(1);
case 3:
b1 = src.get();
int b2 = src.get(); // no need to lookup b3
return CoderResult.malformedForLength(((b1 == (byte) 0xe0 && (b2 & 0xe0) == 0x80) || isNotContinuation(b2)) ? 1 : 2);
case 4: // we don't care the speed here
b1 = src.get() & 0xff;
b2 = src.get() & 0xff;
if (b1 > 0xf4 || (b1 == 0xf0 && (b2 < 0x90 || b2 > 0xbf)) || (b1 == 0xf4 && (b2 & 0xf0) != 0x80) || isNotContinuation(b2)) {
return CoderResult.malformedForLength(1);
}
if (isNotContinuation(src.get())) {
return CoderResult.malformedForLength(2);
}
return CoderResult.malformedForLength(3);
default:
throw new IllegalStateException();
}
}
private static CoderResult malformed(ByteBuffer src, int sp, CharBuffer dst, int dp, int nb) {
src.position(sp - src.arrayOffset());
CoderResult cr = malformedN(src, nb);
updatePositions(src, sp, dst, dp);
return cr;
}
private static CoderResult xflow(Buffer src, int sp, int sl, Buffer dst, int dp, int nb) {
updatePositions(src, sp, dst, dp);
return (nb == 0 || sl - sp < nb) ? CoderResult.UNDERFLOW : CoderResult.OVERFLOW;
}
private CoderResult decodeArrayLoop(ByteBuffer src, CharBuffer dst) {
// This method is optimized for ASCII input.
byte[] srcArray = src.array();
int srcPosition = src.arrayOffset() + src.position();
int srcLength = src.arrayOffset() + src.limit();
char[] destArray = dst.array();
int destPosition = dst.arrayOffset() + dst.position();
int destLength = dst.arrayOffset() + dst.limit();
int destLengthASCII = destPosition + Math.min(srcLength - srcPosition, destLength - destPosition);
// ASCII only loop
while (destPosition < destLengthASCII && srcArray[srcPosition] >= 0) {
destArray[destPosition++] = (char) srcArray[srcPosition++];
}
while (srcPosition < srcLength) {
int b1 = srcArray[srcPosition];
if (b1 >= 0) {
// 1 byte, 7 bits: 0xxxxxxx
if (destPosition >= destLength) {
return xflow(src, srcPosition, srcLength, dst, destPosition, 1);
}
destArray[destPosition++] = (char) b1;
srcPosition++;
} else if ((b1 >> 5) == -2) {
// 2 bytes, 11 bits: 110xxxxx 10xxxxxx
if (srcLength - srcPosition < 2 || destPosition >= destLength) {
return xflow(src, srcPosition, srcLength, dst, destPosition, 2);
}
int b2 = srcArray[srcPosition + 1];
if (isMalformed2(b1, b2)) {
return malformed(src, srcPosition, dst, destPosition, 2);
}
destArray[destPosition++] = (char) (((b1 << 6) ^ b2) ^ 0x0f80);
srcPosition += 2;
} else if ((b1 >> 4) == -2) {
// 3 bytes, 16 bits: 1110xxxx 10xxxxxx 10xxxxxx
if (srcLength - srcPosition < 3 || destPosition >= destLength) {
return xflow(src, srcPosition, srcLength, dst, destPosition, 3);
}
int b2 = srcArray[srcPosition + 1];
int b3 = srcArray[srcPosition + 2];
if (isMalformed3(b1, b2, b3)) {
return malformed(src, srcPosition, dst, destPosition, 3);
}
destArray[destPosition++] = (char) (((b1 << 12) ^ (b2 << 6) ^ b3) ^ 0x1f80);
srcPosition += 3;
} else if ((b1 >> 3) == -2) {
// 4 bytes, 21 bits: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
if (srcLength - srcPosition < 4 || destLength - destPosition < 2) {
return xflow(src, srcPosition, srcLength, dst, destPosition, 4);
}
int b2 = srcArray[srcPosition + 1];
int b3 = srcArray[srcPosition + 2];
int b4 = srcArray[srcPosition + 3];
int uc = ((b1 & 0x07) << 18) | ((b2 & 0x3f) << 12) | ((b3 & 0x3f) << 06) | (b4 & 0x3f);
if (isMalformed4(b2, b3, b4) || !Surrogate.neededFor(uc)) {
return malformed(src, srcPosition, dst, destPosition, 4);
}
destArray[destPosition++] = Surrogate.high(uc);
destArray[destPosition++] = Surrogate.low(uc);
srcPosition += 4;
} else {
return malformed(src, srcPosition, dst, destPosition, 1);
}
}
return xflow(src, srcPosition, srcLength, dst, destPosition, 0);
}
protected CoderResult decodeLoop(ByteBuffer src, CharBuffer dst) {
return decodeArrayLoop(src, dst);
}
static final void updatePositions(Buffer src, int sp, Buffer dst, int dp) {
// src.position(sp - src.arrayOffset());
// dst.position(dp - dst.arrayOffset());
src.position(sp);
dst.position(dp);
}
private static class Surrogate {
public static final int UCS4_MIN = 0x10000;
public static final int UCS4_MAX = (1 << 20) + UCS4_MIN - 1;
public static boolean neededFor(int uc) {
return (uc >= UCS4_MIN) && (uc <= UCS4_MAX);
}
public static char high(int uc) {
assert neededFor(uc);
return (char) (0xd800 | (((uc - UCS4_MIN) >> 10) & 0x3ff));
}
public static char low(int uc) {
assert neededFor(uc);
return (char) (0xdc00 | ((uc - UCS4_MIN) & 0x3ff));
}
}
}