ojluni/src/main/java/sun/nio/cs/CharsetMapping.java - platform/libcore.git - Git at Google

 /*
  * 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;
         }
     }
 }
	/*
	* 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;
	}
	}
	}