content: 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));
          }
      }
  }
  