177 lines · 5.6 KB · Java
RawDownload
/* * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation.  Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ /* */ package sun.nio.cs.ext; import java.nio.ByteBuffer;import java.nio.CharBuffer;import java.nio.charset.Charset;import java.nio.charset.CharsetDecoder;import java.nio.charset.CharsetEncoder;import java.nio.charset.CoderResult;import sun.nio.cs.HistoricallyNamedCharset;import sun.nio.cs.Surrogate; public class EUC_JP_Open    extends Charset    implements HistoricallyNamedCharset{    public EUC_JP_Open() {        super("x-eucJP-Open", ExtendedCharsets.aliasesFor("x-eucJP-Open"));    }     public String historicalName() {        return "EUC_JP_Solaris";    }     public boolean contains(Charset cs) {        return ((cs.name().equals("US-ASCII"))                || (cs instanceof JIS_X_0201)                || (cs instanceof EUC_JP));    }     public CharsetDecoder newDecoder() {        return new Decoder(this);    }     public CharsetEncoder newEncoder() {         // Need to force the replacement byte to 0x3f        // because JIS_X_0208_Encoder defines its own        // alternative 2 byte substitution to permit it        // to exist as a self-standing Encoder         byte[] replacementBytes = { (byte)0x3f };        return new Encoder(this).replaceWith(replacementBytes);    }     private static class Decoder extends EUC_JP.Decoder {        JIS_X_0201.Decoder decoderJ0201;        JIS_X_0212_Solaris_Decoder decodeMappingJ0212;        JIS_X_0208_Solaris_Decoder decodeMappingJ0208;         private static final short[] j0208Index1 =          JIS_X_0208_Solaris_Decoder.getIndex1();        private static final String[] j0208Index2 =          JIS_X_0208_Solaris_Decoder.getIndex2();        private static final int start = 0xa1;        private static final int end = 0xfe;         protected final char REPLACE_CHAR='\uFFFD';         private Decoder(Charset cs) {            super(cs);            decoderJ0201 = new JIS_X_0201.Decoder(cs);            decodeMappingJ0212 = new JIS_X_0212_Solaris_Decoder(cs);        }          protected char decode0212(int byte1, int byte2) {             return decodeMappingJ0212.decodeDouble(byte1, byte2);         }         protected char decodeDouble(int byte1, int byte2) {            if (byte1 == 0x8e) {                return decoderJ0201.decode(byte2 - 256);            }             if (((byte1 < 0)                || (byte1 > j0208Index1.length))                || ((byte2 < start)                || (byte2 > end)))                return REPLACE_CHAR;             char result = super.decodeDouble(byte1, byte2);            if (result != '\uFFFD') {                return result;            } else {                int n = (j0208Index1[byte1 - 0x80] & 0xf) *                        (end - start + 1)                        + (byte2 - start);                return j0208Index2[j0208Index1[byte1 - 0x80] >> 4].charAt(n);            }        }    }      private static class Encoder extends EUC_JP.Encoder {         JIS_X_0201.Encoder encoderJ0201;        JIS_X_0212_Solaris_Encoder encoderJ0212;         private static final short[] j0208Index1 =            JIS_X_0208_Solaris_Encoder.getIndex1();        private static final String[] j0208Index2 =            JIS_X_0208_Solaris_Encoder.getIndex2();         private final Surrogate.Parser sgp = new Surrogate.Parser();         private Encoder(Charset cs) {            super(cs);            encoderJ0201 = new JIS_X_0201.Encoder(cs);            encoderJ0212 = new JIS_X_0212_Solaris_Encoder(cs);        }         protected int encodeSingle(char inputChar, byte[] outputByte) {            byte b;             if (inputChar == 0) {                outputByte[0] = (byte)0;                return 1;            }             if ((b = encoderJ0201.encode(inputChar)) == 0)                return 0;             if (b > 0 && b < 128) {                outputByte[0] = b;                return 1;            }             outputByte[0] = (byte)0x8e;            outputByte[1] = b;            return 2;        }         protected int encodeDouble(char ch) {            int r = super.encodeDouble(ch);            if (r != 0) {                return r;            }            else {                int offset = j0208Index1[((ch & 0xff00) >> 8 )] << 8;                r = j0208Index2[offset >> 12].charAt((offset & 0xfff) +                    (ch & 0xFF));                if (r > 0x7500)                   return 0x8F8080 + encoderJ0212.encodeDouble(ch);                }                return (r==0 ? 0: r + 0x8080);        }    }}