/alcinoe/source/ALHTML.pas

https://bitbucket.org/sas_team/sas.requires · Pascal · 1374 lines · 1111 code · 120 blank · 143 comment · 148 complexity · b6ea3cfaef7d7505bfb1bd8689a8e5c6 MD5 · raw file

Large files are truncated click here to view the full file

    

  1. {*************************************************************

    2. 

  2. www:          http://sourceforge.net/projects/alcinoe/              

    3. 

  3. svn:          svn checkout svn://svn.code.sf.net/p/alcinoe/code/ alcinoe-code              

    4. 

  4. Author(s):    Stéphane Vander Clock (alcinoe@arkadia.com)

    5. 

  5. Sponsor(s):   Arkadia SA (http://www.arkadia.com)

    6. 

  6. 							

    7. 

  7. product:      Alcinoe HTML Functions

    8. 

  8. Version:      4.00

    9. 

  9. 

    10. 

  10. Description:  Functions to work on Html Tag (extract Text, HTML Encode,

    11. 

  11.               HTML Decode, etc. The function ALHTMLdecode and

    12. 

  12.               ALHTMLEncode is to encode decode HTML entity

    13. 

  13.               like  

    14. 

  14. 

    15. 

  15. Legal issues: Copyright (C) 1999-2013 by Arkadia Software Engineering

    16. 

  16. 

    17. 

  17.               This software is provided 'as-is', without any express

    18. 

  18.               or implied warranty.  In no event will the author be

    19. 

  19.               held liable for any  damages arising from the use of

    20. 

  20.               this software.

    21. 

  21. 

    22. 

  22.               Permission is granted to anyone to use this software

    23. 

  23.               for any purpose, including commercial applications,

    24. 

  24.               and to alter it and redistribute it freely, subject

    25. 

  25.               to the following restrictions:

    26. 

  26. 

    27. 

  27.               1. The origin of this software must not be

    28. 

  28.                  misrepresented, you must not claim that you wrote

    29. 

  29.                  the original software. If you use this software in

    30. 

  30.                  a product, an acknowledgment in the product

    31. 

  31.                  documentation would be appreciated but is not

    32. 

  32.                  required.

    33. 

  33. 

    34. 

  34.               2. Altered source versions must be plainly marked as

    35. 

  35.                  such, and must not be misrepresented as being the

    36. 

  36.                  original software.

    37. 

  37. 

    38. 

  38.               3. This notice may not be removed or altered from any

    39. 

  39.                  source distribution.

    40. 

  40. 

    41. 

  41.               4. You must register this software by sending a picture

    42. 

  42.                  postcard to the author. Use a nice stamp and mention

    43. 

  43.                  your name, street address, EMail address and any

    44. 

  44.                  comment you like to say.

    45. 

  45. 

    46. 

  46. Know bug :

    47. 

  47. 

    48. 

  48. History :     19/10/2005: Make The code independant of the current local

    49. 

  49.                           and work with UTF-8 encoding; Also build a most

    50. 

  50.                           complete list of HTML entities

    51. 

  51.               10/09/2007: create ALCompactHtmlTagParams in ALFcnHTML

    52. 

  52.               10/11/2007: move ALXMLTextElementDecode to ALUTF8XMLTextElementDecode and

    53. 

  53.               						to ALUTF8XMLTextElementDecode

    54. 

  54.               						add support for reference like € and '

    55. 

  55.               26/06/2012: Add xe2 support

    56. 

  56.               28/01/2013: Add xe2 ALJavascriptEncode / ALUTF8JavascriptDecode

    57. 

  57.               05/09/2014: Add ALRunJavascript function

    58. 

  58. 

    59. 

  59. Link :

    60. 

  60. 

    61. 

  61. * Please send all your feedback to alcinoe@arkadia.com

    62. 

  62. * If you have downloaded this source from a website different from

    63. 

  63.   sourceforge.net, please get the last version on http://sourceforge.net/projects/alcinoe/

    64. 

  64. * Please, help us to keep the development of these components free by

    65. 

  65.   promoting the sponsor on http://static.arkadia.com/html/alcinoe_like.html

    66. 

  66. **************************************************************}

    67. 

  67. unit ALHTML;

    68. 

  68. 

    69. 

  69. interface

    70. 

  70. 

    71. 

  71. {$IF CompilerVersion >= 25} {Delphi XE4}

    72. 

  72.   {$LEGACYIFEND ON} // http://docwiki.embarcadero.com/RADStudio/XE4/en/Legacy_IFEND_(Delphi)

    73. 

  73. {$IFEND}

    74. 

  74. 

    75. 

  75. uses AlStringList;

    76. 

  76. 

    77. 

  77. procedure ALUTF8ExtractHTMLText(HtmlContent: AnsiString;

    78. 

  78.                                 LstExtractedResourceText: TALStrings;

    79. 

  79.                                 Const DecodeHTMLText: Boolean = True); overload;

    80. 

  80. function  ALUTF8ExtractHTMLText(const HtmlContent: AnsiString;

    81. 

  81.                                 Const DecodeHTMLText: Boolean = True): AnsiString; overload;

    82. 

  82. function  ALXMLCDataElementEncode(const Src: AnsiString): AnsiString;

    83. 

  83. function  ALXMLTextElementEncode(const Src: AnsiString; const useNumericReference: boolean = True): AnsiString;

    84. 

  84. function  ALUTF8XMLTextElementDecode(const Src: AnsiString): AnsiString;

    85. 

  85. function  ALUTF8HTMLEncode(const Src: AnsiString;

    86. 

  86.                            const EncodeASCIIHtmlEntities: Boolean = True;

    87. 

  87.                            const useNumericReference: boolean = True): AnsiString;

    88. 

  88. function  ALUTF8HTMLDecode(const Src: AnsiString): AnsiString;

    89. 

  89. function  ALJavascriptEncode(const Src: AnsiString; const useNumericReference: boolean = true): AnsiString;

    90. 

  90. function  ALUTF8JavascriptDecode(const Src: AnsiString): AnsiString;

    91. 

  91. function  ALRunJavascript(const aCode: AnsiString): AnsiString;

    92. 

  92. procedure ALHideHtmlUnwantedTagForHTMLHandleTagfunct(Var HtmlContent: AnsiString;

    93. 

  93.                                                      Const DeleteBodyOfUnwantedTag: Boolean = False;

    94. 

  94.                                                      const ReplaceUnwantedTagCharBy: AnsiChar = #1);

    95. 

  95. procedure ALCompactHtmlTagParams(TagParams: TALStrings);

    96. 

  96. 

    97. 

  97. implementation

    98. 

  98. 

    99. 

  99. uses {$IF CompilerVersion >= 23} {Delphi XE2}

    100. 

  100.      System.Math,

    101. 

  101.      System.Classes,

    102. 

  102.      System.sysutils,

    103. 

  103.      System.Win.Comobj,

    104. 

  104.      Winapi.Ole2,

    105. 

  105.      {$ELSE}

    106. 

  106.      Math,

    107. 

  107.      Classes,

    108. 

  108.      sysutils,

    109. 

  109.      Comobj,

    110. 

  110.      Ole2,

    111. 

  111.      {$IFEND}

    112. 

  112.      ALString,

    113. 

  113.      ALQuickSortList;

    114. 

  114. 

    115. 

  115. Var vALhtml_LstEntities: TALStrings;

    116. 

  116. 

    117. 

  117. {************************************************************}

    118. 

  118. procedure ALInitHtmlEntitiesLst(aLstHtmlEntities: TALStrings);

    119. 

  119. Begin

    120. 

  120. 

    121. 

  121.   aLstHtmlEntities.Clear;

    122. 

  122.   aLstHtmlEntities.AddObject('zwnj',pointer(8204)); // zero width non-joiner,   U+200C NEW RFC 2070 -->

    123. 

  123.   aLstHtmlEntities.AddObject('zwj',pointer(8205)); // zero width joiner, U+200D NEW RFC 2070 -->

    124. 

  124.   aLstHtmlEntities.AddObject('zeta',pointer(950)); // greek small letter zeta, U+03B6 ISOgrk3 -->

    125. 

  125.   aLstHtmlEntities.AddObject('Zeta',pointer(918)); // greek capital letter zeta, U+0396 -->

    126. 

  126.   aLstHtmlEntities.AddObject('yuml',pointer(255)); // latin small letter y with diaeresis, U+00FF ISOlat1 -->

    127. 

  127.   aLstHtmlEntities.AddObject('Yuml',pointer(376)); // latin capital letter Y with diaeresis,   U+0178 ISOlat2 -->

    128. 

  128.   aLstHtmlEntities.AddObject('yen',pointer(165)); // yen sign = yuan sign, U+00A5 ISOnum -->

    129. 

  129.   aLstHtmlEntities.AddObject('yacute',pointer(253)); // latin small letter y with acute, U+00FD ISOlat1 -->

    130. 

  130.   aLstHtmlEntities.AddObject('Yacute',pointer(221)); // latin capital letter Y with acute, U+00DD ISOlat1 -->

    131. 

  131.   aLstHtmlEntities.AddObject('xi',pointer(958)); // greek small letter xi, U+03BE ISOgrk3 -->

    132. 

  132.   aLstHtmlEntities.AddObject('Xi',pointer(926)); // greek capital letter xi, U+039E ISOgrk3 -->

    133. 

  133.   aLstHtmlEntities.AddObject('weierp',pointer(8472)); // script capital P = power set    = Weierstrass p, U+2118 ISOamso -->

    134. 

  134.   aLstHtmlEntities.AddObject('uuml',pointer(252)); // latin small letter u with diaeresis, U+00FC ISOlat1 -->

    135. 

  135.   aLstHtmlEntities.AddObject('Uuml',pointer(220)); // latin capital letter U with diaeresis, U+00DC ISOlat1 -->

    136. 

  136.   aLstHtmlEntities.AddObject('upsilon',pointer(965)); // greek small letter upsilon,   U+03C5 ISOgrk3 -->

    137. 

  137.   aLstHtmlEntities.AddObject('Upsilon',pointer(933)); // greek capital letter upsilon,   U+03A5 ISOgrk3 -->

    138. 

  138.   aLstHtmlEntities.AddObject('upsih',pointer(978)); // greek upsilon with hook symbol,   U+03D2 NEW -->

    139. 

  139.   aLstHtmlEntities.AddObject('uml',pointer(168)); // diaeresis = spacing diaeresis, U+00A8 ISOdia -->

    140. 

  140.   aLstHtmlEntities.AddObject('ugrave',pointer(249)); // latin small letter u with grave, U+00F9 ISOlat1 -->

    141. 

  141.   aLstHtmlEntities.AddObject('Ugrave',pointer(217)); // latin capital letter U with grave, U+00D9 ISOlat1 -->

    142. 

  142.   aLstHtmlEntities.AddObject('ucirc',pointer(251)); // latin small letter u with circumflex, U+00FB ISOlat1 -->

    143. 

  143.   aLstHtmlEntities.AddObject('Ucirc',pointer(219)); // latin capital letter U with circumflex, U+00DB ISOlat1 -->

    144. 

  144.   aLstHtmlEntities.AddObject('uArr',pointer(8657)); // upwards double arrow, U+21D1 ISOamsa -->

    145. 

  145.   aLstHtmlEntities.AddObject('uarr',pointer(8593)); // upwards arrow, U+2191 ISOnum-->

    146. 

  146.   aLstHtmlEntities.AddObject('uacute',pointer(250)); // latin small letter u with acute, U+00FA ISOlat1 -->

    147. 

  147.   aLstHtmlEntities.AddObject('Uacute',pointer(218)); // latin capital letter U with acute, U+00DA ISOlat1 -->

    148. 

  148.   aLstHtmlEntities.AddObject('trade',pointer(8482)); // trade mark sign, U+2122 ISOnum -->

    149. 

  149.   aLstHtmlEntities.AddObject('times',pointer(215)); // multiplication sign, U+00D7 ISOnum -->

    150. 

  150.   aLstHtmlEntities.AddObject('tilde',pointer(732)); // small tilde, U+02DC ISOdia -->

    151. 

  151.   aLstHtmlEntities.AddObject('thorn',pointer(254)); // latin small letter thorn, U+00FE ISOlat1 -->

    152. 

  152.   aLstHtmlEntities.AddObject('THORN',pointer(222)); // latin capital letter THORN, U+00DE ISOlat1 -->

    153. 

  153.   aLstHtmlEntities.AddObject('thinsp',pointer(8201)); // thin space, U+2009 ISOpub -->

    154. 

  154.   aLstHtmlEntities.AddObject('thetasym',pointer(977)); // greek small letter theta symbol,   U+03D1 NEW -->

    155. 

  155.   aLstHtmlEntities.AddObject('theta',pointer(952)); // greek small letter theta,   U+03B8 ISOgrk3 -->

    156. 

  156.   aLstHtmlEntities.AddObject('Theta',pointer(920)); // greek capital letter theta,   U+0398 ISOgrk3 -->

    157. 

  157.   aLstHtmlEntities.AddObject('there4',pointer(8756)); // therefore, U+2234 ISOtech -->

    158. 

  158.   aLstHtmlEntities.AddObject('tau',pointer(964)); // greek small letter tau, U+03C4 ISOgrk3 -->

    159. 

  159.   aLstHtmlEntities.AddObject('Tau',pointer(932)); // greek capital letter tau, U+03A4 -->

    160. 

  160.   aLstHtmlEntities.AddObject('szlig',pointer(223)); // latin small letter sharp s = ess-zed, U+00DF ISOlat1 -->

    161. 

  161.   aLstHtmlEntities.AddObject('supe',pointer(8839)); // superset of or equal to,    U+2287 ISOtech -->

    162. 

  162.   aLstHtmlEntities.AddObject('sup3',pointer(179)); // superscript three = superscript digit three = cubed, U+00B3 ISOnum -->

    163. 

  163.   aLstHtmlEntities.AddObject('sup2',pointer(178)); // superscript two = superscript digit two = squared, U+00B2 ISOnum -->

    164. 

  164.   aLstHtmlEntities.AddObject('sup1',pointer(185)); // superscript one = superscript digit one, U+00B9 ISOnum -->

    165. 

  165.   aLstHtmlEntities.AddObject('sup',pointer(8835)); // superset of, U+2283 ISOtech -->

    166. 

  166.   aLstHtmlEntities.AddObject('sum',pointer(8721)); // n-ary sumation, U+2211 ISOamsb -->

    167. 

  167.   aLstHtmlEntities.AddObject('sube',pointer(8838)); // subset of or equal to, U+2286 ISOtech -->

    168. 

  168.   aLstHtmlEntities.AddObject('sub',pointer(8834)); // subset of, U+2282 ISOtech -->

    169. 

  169.   aLstHtmlEntities.AddObject('spades',pointer(9824)); // black spade suit, U+2660 ISOpub -->

    170. 

  170.   aLstHtmlEntities.AddObject('sim',pointer(8764)); // tilde operator = varies with = similar to,    U+223C ISOtech -->

    171. 

  171.   aLstHtmlEntities.AddObject('sigmaf',pointer(962)); // greek small letter final sigma,   U+03C2 ISOgrk3 -->

    172. 

  172.   aLstHtmlEntities.AddObject('sigma',pointer(963)); // greek small letter sigma,   U+03C3 ISOgrk3 -->

    173. 

  173.   aLstHtmlEntities.AddObject('Sigma',pointer(931)); // greek capital letter sigma,   U+03A3 ISOgrk3 -->

    174. 

  174.   aLstHtmlEntities.AddObject('shy',pointer(173)); // soft hyphen = discretionary hyphen, U+00AD ISOnum -->

    175. 

  175.   aLstHtmlEntities.AddObject('sect',pointer(167)); // section sign, U+00A7 ISOnum -->

    176. 

  176.   aLstHtmlEntities.AddObject('sdot',pointer(8901)); // dot operator, U+22C5 ISOamsb -->

    177. 

  177.   aLstHtmlEntities.AddObject('scaron',pointer(353)); // latin small letter s with caron,   U+0161 ISOlat2 -->

    178. 

  178.   aLstHtmlEntities.AddObject('Scaron',pointer(352)); // latin capital letter S with caron,   U+0160 ISOlat2 -->

    179. 

  179.   aLstHtmlEntities.AddObject('sbquo',pointer(8218)); // single low-9 quotation mark, U+201A NEW -->

    180. 

  180.   aLstHtmlEntities.AddObject('rsquo',pointer(8217)); // right single quotation mark,   U+2019 ISOnum -->

    181. 

  181.   aLstHtmlEntities.AddObject('rsaquo',pointer(8250)); // single right-pointing angle quotation mark,   U+203A ISO proposed -->

    182. 

  182.   aLstHtmlEntities.AddObject('rlm',pointer(8207)); // right-to-left mark, U+200F NEW RFC 2070 -->

    183. 

  183.   aLstHtmlEntities.AddObject('rho',pointer(961)); // greek small letter rho, U+03C1 ISOgrk3 -->

    184. 

  184.   aLstHtmlEntities.AddObject('Rho',pointer(929)); // greek capital letter rho, U+03A1 -->

    185. 

  185.   aLstHtmlEntities.AddObject('rfloor',pointer(8971)); // right floor, U+230B ISOamsc  -->

    186. 

  186.   aLstHtmlEntities.AddObject('reg',pointer(174)); // registered sign = registered trade mark sign, U+00AE ISOnum -->

    187. 

  187.   aLstHtmlEntities.AddObject('real',pointer(8476)); // blackletter capital R = real part symbol,    U+211C ISOamso -->

    188. 

  188.   aLstHtmlEntities.AddObject('rdquo',pointer(8221)); // right double quotation mark,   U+201D ISOnum -->

    189. 

  189.   aLstHtmlEntities.AddObject('rceil',pointer(8969)); // right ceiling, U+2309 ISOamsc  -->

    190. 

  190.   aLstHtmlEntities.AddObject('rArr',pointer(8658)); // rightwards double arrow,    U+21D2 ISOtech -->

    191. 

  191.   aLstHtmlEntities.AddObject('rarr',pointer(8594)); // rightwards arrow, U+2192 ISOnum -->

    192. 

  192.   aLstHtmlEntities.AddObject('raquo',pointer(187)); // right-pointing double angle quotation mark = right pointing guillemet, U+00BB ISOnum -->

    193. 

  193.   aLstHtmlEntities.AddObject('rang',pointer(9002)); // right-pointing angle bracket = ket,    U+232A ISOtech -->

    194. 

  194.   aLstHtmlEntities.AddObject('radic',pointer(8730)); // square root = radical sign,    U+221A ISOtech -->

    195. 

  195.   aLstHtmlEntities.AddObject('quot',pointer(34)); // quotation mark = APL quote,   U+0022 ISOnum -->

    196. 

  196.   aLstHtmlEntities.AddObject('psi',pointer(968)); // greek small letter psi, U+03C8 ISOgrk3 -->

    197. 

  197.   aLstHtmlEntities.AddObject('Psi',pointer(936)); // greek capital letter psi,   U+03A8 ISOgrk3 -->

    198. 

  198.   aLstHtmlEntities.AddObject('prop',pointer(8733)); // proportional to, U+221D ISOtech -->

    199. 

  199.   aLstHtmlEntities.AddObject('prod',pointer(8719)); // n-ary product = product sign,    U+220F ISOamsb -->

    200. 

  200.   aLstHtmlEntities.AddObject('Prime',pointer(8243)); // double prime = seconds = inches,    U+2033 ISOtech -->

    201. 

  201.   aLstHtmlEntities.AddObject('prime',pointer(8242)); // prime = minutes = feet, U+2032 ISOtech -->

    202. 

  202.   aLstHtmlEntities.AddObject('pound',pointer(163)); // pound sign, U+00A3 ISOnum -->

    203. 

  203.   aLstHtmlEntities.AddObject('plusmn',pointer(177)); // plus-minus sign = plus-or-minus sign, U+00B1 ISOnum -->

    204. 

  204.   aLstHtmlEntities.AddObject('piv',pointer(982)); // greek pi symbol, U+03D6 ISOgrk3 -->

    205. 

  205.   aLstHtmlEntities.AddObject('pi',pointer(960)); // greek small letter pi, U+03C0 ISOgrk3 -->

    206. 

  206.   aLstHtmlEntities.AddObject('Pi',pointer(928)); // greek capital letter pi, U+03A0 ISOgrk3 -->

    207. 

  207.   aLstHtmlEntities.AddObject('phi',pointer(966)); // greek small letter phi, U+03C6 ISOgrk3 -->

    208. 

  208.   aLstHtmlEntities.AddObject('Phi',pointer(934)); // greek capital letter phi,   U+03A6 ISOgrk3 -->

    209. 

  209.   aLstHtmlEntities.AddObject('perp',pointer(8869)); // up tack = orthogonal to = perpendicular,    U+22A5 ISOtech -->

    210. 

  210.   aLstHtmlEntities.AddObject('permil',pointer(8240)); // per mille sign, U+2030 ISOtech -->

    211. 

  211.   aLstHtmlEntities.AddObject('part',pointer(8706)); // partial differential, U+2202 ISOtech  -->

    212. 

  212.   aLstHtmlEntities.AddObject('para',pointer(182)); // pilcrow sign = paragraph sign, U+00B6 ISOnum -->

    213. 

  213.   aLstHtmlEntities.AddObject('ouml',pointer(246)); // latin small letter o with diaeresis, U+00F6 ISOlat1 -->

    214. 

  214.   aLstHtmlEntities.AddObject('Ouml',pointer(214)); // latin capital letter O with diaeresis, U+00D6 ISOlat1 -->

    215. 

  215.   aLstHtmlEntities.AddObject('otimes',pointer(8855)); // circled times = vector product,    U+2297 ISOamsb -->

    216. 

  216.   aLstHtmlEntities.AddObject('otilde',pointer(245)); // latin small letter o with tilde, U+00F5 ISOlat1 -->

    217. 

  217.   aLstHtmlEntities.AddObject('Otilde',pointer(213)); // latin capital letter O with tilde, U+00D5 ISOlat1 -->

    218. 

  218.   aLstHtmlEntities.AddObject('oslash',pointer(248)); // latin small letter o with stroke, = latin small letter o slash, U+00F8 ISOlat1 -->

    219. 

  219.   aLstHtmlEntities.AddObject('Oslash',pointer(216)); // latin capital letter O with stroke = latin capital letter O slash, U+00D8 ISOlat1 -->

    220. 

  220.   aLstHtmlEntities.AddObject('ordm',pointer(186)); // masculine ordinal indicator, U+00BA ISOnum -->

    221. 

  221.   aLstHtmlEntities.AddObject('ordf',pointer(170)); // feminine ordinal indicator, U+00AA ISOnum -->

    222. 

  222.   aLstHtmlEntities.AddObject('or',pointer(8744)); // logical or = vee, U+2228 ISOtech -->

    223. 

  223.   aLstHtmlEntities.AddObject('oplus',pointer(8853)); // circled plus = direct sum,    U+2295 ISOamsb -->

    224. 

  224.   aLstHtmlEntities.AddObject('omicron',pointer(959)); // greek small letter omicron, U+03BF NEW -->

    225. 

  225.   aLstHtmlEntities.AddObject('Omicron',pointer(927)); // greek capital letter omicron, U+039F -->

    226. 

  226.   aLstHtmlEntities.AddObject('omega',pointer(969)); // greek small letter omega,   U+03C9 ISOgrk3 -->

    227. 

  227.   aLstHtmlEntities.AddObject('Omega',pointer(937)); // greek capital letter omega,   U+03A9 ISOgrk3 -->

    228. 

  228.   aLstHtmlEntities.AddObject('oline',pointer(8254)); // overline = spacing overscore,    U+203E NEW -->

    229. 

  229.   aLstHtmlEntities.AddObject('ograve',pointer(242)); // latin small letter o with grave, U+00F2 ISOlat1 -->

    230. 

  230.   aLstHtmlEntities.AddObject('Ograve',pointer(210)); // latin capital letter O with grave, U+00D2 ISOlat1 -->

    231. 

  231.   aLstHtmlEntities.AddObject('oelig',pointer(339)); // latin small ligature oe, U+0153 ISOlat2 -->

    232. 

  232.   aLstHtmlEntities.AddObject('OElig',pointer(338)); // latin capital ligature OE,   U+0152 ISOlat2 -->

    233. 

  233.   aLstHtmlEntities.AddObject('ocirc',pointer(244)); // latin small letter o with circumflex, U+00F4 ISOlat1 -->

    234. 

  234.   aLstHtmlEntities.AddObject('Ocirc',pointer(212)); // latin capital letter O with circumflex, U+00D4 ISOlat1 -->

    235. 

  235.   aLstHtmlEntities.AddObject('oacute',pointer(243)); // latin small letter o with acute, U+00F3 ISOlat1 -->

    236. 

  236.   aLstHtmlEntities.AddObject('Oacute',pointer(211)); // latin capital letter O with acute, U+00D3 ISOlat1 -->

    237. 

  237.   aLstHtmlEntities.AddObject('nu',pointer(957)); // greek small letter nu, U+03BD ISOgrk3 -->

    238. 

  238.   aLstHtmlEntities.AddObject('Nu',pointer(925)); // greek capital letter nu, U+039D -->

    239. 

  239.   aLstHtmlEntities.AddObject('ntilde',pointer(241)); // latin small letter n with tilde, U+00F1 ISOlat1 -->

    240. 

  240.   aLstHtmlEntities.AddObject('Ntilde',pointer(209)); // latin capital letter N with tilde, U+00D1 ISOlat1 -->

    241. 

  241.   aLstHtmlEntities.AddObject('nsub',pointer(8836)); // not a subset of, U+2284 ISOamsn -->

    242. 

  242.   aLstHtmlEntities.AddObject('notin',pointer(8713)); // not an element of, U+2209 ISOtech -->

    243. 

  243.   aLstHtmlEntities.AddObject('not',pointer(172)); // not sign, U+00AC ISOnum -->

    244. 

  244.   aLstHtmlEntities.AddObject('ni',pointer(8715)); // contains as member, U+220B ISOtech -->

    245. 

  245.   aLstHtmlEntities.AddObject('ne',pointer(8800)); // not equal to, U+2260 ISOtech -->

    246. 

  246.   aLstHtmlEntities.AddObject('ndash',pointer(8211)); // en dash, U+2013 ISOpub -->

    247. 

  247.   aLstHtmlEntities.AddObject('nbsp',pointer(160)); // no-break space = non-breaking space, U+00A0 ISOnum -->

    248. 

  248.   aLstHtmlEntities.AddObject('nabla',pointer(8711)); // nabla = backward difference,    U+2207 ISOtech -->

    249. 

  249.   aLstHtmlEntities.AddObject('mu',pointer(956)); // greek small letter mu, U+03BC ISOgrk3 -->

    250. 

  250.   aLstHtmlEntities.AddObject('Mu',pointer(924)); // greek capital letter mu, U+039C -->

    251. 

  251.   aLstHtmlEntities.AddObject('minus',pointer(8722)); // minus sign, U+2212 ISOtech -->

    252. 

  252.   aLstHtmlEntities.AddObject('middot',pointer(183)); // middle dot = Georgian comma = Greek middle dot, U+00B7 ISOnum -->

    253. 

  253.   aLstHtmlEntities.AddObject('micro',pointer(181)); // micro sign, U+00B5 ISOnum -->

    254. 

  254.   aLstHtmlEntities.AddObject('mdash',pointer(8212)); // em dash, U+2014 ISOpub -->

    255. 

  255.   aLstHtmlEntities.AddObject('macr',pointer(175)); // macron = spacing macron = overline = APL overbar, U+00AF ISOdia -->

    256. 

  256.   aLstHtmlEntities.AddObject('lt',pointer(60)); // less-than sign, U+003C ISOnum -->

    257. 

  257.   aLstHtmlEntities.AddObject('lsquo',pointer(8216)); // left single quotation mark,   U+2018 ISOnum -->

    258. 

  258.   aLstHtmlEntities.AddObject('lsaquo',pointer(8249)); // single left-pointing angle quotation mark,   U+2039 ISO proposed -->

    259. 

  259.   aLstHtmlEntities.AddObject('lrm',pointer(8206)); // left-to-right mark, U+200E NEW RFC 2070 -->

    260. 

  260.   aLstHtmlEntities.AddObject('loz',pointer(9674)); // lozenge, U+25CA ISOpub -->

    261. 

  261.   aLstHtmlEntities.AddObject('lowast',pointer(8727)); // asterisk operator, U+2217 ISOtech -->

    262. 

  262.   aLstHtmlEntities.AddObject('lfloor',pointer(8970)); // left floor = apl downstile,    U+230A ISOamsc  -->

    263. 

  263.   aLstHtmlEntities.AddObject('le',pointer(8804)); // less-than or equal to, U+2264 ISOtech -->

    264. 

  264.   aLstHtmlEntities.AddObject('ldquo',pointer(8220)); // left double quotation mark,   U+201C ISOnum -->

    265. 

  265.   aLstHtmlEntities.AddObject('lceil',pointer(8968)); // left ceiling = apl upstile,    U+2308 ISOamsc  -->

    266. 

  266.   aLstHtmlEntities.AddObject('lArr',pointer(8656)); // leftwards double arrow, U+21D0 ISOtech -->

    267. 

  267.   aLstHtmlEntities.AddObject('larr',pointer(8592)); // leftwards arrow, U+2190 ISOnum -->

    268. 

  268.   aLstHtmlEntities.AddObject('laquo',pointer(171)); // left-pointing double angle quotation mark = left pointing guillemet, U+00AB ISOnum -->

    269. 

  269.   aLstHtmlEntities.AddObject('lang',pointer(9001)); // left-pointing angle bracket = bra,    U+2329 ISOtech -->

    270. 

  270.   aLstHtmlEntities.AddObject('lambda',pointer(955)); // greek small letter lambda,   U+03BB ISOgrk3 -->

    271. 

  271.   aLstHtmlEntities.AddObject('Lambda',pointer(923)); // greek capital letter lambda,   U+039B ISOgrk3 -->

    272. 

  272.   aLstHtmlEntities.AddObject('kappa',pointer(954)); // greek small letter kappa,   U+03BA ISOgrk3 -->

    273. 

  273.   aLstHtmlEntities.AddObject('Kappa',pointer(922)); // greek capital letter kappa, U+039A -->

    274. 

  274.   aLstHtmlEntities.AddObject('iuml',pointer(239)); // latin small letter i with diaeresis, U+00EF ISOlat1 -->

    275. 

  275.   aLstHtmlEntities.AddObject('Iuml',pointer(207)); // latin capital letter I with diaeresis, U+00CF ISOlat1 -->

    276. 

  276.   aLstHtmlEntities.AddObject('isin',pointer(8712)); // element of, U+2208 ISOtech -->

    277. 

  277.   aLstHtmlEntities.AddObject('iquest',pointer(191)); // inverted question mark = turned question mark, U+00BF ISOnum -->

    278. 

  278.   aLstHtmlEntities.AddObject('iota',pointer(953)); // greek small letter iota, U+03B9 ISOgrk3 -->

    279. 

  279.   aLstHtmlEntities.AddObject('Iota',pointer(921)); // greek capital letter iota, U+0399 -->

    280. 

  280.   aLstHtmlEntities.AddObject('int',pointer(8747)); // integral, U+222B ISOtech -->

    281. 

  281.   aLstHtmlEntities.AddObject('infin',pointer(8734)); // infinity, U+221E ISOtech -->

    282. 

  282.   aLstHtmlEntities.AddObject('image',pointer(8465)); // blackletter capital I = imaginary part,    U+2111 ISOamso -->

    283. 

  283.   aLstHtmlEntities.AddObject('igrave',pointer(236)); // latin small letter i with grave, U+00EC ISOlat1 -->

    284. 

  284.   aLstHtmlEntities.AddObject('Igrave',pointer(204)); // latin capital letter I with grave, U+00CC ISOlat1 -->

    285. 

  285.   aLstHtmlEntities.AddObject('iexcl',pointer(161)); // inverted exclamation mark, U+00A1 ISOnum -->

    286. 

  286.   aLstHtmlEntities.AddObject('icirc',pointer(238)); // latin small letter i with circumflex, U+00EE ISOlat1 -->

    287. 

  287.   aLstHtmlEntities.AddObject('Icirc',pointer(206)); // latin capital letter I with circumflex, U+00CE ISOlat1 -->

    288. 

  288.   aLstHtmlEntities.AddObject('iacute',pointer(237)); // latin small letter i with acute, U+00ED ISOlat1 -->

    289. 

  289.   aLstHtmlEntities.AddObject('Iacute',pointer(205)); // latin capital letter I with acute, U+00CD ISOlat1 -->

    290. 

  290.   aLstHtmlEntities.AddObject('hellip',pointer(8230)); // horizontal ellipsis = three dot leader,    U+2026 ISOpub  -->

    291. 

  291.   aLstHtmlEntities.AddObject('hearts',pointer(9829)); // black heart suit = valentine,    U+2665 ISOpub -->

    292. 

  292.   aLstHtmlEntities.AddObject('hArr',pointer(8660)); // left right double arrow,    U+21D4 ISOamsa -->

    293. 

  293.   aLstHtmlEntities.AddObject('harr',pointer(8596)); // left right arrow, U+2194 ISOamsa -->

    294. 

  294.   aLstHtmlEntities.AddObject('gt',pointer(62)); // greater-than sign, U+003E ISOnum -->

    295. 

  295.   aLstHtmlEntities.AddObject('ge',pointer(8805)); // greater-than or equal to,    U+2265 ISOtech -->

    296. 

  296.   aLstHtmlEntities.AddObject('gamma',pointer(947)); // greek small letter gamma,   U+03B3 ISOgrk3 -->

    297. 

  297.   aLstHtmlEntities.AddObject('Gamma',pointer(915)); // greek capital letter gamma,   U+0393 ISOgrk3 -->

    298. 

  298.   aLstHtmlEntities.AddObject('frasl',pointer(8260)); // fraction slash, U+2044 NEW -->

    299. 

  299.   aLstHtmlEntities.AddObject('frac34',pointer(190)); // vulgar fraction three quarters = fraction three quarters, U+00BE ISOnum -->

    300. 

  300.   aLstHtmlEntities.AddObject('frac14',pointer(188)); // vulgar fraction one quarter = fraction one quarter, U+00BC ISOnum -->

    301. 

  301.   aLstHtmlEntities.AddObject('frac12',pointer(189)); // vulgar fraction one half = fraction one half, U+00BD ISOnum -->

    302. 

  302.   aLstHtmlEntities.AddObject('forall',pointer(8704)); // for all, U+2200 ISOtech -->

    303. 

  303.   aLstHtmlEntities.AddObject('fnof',pointer(402)); // latin small f with hook = function   = florin, U+0192 ISOtech -->

    304. 

  304.   aLstHtmlEntities.AddObject('exist',pointer(8707)); // there exists, U+2203 ISOtech -->

    305. 

  305.   aLstHtmlEntities.AddObject('euro',pointer(8364)); // euro sign, U+20AC NEW -->

    306. 

  306.   aLstHtmlEntities.AddObject('euml',pointer(235)); // latin small letter e with diaeresis, U+00EB ISOlat1 -->

    307. 

  307.   aLstHtmlEntities.AddObject('Euml',pointer(203)); // latin capital letter E with diaeresis, U+00CB ISOlat1 -->

    308. 

  308.   aLstHtmlEntities.AddObject('eth',pointer(240)); // latin small letter eth, U+00F0 ISOlat1 -->

    309. 

  309.   aLstHtmlEntities.AddObject('ETH',pointer(208)); // latin capital letter ETH, U+00D0 ISOlat1 -->

    310. 

  310.   aLstHtmlEntities.AddObject('eta',pointer(951)); // greek small letter eta, U+03B7 ISOgrk3 -->

    311. 

  311.   aLstHtmlEntities.AddObject('Eta',pointer(919)); // greek capital letter eta, U+0397 -->

    312. 

  312.   aLstHtmlEntities.AddObject('equiv',pointer(8801)); // identical to, U+2261 ISOtech -->

    313. 

  313.   aLstHtmlEntities.AddObject('epsilon',pointer(949)); // greek small letter epsilon,   U+03B5 ISOgrk3 -->

    314. 

  314.   aLstHtmlEntities.AddObject('Epsilon',pointer(917)); // greek capital letter epsilon, U+0395 -->

    315. 

  315.   aLstHtmlEntities.AddObject('ensp',pointer(8194)); // en space, U+2002 ISOpub -->

    316. 

  316.   aLstHtmlEntities.AddObject('emsp',pointer(8195)); // em space, U+2003 ISOpub -->

    317. 

  317.   aLstHtmlEntities.AddObject('empty',pointer(8709)); // empty set = null set = diameter,    U+2205 ISOamso -->

    318. 

  318.   aLstHtmlEntities.AddObject('egrave',pointer(232)); // latin small letter e with grave, U+00E8 ISOlat1 -->

    319. 

  319.   aLstHtmlEntities.AddObject('Egrave',pointer(200)); // latin capital letter E with grave, U+00C8 ISOlat1 -->

    320. 

  320.   aLstHtmlEntities.AddObject('ecirc',pointer(234)); // latin small letter e with circumflex, U+00EA ISOlat1 -->

    321. 

  321.   aLstHtmlEntities.AddObject('Ecirc',pointer(202)); // latin capital letter E with circumflex, U+00CA ISOlat1 -->

    322. 

  322.   aLstHtmlEntities.AddObject('eacute',pointer(233)); // latin small letter e with acute, U+00E9 ISOlat1 -->

    323. 

  323.   aLstHtmlEntities.AddObject('Eacute',pointer(201)); // latin capital letter E with acute, U+00C9 ISOlat1 -->

    324. 

  324.   aLstHtmlEntities.AddObject('divide',pointer(247)); // division sign, U+00F7 ISOnum -->

    325. 

  325.   aLstHtmlEntities.AddObject('diams',pointer(9830)); // black diamond suit, U+2666 ISOpub -->

    326. 

  326.   aLstHtmlEntities.AddObject('delta',pointer(948)); // greek small letter delta,   U+03B4 ISOgrk3 -->

    327. 

  327.   aLstHtmlEntities.AddObject('Delta',pointer(916)); // greek capital letter delta,   U+0394 ISOgrk3 -->

    328. 

  328.   aLstHtmlEntities.AddObject('deg',pointer(176)); // degree sign, U+00B0 ISOnum -->

    329. 

  329.   aLstHtmlEntities.AddObject('dArr',pointer(8659)); // downwards double arrow, U+21D3 ISOamsa -->

    330. 

  330.   aLstHtmlEntities.AddObject('darr',pointer(8595)); // downwards arrow, U+2193 ISOnum -->

    331. 

  331.   aLstHtmlEntities.AddObject('Dagger',pointer(8225)); // double dagger, U+2021 ISOpub -->

    332. 

  332.   aLstHtmlEntities.AddObject('dagger',pointer(8224)); // dagger, U+2020 ISOpub -->

    333. 

  333.   aLstHtmlEntities.AddObject('curren',pointer(164)); // currency sign, U+00A4 ISOnum -->

    334. 

  334.   aLstHtmlEntities.AddObject('cup',pointer(8746)); // union = cup, U+222A ISOtech -->

    335. 

  335.   aLstHtmlEntities.AddObject('crarr',pointer(8629)); // downwards arrow with corner leftwards    = carriage return, U+21B5 NEW -->

    336. 

  336.   aLstHtmlEntities.AddObject('copy',pointer(169)); // copyright sign, U+00A9 ISOnum -->

    337. 

  337.   aLstHtmlEntities.AddObject('cong',pointer(8773)); // approximately equal to, U+2245 ISOtech -->

    338. 

  338.   aLstHtmlEntities.AddObject('clubs',pointer(9827)); // black club suit = shamrock,    U+2663 ISOpub -->

    339. 

  339.   aLstHtmlEntities.AddObject('circ',pointer(710)); // modifier letter circumflex accent,   U+02C6 ISOpub -->

    340. 

  340.   aLstHtmlEntities.AddObject('chi',pointer(967)); // greek small letter chi, U+03C7 ISOgrk3 -->

    341. 

  341.   aLstHtmlEntities.AddObject('Chi',pointer(935)); // greek capital letter chi, U+03A7 -->

    342. 

  342.   aLstHtmlEntities.AddObject('cent',pointer(162)); // cent sign, U+00A2 ISOnum -->

    343. 

  343.   aLstHtmlEntities.AddObject('cedil',pointer(184)); // cedilla = spacing cedilla, U+00B8 ISOdia -->

    344. 

  344.   aLstHtmlEntities.AddObject('ccedil',pointer(231)); // latin small letter c with cedilla, U+00E7 ISOlat1 -->

    345. 

  345.   aLstHtmlEntities.AddObject('Ccedil',pointer(199)); // latin capital letter C with cedilla, U+00C7 ISOlat1 -->

    346. 

  346.   aLstHtmlEntities.AddObject('cap',pointer(8745)); // intersection = cap, U+2229 ISOtech -->

    347. 

  347.   aLstHtmlEntities.AddObject('bull',pointer(8226)); // bullet = black small circle,    U+2022 ISOpub  -->

    348. 

  348.   aLstHtmlEntities.AddObject('brvbar',pointer(166)); // broken bar = broken vertical bar, U+00A6 ISOnum -->

    349. 

  349.   aLstHtmlEntities.AddObject('beta',pointer(946)); // greek small letter beta, U+03B2 ISOgrk3 -->

    350. 

  350.   aLstHtmlEntities.AddObject('Beta',pointer(914)); // greek capital letter beta, U+0392 -->

    351. 

  351.   aLstHtmlEntities.AddObject('bdquo',pointer(8222)); // double low-9 quotation mark, U+201E NEW -->

    352. 

  352.   aLstHtmlEntities.AddObject('auml',pointer(228)); // latin small letter a with diaeresis, U+00E4 ISOlat1 -->

    353. 

  353.   aLstHtmlEntities.AddObject('Auml',pointer(196)); // latin capital letter A with diaeresis, U+00C4 ISOlat1 -->

    354. 

  354.   aLstHtmlEntities.AddObject('atilde',pointer(227)); // latin small letter a with tilde, U+00E3 ISOlat1 -->

    355. 

  355.   aLstHtmlEntities.AddObject('Atilde',pointer(195)); // latin capital letter A with tilde, U+00C3 ISOlat1 -->

    356. 

  356.   aLstHtmlEntities.AddObject('asymp',pointer(8776)); // almost equal to = asymptotic to,    U+2248 ISOamsr -->

    357. 

  357.   aLstHtmlEntities.AddObject('aring',pointer(229)); // latin small letter a with ring above = latin small letter a ring, U+00E5 ISOlat1 -->

    358. 

  358.   aLstHtmlEntities.AddObject('Aring',pointer(197)); // latin capital letter A with ring above = latin capital letter A ring, U+00C5 ISOlat1 -->

    359. 

  359.   aLstHtmlEntities.AddObject('ang',pointer(8736)); // angle, U+2220 ISOamso -->

    360. 

  360.   aLstHtmlEntities.AddObject('and',pointer(8743)); // logical and = wedge, U+2227 ISOtech -->

    361. 

  361.   aLstHtmlEntities.AddObject('amp',pointer(38)); // ampersand, U+0026 ISOnum -->

    362. 

  362.   aLstHtmlEntities.AddObject('alpha',pointer(945)); // greek small letter alpha,   U+03B1 ISOgrk3 -->

    363. 

  363.   aLstHtmlEntities.AddObject('Alpha',pointer(913)); // greek capital letter alpha, U+0391 -->

    364. 

  364.   aLstHtmlEntities.AddObject('alefsym',pointer(8501)); // alef symbol = first transfinite cardinal,    U+2135 NEW -->

    365. 

  365.   aLstHtmlEntities.AddObject('agrave',pointer(224)); // latin small letter a with grave = latin small letter a grave, U+00E0 ISOlat1 -->

    366. 

  366.   aLstHtmlEntities.AddObject('Agrave',pointer(192)); // latin capital letter A with grave = latin capital letter A grave, U+00C0 ISOlat1 -->

    367. 

  367.   aLstHtmlEntities.AddObject('aelig',pointer(230)); // latin small letter ae = latin small ligature ae, U+00E6 ISOlat1 -->

    368. 

  368.   aLstHtmlEntities.AddObject('AElig',pointer(198)); // latin capital letter AE = latin capital ligature AE, U+00C6 ISOlat1 -->

    369. 

  369.   aLstHtmlEntities.AddObject('acute',pointer(180)); // acute accent = spacing acute, U+00B4 ISOdia -->

    370. 

  370.   aLstHtmlEntities.AddObject('acirc',pointer(226)); // latin small letter a with circumflex, U+00E2 ISOlat1 -->

    371. 

  371.   aLstHtmlEntities.AddObject('Acirc',pointer(194)); // latin capital letter A with circumflex, U+00C2 ISOlat1 -->

    372. 

  372.   aLstHtmlEntities.AddObject('aacute',pointer(225)); // latin small letter a with acute, U+00E1 ISOlat1 -->

    373. 

  373.   aLstHtmlEntities.AddObject('Aacute',pointer(193)); // latin capital letter A with acute, U+00C1 ISOlat1 -->

    374. 

  374. 

    375. 

  375. end;

    376. 

  376. 

    377. 

  377. {*******************************************************************}

    378. 

  378. function  ALXMLCDataElementEncode(const Src: AnsiString): AnsiString;

    379. 

  379. Begin

    380. 

  380.   //  The preferred approach to using CDATA sections for encoding text that contains the triad "]]>" is to use multiple CDATA sections by splitting each

    381. 

  381.   //  occurrence of the triad just before the ">". For example, to encode "]]>" one would write:

    382. 

  382.   //  <![CDATA[]]]]><![CDATA[>]]>

    383. 

  383.   //  This means that to encode "]]>" in the middle of a CDATA section, replace all occurrences of "]]>" with the following:

    384. 

  384.   //  ]]]]><![CDATA[>

    385. 

  385.   Result := alStringReplace(Src,']]>',']]]]><![CDATA[>',[rfReplaceAll]);

    386. 

  386. End;

    387. 

  387. 

    388. 

  388. {*************************************************}

    389. 

  389. {we use useNumericReference by default because it's

    390. 

  390.  compatible with XHTML, especially because of the &apos; entity}

    391. 

  391. function ALXMLTextElementEncode(const Src: AnsiString; const useNumericReference: boolean = True): AnsiString;

    392. 

  392. var i, l: integer;

    393. 

  393.     Buf, P: PAnsiChar;

    394. 

  394.     ch: Integer;

    395. 

  395. begin

    396. 

  396.   Result := '';

    397. 

  397.   L := Length(src);

    398. 

  398.   if L = 0 then exit;

    399. 

  399.   GetMem(Buf, L * 6); // to be on the *very* safe side

    400. 

  400.   try

    401. 

  401.     P := Buf;

    402. 

  402.     for i := 1 to L do begin

    403. 

  403.       ch := Ord(src[i]);

    404. 

  404.       case ch of

    405. 

  405.         34: begin // quot "

    406. 

  406.               if useNumericReference then begin

    407. 

  407.                 ALStrMove('&#34;', P, 5);

    408. 

  408.                 Inc(P, 5);

    409. 

  409.               end

    410. 

  410.               else begin

    411. 

  411.                 ALStrMove('&quot;', P, 6);

    412. 

  412.                 Inc(P, 6);

    413. 

  413.               end;

    414. 

  414.             end;

    415. 

  415.         38: begin // amp  &

    416. 

  416.               if useNumericReference then begin

    417. 

  417.                 ALStrMove('&#38;', P, 5);

    418. 

  418.                 Inc(P, 5);

    419. 

  419.               end

    420. 

  420.               else begin

    421. 

  421.                 ALStrMove('&amp;', P, 5);

    422. 

  422.                 Inc(P, 5);

    423. 

  423.               end;

    424. 

  424.             end;

    425. 

  425.         39: begin // apos  '

    426. 

  426.               if useNumericReference then begin

    427. 

  427.                 ALStrMove('&#39;', P, 5);

    428. 

  428.                 Inc(P, 5);

    429. 

  429.               end

    430. 

  430.               else begin

    431. 

  431.                 ALStrMove('&apos;', P, 6);  // !! warning this entity not work in HTML nor in XHTML under IE !!

    432. 

  432.                 Inc(P, 6);

    433. 

  433.               end;

    434. 

  434.             end;

    435. 

  435.         60: begin // lt   <

    436. 

  436.               if useNumericReference then begin

    437. 

  437.                 ALStrMove('&#60;', P, 5);

    438. 

  438.                 Inc(P, 5);

    439. 

  439.               end

    440. 

  440.               else begin

    441. 

  441.                 ALStrMove('&lt;', P, 4);

    442. 

  442.                 Inc(P, 4);

    443. 

  443.               end;

    444. 

  444.             end;

    445. 

  445.         62: begin // gt   >

    446. 

  446.               if useNumericReference then begin

    447. 

  447.                 ALStrMove('&#62;', P, 5);

    448. 

  448.                 Inc(P, 5);

    449. 

  449.               end

    450. 

  450.               else begin

    451. 

  451.                 ALStrMove('&gt;', P, 4);

    452. 

  452.                 Inc(P, 4);

    453. 

  453.               end;

    454. 

  454.             end;

    455. 

  455.         else Begin

    456. 

  456.           P^:= AnsiChar(ch);

    457. 

  457.           Inc(P);

    458. 

  458.         end;

    459. 

  459.       end;

    460. 

  460.     end;

    461. 

  461.     SetString(Result, Buf, P - Buf);

    462. 

  462.   finally

    463. 

  463.     FreeMem(Buf);

    464. 

  464.   end;

    465. 

  465. end;

    466. 

  466. 

    467. 

  467. {*********************************************************************}

    468. 

  468. function ALUTF8XMLTextElementDecode(const Src: AnsiString): AnsiString;

    469. 

  469. var CurrentSrcPos, CurrentResultPos : Integer;

    470. 

  470.     j: integer;

    471. 

  471.     aTmpInteger: Integer;

    472. 

  472.     SrcLength: integer;

    473. 

  473.     aEntity: AnsiString;

    474. 

  474. 

    475. 

  475.     {---------------------------------------}

    476. 

  476.     procedure _CopyCurrentSrcPosCharToResult;

    477. 

  477.     Begin

    478. 

  478.       result[CurrentResultPos] := src[CurrentSrcPos];

    479. 

  479.       inc(CurrentResultPos);

    480. 

  480.       inc(CurrentSrcPos);

    481. 

  481.     end;

    482. 

  482. 

    483. 

  483.     {----------------------------------------------------------------------------------}

    484. 

  484.     procedure _CopyCharToResult(aUnicodeOrdEntity: Integer; aNewCurrentSrcPos: integer);

    485. 

  485.     Var aUTF8String: AnsiString;

    486. 

  486.         K: integer;

    487. 

  487.     Begin

    488. 

  488.       aUTF8String := UTF8Encode(WideChar(aUnicodeOrdEntity));

    489. 

  489.       For k := 1 to length(aUTF8String) do begin

    490. 

  490.         result[CurrentResultPos] := aUTF8String[k];

    491. 

  491.         inc(CurrentResultPos);

    492. 

  492.       end;

    493. 

  493.       CurrentSrcPos := aNewCurrentSrcPos;

    494. 

  494.     end;

    495. 

  495. 

    496. 

  496. begin

    497. 

  497.   {init var}

    498. 

  498.   CurrentSrcPos := 1;

    499. 

  499.   CurrentResultPos := 1;

    500. 

  500.   SrcLength := Length(src);

    501. 

  501.   SetLength(Result,SrcLength);

    502. 

  502. 

    503. 

  503.   {start loop}

    504. 

  504.   while (CurrentSrcPos <= SrcLength) do begin

    505. 

  505. 

    506. 

  506.     {HTMLentity detected}

    507. 

  507.     If src[CurrentSrcPos]='&' then begin

    508. 

  508. 

    509. 

  509.       {extract the HTML entity}

    510. 

  510.       j := CurrentSrcPos;

    511. 

  511.       while (J <= SrcLength) and (src[j] <> ';') and (j-CurrentSrcPos<=12) do inc(j);

    512. 

  512. 

    513. 

  513.       {HTML entity is valid}

    514. 

  514.       If (J<=SrcLength) and (j-CurrentSrcPos<=12) then Begin

    515. 

  515. 

    516. 

  516.         {HTML entity is numeric}

    517. 

  517.         IF (Src[CurrentSrcPos+1] = '#') then begin

    518. 

  518. 

    519. 

  519.           {HTML entity is hexa}

    520. 

  520.           IF (Src[CurrentSrcPos+2] = 'x') then begin

    521. 

  521.             if ALTryStrToInt('$' + ALCopyStr(Src,

    522. 

  522.                                              CurrentSrcPos+3,

    523. 

  523.                                              j-CurrentSrcPos-3),

    524. 

  524.                              aTmpInteger)

    525. 

  525.             then _CopyCharToResult(aTmpInteger, J+1)

    526. 

  526.             else _CopyCurrentSrcPosCharToResult;

    527. 

  527.           end

    528. 

  528. 

    529. 

  529.           {HTML entity is numeric}

    530. 

  530.           else begin

    531. 

  531. 

    532. 

  532.             {numeric HTML entity is valid}

    533. 

  533.             if ALTryStrToInt(ALCopyStr(Src,

    534. 

  534.                                        CurrentSrcPos+2,

    535. 

  535.                                        j-CurrentSrcPos-2),

    536. 

  536.                              aTmpInteger)

    537. 

  537.             then _CopyCharToResult(aTmpInteger, J+1)

    538. 

  538.             else _CopyCurrentSrcPosCharToResult;

    539. 

  539. 

    540. 

  540.           end;

    541. 

  541. 

    542. 

  542.         end

    543. 

  543. 

    544. 

  544.         {HTML entity is litteral}

    545. 

  545.         else begin

    546. 

  546. 

    547. 

  547.           //amp

    548. 

  548.           aEntity := ALCopyStr(Src,

    549. 

  549.                                CurrentSrcPos+1,

    550. 

  550.                                j-CurrentSrcPos-1);

    551. 

  551. 

    552. 

  552.           If aEntity ='quot' then _CopyCharToResult(34, J+1) // "

    553. 

  553.           else if aEntity = 'apos' then _CopyCharToResult(39, J+1) // '

    554. 

  554.           else if aEntity = 'amp' then _CopyCharToResult(38, J+1) // &

    555. 

  555.           else if aEntity = 'lt' then _CopyCharToResult(60, J+1) // <

    556. 

  556.           else if aEntity = 'gt' then _CopyCharToResult(62, J+1) // >

    557. 

  557.           else _CopyCurrentSrcPosCharToResult;

    558. 

  558. 

    559. 

  559.         end;

    560. 

  560. 

    561. 

  561.       end

    562. 

  562.       else _CopyCurrentSrcPosCharToResult;

    563. 

  563. 

    564. 

  564.     end

    565. 

  565.     else _CopyCurrentSrcPosCharToResult;

    566. 

  566. 

    567. 

  567.   end;

    568. 

  568. 

    569. 

  569.   setLength(Result,CurrentResultPos-1);

    570. 

  570. end;

    571. 

  571. 

    572. 

  572. {**********************************************}

    573. 

  573. function ALUTF8HTMLEncode(const Src: AnsiString;

    574. 

  574.                           const EncodeASCIIHtmlEntities: Boolean = True;

    575. 

  575.                           const useNumericReference: boolean = True): AnsiString;

    576. 

  576. 

    577. 

  577. var i, k, l: integer;

    578. 

  578.     Buf, P: PAnsiChar;

    579. 

  579.     aEntityStr: AnsiString;

    580. 

  580.     aEntityInt: Integer;

    581. 

  581.     aIndex: integer;

    582. 

  582.     aTmpWideString: WideString;

    583. 

  583.     LstUnicodeEntitiesNumber: TALIntegerList;

    584. 

  584. 

    585. 

  585. begin

    586. 

  586.   Result := '';

    587. 

  587.   If Src='' then Exit;

    588. 

  588. 

    589. 

  589.   LstUnicodeEntitiesNumber := TALIntegerList.create;

    590. 

  590.   Try

    591. 

  591.     if not useNumericReference then begin

    592. 

  592.       LstUnicodeEntitiesNumber.Duplicates := DupIgnore;

    593. 

  593.       LstUnicodeEntitiesNumber.Sorted := True;

    594. 

  594.       For i := 0 to vALhtml_LstEntities.Count - 1 do

    595. 

  595.         LstUnicodeEntitiesNumber.AddObject(integer(vALhtml_LstEntities.Objects[i]),pointer(i));

    596. 

  596.     end;

    597. 

  597. 

    598. 

  598.     {$IFDEF UNICODE}

    599. 

  599.     aTmpWideString := UTF8ToWideString(Src);

    600. 

  600.     {$ELSE}

    601. 

  601.     aTmpWideString := UTF8Decode(Src);

    602. 

  602.     {$ENDIF}

    603. 

  603.     L := length(aTmpWideString);

    604. 

  604.     If L=0 then Exit;

    605. 

  605. 

    606. 

  606.     GetMem(Buf, length(Src) * 12); // to be on the *very* safe side

    607. 

  607.     try

    608. 

  608.       P := Buf;

    609. 

  609.       For i := 1 to L do begin

    610. 

  610.         aEntityInt := Integer(aTmpWideString[i]);

    611. 

  611.         Case aEntityInt of

    612. 

  612.           34: begin // quot "

    613. 

  613.                 If EncodeASCIIHtmlEntities then begin

    614. 

  614.                   if useNumericReference then begin

    615. 

  615.                     ALStrMove('&#34;', P, 5);

    616. 

  616.                     Inc(P, 5);

    617. 

  617.                   end

    618. 

  618.                   else begin

    619. 

  619.                     ALStrMove('&quot;', P, 6);

    620. 

  620.                     Inc(P, 6);

    621. 

  621.                   end;

    622. 

  622.                 end

    623. 

  623.                 else Begin

    624. 

  624.                   P^ := '"';

    625. 

  625.                   Inc(P, 1);

    626. 

  626.                 end;

    627. 

  627.               end;

    628. 

  628.           38: begin // amp  &

    629. 

  629.                 If EncodeASCIIHtmlEntities then begin

    630. 

  630.                   if useNumericReference then begin

    631. 

  631.                     ALStrMove('&#38;', P, 5);

    632. 

  632.                     Inc(P, 5);

    633. 

  633.                   end

    634. 

  634.                   else begin

    635. 

  635.                     ALStrMove('&amp;', P, 5);

    636. 

  636.                     Inc(P, 5);

    637. 

  637.                   end;

    638. 

  638.                 end

    639. 

  639.                 else Begin

    640. 

  640.                   P^ := '&';

    641. 

  641.                   Inc(P, 1);

    642. 

  642.                 end;

    643. 

  643.               end;

    644. 

  644.           39: begin //  '

    645. 

  645.                 If EncodeASCIIHtmlEntities then begin

    646. 

  646.                   ALStrMove('&#39;', P, 5);

    647. 

  647.                   Inc(P, 5);

    648. 

  648.                 end

    649. 

  649.                 else Begin

    650. 

  650.                   P^ := '''';

    651. 

  651.                   Inc(P, 1);

    652. 

  652.                 end;

    653. 

  653.               end;

    654. 

  654.           60: begin // lt   <

    655. 

  655.                 If EncodeASCIIHtmlEntities then begin

    656. 

  656.                   if useNumericReference then begin

    657. 

  657.                     ALStrMove('&#60;', P, 5);

    658. 

  658.                     Inc(P, 5);

    659. 

  659.                   end

    660. 

  660.                   else begin

    661. 

  661.                     ALStrMove('&lt;', P, 4);

    662. 

  662.                     Inc(P, 4);

    663. 

  663.                   end;

    664. 

  664.                 end

    665. 

  665.                 else Begin

    666. 

  666.                   P^ := '<';

    667. 

  667.                   Inc(P, 1);

    668. 

  668.                 end;

    669. 

  669.               end;

    670. 

  670.           62: begin // gt   >

    671. 

  671.                 If EncodeASCIIHtmlEntities then begin

    672. 

  672.                   if useNumericReference then begin

    673. 

  673.                     ALStrMove('&#62;', P, 5);

    674. 

  674.                     Inc(P, 5);

    675. 

  675.                   end

    676. 

  676.                   else begin

    677. 

  677.                     ALStrMove('&gt;', P, 4);

    678. 

  678.                     Inc(P, 4);

    679. 

  679.                   end;

    680. 

  680.                 end

    681. 

  681.                 else Begin

    682. 

  682.                   P^ := '>';

    683. 

  683.                   Inc(P, 1);

    684. 

  684.                 end;

    685. 

  685.               end;

    686. 

  686.           else begin

    687. 

  687.             if (aEntityInt > 127) then begin

    688. 

  688.               if useNumericReference then aEntityStr := '&#'+ALIntToStr(aEntityInt)+';'

    689. 

  689.               else begin

    690. 

  690.                 aIndex := LstUnicodeEntitiesNumber.IndexOf(aEntityInt);

    691. 

  691.                 If aIndex >= 0 Then begin

    692. 

  692.                   aEntityStr := vALhtml_LstEntities[integer(LstUnicodeEntitiesNumber.Objects[aIndex])];

    693. 

  693.                   If aEntityStr <> '' then aEntityStr := '&' + aEntityStr + ';'

    694. 

  694.                   else aEntityStr := '&#'+ALIntToStr(aEntityInt)+';'

    695. 

  695.                 end

    696. 

  696.                 else aEntityStr := '&#'+ALIntToStr(aEntityInt)+';'

    697. 

  697.               end;

    698. 

  698.             end

    699. 

  699.             else aEntityStr := ansistring(aTmpWideString[i]);

    700. 

  700. 

    701. 

  701.             for k := 1 to Length(aEntityStr) do begin

    702. 

  702.               P^ := aEntityStr[k];

    703. 

  703.               Inc(P)

    704. 

  704.             end;

    705. 

  705.           end;

    706. 

  706.         end;

    707. 

  707.       end;

    708. 

  708. 

    709. 

  709.       SetString(Result, Buf, P - Buf);

    710. 

  710. 

    711. 

  711.     finally

    712. 

  712.       FreeMem(Buf);

    713. 

  713.     end;

    714. 

  714. 

    715. 

  715.   finally

    716. 

  716.     LstUnicodeEntitiesNumber.free;

    717. 

  717.   end;

    718. 

  718. 

    719. 

  719. end;

    720. 

  720. 

    721. 

  721. {***********************************************************}

    722. 

  722. function ALUTF8HTMLDecode(const Src: AnsiString): AnsiString;

    723. 

  723. 

    724. 

  724. var CurrentSrcPos, CurrentResultPos : Integer;

    725. 

  725. 

    726. 

  726.   {---------------------------------------}

    727. 

  727.   procedure _CopyCurrentSrcPosCharToResult;

    728. 

  728.   Begin

    729. 

  729.     result[CurrentResultPos] := src[CurrentSrcPos];

    730. 

  730.     inc(CurrentResultPos);

    731. 

  731.     inc(CurrentSrcPos);

    732. 

  732.   end;

    733. 

  733. 

    734. 

  734.   {----------------------------------------------------------------------------------}

    735. 

  735.   procedure _CopyCharToResult(aUnicodeOrdEntity: Integer; aNewCurrentSrcPos: integer);

    736. 

  736.   Var aUTF8String: AnsiString;

    737. 

  737.       K: integer;

    738. 

  738.   Begin

    739. 

  739.     aUTF8String := UTF8Encode(WideChar(aUnicodeOrdEntity));

    740. 

  740.     For k := 1 to length(aUTF8String) do begin

    741. 

  741.       result[CurrentResultPos] := aUTF8String[k];

    742. 

  742.       inc(CurrentResultPos);

    743. 

  743.     end;

    744. 

  744.     CurrentSrcPos := aNewCurrentSrcPos;

    745. 

  745.   end;

    746. 

  746. 

    747. 

  747. var j: integer;

    748. 

  748.     aTmpInteger: Integer;

    749. 

  749.     SrcLength: integer;

    750. 

  750. 

    751. 

  751. begin

    752. 

  752.   {init var}

    753. 

  753.   CurrentSrcPos := 1;

    754. 

  754.   CurrentResultPos := 1;

    755. 

  755.   SrcLength := Length(src);

    756. 

  756.   SetLength(Result,SrcLength);

    757. 

  757. 

    758. 

  758.   {start loop}

    759. 

  759.   while (CurrentSrcPos <= SrcLength) do begin

    760. 

  760. 

    761. 

  761.     {HTMLentity detected}

    762. 

  762.     If src[CurrentSrcPos]='&' then begin

    763. 

  763. 

    764. 

  764.       {extract the HTML entity}

    765. 

  765.       j := CurrentSrcPos;

    766. 

  766.       while (J <= SrcLength) and (src[j] <> ';') and (j-CurrentSrcPos<=12) do inc(j);

    767. 

  767. 

    768. 

  768.       {HTML entity is valid}

    769. 

  769.       If (J<=SrcLength) and (j-CurrentSrcPos<=12) then Begin

    770. 

  770. 

    771. 

  771.         {HTML entity is numeric}

    772. 

  772.         IF (Src[CurrentSrcPos+1] = '#') then begin

    773. 

  773. 

    774. 

  774.           {HTML entity is hexa}

    775. 

  775.           IF (Src[CurrentSrcPos+2] = 'x') then begin

    776. 

  776.             if ALTryStrToInt('$' + ALCopyStr(Src,

    777. 

  777.                                              CurrentSrcPos+3,

    778. 

  778.                                              j-CurrentSrcPos-3),

    779. 

  779.                              aTmpInteger)

    780. 

  780.             then _CopyCharToResult(aTmpInteger, J+1)

    781. 

  781.             else _CopyCurrentSrcPosCharToResult;

    782. 

  782.           end

    783. 

  783. 

    784. 

  784.           {HTML entity is numeric}

    785. 

  785.           else begin

    786. 

  786. 

    787. 

  787.             {numeric HTML entity is valid}

    788. 

  788.             if ALTryStrToInt(ALCopyStr(Src,

    789. 

  789.                                        CurrentSrcPos+2,

    790. 

  790.                                        j-CurrentSrcPos-2),

    791. 

  791.                              aTmpInteger)

    792. 

  792.             then _CopyCharToResult(aTmpInteger, J+1)

    793. 

  793.             else _CopyCurrentSrcPosCharToResult;

    794. 

  794. 

    795. 

  795.           end;

    796. 

  796. 

    797. 

  797.         end

    798. 

  798. 

    799. 

  799.         {HTML entity is litteral}

    800. 

  800.         else begin

    801. 

  801. 

    802. 

  802.           aTmpInteger := vALhtml_LstEntities.IndexOf(ALCopyStr(Src,

    803. 

  803.                                                                CurrentSrcPos+1,

    804. 

  804.                                                                j-CurrentSrcPos-1));

    805. 

  805.           If aTmpInteger >= 0 then _CopyCharToResult(integer(vALhtml_LstEntities.Objects[aTmpInteger]),J+1)

    806. 

  806.           else _CopyCurrentSrcPosCharToResult;

    807. 

  807. 

    808. 

  808.         end;

    809. 

  809. 

    810. 

  810.       end

    811. 

  811.       else _CopyCurrentSrcPosCharToResult;

    812. 

  812. 

    813. 

  813.     end

    814. 

  814.     else _CopyCurrentSrcPosCharToResult;

    815. 

  815. 

    816. 

  816.   end;

    817. 

  817. 

    818. 

  818.   setLength(Result,CurrentResultPos-1);

    819. 

  819. end;

    820. 

  820. 

    821. 

  821. {******************************************************************************************}

    822. 

  822. // https://developer.mozilla.org/en-US/docs/JavaScript/Guide/Values,_variables,_and_literals

    823. 

  823. function  ALJavascriptEncode(const Src: AnsiString; const useNumericReference: boolean = True): AnsiString;

    824. 

  824. var i, l: integer;

    825. 

  825.     Buf, P: PAnsiChar;

    826. 

  826.     ch: Integer;

    827. 

  827. begin

    828. 

  828.   Result := '';

    829. 

  829.   L := Length(src);

    830. 

  830.   if L = 0 then exit;

    831. 

  831.   if useNumericReference then GetMem(Buf, L * 6) // to be on the *very* safe side

    832. 

  832.   else GetMem(Buf, L * 2); // to be on the *very* safe side

    833. 

  833.   try

    834. 

  834.     P := Buf;

    835. 

  835.     for i := 1 to L do begin

    836. 

  836.       ch := Ord(src[i]);

    837. 

  837.       case ch of

    838. 

  838.         8: begin // Backspace

    839. 

  839.              if useNumericReference then begin

    840. 

  840.                ALStrMove('\u0008', P, 6);

    841. 

  841.                Inc(P, 6);

    842. 

  842.              end

    843. 

  843.              else begin

    844. 

  844.                ALStrMove('\b', P, 2);

    845. 

  845.                Inc(P, 2);

    846. 

  846.              end;

    847. 

  847.            end;

    848. 

  848.         9: begin // Tab

    849. 

  849.              if useNumericReference then begin

    850. 

  850.                ALStrMove('\u0009', P, 6);

    851. 

  851.                Inc(P, 6);

    852. 

  852.              end

    853. 

  853.              else begin

    854. 

  854.                ALStrMove('\t', P, 2);

    855. 

  855.                Inc(P, 2);

    856. 

  856.              end;

    857. 

  857.            end;

    858. 

  858.         10: begin // New line

    859. 

  859.               if useNumericReference then begin

    860. 

  860.                 ALStrMove('\u000A', P, 6);

    861. 

  861.                 Inc(P, 6);

    862. 

  862.               end

    863. 

  863.               else begin

    864. 

  864.                 ALStrMove('\n', P, 2);

    865. 

  865.                 Inc(P, 2);

    866. 

  866.               end;

    867. 

  867.             end;

    868. 

  868.         11: begin // Vertical tab

    869. 

  869.               if useNumericReference then begin

    870. 

  870.                 ALStrMove('\u000B', P, 6);

    871. 

  871.                 Inc(P, 6);

    872. 

  872.               end

    873. 

  873.               else begin

    874. 

  874.                 ALStrMove('\v', P, 2);

    875. 

  875.                 Inc(P, 2);

    876. 

  876.               end;

    877. 

  877.             end;

    878. 

  878.         12: begin // Form feed

    879. 

  879.               if useNumericReference then begin

    880. 

  880.                 ALStrMove('\u000C', P, 6);

    881. 

  881.                 Inc(P, 6);

    882. 

  882.               end

    883. 

  883.               else begin

    884. 

  884.                 ALStrMove('\f', P, 2);

    885. 

  885.                 Inc(P, 2);

    886. 

  886.               end;

    887. 

  887.             end;

    888. 

  888.         13: begin // Carriage return

    889. 

  889.               if useNumericReference then begin

    890. 

  890.                 ALStrMove('\u000D', P, 6);

    891. 

  891.                 Inc(P, 6);

    892. 

  892.               end

    893. 

  893.               else begin

    894. 

  894.                 ALStrMove('\r', P, 2);

    895. 

  895.                 Inc(P, 2);

    896. 

  896.               end;

    897. 

  897.             end;

    898. 

  898.         34: begin // Double quote

    899. 

  899.               if useNumericReference then begin

    900. 

  900.                 ALStrMove('\u0022', P, 6);

    901. 

  901.                 Inc(P, 6);

    902. 

  902.               end

    903. 

  903.               else begin

    904. 

  904.                 ALStrMove('\"', P, 2);

    905. 

  905.                 Inc(P, 2);

    906. 

  906.               end;

    907. 

  907.             end;

    908. 

  908.         38: begin // & ... we need to encode it because in javascript &#39; or &amp; will be converted to ' and error unterminated string

    909. 

  909.               ALStrMove('\u0026', P, 6);

    910. 

  910.               Inc(P, 6);

    911. 

  911.             end;

    912. 

  912.         39: begin // Apostrophe or single quote

    913. 

  913.               if useNumericReference then begin

    914. 

  914.                 ALStrMove('\u0027', P, 6);

    915. 

  915.                 Inc(P, 6);

    916. 

  916.               end

    917. 

  917.               else begin

    918. 

  918.                 ALStrMove('\''', P, 2);

    919. 

  919.                 Inc(P, 2);

    920. 

  920.               end;

    921. 

  921.             end;

    922. 

  922.         60: begin // < ... mostly to hide all </script> tag inside javascript.

    923. 

  923.                   // http://www.wwco.com/~wls/blog/2007/04/25/using-script-in-a-javascript-literal/

    924. 

  924.               ALStrMove('\u003C', P, 6);

    925. 

  925.               Inc(P, 6);

    926. 

  926.             end;

    927. 

  927.         62: begin // > ... mostly to hide all HTML tag inside javascript.

    928. 

  928.               ALStrMove('\u003E', P, 6);

    929. 

  929.               Inc(P, 6);

    930. 

  930.             end;

    931. 

  931.         92: begin // Backslash character (\).

    932. 

  932.               if useNumericReference then begin

    933. 

  933.                 ALStrMove('\u005C', P, 6);

    934. 

  934.                 Inc(P, 6);

    935. 

  935.               end

    936. 

  936.               else begin

    937. 

  937.                 ALStrMove('\\', P, 2);

    938. 

  938.                 Inc(P, 2);

    939. 

  939.               end;

    940. 

  940.             end;

    941. 

  941.         else Begin

    942. 

  942.           P^:= AnsiChar(ch);

    943. 

  943.           Inc(P);

    944. 

  944.         end;

    945. 

  945.       end;

    946. 

  946.     end;

    947. 

  947.     SetString(Result, Buf, P - Buf);…
    948.