/* * Copyright (c) 2008, 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; import java.io.InputStream;import java.io.InputStreamReader;import java.io.OutputStream;import java.io.BufferedReader;import java.io.IOException;import java.util.regex.Matcher;import java.util.regex.Pattern;import java.util.*;import java.security.*; public class CharsetMapping {    public final static char UNMAPPABLE_DECODING = '\uFFFD';    public final static int  UNMAPPABLE_ENCODING = 0xFFFD;     char[] b2cSB;                //singlebyte b->c    char[] b2cDB1;               //dobulebyte b->c /db1    char[] b2cDB2;               //dobulebyte b->c /db2     int    b2Min, b2Max;         //min/max(start/end) value of 2nd byte    int    b1MinDB1, b1MaxDB1;   //min/Max(start/end) value of 1st byte/db1    int    b1MinDB2, b1MaxDB2;   //min/Max(start/end) value of 1st byte/db2    int    dbSegSize;     char[] c2b;    char[] c2bIndex;     // Supplementary    char[] b2cSupp;    char[] c2bSupp;     // Composite    Entry[] b2cComp;    Entry[] c2bComp;     public char decodeSingle(int b) {        return b2cSB[b];    }     public char decodeDouble(int b1, int b2) {        if (b2 >= b2Min && b2 < b2Max) {            b2 -= b2Min;            if (b1 >= b1MinDB1 && b1 <= b1MaxDB1) {                b1 -= b1MinDB1;                return b2cDB1[b1 * dbSegSize + b2];            }            if (b1 >= b1MinDB2 && b1 <= b1MaxDB2) {                b1 -= b1MinDB2;                return b2cDB2[b1 * dbSegSize + b2];            }        }        return UNMAPPABLE_DECODING;    }     // for jis0213 all supplementary characters are in 0x2xxxx range,    // so only the xxxx part is now stored, should actually store the    // codepoint value instead.    public char[] decodeSurrogate(int db, char[] cc) {        int end = b2cSupp.length / 2;        int i = Arrays.binarySearch(b2cSupp, 0, end, (char)db);        if (i >= 0) {            Character.toChars(b2cSupp[end + i] + 0x20000, cc, 0);            return cc;        }        return null;    }     public char[] decodeComposite(Entry comp, char[] cc) {        int i = findBytes(b2cComp, comp);        if (i >= 0) {            cc[0] = (char)b2cComp[i].cp;            cc[1] = (char)b2cComp[i].cp2;            return cc;        }        return null;    }     public int encodeChar(char ch) {        int index = c2bIndex[ch >> 8];        if (index == 0xffff)            return UNMAPPABLE_ENCODING;        return c2b[index + (ch & 0xff)];    }     public int encodeSurrogate(char hi, char lo) {        int cp = Character.toCodePoint(hi, lo);        if (cp < 0x20000 || cp >= 0x30000)            return UNMAPPABLE_ENCODING;        int end = c2bSupp.length / 2;        int i = Arrays.binarySearch(c2bSupp, 0, end, (char)cp);        if (i >= 0)            return c2bSupp[end + i];        return UNMAPPABLE_ENCODING;    }     public boolean isCompositeBase(Entry comp) {        if (comp.cp <= 0x31f7 && comp.cp >= 0xe6) {            return (findCP(c2bComp, comp) >= 0);        }        return false;    }     public int encodeComposite(Entry comp) {        int i = findComp(c2bComp, comp);        if (i >= 0)            return c2bComp[i].bs;        return UNMAPPABLE_ENCODING;    }     // init the CharsetMapping object from the .dat binary file    public static CharsetMapping get(final InputStream is) {        return AccessController.doPrivileged(new PrivilegedAction<CharsetMapping>() {            public CharsetMapping run() {                return new CharsetMapping().load(is);            }        });    }     public static class Entry {        public int bs;   //byte sequence reps        public int cp;   //Unicode codepoint        public int cp2;  //CC of composite    }     static Comparator<Entry> comparatorBytes =        new Comparator<Entry>() {            public int compare(Entry m1, Entry m2) {                return m1.bs - m2.bs;            }            public boolean equals(Object obj) {                return this == obj;            }    };     static Comparator<Entry> comparatorCP =        new Comparator<Entry>() {            public int compare(Entry m1, Entry m2) {                return m1.cp - m2.cp;            }            public boolean equals(Object obj) {                return this == obj;            }    };     static Comparator<Entry> comparatorComp =        new Comparator<Entry>() {            public int compare(Entry m1, Entry m2) {                 int v = m1.cp - m2.cp;                 if (v == 0)                   v = m1.cp2 - m2.cp2;                 return v;            }            public boolean equals(Object obj) {                return this == obj;            }    };     static int findBytes(Entry[] a, Entry k) {        return Arrays.binarySearch(a, 0, a.length, k, comparatorBytes);    }     static int findCP(Entry[] a, Entry k) {        return Arrays.binarySearch(a, 0, a.length, k, comparatorCP);    }     static int findComp(Entry[] a, Entry k) {        return Arrays.binarySearch(a, 0, a.length, k, comparatorComp);    }     /*****************************************************************************/    // tags of different charset mapping tables    private final static int MAP_SINGLEBYTE      = 0x1; // 0..256  : c    private final static int MAP_DOUBLEBYTE1     = 0x2; // min..max: c    private final static int MAP_DOUBLEBYTE2     = 0x3; // min..max: c [DB2]    private final static int MAP_SUPPLEMENT      = 0x5; //           db,c    private final static int MAP_SUPPLEMENT_C2B  = 0x6; //           c,db    private final static int MAP_COMPOSITE       = 0x7; //           db,base,cc    private final static int MAP_INDEXC2B        = 0x8; // index table of c->bb     private static final boolean readNBytes(InputStream in, byte[] bb, int N)        throws IOException    {        int off = 0;        while (N > 0) {            int n = in.read(bb, off, N);            if (n == -1)                return false;            N = N - n;            off += n;        }        return true;    }     int off = 0;    byte[] bb;    private char[] readCharArray() {        // first 2 bytes are the number of "chars" stored in this table        int size  = ((bb[off++]&0xff)<<8) | (bb[off++]&0xff);        char [] cc = new char[size];        for (int i = 0; i < size; i++) {            cc[i] = (char)(((bb[off++]&0xff)<<8) | (bb[off++]&0xff));        }        return cc;    }     void readSINGLEBYTE() {        char[] map = readCharArray();        for (int i = 0; i < map.length; i++) {            char c = map[i];            if (c != UNMAPPABLE_DECODING) {                c2b[c2bIndex[c >> 8] + (c&0xff)] = (char)i;            }        }        b2cSB = map;    }     void readINDEXC2B() {        char[] map = readCharArray();        for (int i = map.length - 1; i >= 0; i--) {            if (c2b == null && map[i] != -1) {                c2b = new char[map[i] + 256];                Arrays.fill(c2b, (char)UNMAPPABLE_ENCODING);                break;            }        }        c2bIndex = map;    }     char[] readDB(int b1Min, int b2Min, int segSize) {        char[] map = readCharArray();        for (int i = 0; i < map.length; i++) {            char c = map[i];            if (c != UNMAPPABLE_DECODING) {                int b1 = i / segSize;                int b2 = i % segSize;                int b = (b1 + b1Min)* 256 + (b2 + b2Min);                //System.out.printf("    DB %x\t%x%n", b, c & 0xffff);                c2b[c2bIndex[c >> 8] + (c&0xff)] = (char)(b);            }        }        return map;    }     void readDOUBLEBYTE1() {        b1MinDB1 = ((bb[off++]&0xff)<<8) | (bb[off++]&0xff);        b1MaxDB1 = ((bb[off++]&0xff)<<8) | (bb[off++]&0xff);        b2Min =    ((bb[off++]&0xff)<<8) | (bb[off++]&0xff);        b2Max =    ((bb[off++]&0xff)<<8) | (bb[off++]&0xff);        dbSegSize = b2Max - b2Min + 1;        b2cDB1 = readDB(b1MinDB1, b2Min, dbSegSize);    }     void readDOUBLEBYTE2() {        b1MinDB2 = ((bb[off++]&0xff)<<8) | (bb[off++]&0xff);        b1MaxDB2 = ((bb[off++]&0xff)<<8) | (bb[off++]&0xff);        b2Min =    ((bb[off++]&0xff)<<8) | (bb[off++]&0xff);        b2Max =    ((bb[off++]&0xff)<<8) | (bb[off++]&0xff);        dbSegSize = b2Max - b2Min + 1;        b2cDB2 = readDB(b1MinDB2, b2Min, dbSegSize);    }     void readCOMPOSITE() {        char[] map = readCharArray();        int mLen = map.length/3;        b2cComp = new Entry[mLen];        c2bComp = new Entry[mLen];        for (int i = 0, j= 0; i < mLen; i++) {            Entry m = new Entry();            m.bs = map[j++];            m.cp = map[j++];            m.cp2 = map[j++];            b2cComp[i] = m;            c2bComp[i] = m;        }        Arrays.sort(c2bComp, 0, c2bComp.length, comparatorComp);    }     CharsetMapping load(InputStream in) {        try {            // The first 4 bytes are the size of the total data followed in            // this .dat file.            int len = ((in.read()&0xff) << 24) | ((in.read()&0xff) << 16) |                      ((in.read()&0xff) << 8) | (in.read()&0xff);            bb = new byte[len];            off = 0;            //System.out.printf("In : Total=%d%n", len);            // Read in all bytes            if (!readNBytes(in, bb, len))                throw new RuntimeException("Corrupted data file");            in.close();             while (off < len) {                int type = ((bb[off++]&0xff)<<8) | (bb[off++]&0xff);                switch(type) {                case MAP_INDEXC2B:                    readINDEXC2B();                    break;                case MAP_SINGLEBYTE:                    readSINGLEBYTE();                    break;                case MAP_DOUBLEBYTE1:                    readDOUBLEBYTE1();                    break;                case MAP_DOUBLEBYTE2:                    readDOUBLEBYTE2();                    break;                case MAP_SUPPLEMENT:                    b2cSupp = readCharArray();                    break;                case MAP_SUPPLEMENT_C2B:                    c2bSupp = readCharArray();                    break;                case MAP_COMPOSITE:                    readCOMPOSITE();                    break;                default:                    throw new RuntimeException("Corrupted data file");                }            }            bb = null;            return this;        } catch (IOException x) {            x.printStackTrace();            return null;        }    }}