PageRenderTime 76ms CodeModel.GetById 28ms RepoModel.GetById 1ms app.codeStats 1ms

/presrc/com/substanceofcode/utils/EncodingUtil.java

http://mobile-rss-reader.googlecode.com/
Java | 1219 lines | 922 code | 67 blank | 230 comment | 131 complexity | e393850742e52f16b4ae5b25b99339e4 MD5 | raw file
Possible License(s): GPL-2.0 
    

  1.  /*

    2. 

  2.  * EncodingUtil.java

    3. 

  3.  TODO methods for booleans

    4. 

  4.  *

    5. 

  5.  * Copyright (C) 2005-2006 Tommi Laukkanen

    6. 

  6.  * http://www.substanceofcode.com

    7. 

  7.  *

    8. 

  8.  * This program is free software; you can redistribute it and/or modify

    9. 

  9.  * it under the terms of the GNU General Public License as published by

    10. 

  10.  * the Free Software Foundation; either version 2 of the License, or

    11. 

  11.  * (at your option) any later version.

    12. 

  12.  *

    13. 

  13.  * This program is distributed in the hope that it will be useful,

    14. 

  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    15. 

  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    16. 

  16.  * GNU General Public License for more details.

    17. 

  17.  *

    18. 

  18.  * You should have received a copy of the GNU General Public License

    19. 

  19.  * along with this program; if not, write to the Free Software

    20. 

  20.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    21. 

  21.  *

    22. 

  22.  */

    23. 

  23. 

    24. 

  24. // Expand to define test define

    25. 

  25. @DTESTDEF@

    26. 

  26. // Expand to define logging define

    27. 

  27. @DLOGDEF@

    28. 

  28. package com.substanceofcode.utils;

    29. 

  29. 

    30. 

  30. import java.io.IOException;

    31. 

  31. import java.io.InputStream;

    32. 

  32. import java.io.InputStreamReader;

    33. 

  33. import java.io.UnsupportedEncodingException;

    34. 

  34. import java.util.Hashtable;

    35. 

  35. import java.util.Vector;

    36. 

  36. 

    37. 

  37. import com.substanceofcode.utils.CauseException;

    38. 

  38. 

    39. 

  39. //#ifdef DLOGGING

    40. 

  40. import net.sf.jlogmicro.util.logging.Logger;

    41. 

  41. import net.sf.jlogmicro.util.logging.Level;

    42. 

  42. //#endif

    43. 

  43. 

    44. 

  44. /**

    45. 

  45.  * Simple encoding handler to allow handling utf-16 and 1252.

    46. 

  46.  *

    47. 

  47.  * @author Irving Bunton Jr

    48. 

  48.  */

    49. 

  49. public class EncodingUtil {

    50. 

  50.     

    51. 

  51. 	final static public boolean m_midpIso = (System.getProperty(

    52. 

  52. 			"microedition.encoding").toLowerCase().startsWith("iso-8859") ||

    53. 

  53. 	                                        System.getProperty(

    54. 

  54. 			"microedition.encoding").toLowerCase().startsWith("iso8859"));

    55. 

  55. 	final static public String m_isoEncoding = initIsoEncoding();

    56. 

  56. 	final static public boolean m_midpWin = (System.getProperty(

    57. 

  57. 			"microedition.encoding").toLowerCase().startsWith("cp") ||

    58. 

  58. 	                                        System.getProperty(

    59. 

  59. 			"microedition.encoding").toLowerCase().startsWith("windows"));

    60. 

  60. 	final static public String m_winEncoding = initWinEncoding();

    61. 

  61. 	final static public boolean m_midpUni = System.getProperty(

    62. 

  62. 			"microedition.encoding").toLowerCase().startsWith("utf-8");

    63. 

  63. 	final static String[] m_isoCommonEntities =

    64. 

  64. 		{"iexcl", "cent", "pound", "curren", "yen",

    65. 

  65. 		"brvbar", "sect", "uml", "copy", "ordf",

    66. 

  66. 		"laquo", "not", "shy", "reg", "macr",

    67. 

  67. 		"deg", "plusmn", "sup2", "sup3", "acute",

    68. 

  68. 		"micro", "para", "middot", "cedil", "sup1",

    69. 

  69. 		"ordm", "raquo", "frac14", "frac12", "frac34",

    70. 

  70. 		"iquest"};

    71. 

  71. 

    72. 

  72. 	final static String[] m_isoSpecialEntities =

    73. 

  73. 			{"ndash", // en dash 

    74. 

  74. 			"mdash", // em dash 

    75. 

  75. 			"lsquo", // left single quotation mark 

    76. 

  76. 			"rsquo", // right single quotation mark 

    77. 

  77. 			"sbquo", // single low-9 quotation mark 

    78. 

  78. 			"ldquo", // left double quotation mark 

    79. 

  79. 			"rdquo", // right double quotation mark 

    80. 

  80. 			"bdquo"}; // double low-9 quotation mark 

    81. 

  81. 

    82. 

  82. 	final static char[] m_isoSpecialValues =

    83. 

  83. 			{'-', // en dash 

    84. 

  84. 			'-', // em dash 

    85. 

  85. 			'\'', // left single quotation mark 

    86. 

  86. 			'\'', // right single quotation mark 

    87. 

  87. 			'\'', // single low-9 quotation mark 

    88. 

  88. 			'\"', // left double quotation mark 

    89. 

  89. 			'\"', // right double quotation mark 

    90. 

  90. 			'\"'}; // double low-9 quotation mark 

    91. 

  91. 

    92. 

  92. 	final static char[] m_isoCommValues = 

    93. 

  93. 		{0xA1, 0xA2, 0xA3, 0xA4, 0xA5,

    94. 

  94. 		0xA6, 0xA7, 0xA8, 0xA9, 0xAA,

    95. 

  95. 		0xAB, 0xAC, 0xAD, 0xAE, 0xAF,

    96. 

  96. 		0xB0, 0xB1, 0xB2, 0xB3, 0xB4,

    97. 

  97. 		0xB5, 0xB6, 0xB7, 0xB8, 0xB9,

    98. 

  98. 		0xBA, 0xBB, 0xBC, 0xBD, 0xBE,

    99. 

  99. 		0xBF};

    100. 

  100. 

    101. 

  101. 	final static String[] m_isoLatin1Entities = 

    102. 

  102. 		{"Agrave", "Aacute", "Acirc", "Atilde", "Auml",

    103. 

  103. 		"Aring", "AElig", "Ccedil", "Egrave", "Eacute", "Ecirc", "Euml",

    104. 

  104. 		"Igrave", "Iacute", "Icirc", "Iuml", "ETH", "Ntilde", "Ograve",

    105. 

  105. 		"Oacute", "Ocirc", "Otilde", "Ouml", "times", "Oslash", "Ugrave",

    106. 

  106. 		"Uacute", "Ucirc", "Uuml", "Yacute", "THORN", "szlig", "agrave",

    107. 

  107. 		"aacute", "acirc", "atilde", "auml", "aring", "aelig", "ccedil",

    108. 

  108. 		"egrave", "eacute", "ecirc", "euml", "igrave", "iacute", "icirc",

    109. 

  109. 		"iuml", "eth", "ntilde", "ograve", "oacute", "ocirc", "otilde",

    110. 

  110. 		"ouml", "divide", "oslash", "ugrave", "uacute", "ucirc", "uuml",

    111. 

  111. 		"yacute", "thorn", "yuml"};

    112. 

  112. 

    113. 

  113. 	// Convert windows characters in iso 8859 control range to ISO

    114. 

  114. 	// (not the actual character, but a good fix or remove if no equivalent)

    115. 

  115. 	final public static char[] m_winIsoConvx80 = initWinIsoConv();

    116. 

  116. 

    117. 

  117. 	// Convert uni chars to equivalent windows characters in the 0x80 - 0x9f

    118. 

  118. 	// range.

    119. 

  119. 	final public static char[] m_uniWinConvx80 = initUniWinConvx80();

    120. 

  120. 

    121. 

  121. 	// See if windows cp-1252 is supported.

    122. 

  122. 	final public static boolean m_hasWinEncoding = hasWinEncoding();

    123. 

  123. 	// See if ISO8859-1 is supported.

    124. 

  124. 	final public static boolean m_hasIso8859Encoding = hasIso8859Encoding();

    125. 

  125. 

    126. 

  126. 	final private static String m_xmlEntKeys =

    127. 

  127. 			"<  >   & '"";

    128. 

  128. 	final private static String[] m_xmlEntValues =

    129. 

  129. 			{"<", ">", " ", "&", "'", "\""};

    130. 

  130. 

    131. 

  131. 	// Left single quote in cp-1252 (Windows) encoding.

    132. 

  132.     public static final char CWSGL_LOW9_QUOTE = 0x82; // #130;

    133. 

  133.     public static final char CWDBL_LOW9_QUOTE = 0x84; // #132;

    134. 

  134.     public static final char CWLEFT_SGL_QUOTE = 0x91; // #145;

    135. 

  135.     public static final char CWRIGHT_SGL_QUOTE = 0x92; // #146;

    136. 

  136.     public static final char [] CAWRIGHT_SGL_QUOTE = {CWRIGHT_SGL_QUOTE};

    137. 

  137.     public static final String WRIGHT_SGL_QUOTE = new String(CAWRIGHT_SGL_QUOTE);

    138. 

  138.     public static final char CWLEFT_DBL_QUOTE = 0x93; // #147;

    139. 

  139.     public static final char CWRIGHT_DBL_QUOTE = 0x94; // #148;

    140. 

  140.     public static final char CWEN_DASH = 0x96; // #150;

    141. 

  141.     public static final char CWEM_DASH = 0x97; // #151;

    142. 

  142. 	// Left single quote in Unicode (utf-16) encoding.

    143. 

  143. 	// Long dash a.k.a en dash

    144. 

  144.     public static final char CEN_DASH = 0x2013;

    145. 

  145.     public static final char CEM_DASH = 0x2014;

    146. 

  146.     public static final char CLEFT_SGL_QUOTE = 0x2018;

    147. 

  147.     public static final char CRIGHT_SGL_QUOTE = 0x2019;

    148. 

  148.     public static final char [] CARIGHT_SGL_QUOTE = {CRIGHT_SGL_QUOTE};

    149. 

  149.     public static final String RIGHT_SGL_QUOTE = new String(CARIGHT_SGL_QUOTE);

    150. 

  150.     public static final char CSGL_LOW9_QUOTE = 0x201A;

    151. 

  151.     private static final char CLEFT_DBL_QUOTE = 0x201C;

    152. 

  152.     private static final char CRIGHT_DBL_QUOTE = 0x201D;

    153. 

  153.     public static final char CDBL_LOW9_QUOTE = 0x201E;

    154. 

  154.     public static final char CA_UMLAUTE = (char)228;

    155. 

  155.     private static final char CO_UMLAUTE = (char)246;

    156. 

  156.     public static final char CNON_BREAKING_SP = (char)160;

    157. 

  157.     

    158. 

  158.     private EncodingStreamReader m_encodingStreamReader;

    159. 

  159. 	final private static Hashtable m_convXmlEntities = initXmlEntities();

    160. 

  160. 	final private static Hashtable m_convIso88591 = initAlphaIso88591(false);

    161. 

  161. 	final private static Hashtable m_convXmlIso88591 = initAlphaIso88591(true);

    162. 

  162. 	final private static Hashtable m_convCp1252 = initAlphaCp1252(false);

    163. 

  163. 	final private static Hashtable m_convXmlCp1252 = initAlphaCp1252(true);

    164. 

  164.     private String m_docEncoding = "";  // Default for XML is UTF-8.

    165. 

  165. 	                                    // unexpected UTF-16.

    166. 

  166.     private boolean m_utf = false;  // Doc is utf.

    167. 

  167.     private boolean m_getPrologue = true;

    168. 

  168.     private boolean m_windows = false;  // True if windows code space

    169. 

  169. 	final private static boolean m_convWinUni = initConvWinUni();

    170. 

  170. 	static Vector m_statExcs = null; // Exceptions encountered


    171. 

  171. 	Vector m_excs = null; // Exceptions encountered


    172. 

  172. 	//#ifdef DTEST

    173. 

  173.     final private static boolean m_debugTrace = false;  // True if want to trace more

    174. 

  174. 	//#endif

    175. 

  175. 	//#ifdef DLOGGING

    176. 

  176.     final private Logger logger = Logger.getLogger("EncodingUtil");

    177. 

  177.     final private boolean fineLoggable = logger.isLoggable(Level.FINE);

    178. 

  178.     final private boolean finestLoggable = logger.isLoggable(Level.FINEST);

    179. 

  179. 	//#endif

    180. 

  180.     

    181. 

  181.     /** Creates a new instance of EncodingUtil */

    182. 

  182.     public EncodingUtil(InputStream inputStream) {

    183. 

  183. 		m_encodingStreamReader = new EncodingStreamReader(inputStream);

    184. 

  184.     }

    185. 

  185. 

    186. 

  186. 	/**  Determine the encoding based on what is passed in as well

    187. 

  187. 	  as if/when strings are to be further encoded.  Also decide to

    188. 

  188. 	  modify bytes read.  

    189. 

  189. 	 **/

    190. 

  190. 

    191. 

  191.     public void getEncoding(final String fileEncoding, final String encoding) {

    192. 

  192. 		getEncoding(m_hasIso8859Encoding, m_isoEncoding, m_hasWinEncoding,

    193. 

  193. 				m_winEncoding, fileEncoding, encoding);

    194. 

  194. 	}

    195. 

  195. 

    196. 

  196. 	/**  Determine the encoding based on what is passed in as well

    197. 

  197. 	  as if/when strings are to be further encoded.  Also decide to

    198. 

  198. 	  modify bytes read.  

    199. 

  199. 	 **/

    200. 

  200. 

    201. 

  201.     public void getEncoding(final boolean hasIso8859Encoding,

    202. 

  202. 			final String isoEncoding, final boolean hasWinEncoding,

    203. 

  203. 			final String winEncoding, final String fileEncoding,

    204. 

  204. 			final String encoding) {

    205. 

  205. 		String cencoding = encoding;

    206. 

  206.         // If there is a second char, don't stop splitting until we

    207. 

  207.         // return that char as input.

    208. 

  208.         if (cencoding == null) {

    209. 

  209.            cencoding = "UTF-8";

    210. 

  210.         }

    211. 

  211.         cencoding = cencoding.toUpperCase();

    212. 

  212. 		boolean modUTF16 = m_encodingStreamReader.isModUTF16();

    213. 

  213. 		boolean modEncoding = m_encodingStreamReader.isModEncoding();

    214. 

  214. 		m_utf = false;

    215. 

  215. 		m_windows = false;

    216. 

  216. 		String docEncoding = fileEncoding;

    217. 

  217. 		// Only need to convert from 2 byte to 1 byte and vsa versa.

    218. 

  218.         if ((cencoding.equals("UTF-8") || cencoding.equals("UTF8"))) {

    219. 

  219.             docEncoding = "UTF-8";

    220. 

  220.             modEncoding = false;

    221. 

  221. 			m_utf = true;

    222. 

  222.         } else if (cencoding.equals("UTF-16") || cencoding.equals("UTF16")) {

    223. 

  223. 			// If utf-16, don't set doc encoding as we are converting the

    224. 

  224. 			// bytes to single chars.

    225. 

  225.             modUTF16 = true;

    226. 

  226. 			m_utf = true;

    227. 

  227. 			// Don't do doc encoding as the stream reader does it.

    228. 

  228.             docEncoding = "";

    229. 

  229. 		} else if (cencoding.startsWith("ISO-8859")) {

    230. 

  230. 			if (hasIso8859Encoding) {

    231. 

  231. 				if (isoEncoding.indexOf("-") == -1) {

    232. 

  232. 					docEncoding = StringUtil.replace(cencoding, "ISO-",

    233. 

  233. 							"ISO");

    234. 

  234. 					docEncoding = docEncoding.replace('-', '_');

    235. 

  235. 				} else {

    236. 

  236. 					docEncoding = cencoding;

    237. 

  237. 				}

    238. 

  238. 			} else {

    239. 

  239. 				docEncoding = "";

    240. 

  240. 			}

    241. 

  241. 			modEncoding = false;

    242. 

  242. 

    243. 

  243. 		} else if (cencoding.startsWith("ISO8859")) {

    244. 

  244. 			if (hasIso8859Encoding) {

    245. 

  245. 				if (isoEncoding.indexOf("-") >= 0) {

    246. 

  246. 					docEncoding = StringUtil.replace(cencoding, "ISO",

    247. 

  247. 							"ISO-");

    248. 

  248. 					docEncoding = docEncoding.replace('_', '-');

    249. 

  249. 				} else {

    250. 

  250. 					docEncoding = cencoding;

    251. 

  251. 				}

    252. 

  252. 			} else {

    253. 

  253. 				docEncoding = "";

    254. 

  254. 			}

    255. 

  255. 			modEncoding = false;

    256. 

  256. 		} else if (cencoding.startsWith("WINDOWS-12")) {

    257. 

  257. 			if (hasWinEncoding) {

    258. 

  258. 				if (winEncoding.indexOf("-") == -1) {

    259. 

  259. 					docEncoding = StringUtil.replace(cencoding, "WINDOWS-",

    260. 

  260. 							"Cp");

    261. 

  261. 				} else {

    262. 

  262. 					docEncoding = cencoding;

    263. 

  263. 				}

    264. 

  264. 			} else {

    265. 

  265. 				docEncoding = "";

    266. 

  266. 			}

    267. 

  267. 			modEncoding = false;

    268. 

  268. 			m_windows = true;

    269. 

  269. 		} else if (cencoding.indexOf("CP-") == 0) {

    270. 

  270. 			if (hasWinEncoding) {

    271. 

  271. 				if (winEncoding.indexOf("-") >= 0) {

    272. 

  272. 					docEncoding = StringUtil.replace(cencoding, "CP-",

    273. 

  273. 							"WINDOWS-");

    274. 

  274. 				} else {

    275. 

  275. 					docEncoding = StringUtil.replace(cencoding, "CP-",

    276. 

  276. 							"Cp");

    277. 

  277. 				}

    278. 

  278. 			} else {

    279. 

  279. 				docEncoding = "";

    280. 

  280. 			}

    281. 

  281. 			modEncoding = false;

    282. 

  282. 			m_windows = true;

    283. 

  283. 		} else if (cencoding.startsWith("CP")) {

    284. 

  284. 			if (hasWinEncoding) {

    285. 

  285. 				if (winEncoding.indexOf("-") >= 0) {

    286. 

  286. 					docEncoding = StringUtil.replace(cencoding, "CP",

    287. 

  287. 							"WINDOWS-");

    288. 

  288. 				} else {

    289. 

  289. 					docEncoding = StringUtil.replace(cencoding, "CP", "Cp");

    290. 

  290. 				}

    291. 

  291. 			} else {

    292. 

  292. 				docEncoding = "";

    293. 

  293. 			}

    294. 

  294. 			modEncoding = false;

    295. 

  295. 			m_windows = true;

    296. 

  296. 		}

    297. 

  297. 		if (docEncoding.equals(fileEncoding)) {

    298. 

  298. 			m_docEncoding = "";

    299. 

  299. 		} else {

    300. 

  300. 			m_docEncoding = docEncoding;

    301. 

  301. 		}

    302. 

  302. 		if (m_docEncoding.length() != 0) {

    303. 

  303. 			try {

    304. 

  304. 				String a = new String("a".getBytes(), m_docEncoding);

    305. 

  305. 			} catch (UnsupportedEncodingException e) {

    306. 

  306. 				CauseException ce = new CauseException(

    307. 

  307. 						"UnsupportedEncodingException while trying to " +

    308. 

  308. 						"convert doc encoding: " + m_docEncoding, e);

    309. 

  309. 				if (m_excs == null) {

    310. 

  310. 					m_excs = new Vector();

    311. 

  311. 				}

    312. 

  312. 				m_excs.addElement(ce);

    313. 

  313. 				//#ifdef DLOGGING

    314. 

  314. 				logger.severe(ce.getMessage(), e);

    315. 

  315. 				//#endif

    316. 

  316. 				System.out.println(ce.getMessage());

    317. 

  317. 				// If encoding problem, use the main encoding as it is

    318. 

  318. 				// close enough.

    319. 

  319. 				if (m_windows) {

    320. 

  320. 					if (hasWinEncoding) {

    321. 

  321. 						m_docEncoding = winEncoding;

    322. 

  322. 					} else {

    323. 

  323. 						m_docEncoding = "";

    324. 

  324. 					}

    325. 

  325. 				} else if (m_utf) {

    326. 

  326. 					m_docEncoding = "";

    327. 

  327. 				} else {

    328. 

  328. 					if (hasIso8859Encoding) {

    329. 

  329. 						m_docEncoding = isoEncoding;

    330. 

  330. 					} else {

    331. 

  331. 						m_docEncoding = "";

    332. 

  332. 					}

    333. 

  333. 				}

    334. 

  334. 				try {

    335. 

  335. 					String a = new String("a".getBytes(), m_docEncoding);

    336. 

  336. 				} catch (UnsupportedEncodingException e2) {

    337. 

  337. 					CauseException ce2 = new CauseException(

    338. 

  338. 							"Second unsupportedEncodingException while " +

    339. 

  339. 							" trying to convert doc encoding: " +

    340. 

  340. 							m_docEncoding, e2);

    341. 

  341. 					m_excs.addElement(ce2);

    342. 

  342. 					//#ifdef DLOGGING

    343. 

  343. 					logger.severe(ce2.getMessage(), e2);

    344. 

  344. 					//#endif

    345. 

  345. 					System.out.println(ce2.getMessage());

    346. 

  346. 					m_docEncoding = "";

    347. 

  347. 				}

    348. 

  348. 			}

    349. 

  349. 		}

    350. 

  350. 		m_encodingStreamReader.setModEncoding(modEncoding);

    351. 

  351. 		m_encodingStreamReader.setModUTF16(modUTF16);

    352. 

  352. 

    353. 

  353. 		//#ifdef DLOGGING

    354. 

  354.         if (fineLoggable) {logger.fine("hasIso8859Encoding=" + hasIso8859Encoding);}

    355. 

  355.         if (fineLoggable) {logger.fine("isoEncoding=" + isoEncoding);}

    356. 

  356.         if (fineLoggable) {logger.fine("hasWinEncoding=" + hasWinEncoding);}

    357. 

  357.         if (fineLoggable) {logger.fine("winEncoding=" + winEncoding);}

    358. 

  358.         if (fineLoggable) {logger.fine("encoding=" + encoding);}

    359. 

  359.         if (fineLoggable) {logger.fine("cencoding=" + cencoding);}

    360. 

  360.         if (fineLoggable) {logger.fine("docEncoding=" + docEncoding);}

    361. 

  361.         if (fineLoggable) {logger.fine("m_docEncoding=" + m_docEncoding);}

    362. 

  362.         if (fineLoggable) {logger.fine("fileEncoding=" + fileEncoding);}

    363. 

  363.         if (fineLoggable) {logger.fine("m_windows=" + m_windows);}

    364. 

  364.         if (fineLoggable) {logger.fine("m_utf=" + m_utf);}

    365. 

  365.         if (fineLoggable) {logger.fine("modEncoding=" + modEncoding);}

    366. 

  366.         if (fineLoggable) {logger.fine("modUTF16=" + modUTF16);}

    367. 

  367. 		//#endif

    368. 

  368.     }

    369. 

  369. 

    370. 

  370. 	/* Replace special characters with valid ones for the specified

    371. 

  371. 	   encoding. */

    372. 

  372. 	public static String replaceSpChars(String text, boolean isWindows,

    373. 

  373. 										boolean isUtf) {

    374. 

  374. 		return replaceSpChars(text, isWindows, isUtf, m_midpWin, m_midpUni);

    375. 

  375. 	}

    376. 

  376. 

    377. 

  377. 	/* Replace special characters with valid ones for the specified

    378. 

  378. 	   encoding.   For callers which use an instance of this class.  */

    379. 

  379. 	public String replaceSpChars(String text) {

    380. 

  380. 		return replaceSpChars(text, m_windows, m_utf, m_midpWin, m_midpUni);

    381. 

  381. 	}

    382. 

  382. 

    383. 

  383. 	/* Replace special characters with valid ones for the specified

    384. 

  384. 	   encoding. */

    385. 

  385. 	public static String replaceSpChars(String text, final boolean isWindows,

    386. 

  386. 										final boolean isUtf,

    387. 

  387. 										final boolean midpWin,

    388. 

  388. 										final boolean midpUni) {

    389. 

  389. 		try {

    390. 

  390. 			// No need to convert i diaeresis anymore as we do encoding

    391. 

  391. 			// change.

    392. 

  392. 			if (isWindows) {

    393. 

  393. 				if (midpWin) {

    394. 

  394. 					if (m_convWinUni) {

    395. 

  395. 						text = replaceSpUniChars(text);

    396. 

  396. 						return text;

    397. 

  397. 					}

    398. 

  398. 				/* If we are converting a windows doc, the windows special

    399. 

  399. 				   characters are control characters in other encodings,

    400. 

  400. 				   so change to ASCII. */

    401. 

  401. 				} else if (m_convWinUni) {

    402. 

  402. 					if (!midpUni) {

    403. 

  403. 						text = replaceSpUniWinChars(text);

    404. 

  404. 					}

    405. 

  405. 				} else {

    406. 

  406. 					char [] ctext = text.toCharArray();

    407. 

  407. 					char [] ntext = new char[text.length()];

    408. 

  408. 					int jc = 0;

    409. 

  409. 					for (int ic = 0; ic < ctext.length; ic++) {

    410. 

  410. 						final char cchr = ctext[ic];

    411. 

  411. 						if ((0x80 <= (int)cchr) && ((int)cchr <= 0x9f)) {

    412. 

  412. 							if (m_winIsoConvx80[(int)cchr - 0x80] != 0x01) {

    413. 

  413. 								ntext[jc++] = m_winIsoConvx80[(int)cchr - 0x80];

    414. 

  414. 								//#ifdef DTEST

    415. 

  415. 								if (m_debugTrace) {System.out.println("array cchr,conv=" + cchr + "," + Integer.toHexString(cchr) + "," + ntext[jc - 1] + "," + Integer.toHexString(ntext[jc - 1]));}

    416. 

  416. 								//#endif

    417. 

  417. 							}

    418. 

  418. 						} else {

    419. 

  419. 							ntext[jc++] = cchr;

    420. 

  420. 							//#ifdef DTEST

    421. 

  421. 							if (m_debugTrace) {System.out.println("cchr,conv=" + cchr + "," + Integer.toHexString(cchr) + "," + ntext[jc - 1] + "," + Integer.toHexString(ntext[jc - 1]));}

    422. 

  422. 							//#endif

    423. 

  423. 						}

    424. 

  424. 					}

    425. 

  425. 					text = new String(ntext, 0, jc);

    426. 

  426. 					//#ifdef DTEST

    427. 

  427. 					if (m_debugTrace) {System.out.println( "text,len=" + text + "," + text.length());}

    428. 

  428. 					//#endif

    429. 

  429. 				}

    430. 

  430. 			} else if (isUtf && !midpUni) {

    431. 

  431. 				text = replaceSpUniChars(text);

    432. 

  432. 			}

    433. 

  433. 			text = text.replace(CNON_BREAKING_SP, ' ');

    434. 

  434. 		} catch (Throwable t) {

    435. 

  435. 			//#ifdef DLOGGING

    436. 

  436. 			Logger logger = Logger.getLogger("EncodingUtil");

    437. 

  437.             logger.severe("replaceSpChars error ", t);

    438. 

  438. 			//#endif

    439. 

  439.             System.out.println("replaceSpChars error " + t + "," +

    440. 

  440. 					           t.getMessage());

    441. 

  441. 		}

    442. 

  442. 		return text;

    443. 

  443. 	}

    444. 

  444. 

    445. 

  445. 	/* Replace Unicode special characters with valid ones for Windows

    446. 

  446. 	   encoding as they sometimes are valid even in iso8859_1 even though

    447. 

  447. 	   it shouldn't be.  */

    448. 

  448. 	public static String replaceSpUniWinChars(String text) {

    449. 

  449. 		try {

    450. 

  450. 			final char [] ctext = text.toCharArray();

    451. 

  451. 			char [] ntext = new char[text.length()];

    452. 

  452. 			int jc = 0;

    453. 

  453. 			for (int ic = 0; ic < ctext.length; ic++) {

    454. 

  454. 				final char c = ctext[ic];

    455. 

  455. 				switch(c & 0xff00) {

    456. 

  456. 					case 0x2000:

    457. 

  457. 						switch(c) {

    458. 

  458. 							case CEN_DASH:

    459. 

  459. 								ntext[jc++] = '-';

    460. 

  460. 								break;

    461. 

  461. 							case CEM_DASH:

    462. 

  462. 								ntext[jc++] = '-';

    463. 

  463. 								break;

    464. 

  464. 							case CLEFT_SGL_QUOTE:

    465. 

  465. 								ntext[jc++] = '\'';

    466. 

  466. 								break;

    467. 

  467. 							case CRIGHT_SGL_QUOTE:

    468. 

  468. 								ntext[jc++] = '\'';

    469. 

  469. 								break;

    470. 

  470. 							case CSGL_LOW9_QUOTE:

    471. 

  471. 								ntext[jc++] = '\'';

    472. 

  472. 								break;

    473. 

  473. 							case CLEFT_DBL_QUOTE:

    474. 

  474. 								ntext[jc++] = '\"';

    475. 

  475. 								break;

    476. 

  476. 							case CRIGHT_DBL_QUOTE:

    477. 

  477. 								ntext[jc++] = '\"';

    478. 

  478. 								break;

    479. 

  479. 							case CDBL_LOW9_QUOTE:

    480. 

  480. 								ntext[jc++] = '\"';

    481. 

  481. 								break;

    482. 

  482. 							case 0x2020:

    483. 

  483. 								ntext[jc++] = 0x86;

    484. 

  484. 								break;

    485. 

  485. 							case 0x2021:

    486. 

  486. 								ntext[jc++] = 0x87;

    487. 

  487. 								break;

    488. 

  488. 							case 0x2022:

    489. 

  489. 								ntext[jc++] = 0x95;

    490. 

  490. 								break;

    491. 

  491. 							case 0x2026:

    492. 

  492. 								ntext[jc++] = 0x85;

    493. 

  493. 								break;

    494. 

  494. 							case 0x2030:

    495. 

  495. 								ntext[jc++] = 0x89;

    496. 

  496. 								break;

    497. 

  497. 							case 0x2039:

    498. 

  498. 								ntext[jc++] = 0x8B;

    499. 

  499. 								break;

    500. 

  500. 							case 0x203A:

    501. 

  501. 								ntext[jc++] = 0x9B;

    502. 

  502. 								break;

    503. 

  503. 							case 0x20AC:

    504. 

  504. 								ntext[jc++] = 0x80;

    505. 

  505. 								System.out.println("ic,c=" + c + "," + Integer.toHexString(ntext[jc-1]));

    506. 

  506. 								break;

    507. 

  507. 							default:

    508. 

  508. 								ntext[jc++] = c;

    509. 

  509. 								break;

    510. 

  510. 						}

    511. 

  511. 						break;

    512. 

  512. 					default:

    513. 

  513. 						ntext[jc++] = c;

    514. 

  514. 						break;

    515. 

  515. 				}

    516. 

  516. 			}

    517. 

  517. 			text = new String(ntext, 0, jc);

    518. 

  518. 		} catch (Throwable t) {

    519. 

  519. 			//#ifdef DLOGGING

    520. 

  520. 			Logger logger = Logger.getLogger("EncodingUtil");

    521. 

  521.             logger.severe("replaceSpUniWinChars error ", t);

    522. 

  522. 			//#endif

    523. 

  523.             System.out.println("replaceSpUniWinChars error " + t + "," +

    524. 

  524. 					           t.getMessage());

    525. 

  525. 		}

    526. 

  526. 		return text;

    527. 

  527. 	}

    528. 

  528. 

    529. 

  529. 	/* Replace Unicode special characters which have Windows (cp1252)

    530. 

  530. 	   equivalents into their windows equivalents except for those

    531. 

  531. 	   that have simi-equivalents (e.g. en dash to regular dash)*/

    532. 

  532. 	public static String replaceSpUniChars(String text) {

    533. 

  533. 		text = text.replace(CSGL_LOW9_QUOTE, '\'');

    534. 

  534. 		text = text.replace(CLEFT_SGL_QUOTE, '\'');

    535. 

  535. 		text = text.replace(CRIGHT_SGL_QUOTE, '\'');

    536. 

  536. 		text = text.replace(CLEFT_DBL_QUOTE, '\"');

    537. 

  537. 		text = text.replace(CRIGHT_DBL_QUOTE, '\"');

    538. 

  538. 		text = text.replace(CDBL_LOW9_QUOTE, '\"');

    539. 

  539. 		text = text.replace(CEN_DASH, '-');

    540. 

  540. 		text = text.replace(CEM_DASH, '-');

    541. 

  541. 		return text;

    542. 

  542. 	}

    543. 

  543. 

    544. 

  544. 	/* Replace Windows special characters with simi-equivalents

    545. 

  545. 	   (e.g. en dash to regular dash)*/

    546. 

  546. 	public static String replaceSpWinChars(String text) {

    547. 

  547. 		text = text.replace(CWSGL_LOW9_QUOTE, '\'');

    548. 

  548. 		text = text.replace(CWLEFT_SGL_QUOTE, '\'');

    549. 

  549. 		text = text.replace(CWRIGHT_SGL_QUOTE, '\'');

    550. 

  550. 		text = text.replace(CWLEFT_DBL_QUOTE, '\"');

    551. 

  551. 		text = text.replace(CWRIGHT_DBL_QUOTE, '\"');

    552. 

  552. 		text = text.replace(CWDBL_LOW9_QUOTE, '\"');

    553. 

  553. 		text = text.replace(CWEN_DASH, '-');

    554. 

  554. 		text = text.replace(CWEM_DASH, '-');

    555. 

  555. 		return text;

    556. 

  556. 	}

    557. 

  557. 

    558. 

  558.     /* Replace all numeric entites e.g. &#228;

    559. 

  559.      *   @param  s  String to alter.

    560. 

  560.      */

    561. 

  561.     public static String replaceNumEntity( String s) {

    562. 

  562.         if (s == null)  return s;

    563. 

  563. 		String snum = "";

    564. 

  564. 		try {

    565. 

  565. 			

    566. 

  566. 			int index01 = s.indexOf( "&#" );

    567. 

  567. 			char [] achar = new char[1];

    568. 

  568. 			while (index01 != -1) {

    569. 

  569. 				int index02 = s.indexOf( ';' , index01 );

    570. 

  570. 				if (index02 == -1) {

    571. 

  571. 					return s;

    572. 

  572. 				}

    573. 

  573. 				try {

    574. 

  574. 					snum = s.substring(index01 + 2, index02);

    575. 

  575. 					// TODO redo with StringBuffer?

    576. 

  576. 					if (snum.length() == 0) {

    577. 

  577. 						return s;

    578. 

  578. 					}

    579. 

  579. 					switch (snum.charAt(0)) {

    580. 

  580. 						case 'x':

    581. 

  581. 						case 'X':

    582. 

  582. 							achar[0] = (char)Integer.parseInt(snum.substring(

    583. 

  583. 										1), 16);

    584. 

  584. 							break;

    585. 

  585. 						default:

    586. 

  586. 							achar[0] = (char)Integer.parseInt(snum);

    587. 

  587. 							break;

    588. 

  588. 					}

    589. 

  589. 					s = s.substring(0, index01) + new String(achar) +

    590. 

  590. 							  s.substring(index02 + 1);

    591. 

  591. 				} catch (NumberFormatException e) {

    592. 

  592. 					//#ifdef DLOGGING

    593. 

  593. 					Logger logger = Logger.getLogger("EncodingUtil");

    594. 

  594. 					logger.severe("replaceNumEntity NumberFormatException error  for " + snum, e);

    595. 

  595. 					//#endif

    596. 

  596. 					System.out.println("replaceNumEntity error " + e + "," +

    597. 

  597. 									   e.getMessage());

    598. 

  598. 					return s;

    599. 

  599. 				}

    600. 

  600. 				index01 = s.indexOf( "&#" );

    601. 

  601. 			}

    602. 

  602. 		} catch (Throwable t) {

    603. 

  603. 			//#ifdef DLOGGING

    604. 

  604. 			Logger logger = Logger.getLogger("EncodingUtil");

    605. 

  605.             logger.severe("replaceNumEntity error ", t);

    606. 

  606. 			//#endif

    607. 

  607.             System.out.println("replaceNumEntity error " + t + "," +

    608. 

  608. 					           t.getMessage());

    609. 

  609. 		}

    610. 

  610.         return s;

    611. 

  611.     }

    612. 

  612.     

    613. 

  613. 	/**

    614. 

  614. 	  Replace alphabetic entities.

    615. 

  615. 	  */

    616. 

  616. 	public static String replaceAlphaEntities(final boolean convXmlEnts,

    617. 

  617. 			String text) {

    618. 

  618. 		final Hashtable m_convEntities = (m_midpWin) ?

    619. 

  619. 			    (convXmlEnts ? m_convXmlCp1252 : m_convCp1252) :

    620. 

  620. 				(convXmlEnts ? m_convXmlIso88591 : m_convIso88591);

    621. 

  621. 		int beginPos = 0;

    622. 

  622. 		int pos = -1;

    623. 

  623. 		while ((pos = text.indexOf('&', beginPos)) >= 0) {

    624. 

  624. 			int epos = text.indexOf(';', pos);

    625. 

  625. 			if (epos < 0) {

    626. 

  626. 				break;

    627. 

  627. 			}

    628. 

  628. 			int nbpos = text.indexOf('&', pos + 1);

    629. 

  629. 			if ((nbpos >= 0) && (nbpos < epos)) {

    630. 

  630. 				beginPos = nbpos;

    631. 

  631. 				continue;

    632. 

  632. 			}

    633. 

  633. 			if ((pos + 1) == epos) {

    634. 

  634. 				beginPos = epos + 1;

    635. 

  635. 				continue;

    636. 

  636. 			}

    637. 

  637. 			String entity = text.substring(pos + 1, epos);

    638. 

  638. 			Object oent = m_convEntities.get(entity);

    639. 

  639. 			if (oent != null) {

    640. 

  640. 				String ent = (String)oent;

    641. 

  641. 				text = text.substring(0, pos) + ent + text.substring(epos + 1);

    642. 

  642. 				// If we made a substitution, keep the position the same

    643. 

  643. 				// as sometimes, we get a double substitution when

    644. 

  644. 				// we substitute &amp; for & this may create another

    645. 

  645. 				// entity (e.g. &amp;quot; becomes & &quot;)

    646. 

  646. 				beginPos = pos;

    647. 

  647. 			} else {

    648. 

  648. 				beginPos = epos + 1;

    649. 

  649. 			}

    650. 

  650. 		}

    651. 

  651. 		return text;

    652. 

  652. 	}

    653. 

  653. 

    654. 

  654. 	/**

    655. 

  655. 	  Replace alphabetic entities.

    656. 

  656. 	  */

    657. 

  657. 	public static String replaceXmlEntities(String text) {

    658. 

  658. 		int beginPos = 0;

    659. 

  659. 		int pos = -1;

    660. 

  660. 		while ((pos = text.indexOf('&', beginPos)) >= 0) {

    661. 

  661. 			int epos = text.indexOf(';', pos);

    662. 

  662. 			if (epos < 0) {

    663. 

  663. 				break;

    664. 

  664. 			}

    665. 

  665. 			int nbpos = text.indexOf('&', pos + 1);

    666. 

  666. 			if ((nbpos >= 0) && (nbpos < epos)) {

    667. 

  667. 				beginPos = nbpos;

    668. 

  668. 				continue;

    669. 

  669. 			}

    670. 

  670. 			if ((pos + 1) == epos) {

    671. 

  671. 				beginPos = epos + 1;

    672. 

  672. 				continue;

    673. 

  673. 			}

    674. 

  674. 			String entity = text.substring(pos, epos + 1);

    675. 

  675. 			int spos = m_xmlEntKeys.indexOf(entity);

    676. 

  676. 			if (spos >= 0) {

    677. 

  677. 				String ent = m_xmlEntValues[spos / 6];

    678. 

  678. 				text = text.substring(0, pos) + ent + text.substring(epos + 1);

    679. 

  679. 				// If we made a substitution, keep the position the same

    680. 

  680. 				// as sometimes, we get a double substitution when

    681. 

  681. 				// we substitute &amp; for & this may create another

    682. 

  682. 				// entity (e.g. &amp;quot; becomes & &quot;)

    683. 

  683. 				beginPos = pos;

    684. 

  684. 			} else {

    685. 

  685. 				beginPos = epos + 1;

    686. 

  686. 			}

    687. 

  687. 		}

    688. 

  688. 		return text;

    689. 

  689. 	}

    690. 

  690. 

    691. 

  691. 	/**

    692. 

  692. 	  Create table of XML entities.

    693. 

  693. 	  */

    694. 

  694. 	public static Hashtable initXmlEntities() {

    695. 

  695. 		Hashtable convEntities = new Hashtable();

    696. 

  696. 		try {

    697. 

  697. 			initHtmlCommEnts(convEntities);

    698. 

  698. 		} catch (Throwable t) {

    699. 

  699. 			//#ifdef DLOGGING

    700. 

  700. 			Logger logger = Logger.getLogger("EncodingUtil");

    701. 

  701. 			logger.severe("initXmlEntities", t);

    702. 

  702. 			//#endif

    703. 

  703. 		}

    704. 

  704. 		return convEntities;

    705. 

  705. 	}

    706. 

  706. 

    707. 

  707. 	/**

    708. 

  708. 	  Create table of alpha entities for iso8859-1.

    709. 

  709. 	  */

    710. 

  710. 	public static Hashtable initAlphaIso88591(final boolean convXmlEnts) {

    711. 

  711. 

    712. 

  712. 		//#ifdef DTEST

    713. 

  713. 		System.out.println( "m_midpIso=" + m_midpIso);

    714. 

  714. 		//#endif

    715. 

  715. 		final char isoLatin1Values[] =

    716. 

  716. 			{0xC0, 0xC1, 0xC2, 0xC3, 0xC4,

    717. 

  717. 			0xC5, 0xC6, 0xC7, 0xC8, 0xC9,

    718. 

  718. 			0xCA, 0xCB, 0xCC, 0xCD, 0xCE,

    719. 

  719. 			0xCF, 0xD0, 0xD1, 0xD2, 0xD3,

    720. 

  720. 			0xD4, 0xD5, 0xD6, 0xD7, 0xD8,

    721. 

  721. 			0xD9, 0xDA, 0xDB, 0xDC, 0xDD,

    722. 

  722. 			0xDE, 0xDF, 0xE0, 0xE1, 0xE2,

    723. 

  723. 			0xE3, 0xE4, 0xE5, 0xE6, 0xE7,

    724. 

  724. 			0xE8, 0xE9, 0xEA, 0xEB, 0xEC,

    725. 

  725. 			0xED, 0xEE, 0xEF, 0xF0, 0xF1,

    726. 

  726. 			0xF2, 0xF3, 0xF4, 0xF5, 0xF6,

    727. 

  727. 			0xF7, 0xF8, 0xF9, 0xFA, 0xFB,

    728. 

  728. 			0xFC, 0xFD, 0xFE, 0xFF};

    729. 

  729. 

    730. 

  730. 		Hashtable convEntities = new Hashtable();

    731. 

  731. 		try {

    732. 

  732. 			initEntVals(convEntities, m_isoCommonEntities, m_isoCommValues);

    733. 

  733. 			initEntVals(convEntities, m_isoLatin1Entities, isoLatin1Values);

    734. 

  734. 			initEntVals(convEntities, m_isoSpecialEntities, m_isoSpecialValues);

    735. 

  735. 			if (convXmlEnts) {

    736. 

  736. 				initHtmlCommEnts(convEntities);

    737. 

  737. 			}

    738. 

  738. 		} catch (Throwable t) {

    739. 

  739. 			//#ifdef DLOGGING

    740. 

  740. 			Logger logger = Logger.getLogger("EncodingUtil");

    741. 

  741. 			logger.severe("initAlphaIso88591", t);

    742. 

  742. 			//#endif

    743. 

  743. 		}

    744. 

  744. 		return convEntities;

    745. 

  745. 	}

    746. 

  746. 

    747. 

  747. 	/**

    748. 

  748. 	  Create table of alpha entities for windows 1252.

    749. 

  749. 	  */

    750. 

  750. 	public static Hashtable initAlphaCp1252(final boolean convXmlEnts) {

    751. 

  751. 

    752. 

  752. 		//#ifdef DTEST

    753. 

  753. 		System.out.println( "m_midpWin=" + m_midpWin);

    754. 

  754. 		//#endif

    755. 

  755. 		char isoLatin1Values[] =

    756. 

  756. 			{0xC0, 0xC1, 0xC2, 0xC3, 0xC4,

    757. 

  757. 			0xC5, 0xC6, 0xC7, 0xC8, 0xC9,

    758. 

  758. 			0xCA, 0xCB, 0xCC, 0xCD, 0xCE,

    759. 

  759. 			0xCF, 0xD0, 0xD1, 0xD2, 0xD3,

    760. 

  760. 			0xD4, 0xD5, 0xD6, 0xD7, 0xD8,

    761. 

  761. 			0xD9, 0xDA, 0xDB, 0xDC, 0xDD,

    762. 

  762. 			0xDE, 0xDF, 0xE0, 0xE1, 0xE2,

    763. 

  763. 			0xE3, 0xE4, 0xE5, 0xE6, 0xE7,

    764. 

  764. 			0xE8, 0xE9, 0xEA, 0xEB, 0xEC,

    765. 

  765. 			0xED, 0xEE, 0xEF, 0xF0, 0xF1,

    766. 

  766. 			0xF2, 0xF3, 0xF4, 0xF5, 0xF6,

    767. 

  767. 			0xF7, 0xF8, 0xF9, 0xFA, 0xFB,

    768. 

  768. 			0xFC, 0xFD, 0xFE, 0xFF};

    769. 

  769. 

    770. 

  770. 		Hashtable convEntities = new Hashtable();

    771. 

  771. 		try {

    772. 

  772. 			/* ISO common entities have same encodings as Cp1252 */

    773. 

  773. 			initEntVals(convEntities, m_isoCommonEntities, m_isoCommValues);

    774. 

  774. 			initEntVals(convEntities, m_isoLatin1Entities, isoLatin1Values);

    775. 

  775. 			char wm_isoSpecialValues[] =

    776. 

  776. 				{CWEN_DASH, // en dash 

    777. 

  777. 				CWEM_DASH, // em dash 

    778. 

  778. 				CWLEFT_SGL_QUOTE, // left single quotation mark 

    779. 

  779. 				CWRIGHT_SGL_QUOTE, // right single quotation mark 

    780. 

  780. 				0x82, // single low-9 quotation mark 

    781. 

  781. 				CWLEFT_DBL_QUOTE, // left double quotation mark 

    782. 

  782. 				CWRIGHT_DBL_QUOTE, // right double quotation mark 

    783. 

  783. 				0x84}; // double low-9 quotation mark 

    784. 

  784. 			initEntVals(convEntities, m_isoSpecialEntities, wm_isoSpecialValues);

    785. 

  785. 			if (convXmlEnts) {

    786. 

  786. 				initHtmlCommEnts(convEntities);

    787. 

  787. 			}

    788. 

  788. 		} catch (Throwable t) {

    789. 

  789. 			//#ifdef DLOGGING

    790. 

  790. 			Logger logger = Logger.getLogger("EncodingUtil");

    791. 

  791. 			logger.severe("initAlphaCp1252", t);

    792. 

  792. 			//#endif

    793. 

  793. 		}

    794. 

  794. 		return convEntities;

    795. 

  795. 	}

    796. 

  796. 

    797. 

  797. 	/* Initialize entries with passed in entity strings and character

    798. 

  798. 	   values turned into strings. */

    799. 

  799. 	public static void initEntVals(Hashtable convEntities, String[] entities, char[] entValues) {

    800. 

  800. 		try {

    801. 

  801. 			//#ifdef DTEST

    802. 

  802. 			System.out.println( "Entities, values len=" + entities.length + "," + entValues.length);

    803. 

  803. 			//#endif

    804. 

  804. 			for (int ic = 0; (ic < entities.length) && (ic < entValues.length);

    805. 

  805. 					ic++) {

    806. 

  806. 				char [] cvalue = {entValues[ic]};

    807. 

  807. 				// Sometimes, this can produce an error in some default

    808. 

  808. 				// encodings.

    809. 

  809. 				try {

    810. 

  810. 					String value = new String(cvalue);

    811. 

  811. 					convEntities.put(entities[ic], value);

    812. 

  812. 				} catch (Throwable t) {

    813. 

  813. 					//#ifdef DLOGGING

    814. 

  814. 					Logger logger = Logger.getLogger("EncodingUtil");

    815. 

  815. 					logger.severe("initEntVals convert error bvalue=" +

    816. 

  816. 							Integer.toHexString(cvalue[0]), t);

    817. 

  817. 					//#endif

    818. 

  818. 				}

    819. 

  819. 			}

    820. 

  820. 		} catch (Throwable t) {

    821. 

  821. 			//#ifdef DLOGGING

    822. 

  822. 			Logger logger = Logger.getLogger("EncodingUtil");

    823. 

  823. 			logger.severe("initEntVals", t);

    824. 

  824. 			//#endif

    825. 

  825. 		}

    826. 

  826. 	}

    827. 

  827. 

    828. 

  828. 	/* Init windows (cp-1252) to Iso 8859 encoding.  This has either 1

    829. 

  829. 	   if there is no equivalent (this is used to remove the equivalent char

    830. 

  830. 	   from the string to be converted).  If not a 1, the character is

    831. 

  831. 	   used to replace the character in the string to be converted.

    832. 

  832. 	   The conversion starts at 0x80 and goes to including 0x9f.

    833. 

  833. 	   */

    834. 

  834. 	private static char [] initWinIsoConv() {

    835. 

  835. 		char [] convTable = new char[0x9f - 0x80 + 1];

    836. 

  836. 		try {

    837. 

  837. 			//#ifdef DTEST

    838. 

  838. 			System.out.println( "convTable.length=" + convTable.length);

    839. 

  839. 			//#endif

    840. 

  840. 			convTable[0x80 - 0x80] = 0x20AC; //EURO SIGN

    841. 

  841. 			convTable[0x81 - 0x80] = 0x01;

    842. 

  842. 			convTable[0x82 - 0x80] = '\''; //SINGLE LOW-9 QUOTATION MARK

    843. 

  843. 			convTable[0x83 - 0x80] = 0x0192; //LATIN SMALL LETTER F WITH HOOK

    844. 

  844. 			convTable[0x84 - 0x80] = '\"'; //DOUBLE LOW-9 QUOTATION MARK

    845. 

  845. 			convTable[0x85 - 0x80] = 0x2026; //HORIZONTAL ELLIPSIS

    846. 

  846. 			convTable[0x86 - 0x80] = 0x2020; //DAGGER

    847. 

  847. 			convTable[0x87 - 0x80] = 0x2021; //DOUBLE DAGGER

    848. 

  848. 			convTable[0x88 - 0x80] = 0x02C6; //MODIFIER LETTER CIRCUMFLEX ACCENT

    849. 

  849. 			convTable[0x89 - 0x80] = 0x2030; //PER MILLE SIGN

    850. 

  850. 			convTable[0x8A - 0x80] = 0x0160; //LATIN CAPITAL LETTER S WITH CARON

    851. 

  851. 			convTable[0x8B - 0x80] = 0x2039; //SINGLE LEFT-POINTING ANGLE QUOTATION MARK

    852. 

  852. 			convTable[0x8C - 0x80] = 0x0152; //LATIN CAPITAL LIGATURE OE

    853. 

  853. 			convTable[0x8D - 0x80] = 0x01;

    854. 

  854. 			convTable[0x8E - 0x80] = 0x017D; //LATIN CAPITAL LETTER Z WITH CARON

    855. 

  855. 			convTable[0x8F - 0x80] = 0x01;

    856. 

  856. 			convTable[0x90 - 0x80] = 0x01;

    857. 

  857. 			convTable[0x91 - 0x80] = '\''; //LEFT SINGLE QUOTATION MARK

    858. 

  858. 			convTable[0x92 - 0x80] = '\''; //RIGHT SINGLE QUOTATION MARK

    859. 

  859. 			convTable[0x93 - 0x80] = '\"'; //LEFT DOUBLE QUOTATION MARK

    860. 

  860. 			convTable[0x94 - 0x80] = '\"'; //RIGHT DOUBLE QUOTATION MARK

    861. 

  861. 			convTable[0x95 - 0x80] = 0x2022; //BULLET

    862. 

  862. 			convTable[0x96 - 0x80] = '-'; //EN DASH

    863. 

  863. 			convTable[0x97 - 0x80] = '-'; //EM DASH

    864. 

  864. 			convTable[0x98 - 0x80] = 0x02DC; //SMALL TILDE

    865. 

  865. 			convTable[0x99 - 0x80] = 0x2122; //TRADE MARK SIGN

    866. 

  866. 			convTable[0x9A - 0x80] = 0x0161; //LATIN SMALL LETTER S WITH CARON

    867. 

  867. 			convTable[0x9B - 0x80] = 0x203A; //SINGLE RIGHT-POINTING ANGLE QUOTATION MARK

    868. 

  868. 			convTable[0x9C - 0x80] = 0x0153; //LATIN SMALL LIGATURE OE

    869. 

  869. 			convTable[0x9D - 0x80] = 0x01;

    870. 

  870. 			convTable[0x9E - 0x80] = 0x017E; //LATIN SMALL LETTER Z WITH CARON

    871. 

  871. 			convTable[0x9F - 0x80] = 0x0178; //LATIN CAPITAL LETTER Y WITH DIAERESIS

    872. 

  872. 		} catch (Throwable t) {

    873. 

  873. 			//#ifdef DLOGGING

    874. 

  874. 			Logger logger = Logger.getLogger("EncodingUtil");

    875. 

  875. 			logger.severe("initWinIsoConv", t);

    876. 

  876. 			//#endif

    877. 

  877. 		}

    878. 

  878. 		return convTable;

    879. 

  879. 	}

    880. 

  880. 

    881. 

  881. 	/* Init unicode to windows (cp-1252).  This has either 1

    882. 

  882. 	   if there is no equivalent (this is used to remove the equivalent char

    883. 

  883. 	   from the string to be converted).  If not a 1, the character is

    884. 

  884. 	   used to replace the character in the string to be converted.

    885. 

  885. 	   The conversion starts at 0x80 and goes to including 0x9f.

    886. 

  886. 	   */

    887. 

  887. 	private static char [] initUniWinConvx80() {

    888. 

  888. 		char [] convTable = new char[0x9f - 0x80 + 1];

    889. 

  889. 		try {

    890. 

  890. 			//#ifdef DTEST

    891. 

  891. 			System.out.println( "convTable.length=" + convTable.length);

    892. 

  892. 			//#endif

    893. 

  893. 			for (int ic = 0; ic < convTable.length; ic++) {

    894. 

  894. 				char cc = (char)(ic + 0x80);

    895. 

  895. 				switch (cc) {

    896. 

  896. 					case CWSGL_LOW9_QUOTE:

    897. 

  897. 						convTable[ic] = '\'';

    898. 

  898. 						break;

    899. 

  899. 					case CWDBL_LOW9_QUOTE:

    900. 

  900. 						convTable[ic] = '\"';

    901. 

  901. 						break;

    902. 

  902. 					case CWLEFT_DBL_QUOTE:

    903. 

  903. 						convTable[ic] = '\"';

    904. 

  904. 						break;

    905. 

  905. 					case CWRIGHT_DBL_QUOTE:

    906. 

  906. 						convTable[ic] = '\"';

    907. 

  907. 						break;

    908. 

  908. 					case CWLEFT_SGL_QUOTE:

    909. 

  909. 						convTable[ic] = '\'';

    910. 

  910. 						break;

    911. 

  911. 					case CWEN_DASH:

    912. 

  912. 						convTable[ic] = '-';

    913. 

  913. 						break;

    914. 

  914. 					case CWEM_DASH:

    915. 

  915. 						convTable[ic] = '-';

    916. 

  916. 						break;

    917. 

  917. 					default:

    918. 

  918. 						convTable[ic] = 0x01;

    919. 

  919. 						break;

    920. 

  920. 				}

    921. 

  921. 			}

    922. 

  922. 		} catch (Throwable t) {

    923. 

  923. 			//#ifdef DLOGGING

    924. 

  924. 			Logger logger = Logger.getLogger("EncodingUtil");

    925. 

  925. 			logger.severe("initUniWinConvx80", t);

    926. 

  926. 			//#endif

    927. 

  927. 		}

    928. 

  928. 		return convTable;

    929. 

  929. 	}

    930. 

  930. 

    931. 

  931. 	/* Initialize entries for XML. */

    932. 

  932. 	private static void initHtmlCommEnts(Hashtable convEntities) {

    933. 

  933. 		String htmlCommonEntities[] =

    934. 

  934. 				{"lt", "gt", "nbsp", "amp", "apos", "quot"};

    935. 

  935. 		char htmlCommonValues[] = {'<', '>', ' ', '&', '\'', '\"'};

    936. 

  936. 		initEntVals(convEntities, htmlCommonEntities, htmlCommonValues);

    937. 

  937. 	}

    938. 

  938. 

    939. 

  939. 	/* Determine if creating a string converts the windows chars to

    940. 

  940. 	   Unicode. */

    941. 

  941. 	private static boolean initConvWinUni() {

    942. 

  942. 		boolean rtn = false;

    943. 

  943. 		try {

    944. 

  944. 			byte[] blftSgl = {(byte)CWLEFT_SGL_QUOTE};

    945. 

  945. 			try {

    946. 

  946. 				String convStr = new String(blftSgl, "Cp1252");

    947. 

  947. 				rtn = convStr.charAt(0) == CLEFT_SGL_QUOTE;

    948. 

  948. 			} catch (UnsupportedEncodingException e) {

    949. 

  949. 				//#ifdef DTEST

    950. 

  950. 				System.out.println( "Unsupported encoding Cp1252");

    951. 

  951. 				//#endif

    952. 

  952. 				//#ifdef DLOGGING

    953. 

  953. 				Logger logger = Logger.getLogger("EncodingUtil");

    954. 

  954. 				logger.severe("UnsupportedEncodingException Cp1252", e);

    955. 

  955. 				//#endif

    956. 

  956. 				try {

    957. 

  957. 					String convStr2 = new String(blftSgl, "Cp1252");

    958. 

  958. 					rtn = convStr2.charAt(0) == CLEFT_SGL_QUOTE;

    959. 

  959. 				} catch (UnsupportedEncodingException e2) {

    960. 

  960. 					//#ifdef DTEST

    961. 

  961. 					System.out.println( "Unsupported encoding WINDOWS-1252");

    962. 

  962. 					//#endif

    963. 

  963. 					//#ifdef DLOGGING

    964. 

  964. 					logger.severe("UnsupportedEncodingException Cp1252", e2);

    965. 

  965. 					//#endif

    966. 

  966. 				}

    967. 

  967. 			}

    968. 

  968. 			//#ifdef DTEST

    969. 

  969. 			System.out.println( "initConvWinUni()=" + rtn);

    970. 

  970. 			//#endif

    971. 

  971. 		} catch (Throwable t) {

    972. 

  972. 			//#ifdef DLOGGING

    973. 

  973. 			Logger logger = Logger.getLogger("EncodingUtil");

    974. 

  974. 			logger.severe("initConvWinUni", t);

    975. 

  975. 			//#endif

    976. 

  976. 		}

    977. 

  977. 		return rtn;

    978. 

  978. 	}

    979. 

  979. 

    980. 

  980. 	/* Determine ISO encoding string. */

    981. 

  981. 	private static String initIsoEncoding() {

    982. 

  982. 		try {

    983. 

  983. 			try {

    984. 

  984. 				String convStr = new String("a".getBytes(), "ISO8859_1");

    985. 

  985. 				return "ISO8859_1";

    986. 

  986. 			} catch (UnsupportedEncodingException e) {

    987. 

  987. 				//#ifdef DTEST

    988. 

  988. 				System.out.println( "Unsupported encoding ISO8859_1");

    989. 

  989. 				//#endif

    990. 

  990. 				//#ifdef DLOGGING

    991. 

  991. 				Logger logger = Logger.getLogger("EncodingUtil");

    992. 

  992. 				logger.severe("initIsoEncoding UnsupportedEncodingException ISO8859_1", e);

    993. 

  993. 				//#endif

    994. 

  994. 				try {

    995. 

  995. 					String convStr2 = new String("a".getBytes(), "ISO-8859-1");

    996. 

  996. 					return "ISO-8859-1";

    997. 

  997. 				} catch (UnsupportedEncodingException e2) {

    998. 

  998. 					//#ifdef DTEST

    999. 

  999. 					System.out.println("initIsoEncoding Unsupported encoding ISO-8859-1");

    1000. 

  1000. 					//#endif

    1001. 

  1001. 					//#ifdef DLOGGING

    1002. 

  1002. 					logger.severe("initIsoEncoding UnsupportedEncodingException ISO-8859-1", e2);

    1003. 

  1003. 					//#endif

    1004. 

  1004. 				}

    1005. 

  1005. 			}

    1006. 

  1006. 		} catch (Throwable t) {

    1007. 

  1007. 			//#ifdef DLOGGING

    1008. 

  1008. 			Logger logger = Logger.getLogger("EncodingUtil");

    1009. 

  1009. 			logger.severe("initIsoEncoding initConvWinUni", t);

    1010. 

  1010. 			//#endif

    1011. 

  1011. 		}

    1012. 

  1012. 		return "ISO8859_1";

    1013. 

  1013. 	}

    1014. 

  1014. 

    1015. 

  1015. 	/* Determine Windows encoding string. */

    1016. 

  1016. 	private static String initWinEncoding() {

    1017. 

  1017. 		try {

    1018. 

  1018. 			try {

    1019. 

  1019. 				String convStr = new String("a".getBytes(), "Cp1252");

    1020. 

  1020. 				return "Cp1252";

    1021. 

  1021. 			} catch (UnsupportedEncodingException e) {

    1022. 

  1022. 				CauseException ce = new CauseException(

    1023. 

  1023. 						"initWinEncoding UnsupportedEncodingException " +

    1024. 

  1024. 						"while trying to convert encoding Cp1252.", e);

    1025. 

  1025. 				if (m_statExcs == null) {

    1026. 

  1026. 					m_statExcs = new Vector();

    1027. 

  1027. 				}

    1028. 

  1028. 				m_statExcs.addElement(ce);

    1029. 

  1029. 				//#ifdef DTEST

    1030. 

  1030. 				System.out.println(ce.getMessage());

    1031. 

  1031. 				//#endif

    1032. 

  1032. 				//#ifdef DLOGGING

    1033. 

  1033. 				Logger logger = Logger.getLogger("EncodingUtil");

    1034. 

  1034. 				logger.severe(ce.getMessage(), e);

    1035. 

  1035. 				//#endif

    1036. 

  1036. 				try {

    1037. 

  1037. 					String convStr2 = new String("a".getBytes(), "WINDOWS-1252");

    1038. 

  1038. 					return "WINDOWS-1252";

    1039. 

  1039. 				} catch (UnsupportedEncodingException e2) {

    1040. 

  1040. 					CauseException ce2 = new CauseException(

    1041. 

  1041. 							"initWinEncoding second " +

    1042. 

  1042. 							"unsupportedEncodingException while " +

    1043. 

  1043. 							" trying to convert encoding WINDOWS-1252.", e2);

    1044. 

  1044. 					m_statExcs.addElement(ce2);

    1045. 

  1045. 					//#ifdef DTEST

    1046. 

  1046. 					System.out.println(ce2.getMessage());

    1047. 

  1047. 					//#endif

    1048. 

  1048. 					//#ifdef DLOGGING

    1049. 

  1049. 					logger.severe(ce2.getMessage(), e2);

    1050. 

  1050. 					//#endif

    1051. 

  1051. 				}

    1052. 

  1052. 			}

    1053. 

  1053. 		} catch (Throwable t) {

    1054. 

  1054. 			//#ifdef DLOGGING

    1055. 

  1055. 			Logger logger = Logger.getLogger("EncodingUtil");

    1056. 

  1056. 			logger.severe("initWinEncoding() initConvWinUni", t);

    1057. 

  1057. 			//#endif

    1058. 

  1058. 		}

    1059. 

  1059. 		return "Cp1252";

    1060. 

  1060. 	}

    1061. 

  1061. 

    1062. 

  1062. 	/* Determine if windows encoding is supported.  */

    1063. 

  1063. 	public static boolean hasWinEncoding() {

    1064. 

  1064. 		try {

    1065. 

  1065. 			try {

    1066. 

  1066. 				String convStr = new String("a".getBytes(), "Cp1252");

    1067. 

  1067. 				return true;

    1068. 

  1068. 			} catch (UnsupportedEncodingException e) {

    1069. 

  1069. 				CauseException ce = new CauseException(

    1070. 

  1070. 						"hasWinEncoding UnsupportedEncodingException " +

    1071. 

  1071. 						"while trying to convert encoding Cp1252.", e);

    1072. 

  1072. 				if (m_statExcs == null) {

    1073. 

  1073. 					m_statExcs = new Vector();

    1074. 

  1074. 				}

    1075. 

  1075. 				m_statExcs.addElement(ce);

    1076. 

  1076. 				//#ifdef DTEST

    1077. 

  1077. 				System.out.println(ce.getMessage());

    1078. 

  1078. 				//#endif

    1079. 

  1079. 				//#ifdef DLOGGING

    1080. 

  1080. 				Logger logger = Logger.getLogger("EncodingUtil");

    1081. 

  1081. 				logger.severe(ce.getMessage(), e);

    1082. 

  1082. 				//#endif

    1083. 

  1083. 				try {

    1084. 

  1084. 					String convStr2 = new String("a".getBytes(), "WINDOWS-1252");

    1085. 

  1085. 					return true;

    1086. 

  1086. 				} catch (UnsupportedEncodingException e2) {

    1087. 

  1087. 					CauseException ce2 = new CauseException(

    1088. 

  1088. 							"initWinEncoding second " +

    1089. 

  1089. 							"unsupportedEncodingException while " +

    1090. 

  1090. 							" trying to convert encoding WINDOWS-1252.", e2);

    1091. 

  1091. 					m_statExcs.addElement(ce2);

    1092. 

  1092. 					//#ifdef DTEST

    1093. 

  1093. 					System.out.println(ce2.getMessage());

    1094. 

  1094. 					//#endif

    1095. 

  1095. 					//#ifdef DLOGGING

    1096. 

  1096. 					logger.severe(ce2.getMessage(), e2);

    1097. 

  1097. 					//#endif

    1098. 

  1098. 				}

    1099. 

  1099. 			}

    1100. 

  1100. 		} catch (Throwable t) {

    1101. 

  1101. 			//#ifdef DLOGGING

    1102. 

  1102. 			Logger logger = Logger.getLogger("EncodingUtil");

    1103. 

  1103. 			logger.severe("hasWinEncoding initConvWinUni", t);

    1104. 

  1104. 			//#endif

    1105. 

  1105. 		}

    1106. 

  1106. 		return false;

    1107. 

  1107. 	}

    1108. 

  1108. 

    1109. 

  1109. 	/* Determine if iso-8859-1 encoding is supported.  */

    1110. 

  1110. 	private static boolean hasIso8859Encoding() {

    1111. 

  1111. 		try {

    1112. 

  1112. 			try {

    1113. 

  1113. 				String convStr = new String("a".getBytes(), "ISO8859_1");

    1114. 

  1114. 				return true;

    1115. 

  1115. 			} catch (UnsupportedEncodingException e) {

    1116. 

  1116. 				//#ifdef DTEST

    1117. 

  1117. 				System.out.println( "Unsupported encoding ISO8859_1");

    1118. 

  1118. 				//#endif

    1119. 

  1119. 				//#ifdef DLOGGING

    1120. 

  1120. 				Logger logger = Logger.getLogger("EncodingUtil");

    1121. 

  1121. 				logger.severe("hasIso8859Encoding UnsupportedEncodingException ISO8859_1", e);

    1122. 

  1122. 				//#endif

    1123. 

  1123. 				try {

    1124. 

  1124. 					String convStr2 = new String("a".getBytes(), "ISO-8859-1");

    1125. 

  1125. 					return true;

    1126. 

  1126. 				} catch (UnsupportedEncodingException e2) {

    1127. 

  1127. 					//#ifdef DTEST

    1128. 

  1128. 					System.out.println("hasIso8859Encoding Unsupported encoding ISO-8859-1");

    1129. 

  1129. 					//#endif

    1130. 

  1130. 					//#ifdef DLOGGING

    1131. 

  1131. 					logger.severe("initIsoEncoding UnsupportedEncodingException ISO-8859-1", e2);

    1132. 

  1132. 					//#endif

    1133. 

  1133. 				}

    1134. 

  1134. 			}

    1135. 

  1135. 		} catch (Throwable t) {

    1136. 

  1136. 			//#ifdef DLOGGING

    1137. 

  1137. 			Logger logger = Logger.getLogger("EncodingUtil");

    1138. 

  1138. 			logger.severe("hasIso8859Encoding initConvWinUni", t);

    1139. 

  1139. 			//#endif

    1140. 

  1140. 		}

    1141. 

  1141. 		return false;

    1142. 

  1142. 	}

    1143. 

  1143. 

    1144. 

  1144.     public void setDocEncoding(String m_docEncoding) {

    1145. 

  1145.         this.m_docEncoding = m_docEncoding;

    1146. 

  1146.     }

    1147. 

  1147. 

    1148. 

  1148.     public String getDocEncoding() {

    1149. 

  1149.         return (m_docEncoding);

    1150. 

  1150.     }

    1151. 

  1151. 

    1152. 

  1152.     public void setEncodingStreamReader(EncodingStreamReader m_encodingStreamReader) {

    1153. 

  1153.         this.m_encodingStreamReader = m_encodingStreamReader;

    1154. 

  1154.     }

    1155. 

  1155. 

    1156. 

  1156.     public EncodingStreamReader getEncodingStreamReader() {

    1157. 

  1157.         return (m_encodingStreamReader);

    1158. 

  1158.     }

    1159. 

  1159. 

    1160. 

  1160.     public boolean isWindows() {

    1161. 

  1161.         return (m_windows);

    1162. 

  1162.     }

    1163. 

  1163. 

    1164. 

  1164.     public boolean isUtf() {

    1165. 

  1165.         return (m_utf);

    1166. 

  1166.     }

    1167. 

  1167. 

    1168. 

  1168. 	//#ifdef DTEST

    1169. 

  1169.     public static String[] getIsoCommonEntities() {

    1170. 

  1170.         return (m_isoCommonEntities);

    1171. 

  1171.     }

    1172. 

  1172. 

    1173. 

  1173.     public static Hashtable getConvIso88591() {

    1174. 

  1174.         return (m_convIso88591);

    1175. 

  1175.     }

    1176. 

  1176. 

    1177. 

  1177.     public static Hashtable getConvCp1252() {

    1178. 

  1178.         return (m_convCp1252);

    1179. 

  1179.     }

    1180. 

  1180. 

    1181. 

  1181.     static public String[] getIsoSpecialEntities() {

    1182. 

  1182.         return (m_isoSpecialEntities);

    1183. 

  1183.     }

    1184. 

  1184. 

    1185. 

  1185.     static public String getWinEncoding() {

    1186. 

  1186.         return (m_winEncoding);

    1187. 

  1187.     }

    1188. 

  1188. 

    1189. 

  1189.     public static boolean isConvWinUni() {

    1190. 

  1190.         return (m_convWinUni);

    1191. 

  1191.     }

    1192. 

  1192. 

    1193. 

  1193.     public static boolean isHasWinEncoding() {

    1194. 

  1194.         return (m_hasWinEncoding);

    1195. 

  1195.     }

    1196. 

  1196. 

    1197. 

  1197. 	//#endif

    1198. 

  1198. 

    1199. 

  1199.     static public String getIsoEncoding() {

    1200. 

  1200.         return (m_isoEncoding);

    1201. 

  1201.     }

    1202. 

  1202. 

    1203. 

  1203.     public Vector getExcs() {

    1204. 

  1204. 		if (m_excs == null) {

    1205. 

  1205. 			return new Vector();

    1206. 

  1206. 		} else {

    1207. 

  1207. 			return (m_excs);

    1208. 

  1208. 		}

    1209. 

  1209.     }

    1210. 

  1210. 

    1211. 

  1211.     public static Vector getStatExcs() {

    1212. 

  1212. 		if (m_statExcs == null) {

    1213. 

  1213. 			return new Vector();

    1214. 

  1214. 		} else {

    1215. 

  1215. 			return (m_statExcs);

    1216. 

  1216. 		}

    1217. 

  1217.     }

    1218. 

  1218. 

    1219. 

  1219. }

    1220. 

  1220.