PageRenderTime 64ms CodeModel.GetById 1ms RepoModel.GetById 0ms app.codeStats 0ms

/mcs/class/System.Web/Test/mainsoft/MainsoftWebTest/HtmlAgilityPack/HtmlEntity.cs

https://github.com/iainlane/mono
C# | 802 lines | 719 code | 30 blank | 53 comment | 42 complexity | 549c3ec2ed857382ff28b096f8585cc0 MD5 | raw file
    

  1. // HtmlAgilityPack V1.0 - Simon Mourier <simonm@microsoft.com>
    2. 

  2. using System;
    3. 

  3. using System.Collections;
    4. 

  4. using System.Text;
    5. 

  5. 

  6. namespace HtmlAgilityPack
    7. 

  7. {
    8. 

  8. 	/// <summary>
    9. 

  9. 	/// A utility class to replace special characters by entities and vice-versa.
    10. 

  10. 	/// Follows HTML 4.0 specification found at http://www.w3.org/TR/html4/sgml/entities.html
    11. 

  11. 	/// </summary>
    12. 

  12. 	public class HtmlEntity
    13. 

  13. 	{
    14. 

  14. 		private static Hashtable _entityName;
    15. 

  15. 		private static Hashtable _entityValue;
    16. 

  16. 		private static readonly int _maxEntitySize;
    17. 

  17. 

  18. 		private HtmlEntity()
    19. 

  19. 		{
    20. 

  20. 		}
    21. 

  21. 

  22. 		static HtmlEntity()
    23. 

  23. 		{
    24. 

  24. 			_entityName = new Hashtable();
    25. 

  25. 			_entityValue = new Hashtable();
    26. 

  26. 

  27. 			#region Entities Definition
    28. 

  28. 			_entityValue.Add("nbsp", 160);	// no-break space = non-breaking space, U+00A0 ISOnum 
    29. 

  29. 			_entityName.Add(160, "nbsp");
    30. 

  30. 			_entityValue.Add("iexcl", 161);	// inverted exclamation mark, U+00A1 ISOnum 
    31. 

  31. 			_entityName.Add(161, "iexcl");
    32. 

  32. 			_entityValue.Add("cent", 162);	// cent sign, U+00A2 ISOnum 
    33. 

  33. 			_entityName.Add(162, "cent");
    34. 

  34. 			_entityValue.Add("pound", 163);	// pound sign, U+00A3 ISOnum 
    35. 

  35. 			_entityName.Add(163, "pound");
    36. 

  36. 			_entityValue.Add("curren", 164);	// currency sign, U+00A4 ISOnum 
    37. 

  37. 			_entityName.Add(164, "curren");
    38. 

  38. 			_entityValue.Add("yen", 165);	// yen sign = yuan sign, U+00A5 ISOnum 
    39. 

  39. 			_entityName.Add(165, "yen");
    40. 

  40. 			_entityValue.Add("brvbar", 166);	// broken bar = broken vertical bar, U+00A6 ISOnum 
    41. 

  41. 			_entityName.Add(166, "brvbar");
    42. 

  42. 			_entityValue.Add("sect", 167);	// section sign, U+00A7 ISOnum 
    43. 

  43. 			_entityName.Add(167, "sect");
    44. 

  44. 			_entityValue.Add("uml", 168);	// diaeresis = spacing diaeresis, U+00A8 ISOdia 
    45. 

  45. 			_entityName.Add(168, "uml");
    46. 

  46. 			_entityValue.Add("copy", 169);	// copyright sign, U+00A9 ISOnum 
    47. 

  47. 			_entityName.Add(169, "copy");
    48. 

  48. 			_entityValue.Add("ordf", 170);	// feminine ordinal indicator, U+00AA ISOnum 
    49. 

  49. 			_entityName.Add(170, "ordf");
    50. 

  50. 			_entityValue.Add("laquo", 171);	// left-pointing double angle quotation mark = left pointing guillemet, U+00AB ISOnum 
    51. 

  51. 			_entityName.Add(171, "laquo");
    52. 

  52. 			_entityValue.Add("not", 172);	// not sign, U+00AC ISOnum 
    53. 

  53. 			_entityName.Add(172, "not");
    54. 

  54. 			_entityValue.Add("shy", 173);	// soft hyphen = discretionary hyphen, U+00AD ISOnum 
    55. 

  55. 			_entityName.Add(173, "shy");
    56. 

  56. 			_entityValue.Add("reg", 174);	// registered sign = registered trade mark sign, U+00AE ISOnum 
    57. 

  57. 			_entityName.Add(174, "reg");
    58. 

  58. 			_entityValue.Add("macr", 175);	// macron = spacing macron = overline = APL overbar, U+00AF ISOdia 
    59. 

  59. 			_entityName.Add(175, "macr");
    60. 

  60. 			_entityValue.Add("deg", 176);	// degree sign, U+00B0 ISOnum 
    61. 

  61. 			_entityName.Add(176, "deg");
    62. 

  62. 			_entityValue.Add("plusmn", 177);	// plus-minus sign = plus-or-minus sign, U+00B1 ISOnum 
    63. 

  63. 			_entityName.Add(177, "plusmn");
    64. 

  64. 			_entityValue.Add("sup2", 178);	// superscript two = superscript digit two = squared, U+00B2 ISOnum 
    65. 

  65. 			_entityName.Add(178, "sup2");
    66. 

  66. 			_entityValue.Add("sup3", 179);	// superscript three = superscript digit three = cubed, U+00B3 ISOnum 
    67. 

  67. 			_entityName.Add(179, "sup3");
    68. 

  68. 			_entityValue.Add("acute", 180);	// acute accent = spacing acute, U+00B4 ISOdia 
    69. 

  69. 			_entityName.Add(180, "acute");
    70. 

  70. 			_entityValue.Add("micro", 181);	// micro sign, U+00B5 ISOnum 
    71. 

  71. 			_entityName.Add(181, "micro");
    72. 

  72. 			_entityValue.Add("para", 182);	// pilcrow sign = paragraph sign, U+00B6 ISOnum 
    73. 

  73. 			_entityName.Add(182, "para");
    74. 

  74. 			_entityValue.Add("middot", 183);	// middle dot = Georgian comma = Greek middle dot, U+00B7 ISOnum 
    75. 

  75. 			_entityName.Add(183, "middot");
    76. 

  76. 			_entityValue.Add("cedil", 184);	// cedilla = spacing cedilla, U+00B8 ISOdia 
    77. 

  77. 			_entityName.Add(184, "cedil");
    78. 

  78. 			_entityValue.Add("sup1", 185);	// superscript one = superscript digit one, U+00B9 ISOnum 
    79. 

  79. 			_entityName.Add(185, "sup1");
    80. 

  80. 			_entityValue.Add("ordm", 186);	// masculine ordinal indicator, U+00BA ISOnum 
    81. 

  81. 			_entityName.Add(186, "ordm");
    82. 

  82. 			_entityValue.Add("raquo", 187);	// right-pointing double angle quotation mark = right pointing guillemet, U+00BB ISOnum 
    83. 

  83. 			_entityName.Add(187, "raquo");
    84. 

  84. 			_entityValue.Add("frac14", 188);	// vulgar fraction one quarter = fraction one quarter, U+00BC ISOnum 
    85. 

  85. 			_entityName.Add(188, "frac14");
    86. 

  86. 			_entityValue.Add("frac12", 189);	// vulgar fraction one half = fraction one half, U+00BD ISOnum 
    87. 

  87. 			_entityName.Add(189, "frac12");
    88. 

  88. 			_entityValue.Add("frac34", 190);	// vulgar fraction three quarters = fraction three quarters, U+00BE ISOnum 
    89. 

  89. 			_entityName.Add(190, "frac34");
    90. 

  90. 			_entityValue.Add("iquest", 191);	// inverted question mark = turned question mark, U+00BF ISOnum 
    91. 

  91. 			_entityName.Add(191, "iquest");
    92. 

  92. 			_entityValue.Add("Agrave", 192);	// latin capital letter A with grave = latin capital letter A grave, U+00C0 ISOlat1 
    93. 

  93. 			_entityName.Add(192, "Agrave");
    94. 

  94. 			_entityValue.Add("Aacute", 193);	// latin capital letter A with acute, U+00C1 ISOlat1 
    95. 

  95. 			_entityName.Add(193, "Aacute");
    96. 

  96. 			_entityValue.Add("Acirc", 194);	// latin capital letter A with circumflex, U+00C2 ISOlat1 
    97. 

  97. 			_entityName.Add(194, "Acirc");
    98. 

  98. 			_entityValue.Add("Atilde", 195);	// latin capital letter A with tilde, U+00C3 ISOlat1 
    99. 

  99. 			_entityName.Add(195, "Atilde");
    100. 

  100. 			_entityValue.Add("Auml", 196);	// latin capital letter A with diaeresis, U+00C4 ISOlat1 
    101. 

  101. 			_entityName.Add(196, "Auml");
    102. 

  102. 			_entityValue.Add("Aring", 197);	// latin capital letter A with ring above = latin capital letter A ring, U+00C5 ISOlat1 
    103. 

  103. 			_entityName.Add(197, "Aring");
    104. 

  104. 			_entityValue.Add("AElig", 198);	// latin capital letter AE = latin capital ligature AE, U+00C6 ISOlat1 
    105. 

  105. 			_entityName.Add(198, "AElig");
    106. 

  106. 			_entityValue.Add("Ccedil", 199);	// latin capital letter C with cedilla, U+00C7 ISOlat1 
    107. 

  107. 			_entityName.Add(199, "Ccedil");
    108. 

  108. 			_entityValue.Add("Egrave", 200);	// latin capital letter E with grave, U+00C8 ISOlat1 
    109. 

  109. 			_entityName.Add(200, "Egrave");
    110. 

  110. 			_entityValue.Add("Eacute", 201);	// latin capital letter E with acute, U+00C9 ISOlat1 
    111. 

  111. 			_entityName.Add(201, "Eacute");
    112. 

  112. 			_entityValue.Add("Ecirc", 202);	// latin capital letter E with circumflex, U+00CA ISOlat1 
    113. 

  113. 			_entityName.Add(202, "Ecirc");
    114. 

  114. 			_entityValue.Add("Euml", 203);	// latin capital letter E with diaeresis, U+00CB ISOlat1 
    115. 

  115. 			_entityName.Add(203, "Euml");
    116. 

  116. 			_entityValue.Add("Igrave", 204);	// latin capital letter I with grave, U+00CC ISOlat1 
    117. 

  117. 			_entityName.Add(204, "Igrave");
    118. 

  118. 			_entityValue.Add("Iacute", 205);	// latin capital letter I with acute, U+00CD ISOlat1 
    119. 

  119. 			_entityName.Add(205, "Iacute");
    120. 

  120. 			_entityValue.Add("Icirc", 206);	// latin capital letter I with circumflex, U+00CE ISOlat1 
    121. 

  121. 			_entityName.Add(206, "Icirc");
    122. 

  122. 			_entityValue.Add("Iuml", 207);	// latin capital letter I with diaeresis, U+00CF ISOlat1 
    123. 

  123. 			_entityName.Add(207, "Iuml");
    124. 

  124. 			_entityValue.Add("ETH", 208);	// latin capital letter ETH, U+00D0 ISOlat1 
    125. 

  125. 			_entityName.Add(208, "ETH");
    126. 

  126. 			_entityValue.Add("Ntilde", 209);	// latin capital letter N with tilde, U+00D1 ISOlat1 
    127. 

  127. 			_entityName.Add(209, "Ntilde");
    128. 

  128. 			_entityValue.Add("Ograve", 210);	// latin capital letter O with grave, U+00D2 ISOlat1 
    129. 

  129. 			_entityName.Add(210, "Ograve");
    130. 

  130. 			_entityValue.Add("Oacute", 211);	// latin capital letter O with acute, U+00D3 ISOlat1 
    131. 

  131. 			_entityName.Add(211, "Oacute");
    132. 

  132. 			_entityValue.Add("Ocirc", 212);	// latin capital letter O with circumflex, U+00D4 ISOlat1 
    133. 

  133. 			_entityName.Add(212, "Ocirc");
    134. 

  134. 			_entityValue.Add("Otilde", 213);	// latin capital letter O with tilde, U+00D5 ISOlat1 
    135. 

  135. 			_entityName.Add(213, "Otilde");
    136. 

  136. 			_entityValue.Add("Ouml", 214);	// latin capital letter O with diaeresis, U+00D6 ISOlat1 
    137. 

  137. 			_entityName.Add(214, "Ouml");
    138. 

  138. 			_entityValue.Add("times", 215);	// multiplication sign, U+00D7 ISOnum 
    139. 

  139. 			_entityName.Add(215, "times");
    140. 

  140. 			_entityValue.Add("Oslash", 216);	// latin capital letter O with stroke = latin capital letter O slash, U+00D8 ISOlat1 
    141. 

  141. 			_entityName.Add(216, "Oslash");
    142. 

  142. 			_entityValue.Add("Ugrave", 217);	// latin capital letter U with grave, U+00D9 ISOlat1 
    143. 

  143. 			_entityName.Add(217, "Ugrave");
    144. 

  144. 			_entityValue.Add("Uacute", 218);	// latin capital letter U with acute, U+00DA ISOlat1 
    145. 

  145. 			_entityName.Add(218, "Uacute");
    146. 

  146. 			_entityValue.Add("Ucirc", 219);	// latin capital letter U with circumflex, U+00DB ISOlat1 
    147. 

  147. 			_entityName.Add(219, "Ucirc");
    148. 

  148. 			_entityValue.Add("Uuml", 220);	// latin capital letter U with diaeresis, U+00DC ISOlat1 
    149. 

  149. 			_entityName.Add(220, "Uuml");
    150. 

  150. 			_entityValue.Add("Yacute", 221);	// latin capital letter Y with acute, U+00DD ISOlat1 
    151. 

  151. 			_entityName.Add(221, "Yacute");
    152. 

  152. 			_entityValue.Add("THORN", 222);	// latin capital letter THORN, U+00DE ISOlat1 
    153. 

  153. 			_entityName.Add(222, "THORN");
    154. 

  154. 			_entityValue.Add("szlig", 223);	// latin small letter sharp s = ess-zed, U+00DF ISOlat1 
    155. 

  155. 			_entityName.Add(223, "szlig");
    156. 

  156. 			_entityValue.Add("agrave", 224);	// latin small letter a with grave = latin small letter a grave, U+00E0 ISOlat1 
    157. 

  157. 			_entityName.Add(224, "agrave");
    158. 

  158. 			_entityValue.Add("aacute", 225);	// latin small letter a with acute, U+00E1 ISOlat1 
    159. 

  159. 			_entityName.Add(225, "aacute");
    160. 

  160. 			_entityValue.Add("acirc", 226);	// latin small letter a with circumflex, U+00E2 ISOlat1 
    161. 

  161. 			_entityName.Add(226, "acirc");
    162. 

  162. 			_entityValue.Add("atilde", 227);	// latin small letter a with tilde, U+00E3 ISOlat1 
    163. 

  163. 			_entityName.Add(227, "atilde");
    164. 

  164. 			_entityValue.Add("auml", 228);	// latin small letter a with diaeresis, U+00E4 ISOlat1 
    165. 

  165. 			_entityName.Add(228, "auml");
    166. 

  166. 			_entityValue.Add("aring", 229);	// latin small letter a with ring above = latin small letter a ring, U+00E5 ISOlat1 
    167. 

  167. 			_entityName.Add(229, "aring");
    168. 

  168. 			_entityValue.Add("aelig", 230);	// latin small letter ae = latin small ligature ae, U+00E6 ISOlat1 
    169. 

  169. 			_entityName.Add(230, "aelig");
    170. 

  170. 			_entityValue.Add("ccedil", 231);	// latin small letter c with cedilla, U+00E7 ISOlat1 
    171. 

  171. 			_entityName.Add(231, "ccedil");
    172. 

  172. 			_entityValue.Add("egrave", 232);	// latin small letter e with grave, U+00E8 ISOlat1 
    173. 

  173. 			_entityName.Add(232, "egrave");
    174. 

  174. 			_entityValue.Add("eacute", 233);	// latin small letter e with acute, U+00E9 ISOlat1 
    175. 

  175. 			_entityName.Add(233, "eacute");
    176. 

  176. 			_entityValue.Add("ecirc", 234);	// latin small letter e with circumflex, U+00EA ISOlat1 
    177. 

  177. 			_entityName.Add(234, "ecirc");
    178. 

  178. 			_entityValue.Add("euml", 235);	// latin small letter e with diaeresis, U+00EB ISOlat1 
    179. 

  179. 			_entityName.Add(235, "euml");
    180. 

  180. 			_entityValue.Add("igrave", 236);	// latin small letter i with grave, U+00EC ISOlat1 
    181. 

  181. 			_entityName.Add(236, "igrave");
    182. 

  182. 			_entityValue.Add("iacute", 237);	// latin small letter i with acute, U+00ED ISOlat1 
    183. 

  183. 			_entityName.Add(237, "iacute");
    184. 

  184. 			_entityValue.Add("icirc", 238);	// latin small letter i with circumflex, U+00EE ISOlat1 
    185. 

  185. 			_entityName.Add(238, "icirc");
    186. 

  186. 			_entityValue.Add("iuml", 239);	// latin small letter i with diaeresis, U+00EF ISOlat1 
    187. 

  187. 			_entityName.Add(239, "iuml");
    188. 

  188. 			_entityValue.Add("eth", 240);	// latin small letter eth, U+00F0 ISOlat1 
    189. 

  189. 			_entityName.Add(240, "eth");
    190. 

  190. 			_entityValue.Add("ntilde", 241);	// latin small letter n with tilde, U+00F1 ISOlat1 
    191. 

  191. 			_entityName.Add(241, "ntilde");
    192. 

  192. 			_entityValue.Add("ograve", 242);	// latin small letter o with grave, U+00F2 ISOlat1 
    193. 

  193. 			_entityName.Add(242, "ograve");
    194. 

  194. 			_entityValue.Add("oacute", 243);	// latin small letter o with acute, U+00F3 ISOlat1 
    195. 

  195. 			_entityName.Add(243, "oacute");
    196. 

  196. 			_entityValue.Add("ocirc", 244);	// latin small letter o with circumflex, U+00F4 ISOlat1 
    197. 

  197. 			_entityName.Add(244, "ocirc");
    198. 

  198. 			_entityValue.Add("otilde", 245);	// latin small letter o with tilde, U+00F5 ISOlat1 
    199. 

  199. 			_entityName.Add(245, "otilde");
    200. 

  200. 			_entityValue.Add("ouml", 246);	// latin small letter o with diaeresis, U+00F6 ISOlat1 
    201. 

  201. 			_entityName.Add(246, "ouml");
    202. 

  202. 			_entityValue.Add("divide", 247);	// division sign, U+00F7 ISOnum 
    203. 

  203. 			_entityName.Add(247, "divide");
    204. 

  204. 			_entityValue.Add("oslash", 248);	// latin small letter o with stroke, = latin small letter o slash, U+00F8 ISOlat1 
    205. 

  205. 			_entityName.Add(248, "oslash");
    206. 

  206. 			_entityValue.Add("ugrave", 249);	// latin small letter u with grave, U+00F9 ISOlat1 
    207. 

  207. 			_entityName.Add(249, "ugrave");
    208. 

  208. 			_entityValue.Add("uacute", 250);	// latin small letter u with acute, U+00FA ISOlat1 
    209. 

  209. 			_entityName.Add(250, "uacute");
    210. 

  210. 			_entityValue.Add("ucirc", 251);	// latin small letter u with circumflex, U+00FB ISOlat1 
    211. 

  211. 			_entityName.Add(251, "ucirc");
    212. 

  212. 			_entityValue.Add("uuml", 252);	// latin small letter u with diaeresis, U+00FC ISOlat1 
    213. 

  213. 			_entityName.Add(252, "uuml");
    214. 

  214. 			_entityValue.Add("yacute", 253);	// latin small letter y with acute, U+00FD ISOlat1 
    215. 

  215. 			_entityName.Add(253, "yacute");
    216. 

  216. 			_entityValue.Add("thorn", 254);	// latin small letter thorn, U+00FE ISOlat1 
    217. 

  217. 			_entityName.Add(254, "thorn");
    218. 

  218. 			_entityValue.Add("yuml", 255);	// latin small letter y with diaeresis, U+00FF ISOlat1 
    219. 

  219. 			_entityName.Add(255, "yuml");
    220. 

  220. 			_entityValue.Add("fnof", 402);	// latin small f with hook = function = florin, U+0192 ISOtech 
    221. 

  221. 			_entityName.Add(402, "fnof");
    222. 

  222. 			_entityValue.Add("Alpha", 913);	// greek capital letter alpha, U+0391 
    223. 

  223. 			_entityName.Add(913, "Alpha");
    224. 

  224. 			_entityValue.Add("Beta", 914);	// greek capital letter beta, U+0392 
    225. 

  225. 			_entityName.Add(914, "Beta");
    226. 

  226. 			_entityValue.Add("Gamma", 915);	// greek capital letter gamma, U+0393 ISOgrk3 
    227. 

  227. 			_entityName.Add(915, "Gamma");
    228. 

  228. 			_entityValue.Add("Delta", 916);	// greek capital letter delta, U+0394 ISOgrk3 
    229. 

  229. 			_entityName.Add(916, "Delta");
    230. 

  230. 			_entityValue.Add("Epsilon", 917);	// greek capital letter epsilon, U+0395 
    231. 

  231. 			_entityName.Add(917, "Epsilon");
    232. 

  232. 			_entityValue.Add("Zeta", 918);	// greek capital letter zeta, U+0396 
    233. 

  233. 			_entityName.Add(918, "Zeta");
    234. 

  234. 			_entityValue.Add("Eta", 919);	// greek capital letter eta, U+0397 
    235. 

  235. 			_entityName.Add(919, "Eta");
    236. 

  236. 			_entityValue.Add("Theta", 920);	// greek capital letter theta, U+0398 ISOgrk3 
    237. 

  237. 			_entityName.Add(920, "Theta");
    238. 

  238. 			_entityValue.Add("Iota", 921);	// greek capital letter iota, U+0399 
    239. 

  239. 			_entityName.Add(921, "Iota");
    240. 

  240. 			_entityValue.Add("Kappa", 922);	// greek capital letter kappa, U+039A 
    241. 

  241. 			_entityName.Add(922, "Kappa");
    242. 

  242. 			_entityValue.Add("Lambda", 923);	// greek capital letter lambda, U+039B ISOgrk3 
    243. 

  243. 			_entityName.Add(923, "Lambda");
    244. 

  244. 			_entityValue.Add("Mu", 924);	// greek capital letter mu, U+039C 
    245. 

  245. 			_entityName.Add(924, "Mu");
    246. 

  246. 			_entityValue.Add("Nu", 925);	// greek capital letter nu, U+039D 
    247. 

  247. 			_entityName.Add(925, "Nu");
    248. 

  248. 			_entityValue.Add("Xi", 926);	// greek capital letter xi, U+039E ISOgrk3 
    249. 

  249. 			_entityName.Add(926, "Xi");
    250. 

  250. 			_entityValue.Add("Omicron", 927);	// greek capital letter omicron, U+039F 
    251. 

  251. 			_entityName.Add(927, "Omicron");
    252. 

  252. 			_entityValue.Add("Pi", 928);	// greek capital letter pi, U+03A0 ISOgrk3 
    253. 

  253. 			_entityName.Add(928, "Pi");
    254. 

  254. 			_entityValue.Add("Rho", 929);	// greek capital letter rho, U+03A1 
    255. 

  255. 			_entityName.Add(929, "Rho");
    256. 

  256. 			_entityValue.Add("Sigma", 931);	// greek capital letter sigma, U+03A3 ISOgrk3 
    257. 

  257. 			_entityName.Add(931, "Sigma");
    258. 

  258. 			_entityValue.Add("Tau", 932);	// greek capital letter tau, U+03A4 
    259. 

  259. 			_entityName.Add(932, "Tau");
    260. 

  260. 			_entityValue.Add("Upsilon", 933);	// greek capital letter upsilon, U+03A5 ISOgrk3 
    261. 

  261. 			_entityName.Add(933, "Upsilon");
    262. 

  262. 			_entityValue.Add("Phi", 934);	// greek capital letter phi, U+03A6 ISOgrk3 
    263. 

  263. 			_entityName.Add(934, "Phi");
    264. 

  264. 			_entityValue.Add("Chi", 935);	// greek capital letter chi, U+03A7 
    265. 

  265. 			_entityName.Add(935, "Chi");
    266. 

  266. 			_entityValue.Add("Psi", 936);	// greek capital letter psi, U+03A8 ISOgrk3 
    267. 

  267. 			_entityName.Add(936, "Psi");
    268. 

  268. 			_entityValue.Add("Omega", 937);	// greek capital letter omega, U+03A9 ISOgrk3 
    269. 

  269. 			_entityName.Add(937, "Omega");
    270. 

  270. 			_entityValue.Add("alpha", 945);	// greek small letter alpha, U+03B1 ISOgrk3 
    271. 

  271. 			_entityName.Add(945, "alpha");
    272. 

  272. 			_entityValue.Add("beta", 946);	// greek small letter beta, U+03B2 ISOgrk3 
    273. 

  273. 			_entityName.Add(946, "beta");
    274. 

  274. 			_entityValue.Add("gamma", 947);	// greek small letter gamma, U+03B3 ISOgrk3 
    275. 

  275. 			_entityName.Add(947, "gamma");
    276. 

  276. 			_entityValue.Add("delta", 948);	// greek small letter delta, U+03B4 ISOgrk3 
    277. 

  277. 			_entityName.Add(948, "delta");
    278. 

  278. 			_entityValue.Add("epsilon", 949);	// greek small letter epsilon, U+03B5 ISOgrk3 
    279. 

  279. 			_entityName.Add(949, "epsilon");
    280. 

  280. 			_entityValue.Add("zeta", 950);	// greek small letter zeta, U+03B6 ISOgrk3 
    281. 

  281. 			_entityName.Add(950, "zeta");
    282. 

  282. 			_entityValue.Add("eta", 951);	// greek small letter eta, U+03B7 ISOgrk3 
    283. 

  283. 			_entityName.Add(951, "eta");
    284. 

  284. 			_entityValue.Add("theta", 952);	// greek small letter theta, U+03B8 ISOgrk3 
    285. 

  285. 			_entityName.Add(952, "theta");
    286. 

  286. 			_entityValue.Add("iota", 953);	// greek small letter iota, U+03B9 ISOgrk3 
    287. 

  287. 			_entityName.Add(953, "iota");
    288. 

  288. 			_entityValue.Add("kappa", 954);	// greek small letter kappa, U+03BA ISOgrk3 
    289. 

  289. 			_entityName.Add(954, "kappa");
    290. 

  290. 			_entityValue.Add("lambda", 955);	// greek small letter lambda, U+03BB ISOgrk3 
    291. 

  291. 			_entityName.Add(955, "lambda");
    292. 

  292. 			_entityValue.Add("mu", 956);	// greek small letter mu, U+03BC ISOgrk3 
    293. 

  293. 			_entityName.Add(956, "mu");
    294. 

  294. 			_entityValue.Add("nu", 957);	// greek small letter nu, U+03BD ISOgrk3 
    295. 

  295. 			_entityName.Add(957, "nu");
    296. 

  296. 			_entityValue.Add("xi", 958);	// greek small letter xi, U+03BE ISOgrk3 
    297. 

  297. 			_entityName.Add(958, "xi");
    298. 

  298. 			_entityValue.Add("omicron", 959);	// greek small letter omicron, U+03BF NEW 
    299. 

  299. 			_entityName.Add(959, "omicron");
    300. 

  300. 			_entityValue.Add("pi", 960);	// greek small letter pi, U+03C0 ISOgrk3 
    301. 

  301. 			_entityName.Add(960, "pi");
    302. 

  302. 			_entityValue.Add("rho", 961);	// greek small letter rho, U+03C1 ISOgrk3 
    303. 

  303. 			_entityName.Add(961, "rho");
    304. 

  304. 			_entityValue.Add("sigmaf", 962);	// greek small letter final sigma, U+03C2 ISOgrk3 
    305. 

  305. 			_entityName.Add(962, "sigmaf");
    306. 

  306. 			_entityValue.Add("sigma", 963);	// greek small letter sigma, U+03C3 ISOgrk3 
    307. 

  307. 			_entityName.Add(963, "sigma");
    308. 

  308. 			_entityValue.Add("tau", 964);	// greek small letter tau, U+03C4 ISOgrk3 
    309. 

  309. 			_entityName.Add(964, "tau");
    310. 

  310. 			_entityValue.Add("upsilon", 965);	// greek small letter upsilon, U+03C5 ISOgrk3 
    311. 

  311. 			_entityName.Add(965, "upsilon");
    312. 

  312. 			_entityValue.Add("phi", 966);	// greek small letter phi, U+03C6 ISOgrk3 
    313. 

  313. 			_entityName.Add(966, "phi");
    314. 

  314. 			_entityValue.Add("chi", 967);	// greek small letter chi, U+03C7 ISOgrk3 
    315. 

  315. 			_entityName.Add(967, "chi");
    316. 

  316. 			_entityValue.Add("psi", 968);	// greek small letter psi, U+03C8 ISOgrk3 
    317. 

  317. 			_entityName.Add(968, "psi");
    318. 

  318. 			_entityValue.Add("omega", 969);	// greek small letter omega, U+03C9 ISOgrk3 
    319. 

  319. 			_entityName.Add(969, "omega");
    320. 

  320. 			_entityValue.Add("thetasym", 977);	// greek small letter theta symbol, U+03D1 NEW 
    321. 

  321. 			_entityName.Add(977, "thetasym");
    322. 

  322. 			_entityValue.Add("upsih", 978);	// greek upsilon with hook symbol, U+03D2 NEW 
    323. 

  323. 			_entityName.Add(978, "upsih");
    324. 

  324. 			_entityValue.Add("piv", 982);	// greek pi symbol, U+03D6 ISOgrk3 
    325. 

  325. 			_entityName.Add(982, "piv");
    326. 

  326. 			_entityValue.Add("bull", 8226);	// bullet = black small circle, U+2022 ISOpub 
    327. 

  327. 			_entityName.Add(8226, "bull");
    328. 

  328. 			_entityValue.Add("hellip", 8230);	// horizontal ellipsis = three dot leader, U+2026 ISOpub 
    329. 

  329. 			_entityName.Add(8230, "hellip");
    330. 

  330. 			_entityValue.Add("prime", 8242);	// prime = minutes = feet, U+2032 ISOtech 
    331. 

  331. 			_entityName.Add(8242, "prime");
    332. 

  332. 			_entityValue.Add("Prime", 8243);	// double prime = seconds = inches, U+2033 ISOtech 
    333. 

  333. 			_entityName.Add(8243, "Prime");
    334. 

  334. 			_entityValue.Add("oline", 8254);	// overline = spacing overscore, U+203E NEW 
    335. 

  335. 			_entityName.Add(8254, "oline");
    336. 

  336. 			_entityValue.Add("frasl", 8260);	// fraction slash, U+2044 NEW 
    337. 

  337. 			_entityName.Add(8260, "frasl");
    338. 

  338. 			_entityValue.Add("weierp", 8472);	// script capital P = power set = Weierstrass p, U+2118 ISOamso 
    339. 

  339. 			_entityName.Add(8472, "weierp");
    340. 

  340. 			_entityValue.Add("image", 8465);	// blackletter capital I = imaginary part, U+2111 ISOamso 
    341. 

  341. 			_entityName.Add(8465, "image");
    342. 

  342. 			_entityValue.Add("real", 8476);	// blackletter capital R = real part symbol, U+211C ISOamso 
    343. 

  343. 			_entityName.Add(8476, "real");
    344. 

  344. 			_entityValue.Add("trade", 8482);	// trade mark sign, U+2122 ISOnum 
    345. 

  345. 			_entityName.Add(8482, "trade");
    346. 

  346. 			_entityValue.Add("alefsym", 8501);	// alef symbol = first transfinite cardinal, U+2135 NEW 
    347. 

  347. 			_entityName.Add(8501, "alefsym");
    348. 

  348. 			_entityValue.Add("larr", 8592);	// leftwards arrow, U+2190 ISOnum 
    349. 

  349. 			_entityName.Add(8592, "larr");
    350. 

  350. 			_entityValue.Add("uarr", 8593);	// upwards arrow, U+2191 ISOnum
    351. 

  351. 			_entityName.Add(8593, "uarr");
    352. 

  352. 			_entityValue.Add("rarr", 8594);	// rightwards arrow, U+2192 ISOnum 
    353. 

  353. 			_entityName.Add(8594, "rarr");
    354. 

  354. 			_entityValue.Add("darr", 8595);	// downwards arrow, U+2193 ISOnum 
    355. 

  355. 			_entityName.Add(8595, "darr");
    356. 

  356. 			_entityValue.Add("harr", 8596);	// left right arrow, U+2194 ISOamsa 
    357. 

  357. 			_entityName.Add(8596, "harr");
    358. 

  358. 			_entityValue.Add("crarr", 8629);	// downwards arrow with corner leftwards = carriage return, U+21B5 NEW 
    359. 

  359. 			_entityName.Add(8629, "crarr");
    360. 

  360. 			_entityValue.Add("lArr", 8656);	// leftwards double arrow, U+21D0 ISOtech 
    361. 

  361. 			_entityName.Add(8656, "lArr");
    362. 

  362. 			_entityValue.Add("uArr", 8657);	// upwards double arrow, U+21D1 ISOamsa 
    363. 

  363. 			_entityName.Add(8657, "uArr");
    364. 

  364. 			_entityValue.Add("rArr", 8658);	// rightwards double arrow, U+21D2 ISOtech 
    365. 

  365. 			_entityName.Add(8658, "rArr");
    366. 

  366. 			_entityValue.Add("dArr", 8659);	// downwards double arrow, U+21D3 ISOamsa 
    367. 

  367. 			_entityName.Add(8659, "dArr");
    368. 

  368. 			_entityValue.Add("hArr", 8660);	// left right double arrow, U+21D4 ISOamsa 
    369. 

  369. 			_entityName.Add(8660, "hArr");
    370. 

  370. 			_entityValue.Add("forall", 8704);	// for all, U+2200 ISOtech 
    371. 

  371. 			_entityName.Add(8704, "forall");
    372. 

  372. 			_entityValue.Add("part", 8706);	// partial differential, U+2202 ISOtech 
    373. 

  373. 			_entityName.Add(8706, "part");
    374. 

  374. 			_entityValue.Add("exist", 8707);	// there exists, U+2203 ISOtech 
    375. 

  375. 			_entityName.Add(8707, "exist");
    376. 

  376. 			_entityValue.Add("empty", 8709);	// empty set = null set = diameter, U+2205 ISOamso 
    377. 

  377. 			_entityName.Add(8709, "empty");
    378. 

  378. 			_entityValue.Add("nabla", 8711);	// nabla = backward difference, U+2207 ISOtech 
    379. 

  379. 			_entityName.Add(8711, "nabla");
    380. 

  380. 			_entityValue.Add("isin", 8712);	// element of, U+2208 ISOtech 
    381. 

  381. 			_entityName.Add(8712, "isin");
    382. 

  382. 			_entityValue.Add("notin", 8713);	// not an element of, U+2209 ISOtech 
    383. 

  383. 			_entityName.Add(8713, "notin");
    384. 

  384. 			_entityValue.Add("ni", 8715);	// contains as member, U+220B ISOtech 
    385. 

  385. 			_entityName.Add(8715, "ni");
    386. 

  386. 			_entityValue.Add("prod", 8719);	// n-ary product = product sign, U+220F ISOamsb 
    387. 

  387. 			_entityName.Add(8719, "prod");
    388. 

  388. 			_entityValue.Add("sum", 8721);	// n-ary sumation, U+2211 ISOamsb 
    389. 

  389. 			_entityName.Add(8721, "sum");
    390. 

  390. 			_entityValue.Add("minus", 8722);	// minus sign, U+2212 ISOtech 
    391. 

  391. 			_entityName.Add(8722, "minus");
    392. 

  392. 			_entityValue.Add("lowast", 8727);	// asterisk operator, U+2217 ISOtech 
    393. 

  393. 			_entityName.Add(8727, "lowast");
    394. 

  394. 			_entityValue.Add("radic", 8730);	// square root = radical sign, U+221A ISOtech 
    395. 

  395. 			_entityName.Add(8730, "radic");
    396. 

  396. 			_entityValue.Add("prop", 8733);	// proportional to, U+221D ISOtech 
    397. 

  397. 			_entityName.Add(8733, "prop");
    398. 

  398. 			_entityValue.Add("infin", 8734);	// infinity, U+221E ISOtech 
    399. 

  399. 			_entityName.Add(8734, "infin");
    400. 

  400. 			_entityValue.Add("ang", 8736);	// angle, U+2220 ISOamso 
    401. 

  401. 			_entityName.Add(8736, "ang");
    402. 

  402. 			_entityValue.Add("and", 8743);	// logical and = wedge, U+2227 ISOtech 
    403. 

  403. 			_entityName.Add(8743, "and");
    404. 

  404. 			_entityValue.Add("or", 8744);	// logical or = vee, U+2228 ISOtech 
    405. 

  405. 			_entityName.Add(8744, "or");
    406. 

  406. 			_entityValue.Add("cap", 8745);	// intersection = cap, U+2229 ISOtech 
    407. 

  407. 			_entityName.Add(8745, "cap");
    408. 

  408. 			_entityValue.Add("cup", 8746);	// union = cup, U+222A ISOtech 
    409. 

  409. 			_entityName.Add(8746, "cup");
    410. 

  410. 			_entityValue.Add("int", 8747);	// integral, U+222B ISOtech 
    411. 

  411. 			_entityName.Add(8747, "int");
    412. 

  412. 			_entityValue.Add("there4", 8756);	// therefore, U+2234 ISOtech 
    413. 

  413. 			_entityName.Add(8756, "there4");
    414. 

  414. 			_entityValue.Add("sim", 8764);	// tilde operator = varies with = similar to, U+223C ISOtech 
    415. 

  415. 			_entityName.Add(8764, "sim");
    416. 

  416. 			_entityValue.Add("cong", 8773);	// approximately equal to, U+2245 ISOtech 
    417. 

  417. 			_entityName.Add(8773, "cong");
    418. 

  418. 			_entityValue.Add("asymp", 8776);	// almost equal to = asymptotic to, U+2248 ISOamsr 
    419. 

  419. 			_entityName.Add(8776, "asymp");
    420. 

  420. 			_entityValue.Add("ne", 8800);	// not equal to, U+2260 ISOtech 
    421. 

  421. 			_entityName.Add(8800, "ne");
    422. 

  422. 			_entityValue.Add("equiv", 8801);	// identical to, U+2261 ISOtech 
    423. 

  423. 			_entityName.Add(8801, "equiv");
    424. 

  424. 			_entityValue.Add("le", 8804);	// less-than or equal to, U+2264 ISOtech 
    425. 

  425. 			_entityName.Add(8804, "le");
    426. 

  426. 			_entityValue.Add("ge", 8805);	// greater-than or equal to, U+2265 ISOtech 
    427. 

  427. 			_entityName.Add(8805, "ge");
    428. 

  428. 			_entityValue.Add("sub", 8834);	// subset of, U+2282 ISOtech 
    429. 

  429. 			_entityName.Add(8834, "sub");
    430. 

  430. 			_entityValue.Add("sup", 8835);	// superset of, U+2283 ISOtech 
    431. 

  431. 			_entityName.Add(8835, "sup");
    432. 

  432. 			_entityValue.Add("nsub", 8836);	// not a subset of, U+2284 ISOamsn 
    433. 

  433. 			_entityName.Add(8836, "nsub");
    434. 

  434. 			_entityValue.Add("sube", 8838);	// subset of or equal to, U+2286 ISOtech 
    435. 

  435. 			_entityName.Add(8838, "sube");
    436. 

  436. 			_entityValue.Add("supe", 8839);	// superset of or equal to, U+2287 ISOtech 
    437. 

  437. 			_entityName.Add(8839, "supe");
    438. 

  438. 			_entityValue.Add("oplus", 8853);	// circled plus = direct sum, U+2295 ISOamsb 
    439. 

  439. 			_entityName.Add(8853, "oplus");
    440. 

  440. 			_entityValue.Add("otimes", 8855);	// circled times = vector product, U+2297 ISOamsb 
    441. 

  441. 			_entityName.Add(8855, "otimes");
    442. 

  442. 			_entityValue.Add("perp", 8869);	// up tack = orthogonal to = perpendicular, U+22A5 ISOtech 
    443. 

  443. 			_entityName.Add(8869, "perp");
    444. 

  444. 			_entityValue.Add("sdot", 8901);	// dot operator, U+22C5 ISOamsb 
    445. 

  445. 			_entityName.Add(8901, "sdot");
    446. 

  446. 			_entityValue.Add("lceil", 8968);	// left ceiling = apl upstile, U+2308 ISOamsc 
    447. 

  447. 			_entityName.Add(8968, "lceil");
    448. 

  448. 			_entityValue.Add("rceil", 8969);	// right ceiling, U+2309 ISOamsc 
    449. 

  449. 			_entityName.Add(8969, "rceil");
    450. 

  450. 			_entityValue.Add("lfloor", 8970);	// left floor = apl downstile, U+230A ISOamsc 
    451. 

  451. 			_entityName.Add(8970, "lfloor");
    452. 

  452. 			_entityValue.Add("rfloor", 8971);	// right floor, U+230B ISOamsc 
    453. 

  453. 			_entityName.Add(8971, "rfloor");
    454. 

  454. 			_entityValue.Add("lang", 9001);	// left-pointing angle bracket = bra, U+2329 ISOtech 
    455. 

  455. 			_entityName.Add(9001, "lang");
    456. 

  456. 			_entityValue.Add("rang", 9002);	// right-pointing angle bracket = ket, U+232A ISOtech 
    457. 

  457. 			_entityName.Add(9002, "rang");
    458. 

  458. 			_entityValue.Add("loz", 9674);	// lozenge, U+25CA ISOpub 
    459. 

  459. 			_entityName.Add(9674, "loz");
    460. 

  460. 			_entityValue.Add("spades", 9824);	// black spade suit, U+2660 ISOpub 
    461. 

  461. 			_entityName.Add(9824, "spades");
    462. 

  462. 			_entityValue.Add("clubs", 9827);	// black club suit = shamrock, U+2663 ISOpub 
    463. 

  463. 			_entityName.Add(9827, "clubs");
    464. 

  464. 			_entityValue.Add("hearts", 9829);	// black heart suit = valentine, U+2665 ISOpub 
    465. 

  465. 			_entityName.Add(9829, "hearts");
    466. 

  466. 			_entityValue.Add("diams", 9830);	// black diamond suit, U+2666 ISOpub 
    467. 

  467. 			_entityName.Add(9830, "diams");
    468. 

  468. 			_entityValue.Add("quot", 34);	// quotation mark = APL quote, U+0022 ISOnum 
    469. 

  469. 			_entityName.Add(34, "quot");
    470. 

  470. 			_entityValue.Add("amp", 38);	// ampersand, U+0026 ISOnum 
    471. 

  471. 			_entityName.Add(38, "amp");
    472. 

  472. 			_entityValue.Add("lt", 60);	// less-than sign, U+003C ISOnum 
    473. 

  473. 			_entityName.Add(60, "lt");
    474. 

  474. 			_entityValue.Add("gt", 62);	// greater-than sign, U+003E ISOnum 
    475. 

  475. 			_entityName.Add(62, "gt");
    476. 

  476. 			_entityValue.Add("OElig", 338);	// latin capital ligature OE, U+0152 ISOlat2 
    477. 

  477. 			_entityName.Add(338, "OElig");
    478. 

  478. 			_entityValue.Add("oelig", 339);	// latin small ligature oe, U+0153 ISOlat2 
    479. 

  479. 			_entityName.Add(339, "oelig");
    480. 

  480. 			_entityValue.Add("Scaron", 352);	// latin capital letter S with caron, U+0160 ISOlat2 
    481. 

  481. 			_entityName.Add(352, "Scaron");
    482. 

  482. 			_entityValue.Add("scaron", 353);	// latin small letter s with caron, U+0161 ISOlat2 
    483. 

  483. 			_entityName.Add(353, "scaron");
    484. 

  484. 			_entityValue.Add("Yuml", 376);	// latin capital letter Y with diaeresis, U+0178 ISOlat2 
    485. 

  485. 			_entityName.Add(376, "Yuml");
    486. 

  486. 			_entityValue.Add("circ", 710);	// modifier letter circumflex accent, U+02C6 ISOpub 
    487. 

  487. 			_entityName.Add(710, "circ");
    488. 

  488. 			_entityValue.Add("tilde", 732);	// small tilde, U+02DC ISOdia 
    489. 

  489. 			_entityName.Add(732, "tilde");
    490. 

  490. 			_entityValue.Add("ensp", 8194);	// en space, U+2002 ISOpub 
    491. 

  491. 			_entityName.Add(8194, "ensp");
    492. 

  492. 			_entityValue.Add("emsp", 8195);	// em space, U+2003 ISOpub 
    493. 

  493. 			_entityName.Add(8195, "emsp");
    494. 

  494. 			_entityValue.Add("thinsp", 8201);	// thin space, U+2009 ISOpub 
    495. 

  495. 			_entityName.Add(8201, "thinsp");
    496. 

  496. 			_entityValue.Add("zwnj", 8204);	// zero width non-joiner, U+200C NEW RFC 2070 
    497. 

  497. 			_entityName.Add(8204, "zwnj");
    498. 

  498. 			_entityValue.Add("zwj", 8205);	// zero width joiner, U+200D NEW RFC 2070 
    499. 

  499. 			_entityName.Add(8205, "zwj");
    500. 

  500. 			_entityValue.Add("lrm", 8206);	// left-to-right mark, U+200E NEW RFC 2070 
    501. 

  501. 			_entityName.Add(8206, "lrm");
    502. 

  502. 			_entityValue.Add("rlm", 8207);	// right-to-left mark, U+200F NEW RFC 2070 
    503. 

  503. 			_entityName.Add(8207, "rlm");
    504. 

  504. 			_entityValue.Add("ndash", 8211);	// en dash, U+2013 ISOpub 
    505. 

  505. 			_entityName.Add(8211, "ndash");
    506. 

  506. 			_entityValue.Add("mdash", 8212);	// em dash, U+2014 ISOpub 
    507. 

  507. 			_entityName.Add(8212, "mdash");
    508. 

  508. 			_entityValue.Add("lsquo", 8216);	// left single quotation mark, U+2018 ISOnum 
    509. 

  509. 			_entityName.Add(8216, "lsquo");
    510. 

  510. 			_entityValue.Add("rsquo", 8217);	// right single quotation mark, U+2019 ISOnum 
    511. 

  511. 			_entityName.Add(8217, "rsquo");
    512. 

  512. 			_entityValue.Add("sbquo", 8218);	// single low-9 quotation mark, U+201A NEW 
    513. 

  513. 			_entityName.Add(8218, "sbquo");
    514. 

  514. 			_entityValue.Add("ldquo", 8220);	// left double quotation mark, U+201C ISOnum 
    515. 

  515. 			_entityName.Add(8220, "ldquo");
    516. 

  516. 			_entityValue.Add("rdquo", 8221);	// right double quotation mark, U+201D ISOnum 
    517. 

  517. 			_entityName.Add(8221, "rdquo");
    518. 

  518. 			_entityValue.Add("bdquo", 8222);	// double low-9 quotation mark, U+201E NEW 
    519. 

  519. 			_entityName.Add(8222, "bdquo");
    520. 

  520. 			_entityValue.Add("dagger", 8224);	// dagger, U+2020 ISOpub 
    521. 

  521. 			_entityName.Add(8224, "dagger");
    522. 

  522. 			_entityValue.Add("Dagger", 8225);	// double dagger, U+2021 ISOpub 
    523. 

  523. 			_entityName.Add(8225, "Dagger");
    524. 

  524. 			_entityValue.Add("permil", 8240);	// per mille sign, U+2030 ISOtech 
    525. 

  525. 			_entityName.Add(8240, "permil");
    526. 

  526. 			_entityValue.Add("lsaquo", 8249);	// single left-pointing angle quotation mark, U+2039 ISO proposed 
    527. 

  527. 			_entityName.Add(8249, "lsaquo");
    528. 

  528. 			_entityValue.Add("rsaquo", 8250);	// single right-pointing angle quotation mark, U+203A ISO proposed 
    529. 

  529. 			_entityName.Add(8250, "rsaquo");
    530. 

  530. 			_entityValue.Add("euro", 8364);	// euro sign, U+20AC NEW 
    531. 

  531. 			_entityName.Add(8364, "euro");
    532. 

  532. 

  533. 			_maxEntitySize = 8 + 1; // we add the # char
    534. 

  534. 			#endregion
    535. 

  535. 		}
    536. 

  536. 

  537. 		/// <summary>
    538. 

  538. 		/// A collection of entities indexed by name.
    539. 

  539. 		/// </summary>
    540. 

  540. 		public static Hashtable EntityName
    541. 

  541. 		{
    542. 

  542. 			get
    543. 

  543. 			{
    544. 

  544. 				return _entityName;
    545. 

  545. 			}
    546. 

  546. 		}
    547. 

  547. 

  548. 		/// <summary>
    549. 

  549. 		/// A collection of entities indexed by value.
    550. 

  550. 		/// </summary>
    551. 

  551. 		public static Hashtable EntityValue
    552. 

  552. 		{
    553. 

  553. 			get
    554. 

  554. 			{
    555. 

  555. 				return _entityValue;
    556. 

  556. 			}
    557. 

  557. 		}
    558. 

  558. 

  559. 		/// <summary>
    560. 

  560. 		/// Clone and entitize an HtmlNode. This will affect attribute values and nodes' text. It will also entitize all child nodes.
    561. 

  561. 		/// </summary>
    562. 

  562. 		/// <param name="node">The node to entitize.</param>
    563. 

  563. 		/// <returns>An entitized cloned node.</returns>
    564. 

  564. 		public static HtmlNode Entitize(HtmlNode node)
    565. 

  565. 		{
    566. 

  566. 			if (node == null)
    567. 

  567. 			{
    568. 

  568. 				throw new ArgumentNullException("node");
    569. 

  569. 			}
    570. 

  570. 			HtmlNode result = node.CloneNode(true);
    571. 

  571. 			if (result.HasAttributes)
    572. 

  572. 				Entitize(result.Attributes);
    573. 

  573. 

  574. 			if (result.HasChildNodes)
    575. 

  575. 			{
    576. 

  576. 				Entitize(result.ChildNodes);
    577. 

  577. 			}
    578. 

  578. 			else
    579. 

  579. 			{
    580. 

  580. 				if (result.NodeType == HtmlNodeType.Text)
    581. 

  581. 				{
    582. 

  582. 					((HtmlTextNode)result).Text = Entitize(((HtmlTextNode)result).Text, true, true);
    583. 

  583. 				}
    584. 

  584. 			}
    585. 

  585. 			return result;
    586. 

  586. 		}
    587. 

  587. 

  588. 		private static void Entitize(HtmlAttributeCollection collection)
    589. 

  589. 		{
    590. 

  590. 			foreach(HtmlAttribute at in collection)
    591. 

  591. 			{
    592. 

  592. 				at.Value = Entitize(at.Value);
    593. 

  593. 			}
    594. 

  594. 		}
    595. 

  595. 

  596. 		private static void Entitize(HtmlNodeCollection collection)
    597. 

  597. 		{
    598. 

  598. 			foreach(HtmlNode node in collection)
    599. 

  599. 			{
    600. 

  600. 				if (node.HasAttributes)
    601. 

  601. 					Entitize(node.Attributes);
    602. 

  602. 

  603. 				if (node.HasChildNodes)
    604. 

  604. 				{
    605. 

  605. 					Entitize(node.ChildNodes);
    606. 

  606. 				}
    607. 

  607. 				else
    608. 

  608. 				{
    609. 

  609. 					if (node.NodeType == HtmlNodeType.Text)
    610. 

  610. 					{
    611. 

  611. 						((HtmlTextNode)node).Text = Entitize(((HtmlTextNode)node).Text, true, true);
    612. 

  612. 					}
    613. 

  613. 				}
    614. 

  614. 			}
    615. 

  615. 		}
    616. 

  616. 

  617. 

  618. 		/// <summary>
    619. 

  619. 		/// Replace characters above 127 by entities.
    620. 

  620. 		/// </summary>
    621. 

  621. 		/// <param name="text">The source text.</param>
    622. 

  622. 		/// <returns>The result text.</returns>
    623. 

  623. 		public static string Entitize(string text)
    624. 

  624. 		{
    625. 

  625. 			return Entitize(text, true);
    626. 

  626. 		}
    627. 

  627. 

  628. 		/// <summary>
    629. 

  629. 		/// Replace characters above 127 by entities.
    630. 

  630. 		/// </summary>
    631. 

  631. 		/// <param name="text">The source text.</param>
    632. 

  632. 		/// <param name="useNames">If set to false, the function will not use known entities name. Default is true.</param>
    633. 

  633. 		/// <returns>The result text.</returns>
    634. 

  634. 		public static string Entitize(string text, bool useNames)
    635. 

  635. 		{
    636. 

  636. 			return Entitize( text, useNames, false);
    637. 

  637. 		}
    638. 

  638. 		/// <summary>
    639. 

  639. 		/// Replace characters above 127 by entities.
    640. 

  640. 		/// </summary>
    641. 

  641. 		/// <param name="text">The source text.</param>
    642. 

  642. 		/// <param name="useNames">If set to false, the function will not use known entities name. Default is true.</param>
    643. 

  643. 		/// <param name="entitizeQuotAmpAndLtGt">If set to true, the [quote], [ampersand], [lower than] and [greather than] characters will be entitized.</param>
    644. 

  644. 		/// <returns>The result text</returns>
    645. 

  645. 		public static string Entitize(string text, bool useNames, bool entitizeQuotAmpAndLtGt)
    646. 

  646. //		_entityValue.Add("quot", 34);	// quotation mark = APL quote, U+0022 ISOnum 
    647. 

  647. //		_entityName.Add(34, "quot");
    648. 

  648. //		_entityValue.Add("amp", 38);	// ampersand, U+0026 ISOnum 
    649. 

  649. //		_entityName.Add(38, "amp");
    650. 

  650. //		_entityValue.Add("lt", 60);	// less-than sign, U+003C ISOnum 
    651. 

  651. //		_entityName.Add(60, "lt");
    652. 

  652. //		_entityValue.Add("gt", 62);	// greater-than sign, U+003E ISOnum 
    653. 

  653. //		_entityName.Add(62, "gt");
    654. 

  654. 		{
    655. 

  655. 			if (text == null)
    656. 

  656. 				return null;
    657. 

  657. 

  658. 			if (text.Length == 0)
    659. 

  659. 				return text;
    660. 

  660. 

  661. 			StringBuilder sb = new StringBuilder(text.Length);
    662. 

  662. 			for(int i=0;i<text.Length;i++)
    663. 

  663. 			{
    664. 

  664. 				int code = (int)text[i];
    665. 

  665. 				if ((code>127) || (entitizeQuotAmpAndLtGt && ((code == 34) || (code == 38) || (code == 60) || (code == 62))))
    666. 

  666. 				{
    667. 

  667. 					string entity = _entityName[code] as string;
    668. 

  668. 					if ((entity == null) || (!useNames))
    669. 

  669. 					{
    670. 

  670. 						sb.Append("&#" + code + ";");
    671. 

  671. 					}
    672. 

  672. 					else
    673. 

  673. 					{
    674. 

  674. 						sb.Append("&" + entity + ";");
    675. 

  675. 					}
    676. 

  676. 				}
    677. 

  677. 				else
    678. 

  678. 				{
    679. 

  679. 					sb.Append(text[i]);
    680. 

  680. 				}
    681. 

  681. 			}
    682. 

  682. 

  683. 			return sb.ToString();
    684. 

  684. 		}
    685. 

  685. 

  686. 		/// <summary>
    687. 

  687. 		/// Replace known entities by characters.
    688. 

  688. 		/// </summary>
    689. 

  689. 		/// <param name="text">The source text.</param>
    690. 

  690. 		/// <returns>The result text.</returns>
    691. 

  691. 		public static string DeEntitize(string text)
    692. 

  692. 		{
    693. 

  693. 			if (text == null)
    694. 

  694. 				return null;
    695. 

  695. 

  696. 			if (text.Length == 0)
    697. 

  697. 				return text;
    698. 

  698. 

  699. 			StringBuilder sb = new StringBuilder(text.Length);
    700. 

  700. 			ParseState state = ParseState.Text;
    701. 

  701. 			StringBuilder entity = new StringBuilder(10);
    702. 

  702. 			
    703. 

  703. 			for(int i=0;i<text.Length;i++)
    704. 

  704. 			{
    705. 

  705. 				switch(state)
    706. 

  706. 				{
    707. 

  707. 					case ParseState.Text:
    708. 

  708. 						switch(text[i])
    709. 

  709. 						{
    710. 

  710. 							case '&':
    711. 

  711. 								state = ParseState.EntityStart;
    712. 

  712. 								break;
    713. 

  713. 

  714. 							default:
    715. 

  715. 								sb.Append(text[i]);
    716. 

  716. 								break;
    717. 

  717. 

  718. 						}
    719. 

  719. 						break;
    720. 

  720. 

  721. 					case ParseState.EntityStart:
    722. 

  722. 						switch(text[i])
    723. 

  723. 						{
    724. 

  724. 							case ';':
    725. 

  725. 								if (entity.Length == 0)
    726. 

  726. 								{
    727. 

  727. 									sb.Append("&;");
    728. 

  728. 								}
    729. 

  729. 								else
    730. 

  730. 								{
    731. 

  731. 									if (entity[0] == '#')
    732. 

  732. 									{
    733. 

  733. 										string e = entity.ToString();
    734. 

  734. 										try
    735. 

  735. 										{
    736. 

  736. 											int code = Convert.ToInt32(e.Substring(1, e.Length-1));
    737. 

  737. 											sb.Append(Convert.ToChar(code));
    738. 

  738. 										}
    739. 

  739. 										catch
    740. 

  740. 										{
    741. 

  741. 											sb.Append("&#" + e + ";");
    742. 

  742. 										}
    743. 

  743. 									}
    744. 

  744. 									else
    745. 

  745. 									{
    746. 

  746. 										// named entity?
    747. 

  747. 										int code;
    748. 

  748. 										object o = _entityValue[entity.ToString()];
    749. 

  749. 										if (o == null)
    750. 

  750. 										{
    751. 

  751. 											// nope
    752. 

  752. 											sb.Append("&" + entity + ";");
    753. 

  753. 										}
    754. 

  754. 										else
    755. 

  755. 										{
    756. 

  756. 											// we found one
    757. 

  757. 											code = (int)o;
    758. 

  758. 											sb.Append(Convert.ToChar(code));
    759. 

  759. 										}
    760. 

  760. 									}
    761. 

  761. 									entity.Remove(0, entity.Length);
    762. 

  762. 								}
    763. 

  763. 								state = ParseState.Text;
    764. 

  764. 								break;
    765. 

  765. 

  766. 							case '&':
    767. 

  767. 								// new entity start without end, it was not an entity...
    768. 

  768. 								sb.Append("&" + entity);
    769. 

  769. 								entity.Remove(0, entity.Length);
    770. 

  770. 								break;
    771. 

  771. 

  772. 							default:
    773. 

  773. 								entity.Append(text[i]);
    774. 

  774. 								if (entity.Length>_maxEntitySize)
    775. 

  775. 								{
    776. 

  776. 									// unknown stuff, just don't touch it
    777. 

  777. 									state = ParseState.Text;
    778. 

  778. 									sb.Append("&" + entity);
    779. 

  779. 									entity.Remove(0, entity.Length);
    780. 

  780. 								}
    781. 

  781. 								break;
    782. 

  782. 

  783. 						}
    784. 

  784. 						break;
    785. 

  785. 				}
    786. 

  786. 			}
    787. 

  787. 

  788. 			// finish the work
    789. 

  789. 			if (state == ParseState.EntityStart)
    790. 

  790. 			{
    791. 

  791. 				sb.Append("&" + entity);
    792. 

  792. 			}
    793. 

  793. 			return sb.ToString();
    794. 

  794. 		}
    795. 

  795. 

  796. 		private enum ParseState
    797. 

  797. 		{
    798. 

  798. 			Text,
    799. 

  799. 			EntityStart
    800. 

  800. 		}
    801. 

  801. 	}
    802. 

  802. }
    803. 

  803.