1. /*

  2.  * Copyright 2002-2004 the original author or authors.

  3.  * 

  4.  * Licensed under the Apache License, Version 2.0 (the "License");

  5.  * you may not use this file except in compliance with the License.

  6.  * You may obtain a copy of the License at

  7.  * 

  8.  *      http://www.apache.org/licenses/LICENSE-2.0

  9.  * 

  10.  * Unless required by applicable law or agreed to in writing, software

  11.  * distributed under the License is distributed on an "AS IS" BASIS,

  12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  13.  * See the License for the specific language governing permissions and

  14.  * limitations under the License.

  15.  */ 

  16. 

  17. package org.springframework.web.util;

  18. 

  19. import java.util.HashMap;

  20. import java.util.Map;

  21. 

  22. /**

  23.  * Utility class for HTML escaping. Escapes and unescapes

  24.  * based on the W3C HTML 4.01 recommendation.

  25.  *

  26.  * <p>Reference:

  27.  * <a href="http://www.w3.org/TR/html4/charset.html">

  28.  * http://www.w3.org/TR/html4/charset.html

  29.  * </a>

  30.  *

  31.  * @author Chris Wilson

  32.  * @author Juergen Hoeller

  33.  * @since 01.03.2003

  34.  */

  35. public abstract class HtmlUtils {

  36. 

  37. 	private static final String EMPTY_REFERENCE = "&;";

  38. 	private static final String REFERENCE_START = "&#";

  39. 	private static final String MALFORMED_REFERENCE = "&#;";

  40. 

  41. 	private static final Map ENTITIES = new HashMap();

  42. 

  43. 	static {

  44. 		ENTITIES.put("nbsp", new Integer(160));

  45. 		ENTITIES.put("iexcl", new Integer(161));

  46. 		ENTITIES.put("cent", new Integer(162));

  47. 		ENTITIES.put("pound", new Integer(163));

  48. 		ENTITIES.put("curren", new Integer(164));

  49. 		ENTITIES.put("yen", new Integer(165));

  50. 		ENTITIES.put("brvbar", new Integer(166));

  51. 		ENTITIES.put("sect", new Integer(167));

  52. 		ENTITIES.put("uml", new Integer(168));

  53. 		ENTITIES.put("copy", new Integer(169));

  54. 		ENTITIES.put("ordf", new Integer(170));

  55. 		ENTITIES.put("laquo", new Integer(171));

  56. 		ENTITIES.put("not", new Integer(172));

  57. 		ENTITIES.put("shy", new Integer(173));

  58. 		ENTITIES.put("reg", new Integer(174));

  59. 		ENTITIES.put("macr", new Integer(175));

  60. 		ENTITIES.put("deg", new Integer(176));

  61. 		ENTITIES.put("plusmn", new Integer(177));

  62. 		ENTITIES.put("sup2", new Integer(178));

  63. 		ENTITIES.put("sup3", new Integer(179));

  64. 		ENTITIES.put("acute", new Integer(180));

  65. 		ENTITIES.put("micro", new Integer(181));

  66. 		ENTITIES.put("para", new Integer(182));

  67. 		ENTITIES.put("middot", new Integer(183));

  68. 		ENTITIES.put("cedil", new Integer(184));

  69. 		ENTITIES.put("sup1", new Integer(185));

  70. 		ENTITIES.put("ordm", new Integer(186));

  71. 		ENTITIES.put("raquo", new Integer(187));

  72. 		ENTITIES.put("frac14", new Integer(188));

  73. 		ENTITIES.put("frac12", new Integer(189));

  74. 		ENTITIES.put("frac34", new Integer(190));

  75. 		ENTITIES.put("iquest", new Integer(191));

  76. 		ENTITIES.put("Agrave", new Integer(192));

  77. 		ENTITIES.put("Aacute", new Integer(193));

  78. 		ENTITIES.put("Acirc", new Integer(194));

  79. 		ENTITIES.put("Atilde", new Integer(195));

  80. 		ENTITIES.put("Auml", new Integer(196));

  81. 		ENTITIES.put("Aring", new Integer(197));

  82. 		ENTITIES.put("AElig", new Integer(198));

  83. 		ENTITIES.put("Ccedil", new Integer(199));

  84. 		ENTITIES.put("Egrave", new Integer(200));

  85. 		ENTITIES.put("Eacute", new Integer(201));

  86. 		ENTITIES.put("Ecirc", new Integer(202));

  87. 		ENTITIES.put("Euml", new Integer(203));

  88. 		ENTITIES.put("Igrave", new Integer(204));

  89. 		ENTITIES.put("Iacute", new Integer(205));

  90. 		ENTITIES.put("Icirc", new Integer(206));

  91. 		ENTITIES.put("Iuml", new Integer(207));

  92. 		ENTITIES.put("ETH", new Integer(208));

  93. 		ENTITIES.put("Ntilde", new Integer(209));

  94. 		ENTITIES.put("Ograve", new Integer(210));

  95. 		ENTITIES.put("Oacute", new Integer(211));

  96. 		ENTITIES.put("Ocirc", new Integer(212));

  97. 		ENTITIES.put("Otilde", new Integer(213));

  98. 		ENTITIES.put("Ouml", new Integer(214));

  99. 		ENTITIES.put("times", new Integer(215));

  100. 		ENTITIES.put("Oslash", new Integer(216));

  101. 		ENTITIES.put("Ugrave", new Integer(217));

  102. 		ENTITIES.put("Uacute", new Integer(218));

  103. 		ENTITIES.put("Ucirc", new Integer(219));

  104. 		ENTITIES.put("Uuml", new Integer(220));

  105. 		ENTITIES.put("Yacute", new Integer(221));

  106. 		ENTITIES.put("THORN", new Integer(222));

  107. 		ENTITIES.put("szlig", new Integer(223));

  108. 		ENTITIES.put("agrave", new Integer(224));

  109. 		ENTITIES.put("aacute", new Integer(225));

  110. 		ENTITIES.put("acirc", new Integer(226));

  111. 		ENTITIES.put("atilde", new Integer(227));

  112. 		ENTITIES.put("auml", new Integer(228));

  113. 		ENTITIES.put("aring", new Integer(229));

  114. 		ENTITIES.put("aelig", new Integer(230));

  115. 		ENTITIES.put("ccedil", new Integer(231));

  116. 		ENTITIES.put("egrave", new Integer(232));

  117. 		ENTITIES.put("eacute", new Integer(233));

  118. 		ENTITIES.put("ecirc", new Integer(234));

  119. 		ENTITIES.put("euml", new Integer(235));

  120. 		ENTITIES.put("igrave", new Integer(236));

  121. 		ENTITIES.put("iacute", new Integer(237));

  122. 		ENTITIES.put("icirc", new Integer(238));

  123. 		ENTITIES.put("iuml", new Integer(239));

  124. 		ENTITIES.put("eth", new Integer(240));

  125. 		ENTITIES.put("ntilde", new Integer(241));

  126. 		ENTITIES.put("ograve", new Integer(242));

  127. 		ENTITIES.put("oacute", new Integer(243));

  128. 		ENTITIES.put("ocirc", new Integer(244));

  129. 		ENTITIES.put("otilde", new Integer(245));

  130. 		ENTITIES.put("ouml", new Integer(246));

  131. 		ENTITIES.put("divide", new Integer(247));

  132. 		ENTITIES.put("oslash", new Integer(248));

  133. 		ENTITIES.put("ugrave", new Integer(249));

  134. 		ENTITIES.put("uacute", new Integer(250));

  135. 		ENTITIES.put("ucirc", new Integer(251));

  136. 		ENTITIES.put("uuml", new Integer(252));

  137. 		ENTITIES.put("yacute", new Integer(253));

  138. 		ENTITIES.put("thorn", new Integer(254));

  139. 		ENTITIES.put("yuml", new Integer(255));

  140. 		ENTITIES.put("fnof", new Integer(402));

  141. 		ENTITIES.put("Alpha", new Integer(913));

  142. 		ENTITIES.put("Beta", new Integer(914));

  143. 		ENTITIES.put("Gamma", new Integer(915));

  144. 		ENTITIES.put("Delta", new Integer(916));

  145. 		ENTITIES.put("Epsilon", new Integer(917));

  146. 		ENTITIES.put("Zeta", new Integer(918));

  147. 		ENTITIES.put("Eta", new Integer(919));

  148. 		ENTITIES.put("Theta", new Integer(920));

  149. 		ENTITIES.put("Iota", new Integer(921));

  150. 		ENTITIES.put("Kappa", new Integer(922));

  151. 		ENTITIES.put("Lambda", new Integer(923));

  152. 		ENTITIES.put("Mu", new Integer(924));

  153. 		ENTITIES.put("Nu", new Integer(925));

  154. 		ENTITIES.put("Xi", new Integer(926));

  155. 		ENTITIES.put("Omicron", new Integer(927));

  156. 		ENTITIES.put("Pi", new Integer(928));

  157. 		ENTITIES.put("Rho", new Integer(929));

  158. 		ENTITIES.put("Sigma", new Integer(931));

  159. 		ENTITIES.put("Tau", new Integer(932));

  160. 		ENTITIES.put("Upsilon", new Integer(933));

  161. 		ENTITIES.put("Phi", new Integer(934));

  162. 		ENTITIES.put("Chi", new Integer(935));

  163. 		ENTITIES.put("Psi", new Integer(936));

  164. 		ENTITIES.put("Omega", new Integer(937));

  165. 		ENTITIES.put("alpha", new Integer(945));

  166. 		ENTITIES.put("beta", new Integer(946));

  167. 		ENTITIES.put("gamma", new Integer(947));

  168. 		ENTITIES.put("delta", new Integer(948));

  169. 		ENTITIES.put("epsilon", new Integer(949));

  170. 		ENTITIES.put("zeta", new Integer(950));

  171. 		ENTITIES.put("eta", new Integer(951));

  172. 		ENTITIES.put("theta", new Integer(952));

  173. 		ENTITIES.put("iota", new Integer(953));

  174. 		ENTITIES.put("kappa", new Integer(954));

  175. 		ENTITIES.put("lambda", new Integer(955));

  176. 		ENTITIES.put("mu", new Integer(956));

  177. 		ENTITIES.put("nu", new Integer(957));

  178. 		ENTITIES.put("xi", new Integer(958));

  179. 		ENTITIES.put("omicron", new Integer(959));

  180. 		ENTITIES.put("pi", new Integer(960));

  181. 		ENTITIES.put("rho", new Integer(961));

  182. 		ENTITIES.put("sigmaf", new Integer(962));

  183. 		ENTITIES.put("sigma", new Integer(963));

  184. 		ENTITIES.put("tau", new Integer(964));

  185. 		ENTITIES.put("upsilon", new Integer(965));

  186. 		ENTITIES.put("phi", new Integer(966));

  187. 		ENTITIES.put("chi", new Integer(967));

  188. 		ENTITIES.put("psi", new Integer(968));

  189. 		ENTITIES.put("omega", new Integer(969));

  190. 		ENTITIES.put("thetasym", new Integer(977));

  191. 		ENTITIES.put("upsih", new Integer(978));

  192. 		ENTITIES.put("piv", new Integer(982));

  193. 		ENTITIES.put("bull", new Integer(8226));

  194. 		ENTITIES.put("hellip", new Integer(8230));

  195. 		ENTITIES.put("prime", new Integer(8242));

  196. 		ENTITIES.put("Prime", new Integer(8243));

  197. 		ENTITIES.put("oline", new Integer(8254));

  198. 		ENTITIES.put("frasl", new Integer(8260));

  199. 		ENTITIES.put("weierp", new Integer(8472));

  200. 		ENTITIES.put("image", new Integer(8465));

  201. 		ENTITIES.put("real", new Integer(8476));

  202. 		ENTITIES.put("trade", new Integer(8482));

  203. 		ENTITIES.put("alefsym", new Integer(8501));

  204. 		ENTITIES.put("larr", new Integer(8592));

  205. 		ENTITIES.put("uarr", new Integer(8593));

  206. 		ENTITIES.put("rarr", new Integer(8594));

  207. 		ENTITIES.put("darr", new Integer(8595));

  208. 		ENTITIES.put("harr", new Integer(8596));

  209. 		ENTITIES.put("crarr", new Integer(8629));

  210. 		ENTITIES.put("lArr", new Integer(8656));

  211. 		ENTITIES.put("uArr", new Integer(8657));

  212. 		ENTITIES.put("rArr", new Integer(8658));

  213. 		ENTITIES.put("dArr", new Integer(8659));

  214. 		ENTITIES.put("hArr", new Integer(8660));

  215. 		ENTITIES.put("forall", new Integer(8704));

  216. 		ENTITIES.put("part", new Integer(8706));

  217. 		ENTITIES.put("exist", new Integer(8707));

  218. 		ENTITIES.put("empty", new Integer(8709));

  219. 		ENTITIES.put("nabla", new Integer(8711));

  220. 		ENTITIES.put("isin", new Integer(8712));

  221. 		ENTITIES.put("notin", new Integer(8713));

  222. 		ENTITIES.put("ni", new Integer(8715));

  223. 		ENTITIES.put("prod", new Integer(8719));

  224. 		ENTITIES.put("sum", new Integer(8721));

  225. 		ENTITIES.put("minus", new Integer(8722));

  226. 		ENTITIES.put("lowast", new Integer(8727));

  227. 		ENTITIES.put("radic", new Integer(8730));

  228. 		ENTITIES.put("prop", new Integer(8733));

  229. 		ENTITIES.put("infin", new Integer(8734));

  230. 		ENTITIES.put("ang", new Integer(8736));

  231. 		ENTITIES.put("and", new Integer(8743));

  232. 		ENTITIES.put("or", new Integer(8744));

  233. 		ENTITIES.put("cap", new Integer(8745));

  234. 		ENTITIES.put("cup", new Integer(8746));

  235. 		ENTITIES.put("int", new Integer(8747));

  236. 		ENTITIES.put("there4", new Integer(8756));

  237. 		ENTITIES.put("sim", new Integer(8764));

  238. 		ENTITIES.put("cong", new Integer(8773));

  239. 		ENTITIES.put("asymp", new Integer(8776));

  240. 		ENTITIES.put("ne", new Integer(8800));

  241. 		ENTITIES.put("equiv", new Integer(8801));

  242. 		ENTITIES.put("le", new Integer(8804));

  243. 		ENTITIES.put("ge", new Integer(8805));

  244. 		ENTITIES.put("sub", new Integer(8834));

  245. 		ENTITIES.put("sup", new Integer(8835));

  246. 		ENTITIES.put("nsub", new Integer(8836));

  247. 		ENTITIES.put("sube", new Integer(8838));

  248. 		ENTITIES.put("supe", new Integer(8839));

  249. 		ENTITIES.put("oplus", new Integer(8853));

  250. 		ENTITIES.put("otimes", new Integer(8855));

  251. 		ENTITIES.put("perp", new Integer(8869));

  252. 		ENTITIES.put("sdot", new Integer(8901));

  253. 		ENTITIES.put("lceil", new Integer(8968));

  254. 		ENTITIES.put("rceil", new Integer(8969));

  255. 		ENTITIES.put("lfloor", new Integer(8970));

  256. 		ENTITIES.put("rfloor", new Integer(8971));

  257. 		ENTITIES.put("lang", new Integer(9001));

  258. 		ENTITIES.put("rang", new Integer(9002));

  259. 		ENTITIES.put("loz", new Integer(9674));

  260. 		ENTITIES.put("spades", new Integer(9824));

  261. 		ENTITIES.put("clubs", new Integer(9827));

  262. 		ENTITIES.put("hearts", new Integer(9829));

  263. 		ENTITIES.put("diams", new Integer(9830));

  264. 		ENTITIES.put("quot", new Integer(34));

  265. 		ENTITIES.put("amp", new Integer(38));

  266. 		ENTITIES.put("lt", new Integer(60));

  267. 		ENTITIES.put("gt", new Integer(62));

  268. 		ENTITIES.put("OElig", new Integer(338));

  269. 		ENTITIES.put("oelig", new Integer(339));

  270. 		ENTITIES.put("Scaron", new Integer(352));

  271. 		ENTITIES.put("scaron", new Integer(353));

  272. 		ENTITIES.put("Yuml", new Integer(376));

  273. 		ENTITIES.put("circ", new Integer(710));

  274. 		ENTITIES.put("tilde", new Integer(732));

  275. 		ENTITIES.put("ensp", new Integer(8194));

  276. 		ENTITIES.put("emsp", new Integer(8195));

  277. 		ENTITIES.put("thinsp", new Integer(8201));

  278. 		ENTITIES.put("zwnj", new Integer(8204));

  279. 		ENTITIES.put("zwj", new Integer(8205));

  280. 		ENTITIES.put("lrm", new Integer(8206));

  281. 		ENTITIES.put("rlm", new Integer(8207));

  282. 		ENTITIES.put("ndash", new Integer(8211));

  283. 		ENTITIES.put("mdash", new Integer(8212));

  284. 		ENTITIES.put("lsquo", new Integer(8216));

  285. 		ENTITIES.put("rsquo", new Integer(8217));

  286. 		ENTITIES.put("sbquo", new Integer(8218));

  287. 		ENTITIES.put("ldquo", new Integer(8220));

  288. 		ENTITIES.put("rdquo", new Integer(8221));

  289. 		ENTITIES.put("bdquo", new Integer(8222));

  290. 		ENTITIES.put("dagger", new Integer(8224));

  291. 		ENTITIES.put("Dagger", new Integer(8225));

  292. 		ENTITIES.put("permil", new Integer(8240));

  293. 		ENTITIES.put("lsaquo", new Integer(8249));

  294. 		ENTITIES.put("rsaquo", new Integer(8250));

  295. 		ENTITIES.put("euro", new Integer(8364));

  296. 	}

  297. 

  298. 	/**

  299. 	 * Turn special characters into HTML character references.

  300. 	 * Handles complete character set defined in HTML 4.01 recommendation.

  301. 	 * <p>Escapes all special characters to their corresponding numerial reference

  302. 	 * in the decimal format: &#<i>Decimal</i>

  303. 	 * <p>Reference:

  304. 	 * <a href="http://www.w3.org/TR/html4/sgml/entities.html">

  305. 	 * http://www.w3.org/TR/html4/sgml/entities.html

  306. 	 * </a>

  307. 	 */

  308. 	public static String htmlEscape(String s) {

  309. 		if (s == null) {

  310. 			return null;

  311. 		}

  312. 

  313. 		StringBuffer escaped = new StringBuffer(s.length());

  314. 		for (int i = 0; i < s.length(); i++) {

  315. 			char c = s.charAt(i);

  316. 			// handle non special ASCII chars first since they will be most common

  317. 			if ((c >= 0 && c <= 33)

  318. 			    || (c >= 35 && c <= 37)

  319. 			    || (c >= 39 && c <= 59)

  320. 			    || (c == 61)

  321. 			    || (c >= 63 && c <= 159)) {

  322. 				escaped.append(c);

  323. 				continue;

  324. 			}

  325. 

  326. 			// handle special chars

  327. 			if (c == 34) {

  328. 				writeDecimalReference(c, escaped);

  329. 				continue;

  330. 			}

  331. 			if (c == 38) {

  332. 				writeDecimalReference(c, escaped);

  333. 				continue;

  334. 			}

  335. 			if (c == 60) {

  336. 				writeDecimalReference(c, escaped);

  337. 				continue;

  338. 			}

  339. 			if (c == 62) {

  340. 				writeDecimalReference(c, escaped);

  341. 				continue;

  342. 			}

  343. 			if (c >= 160 && c <= 255) {

  344. 				writeDecimalReference(c, escaped);

  345. 				continue;

  346. 			}

  347. 			if (c >= 338 && c <= 339) {

  348. 				writeDecimalReference(c, escaped);

  349. 				continue;

  350. 			}

  351. 			if (c >= 352 && c <= 353) {

  352. 				writeDecimalReference(c, escaped);

  353. 				continue;

  354. 			}

  355. 			if (c == 376) {

  356. 				writeDecimalReference(c, escaped);

  357. 				continue;

  358. 			}

  359. 			if (c == 402) {

  360. 				writeDecimalReference(c, escaped);

  361. 				continue;

  362. 			}

  363. 			if (c == 710) {

  364. 				writeDecimalReference(c, escaped);

  365. 				continue;

  366. 			}

  367. 			if (c == 732) {

  368. 				writeDecimalReference(c, escaped);

  369. 				continue;

  370. 			}

  371. 			if (c >= 913 && c <= 929) {

  372. 				writeDecimalReference(c, escaped);

  373. 				continue;

  374. 			}

  375. 			if (c >= 931 && c <= 937) {

  376. 				writeDecimalReference(c, escaped);

  377. 				continue;

  378. 			}

  379. 			if (c >= 945 && c <= 969) {

  380. 				writeDecimalReference(c, escaped);

  381. 				continue;

  382. 			}

  383. 			if (c >= 977 && c <= 978) {

  384. 				writeDecimalReference(c, escaped);

  385. 				continue;

  386. 			}

  387. 			if (c == 982) {

  388. 				writeDecimalReference(c, escaped);

  389. 				continue;

  390. 			}

  391. 			if (c >= 8194 && c <= 8195) {

  392. 				writeDecimalReference(c, escaped);

  393. 				continue;

  394. 			}

  395. 			if (c == 8201) {

  396. 				writeDecimalReference(c, escaped);

  397. 				continue;

  398. 			}

  399. 			if (c >= 8204 && c <= 8207) {

  400. 				writeDecimalReference(c, escaped);

  401. 				continue;

  402. 			}

  403. 			if (c >= 8211 && c <= 8212) {

  404. 				writeDecimalReference(c, escaped);

  405. 				continue;

  406. 			}

  407. 			if (c >= 8216 && c <= 8218) {

  408. 				writeDecimalReference(c, escaped);

  409. 				continue;

  410. 			}

  411. 			if (c >= 8220 && c <= 8222) {

  412. 				writeDecimalReference(c, escaped);

  413. 				continue;

  414. 			}

  415. 			if (c >= 8224 && c <= 8226) {

  416. 				writeDecimalReference(c, escaped);

  417. 				continue;

  418. 			}

  419. 			if (c == 8230) {

  420. 				writeDecimalReference(c, escaped);

  421. 				continue;

  422. 			}

  423. 			if (c == 8240) {

  424. 				writeDecimalReference(c, escaped);

  425. 				continue;

  426. 			}

  427. 			if (c >= 8242 && c <= 8243) {

  428. 				writeDecimalReference(c, escaped);

  429. 				continue;

  430. 			}

  431. 			if (c >= 8249 && c <= 8250) {

  432. 				writeDecimalReference(c, escaped);

  433. 				continue;

  434. 			}

  435. 			if (c == 8254) {

  436. 				writeDecimalReference(c, escaped);

  437. 				continue;

  438. 			}

  439. 			if (c == 8260) {

  440. 				writeDecimalReference(c, escaped);

  441. 				continue;

  442. 			}

  443. 			if (c == 8364) {

  444. 				writeDecimalReference(c, escaped);

  445. 				continue;

  446. 			}

  447. 			if (c == 8465) {

  448. 				writeDecimalReference(c, escaped);

  449. 				continue;

  450. 			}

  451. 			if (c == 8472) {

  452. 				writeDecimalReference(c, escaped);

  453. 				continue;

  454. 			}

  455. 			if (c == 8476) {

  456. 				writeDecimalReference(c, escaped);

  457. 				continue;

  458. 			}

  459. 			if (c == 8482) {

  460. 				writeDecimalReference(c, escaped);

  461. 				continue;

  462. 			}

  463. 			if (c == 8501) {

  464. 				writeDecimalReference(c, escaped);

  465. 				continue;

  466. 			}

  467. 			if (c >= 8592 && c <= 8596) {

  468. 				writeDecimalReference(c, escaped);

  469. 				continue;

  470. 			}

  471. 			if (c == 8629) {

  472. 				writeDecimalReference(c, escaped);

  473. 				continue;

  474. 			}

  475. 			if (c >= 8656 && c <= 8660) {

  476. 				writeDecimalReference(c, escaped);

  477. 				continue;

  478. 			}

  479. 			if (c == 8704) {

  480. 				writeDecimalReference(c, escaped);

  481. 				continue;

  482. 			}

  483. 			if (c >= 8706 && c <= 8707) {

  484. 				writeDecimalReference(c, escaped);

  485. 				continue;

  486. 			}

  487. 			if (c == 8709) {

  488. 				writeDecimalReference(c, escaped);

  489. 				continue;

  490. 			}

  491. 			if (c >= 8711 && c <= 8713) {

  492. 				writeDecimalReference(c, escaped);

  493. 				continue;

  494. 			}

  495. 			if (c == 8715) {

  496. 				writeDecimalReference(c, escaped);

  497. 				continue;

  498. 			}

  499. 			if (c == 8719) {

  500. 				writeDecimalReference(c, escaped);

  501. 				continue;

  502. 			}

  503. 			if (c >= 8721 && c <= 8722) {

  504. 				writeDecimalReference(c, escaped);

  505. 				continue;

  506. 			}

  507. 			if (c == 8727) {

  508. 				writeDecimalReference(c, escaped);

  509. 				continue;

  510. 			}

  511. 			if (c == 8730) {

  512. 				writeDecimalReference(c, escaped);

  513. 				continue;

  514. 			}

  515. 			if (c >= 8733 && c <= 8734) {

  516. 				writeDecimalReference(c, escaped);

  517. 				continue;

  518. 			}

  519. 			if (c == 8736) {

  520. 				writeDecimalReference(c, escaped);

  521. 				continue;

  522. 			}

  523. 			if (c >= 8743 && c <= 8747) {

  524. 				writeDecimalReference(c, escaped);

  525. 				continue;

  526. 			}

  527. 			if (c == 8756) {

  528. 				writeDecimalReference(c, escaped);

  529. 				continue;

  530. 			}

  531. 			if (c == 8764) {

  532. 				writeDecimalReference(c, escaped);

  533. 				continue;

  534. 			}

  535. 			if (c == 8773) {

  536. 				writeDecimalReference(c, escaped);

  537. 				continue;

  538. 			}

  539. 			if (c == 8776) {

  540. 				writeDecimalReference(c, escaped);

  541. 				continue;

  542. 			}

  543. 			if (c >= 8800 && c <= 8801) {

  544. 				writeDecimalReference(c, escaped);

  545. 				continue;

  546. 			}

  547. 			if (c >= 8804 && c <= 8805) {

  548. 				writeDecimalReference(c, escaped);

  549. 				continue;

  550. 			}

  551. 			if (c >= 8834 && c <= 8836) {

  552. 				writeDecimalReference(c, escaped);

  553. 				continue;

  554. 			}

  555. 			if (c >= 8838 && c <= 8839) {

  556. 				writeDecimalReference(c, escaped);

  557. 				continue;

  558. 			}

  559. 			if (c == 8853) {

  560. 				writeDecimalReference(c, escaped);

  561. 				continue;

  562. 			}

  563. 			if (c == 8855) {

  564. 				writeDecimalReference(c, escaped);

  565. 				continue;

  566. 			}

  567. 			if (c == 8869) {

  568. 				writeDecimalReference(c, escaped);

  569. 				continue;

  570. 			}

  571. 			if (c == 8901) {

  572. 				writeDecimalReference(c, escaped);

  573. 				continue;

  574. 			}

  575. 			if (c >= 8968 && c <= 8971) {

  576. 				writeDecimalReference(c, escaped);

  577. 				continue;

  578. 			}

  579. 			if (c >= 9001 && c <= 9002) {

  580. 				writeDecimalReference(c, escaped);

  581. 				continue;

  582. 			}

  583. 			if (c == 9674) {

  584. 				writeDecimalReference(c, escaped);

  585. 				continue;

  586. 			}

  587. 			if (c == 9824) {

  588. 				writeDecimalReference(c, escaped);

  589. 				continue;

  590. 			}

  591. 			if (c == 9827) {

  592. 				writeDecimalReference(c, escaped);

  593. 				continue;

  594. 			}

  595. 

  596. 			// all other chars

  597. 			escaped.append(c);

  598. 		}

  599. 		return escaped.toString();

  600. 	}

  601. 

  602. 	/**

  603. 	 * Turn HTML character references into their plain text UNICODE equivalent.

  604. 	 * <p>Handles complete character set defined in HTML 4.01 recommendation

  605. 	 * and all reference types (decimal, hex, and entity).

  606. 	 * <p>Correctly converts the following formats:

  607. 	 * <blockquote>

  608. 	 * &#<i>Decimal</i> - <i>(Example: &#68;)</i><br>

  609. 	 * &#x<i>Hex</i> - <i>(Example: &#xE5;) case insensitive</i><br>

  610. 	 * &#<i>Entity</i> - <i>(Example: &amp;) case sensitive</i>

  611. 	 * </blockquote>

  612. 	 * Gracefully handles malformed character references by copying original

  613. 	 * characters as is when encountered.<p>

  614. 	 * <p>Reference:

  615. 	 * <a href="http://www.w3.org/TR/html4/sgml/entities.html">

  616. 	 * http://www.w3.org/TR/html4/sgml/entities.html

  617. 	 * </a>

  618. 	 */

  619. 	public static String htmlUnescape(String s) {

  620. 		if (s == null) {

  621. 			return null;

  622. 		}

  623. 

  624. 		StringBuffer unescaped = new StringBuffer(s.length());

  625. 		for (int i = 0; i < s.length(); i++) {

  626. 			char c = s.charAt(i);

  627. 			if (c == '&') {

  628. 				// don't look more than 12 chars ahead as reference like strings

  629. 				// should not be longer than 12 chars in length (including ';')

  630. 				// prevents the entire string from being searched when an '&'

  631. 				// with no following ';' is an encountered

  632. 				int start = Math.min(i + 1, s.length() - 1);

  633. 				int end = Math.min(s.length(), start + 12);

  634. 

  635. 				String reference = s.substring(start, end);

  636. 				int semi = reference.indexOf(';');

  637. 

  638. 				if (semi == -1) {

  639. 					unescaped.append(c);

  640. 					continue;

  641. 				}

  642. 

  643. 				reference = reference.substring(0, semi);

  644. 				i = start + semi;

  645. 

  646. 				// try entity reference first

  647. 				Integer iso = (Integer) ENTITIES.get(reference);

  648. 				if (iso != null) {

  649. 					unescaped.append((char) iso.intValue());

  650. 					continue;

  651. 				}

  652. 

  653. 				if (reference.length() == 0) {

  654. 					unescaped.append(EMPTY_REFERENCE);

  655. 					continue;

  656. 				}

  657. 

  658. 				if (reference.charAt(0) == '#') {

  659. 					if (reference.length() > 2) {

  660. 						int index = 1;

  661. 						if (reference.charAt(1) == 'x' || reference.charAt(1) == 'X') {

  662. 							index = 2;

  663. 						}

  664. 						try {

  665. 							unescaped.append(

  666. 							    (char) Integer.parseInt(

  667. 							        reference.substring(index),

  668. 							        (index == 1) ? 10 : 16));

  669. 							continue;

  670. 						}

  671. 						catch (NumberFormatException e) {

  672. 							// wasn't hex or decimal, copy original chars

  673. 							unescaped.append('&' + reference + ';');

  674. 							continue;

  675. 						}

  676. 					}

  677. 					unescaped.append(MALFORMED_REFERENCE);

  678. 					continue;

  679. 				}

  680. 

  681. 				// may not be valid reference, forget it

  682. 				i = start - 1;

  683. 			}

  684. 			unescaped.append(c);

  685. 		}

  686. 		return unescaped.toString();

  687. 	}

  688. 

  689. 	/**

  690. 	 * Write the given character as decimal reference.

  691. 	 * @param c the character to write

  692. 	 * @param buf the buffer to write into

  693. 	 */

  694. 	private static void writeDecimalReference(char c, StringBuffer buf) {

  695. 		buf.append(REFERENCE_START);

  696. 		buf.append((int) c);

  697. 		buf.append(';');

  698. 	}

  699. 

  700. }