예제 #1
0
    private CoderResult encodeArrayLoop(CharBuffer src, ByteBuffer dst) {
      char[] sa = src.array();
      int sp = src.arrayOffset() + src.position();
      int sl = src.arrayOffset() + src.limit();
      assert (sp <= sl);
      sp = (sp <= sl ? sp : sl);
      byte[] da = dst.array();
      int dp = dst.arrayOffset() + dst.position();
      int dl = dst.arrayOffset() + dst.limit();
      assert (dp <= dl);
      dp = (dp <= dl ? dp : dl);

      try {
        while (sp < sl) {
          char c = sa[sp];
          if (c < 0x80) {
            if (dp >= dl) return CoderResult.OVERFLOW;
            da[dp] = (byte) c;
            sp++;
            dp++;
            continue;
          }
          if (sgp.parse(c, sa, sp, sl) < 0) return sgp.error();
          return sgp.unmappableResult();
        }
        return CoderResult.UNDERFLOW;
      } finally {
        src.position(sp - src.arrayOffset());
        dst.position(dp - dst.arrayOffset());
      }
    }
예제 #2
0
    private CoderResult decodeArrayLoop(ByteBuffer src, CharBuffer dst) {
      byte[] sa = src.array();
      int sp = src.arrayOffset() + src.position();
      int sl = src.arrayOffset() + src.limit();
      assert (sp <= sl);
      sp = (sp <= sl ? sp : sl);
      char[] da = dst.array();
      int dp = dst.arrayOffset() + dst.position();
      int dl = dst.arrayOffset() + dst.limit();
      assert (dp <= dl);
      dp = (dp <= dl ? dp : dl);

      try {
        while (sp < sl) {
          byte b = sa[sp];
          if (b >= 0) {
            if (dp >= dl) return CoderResult.OVERFLOW;
            da[dp++] = (char) b;
            sp++;
            continue;
          }
          return CoderResult.malformedForLength(1);
        }
        return CoderResult.UNDERFLOW;
      } finally {
        src.position(sp - src.arrayOffset());
        dst.position(dp - dst.arrayOffset());
      }
    }
    private CoderResult decodeArrayLoop(ByteBuffer src, CharBuffer dst) {
      byte[] sa = src.array();
      int sp = src.arrayOffset() + src.position();
      int sl = src.arrayOffset() + src.limit();

      char[] da = dst.array();
      int dp = dst.arrayOffset() + dst.position();
      int dl = dst.arrayOffset() + dst.limit();

      CoderResult cr = CoderResult.UNDERFLOW;
      if ((dl - dp) < (sl - sp)) {
        sl = sp + (dl - dp);
        cr = CoderResult.OVERFLOW;
      }

      while (sp < sl) {
        char c = decode(sa[sp]);
        if (c == UNMAPPABLE_DECODING) {
          return withResult(CoderResult.unmappableForLength(1), src, sp, dst, dp);
        }
        da[dp++] = c;
        sp++;
      }
      return withResult(cr, src, sp, dst, dp);
    }
    private CoderResult encodeArrayLoop(CharBuffer src, ByteBuffer dst) {
      char[] sa = src.array();
      int sp = src.arrayOffset() + src.position();
      int sl = src.arrayOffset() + src.limit();

      byte[] da = dst.array();
      int dp = dst.arrayOffset() + dst.position();
      int dl = dst.arrayOffset() + dst.limit();
      int len = Math.min(dl - dp, sl - sp);

      while (len-- > 0) {
        char c = sa[sp];
        int b = encode(c);
        if (b == UNMAPPABLE_ENCODING) {
          if (Character.isSurrogate(c)) {
            if (sgp == null) sgp = new Surrogate.Parser();
            if (sgp.parse(c, sa, sp, sl) < 0) {
              return withResult(sgp.error(), src, sp, dst, dp);
            }
            return withResult(sgp.unmappableResult(), src, sp, dst, dp);
          }
          return withResult(CoderResult.unmappableForLength(1), src, sp, dst, dp);
        }
        da[dp++] = (byte) b;
        sp++;
      }
      return withResult(sp < sl ? CoderResult.OVERFLOW : CoderResult.UNDERFLOW, src, sp, dst, dp);
    }
예제 #5
0
 private BigDecimal toBigDecimal() {
   if (lineBuffer.hasArray()) {
     char[] array = lineBuffer.array();
     int offset = lineBuffer.arrayOffset() + lineBuffer.position();
     int length = lineBuffer.remaining();
     return new BigDecimal(array, offset, length);
   } else {
     return new BigDecimal(lineBuffer.toString());
   }
 }
예제 #6
0
    private CoderResult encodeArrayLoop(CharBuffer src, ByteBuffer dst) {
      char[] sa = src.array();
      int sp = src.arrayOffset() + src.position();
      int sl = src.arrayOffset() + src.limit();

      byte[] da = dst.array();
      int dp = dst.arrayOffset() + dst.position();
      int dl = dst.arrayOffset() + dst.limit();
      int dlASCII = dp + Math.min(sl - sp, dl - dp);

      // ASCII only loop
      while (dp < dlASCII && sa[sp] < '\u0080') da[dp++] = (byte) sa[sp++];
      while (sp < sl) {
        char c = sa[sp];
        if (c < 0x80) {
          // Have at most seven bits
          if (dp >= dl) return overflow(src, sp, dst, dp);
          da[dp++] = (byte) c;
        } else if (c < 0x800) {
          // 2 bytes, 11 bits
          if (dl - dp < 2) return overflow(src, sp, dst, dp);
          da[dp++] = (byte) (0xc0 | (c >> 6));
          da[dp++] = (byte) (0x80 | (c & 0x3f));
        } else if (isSurrogate(c)) {
          // Have a surrogate pair
          if (sgp == null) sgp = new Parser();
          int uc = sgp.parse(c, sa, sp, sl);
          if (uc < 0) {
            updatePositions(src, sp, dst, dp);
            return sgp.error();
          }
          if (dl - dp < 4) return overflow(src, sp, dst, dp);
          da[dp++] = (byte) (0xf0 | ((uc >> 18)));
          da[dp++] = (byte) (0x80 | ((uc >> 12) & 0x3f));
          da[dp++] = (byte) (0x80 | ((uc >> 6) & 0x3f));
          da[dp++] = (byte) (0x80 | (uc & 0x3f));
          sp++; // 2 chars
        } else {
          // 3 bytes, 16 bits
          if (dl - dp < 3) return overflow(src, sp, dst, dp);
          da[dp++] = (byte) (0xe0 | ((c >> 12)));
          da[dp++] = (byte) (0x80 | ((c >> 6) & 0x3f));
          da[dp++] = (byte) (0x80 | (c & 0x3f));
        }
        sp++;
      }
      updatePositions(src, sp, dst, dp);
      return CoderResult.UNDERFLOW;
    }
예제 #7
0
  /**
   * Creates a new big-endian buffer whose content is a subregion of the specified {@code string}
   * encoded in the specified {@code charset}. The new buffer's {@code readerIndex} and {@code
   * writerIndex} are {@code 0} and the length of the encoded string respectively.
   */
  public static ByteBuf copiedBuffer(CharSequence string, int offset, int length, Charset charset) {
    if (string == null) {
      throw new NullPointerException("string");
    }
    if (length == 0) {
      return EMPTY_BUFFER;
    }

    if (string instanceof CharBuffer) {
      CharBuffer buf = (CharBuffer) string;
      if (buf.hasArray()) {
        return copiedBuffer(
            buf.array(), buf.arrayOffset() + buf.position() + offset, length, charset);
      }

      buf = buf.slice();
      buf.limit(length);
      buf.position(offset);
      return copiedBuffer(buf, charset);
    }

    return copiedBuffer(CharBuffer.wrap(string, offset, offset + length), charset);
  }
예제 #8
0
    private CoderResult decodeArrayLoop(ByteBuffer src, CharBuffer dst) {
      // This method is optimized for ASCII input.
      byte[] sa = src.array();
      int sp = src.arrayOffset() + src.position();
      int sl = src.arrayOffset() + src.limit();

      char[] da = dst.array();
      int dp = dst.arrayOffset() + dst.position();
      int dl = dst.arrayOffset() + dst.limit();
      int dlASCII = dp + Math.min(sl - sp, dl - dp);

      // ASCII only loop
      while (dp < dlASCII && sa[sp] >= 0) da[dp++] = (char) sa[sp++];
      while (sp < sl) {
        int b1 = sa[sp];
        if (b1 >= 0) {
          // 1 byte, 7 bits: 0xxxxxxx
          if (dp >= dl) return xflow(src, sp, sl, dst, dp, 1);
          da[dp++] = (char) b1;
          sp++;
        } else if ((b1 >> 5) == -2 && (b1 & 0x1e) != 0) {
          // 2 bytes, 11 bits: 110xxxxx 10xxxxxx
          if (sl - sp < 2 || dp >= dl) return xflow(src, sp, sl, dst, dp, 2);
          int b2 = sa[sp + 1];
          if (isNotContinuation(b2)) return malformedForLength(src, sp, dst, dp, 1);
          da[dp++] = (char) (((b1 << 6) ^ b2) ^ (((byte) 0xC0 << 6) ^ ((byte) 0x80)));
          sp += 2;
        } else if ((b1 >> 4) == -2) {
          // 3 bytes, 16 bits: 1110xxxx 10xxxxxx 10xxxxxx
          int srcRemaining = sl - sp;
          if (srcRemaining < 3 || dp >= dl) {
            if (srcRemaining > 1 && isMalformed3_2(b1, sa[sp + 1]))
              return malformedForLength(src, sp, dst, dp, 1);
            return xflow(src, sp, sl, dst, dp, 3);
          }
          int b2 = sa[sp + 1];
          int b3 = sa[sp + 2];
          if (isMalformed3(b1, b2, b3)) return malformed(src, sp, dst, dp, 3);
          char c =
              (char)
                  ((b1 << 12)
                      ^ (b2 << 6)
                      ^ (b3 ^ (((byte) 0xE0 << 12) ^ ((byte) 0x80 << 6) ^ ((byte) 0x80))));
          if (isSurrogate(c)) return malformedForLength(src, sp, dst, dp, 3);
          da[dp++] = c;
          sp += 3;
        } else if ((b1 >> 3) == -2) {
          // 4 bytes, 21 bits: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
          int srcRemaining = sl - sp;
          if (srcRemaining < 4 || dl - dp < 2) {
            if (srcRemaining > 1 && isMalformed4_2(b1, sa[sp + 1]))
              return malformedForLength(src, sp, dst, dp, 1);
            if (srcRemaining > 2 && isMalformed4_3(sa[sp + 2]))
              return malformedForLength(src, sp, dst, dp, 2);
            return xflow(src, sp, sl, dst, dp, 4);
          }
          int b2 = sa[sp + 1];
          int b3 = sa[sp + 2];
          int b4 = sa[sp + 3];
          int uc =
              ((b1 << 18)
                  ^ (b2 << 12)
                  ^ (b3 << 6)
                  ^ (b4
                      ^ (((byte) 0xF0 << 18)
                          ^ ((byte) 0x80 << 12)
                          ^ ((byte) 0x80 << 6)
                          ^ ((byte) 0x80))));
          if (isMalformed4(b2, b3, b4)
              ||
              // shortest form check
              !Character.isSupplementaryCodePoint(uc)) {
            return malformed(src, sp, dst, dp, 4);
          }
          da[dp++] = highSurrogate(uc);
          da[dp++] = lowSurrogate(uc);
          sp += 4;
        } else return malformed(src, sp, dst, dp, 1);
      }
      return xflow(src, sp, sl, dst, dp, 0);
    }
예제 #9
0
 private static void updatePositions(CharBuffer src, int sp, ByteBuffer dst, int dp) {
   src.position(sp - src.arrayOffset());
   dst.position(dp - dst.arrayOffset());
 }
예제 #10
0
 /**
  * Construct from array backed CharBuffer. The buffer position will not be altered as part of read
  * operations.
  *
  * @throws UnsupportedOperationException if buffer isn't backed by an array.
  * @throws ReadOnlyBufferException if buffer is is read-only.
  */
 public CharArrayReader(CharBuffer buffer) {
   this(buffer.array(), buffer.arrayOffset() + buffer.position(), buffer.remaining());
 }
예제 #11
0
 protected CoderResult decodeLoop(ByteBuffer bb, CharBuffer cb) {
   int cbRemaining = cb.remaining();
   if (CharsetProviderImpl.hasLoadedNatives()
       && bb.isDirect()
       && bb.hasRemaining()
       && cb.hasArray()) {
     int toProceed = bb.remaining();
     int cbPos = cb.position();
     int bbPos = bb.position();
     boolean throwOverflow = false;
     if (cbRemaining < toProceed) {
       toProceed = cbRemaining;
       throwOverflow = true;
     }
     int res =
         nDecode(
             cb.array(),
             cb.arrayOffset() + cbPos,
             toProceed,
             AddressUtil.getDirectBufferAddress(bb),
             bbPos);
     bb.position(bbPos + res);
     cb.position(cbPos + res);
     if (throwOverflow) return CoderResult.OVERFLOW;
   } else {
     if (bb.hasArray() && cb.hasArray()) {
       int rem = bb.remaining();
       rem = cbRemaining >= rem ? rem : cbRemaining;
       byte[] bArr = bb.array();
       char[] cArr = cb.array();
       int bStart = bb.position();
       int cStart = cb.position();
       int i;
       for (i = bStart; i < bStart + rem; i++) {
         char in = (char) (bArr[i] & 0xFF);
         if (in >= 4) {
           int index = (int) in - 4;
           cArr[cStart++] = (char) arr[index];
         } else {
           cArr[cStart++] = (char) (in & 0xFF);
         }
       }
       bb.position(i);
       cb.position(cStart);
       if (rem == cbRemaining && bb.hasRemaining()) return CoderResult.OVERFLOW;
     } else {
       while (bb.hasRemaining()) {
         if (cbRemaining == 0) return CoderResult.OVERFLOW;
         char in = (char) (bb.get() & 0xFF);
         if (in >= 4) {
           int index = (int) in - 4;
           cb.put(arr[index]);
         } else {
           cb.put((char) (in & 0xFF));
         }
         cbRemaining--;
       }
     }
   }
   return CoderResult.UNDERFLOW;
 }
예제 #12
0
 protected CoderResult encodeLoop(CharBuffer cb, ByteBuffer bb) {
   int bbRemaining = bb.remaining();
   if (CharsetProviderImpl.hasLoadedNatives()
       && bb.isDirect()
       && cb.hasRemaining()
       && cb.hasArray()) {
     int toProceed = cb.remaining();
     int cbPos = cb.position();
     int bbPos = bb.position();
     boolean throwOverflow = false;
     if (bbRemaining < toProceed) {
       toProceed = bbRemaining;
       throwOverflow = true;
     }
     int[] res = {toProceed, 0};
     nEncode(
         AddressUtil.getDirectBufferAddress(bb),
         bbPos,
         cb.array(),
         cb.arrayOffset() + cbPos,
         res);
     if (res[0] <= 0) {
       bb.position(bbPos - res[0]);
       cb.position(cbPos - res[0]);
       if (res[1] != 0) {
         if (res[1] < 0) return CoderResult.malformedForLength(-res[1]);
         else return CoderResult.unmappableForLength(res[1]);
       }
     } else {
       bb.position(bbPos + res[0]);
       cb.position(cbPos + res[0]);
       if (throwOverflow) return CoderResult.OVERFLOW;
     }
   } else {
     if (bb.hasArray() && cb.hasArray()) {
       byte[] byteArr = bb.array();
       char[] charArr = cb.array();
       int rem = cb.remaining();
       int byteArrStart = bb.position();
       rem = bbRemaining <= rem ? bbRemaining : rem;
       int x;
       for (x = cb.position(); x < cb.position() + rem; x++) {
         char c = charArr[x];
         if (c > (char) 0x20AC) {
           if (c >= 0xD800 && c <= 0xDFFF) {
             if (x + 1 < cb.limit()) {
               char c1 = charArr[x + 1];
               if (c1 >= 0xD800 && c1 <= 0xDFFF) {
                 cb.position(x);
                 bb.position(byteArrStart);
                 return CoderResult.unmappableForLength(2);
               }
             } else {
               cb.position(x);
               bb.position(byteArrStart);
               return CoderResult.UNDERFLOW;
             }
             cb.position(x);
             bb.position(byteArrStart);
             return CoderResult.malformedForLength(1);
           }
           cb.position(x);
           bb.position(byteArrStart);
           return CoderResult.unmappableForLength(1);
         } else {
           if (c < 0x04) {
             byteArr[byteArrStart++] = (byte) c;
           } else {
             int index = (int) c >> 8;
             index = encodeIndex[index];
             if (index < 0) {
               cb.position(x);
               bb.position(byteArrStart);
               return CoderResult.unmappableForLength(1);
             }
             index <<= 8;
             index += (int) c & 0xFF;
             if ((byte) arr[index] != 0) {
               byteArr[byteArrStart++] = (byte) arr[index];
             } else {
               cb.position(x);
               bb.position(byteArrStart);
               return CoderResult.unmappableForLength(1);
             }
           }
         }
       }
       cb.position(x);
       bb.position(byteArrStart);
       if (rem == bbRemaining && cb.hasRemaining()) {
         return CoderResult.OVERFLOW;
       }
     } else {
       while (cb.hasRemaining()) {
         if (bbRemaining == 0) return CoderResult.OVERFLOW;
         char c = cb.get();
         if (c > (char) 0x20AC) {
           if (c >= 0xD800 && c <= 0xDFFF) {
             if (cb.hasRemaining()) {
               char c1 = cb.get();
               if (c1 >= 0xD800 && c1 <= 0xDFFF) {
                 cb.position(cb.position() - 2);
                 return CoderResult.unmappableForLength(2);
               } else {
                 cb.position(cb.position() - 1);
               }
             } else {
               cb.position(cb.position() - 1);
               return CoderResult.UNDERFLOW;
             }
             cb.position(cb.position() - 1);
             return CoderResult.malformedForLength(1);
           }
           cb.position(cb.position() - 1);
           return CoderResult.unmappableForLength(1);
         } else {
           if (c < 0x04) {
             bb.put((byte) c);
           } else {
             int index = (int) c >> 8;
             index = encodeIndex[index];
             if (index < 0) {
               cb.position(cb.position() - 1);
               return CoderResult.unmappableForLength(1);
             }
             index <<= 8;
             index += (int) c & 0xFF;
             if ((byte) arr[index] != 0) {
               bb.put((byte) arr[index]);
             } else {
               cb.position(cb.position() - 1);
               return CoderResult.unmappableForLength(1);
             }
           }
           bbRemaining--;
         }
       }
     }
   }
   return CoderResult.UNDERFLOW;
 }