/*------------------------------------------------------------------------- * * Encoding.java *     Converts to and from the character encoding used by the backend. * * Copyright (c) 2003, PostgreSQL Global Development Group * * IDENTIFICATION *	  $Header: /cvsroot/pgsql/src/interfaces/jdbc/org/postgresql/core/Attic/Encoding.java,v 1.12 2003/09/08 17:30:22 barry Exp $ * *------------------------------------------------------------------------- */package org.postgresql.core;import java.io.InputStream;import java.io.InputStreamReader;import java.io.Reader;import java.io.UnsupportedEncodingException;import java.sql.SQLException;import java.util.Hashtable;import org.postgresql.util.PSQLException;import org.postgresql.util.PSQLState;public class Encoding{	private static final Encoding DEFAULT_ENCODING = new Encoding(null);	/*	 * Preferred JVM encodings for backend encodings.	 */	private static final Hashtable encodings = new Hashtable();	static {		//Note: this list should match the set of supported server		// encodings found in backend/util/mb/encnames.c		encodings.put("SQL_ASCII", new String[] { "ASCII", "us-ascii" });		encodings.put("UNICODE", new String[] { "UTF-8", "UTF8" });		encodings.put("LATIN1", new String[] { "ISO8859_1" });		encodings.put("LATIN2", new String[] { "ISO8859_2" });		encodings.put("LATIN3", new String[] { "ISO8859_3" });		encodings.put("LATIN4", new String[] { "ISO8859_4" });		encodings.put("ISO_8859_5", new String[] { "ISO8859_5" });		encodings.put("ISO_8859_6", new String[] { "ISO8859_6" });		encodings.put("ISO_8859_7", new String[] { "ISO8859_7" });		encodings.put("ISO_8859_8", new String[] { "ISO8859_8" });		encodings.put("LATIN5", new String[] { "ISO8859_9" });		encodings.put("LATIN7", new String[] { "ISO8859_13" });		encodings.put("LATIN9", new String[] { "ISO8859_15_FDIS" });		encodings.put("EUC_JP", new String[] { "EUC_JP" });		encodings.put("EUC_CN", new String[] { "EUC_CN" });		encodings.put("EUC_KR", new String[] { "EUC_KR" });		encodings.put("JOHAB", new String[] { "Johab" });		encodings.put("EUC_TW", new String[] { "EUC_TW" });		encodings.put("SJIS", new String[] { "MS932", "SJIS" });		encodings.put("BIG5", new String[] { "Big5", "MS950", "Cp950" });		encodings.put("GBK", new String[] { "GBK", "MS936" });		encodings.put("UHC", new String[] { "MS949", "Cp949", "Cp949C" });		encodings.put("TCVN", new String[] { "Cp1258" });		encodings.put("WIN1256", new String[] { "Cp1256" });		encodings.put("WIN1250", new String[] { "Cp1250" });		encodings.put("WIN874", new String[] { "MS874", "Cp874" });		encodings.put("WIN", new String[] { "Cp1251" });		encodings.put("ALT", new String[] { "Cp866" });		// We prefer KOI8-U, since it is a superset of KOI8-R.		encodings.put("KOI8", new String[] { "KOI8_U", "KOI8_R" });		// If the database isn't encoding-aware then we can't have		// any preferred encodings.		encodings.put("UNKNOWN", new String[0]);		// The following encodings do not have a java equivalent		encodings.put("MULE_INTERNAL", new String[0]);		encodings.put("LATIN6", new String[0]);		encodings.put("LATIN8", new String[0]);		encodings.put("LATIN10", new String[0]);	}	private final String encoding;	private Encoding(String encoding)	{		this.encoding = encoding;	}	/*	 * Get an Encoding for from the given database encoding and	 * the encoding passed in by the user.	 */	public static Encoding getEncoding(String databaseEncoding,									   String passedEncoding)	{		if (passedEncoding != null)		{			if (isAvailable(passedEncoding))			{				return new Encoding(passedEncoding);			}			else			{				return defaultEncoding();			}		}		else		{			return encodingForDatabaseEncoding(databaseEncoding);		}	}	/*	 * Get an Encoding matching the given database encoding.	 */	private static Encoding encodingForDatabaseEncoding(String databaseEncoding)	{		// If the backend encoding is known and there is a suitable		// encoding in the JVM we use that. Otherwise we fall back		// to the default encoding of the JVM.		if (encodings.containsKey(databaseEncoding))		{			String[] candidates = (String[]) encodings.get(databaseEncoding);			for (int i = 0; i < candidates.length; i++)			{				if (isAvailable(candidates[i]))				{					return new Encoding(candidates[i]);				}			}		}		return defaultEncoding();	}	/*	 * Name of the (JVM) encoding used.	 */	public String name()	{		return encoding;	}	/*	 * Encode a string to an array of bytes.	 */	public byte[] encode(String s) throws SQLException	{		byte[] l_return;		try		{			if (encoding == null)			{				l_return = s.getBytes();			}			else			{				l_return = s.getBytes(encoding);			}			//Don't return null, return an empty byte[] instead			if (l_return == null) {				return new byte[0];			} else {				return l_return;			}		}		catch (UnsupportedEncodingException e)		{			throw new PSQLException("postgresql.stream.encoding", PSQLState.DATA_ERROR, e);		}	}	/*	 * Decode an array of bytes into a string.	 */	public String decode(byte[] encodedString, int offset, int length) throws SQLException	{		try		{			if (encoding == null)			{				return new String(encodedString, offset, length);			}			else			{				if (encoding.equals("UTF-8")) {					return decodeUTF8(encodedString, offset, length);				}				return new String(encodedString, offset, length, encoding);			}		}		catch (UnsupportedEncodingException e)		{			throw new PSQLException("postgresql.stream.encoding", PSQLState.DATA_ERROR, e);		}	}	/*	 * Decode an array of bytes into a string.	 */	public String decode(byte[] encodedString) throws SQLException	{		return decode(encodedString, 0, encodedString.length);	}	/*	 * Get a Reader that decodes the given InputStream.	 */	public Reader getDecodingReader(InputStream in) throws SQLException	{		try		{			if (encoding == null)			{				return new InputStreamReader(in);			}			else			{				return new InputStreamReader(in, encoding);			}		}		catch (UnsupportedEncodingException e)		{			throw new PSQLException("postgresql.res.encoding", PSQLState.DATA_ERROR, e);		}	}	/*	 * Get an Encoding using the default encoding for the JVM.	 */	public static Encoding defaultEncoding()	{		return DEFAULT_ENCODING;	}	/*	 * Test if an encoding is available in the JVM.	 */	private static boolean isAvailable(String encodingName)	{		try		{			"DUMMY".getBytes(encodingName);			return true;		}		catch (UnsupportedEncodingException e)		{			return false;		}	}	/**	 * custom byte[] -> String conversion routine, 3x-10x faster than	 * standard new String(byte[])	 */	private static final int pow2_6 = 64;		// 26	private static final int pow2_12 = 4096;	// 212	private char[] cdata = new char[50];	private synchronized String decodeUTF8(byte data[], int offset, int length) throws SQLException {		try {			char[] l_cdata = cdata;			if (l_cdata.length < (length)) {				l_cdata = new char[length];			}			int i = offset;			int j = 0;			int k = length + offset;			int z, y, x, val;			while (i < k) {				z = data[i] & 0xFF;				if (z < 0x80) {					l_cdata[j++] = (char)data[i];					i++;				} else if (z >= 0xE0) {		// length == 3					y = data[i+1] & 0xFF;					x = data[i+2] & 0xFF;					val = (z-0xE0)*pow2_12 + (y-0x80)*pow2_6 + (x-0x80);					l_cdata[j++] = (char) val;					i+= 3;				} else {		// length == 2 (maybe add checking for length > 3, throw exception if it is					y = data[i+1] & 0xFF;					val = (z - 0xC0)* (pow2_6)+(y-0x80);					l_cdata[j++] = (char) val;					i+=2;				} 			}				String s = new String(l_cdata, 0, j);			return s;		} catch (Exception l_e) {			throw new PSQLException("postgresql.con.invalidchar", l_e);		}	}}