PageRenderTime 49ms CodeModel.GetById 15ms RepoModel.GetById 0ms app.codeStats 0ms

/lib/typo3/class.t3lib_cs.php

https://bitbucket.org/ceu/moodle_demo
PHP | 2097 lines | 1238 code | 265 blank | 594 comment | 336 complexity | 34dd01786172e1709351050111fe5d6e MD5 | raw file
Possible License(s): BSD-3-Clause, LGPL-2.0, LGPL-2.1

Large files files are truncated, but you can click here to view the full file

    

  1. <?php

    2. 

  2. /***************************************************************

    3. 

  3. *  Copyright notice

    4. 

  4. *

    5. 

  5. *  (c) 2003-2006 Kasper Skaarhoj (kasperYYYY@typo3.com)

    6. 

  6. *  All rights reserved

    7. 

  7. *

    8. 

  8. *  This script is part of the Typo3 project. The Typo3 project is

    9. 

  9. *  free software; you can redistribute it and/or modify

    10. 

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

    11. 

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

    12. 

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

    13. 

  13. *

    14. 

  14. *  The GNU General Public License can be found at

    15. 

  15. *  http://www.gnu.org/copyleft/gpl.html.

    16. 

  16. *

    17. 

  17. *  This script is distributed in the hope that it will be useful,

    18. 

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

    19. 

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

    20. 

  20. *  GNU General Public License for more details.

    21. 

  21. *

    22. 

  22. *  This copyright notice MUST APPEAR in all copies of the script!

    23. 

  23. ***************************************************************/

    24. 

  24. /**

    25. 

  25.  * Class for conversion between charsets.

    26. 

  26.  *

    27. 

  27.  *    Typo Id: class.t3lib_cs.php,v 1.56 2006/05/03 08:47:30 masi Exp $

    28. 

  28.  * Moodle $Id: class.t3lib_cs.php,v 1.7.14.2 2009/11/19 10:10:50 skodak Exp $

    29. 

  29.  *

    30. 

  30.  * @author	Kasper Skaarhoj <kasperYYYY@typo3.com>

    31. 

  31.  * @author	Martin Kutschker <martin.t.kutschker@blackbox.net>

    32. 

  32.  */

    33. 

  33. /**

    34. 

  34.  * [CLASS/FUNCTION INDEX of SCRIPT]

    35. 

  35.  *

    36. 

  36.  *

    37. 

  37.  *

    38. 

  38.  *  136: class t3lib_cs

    39. 

  39.  *  488:     function parse_charset($charset)

    40. 

  40.  *  507:     function get_locale_charset($locale)

    41. 

  41.  *

    42. 

  42.  *              SECTION: Charset Conversion functions

    43. 

  43.  *  560:     function conv($str,$fromCS,$toCS,$useEntityForNoChar=0)

    44. 

  44.  *  600:     function convArray(&$array,$fromCS,$toCS,$useEntityForNoChar=0)

    45. 

  45.  *  617:     function utf8_encode($str,$charset)

    46. 

  46.  *  663:     function utf8_decode($str,$charset,$useEntityForNoChar=0)

    47. 

  47.  *  706:     function utf8_to_entities($str)

    48. 

  48.  *  739:     function entities_to_utf8($str,$alsoStdHtmlEnt=0)

    49. 

  49.  *  773:     function utf8_to_numberarray($str,$convEntities=0,$retChar=0)

    50. 

  50.  *  823:     function UnumberToChar($cbyte)

    51. 

  51.  *  868:     function utf8CharToUnumber($str,$hex=0)

    52. 

  52.  *

    53. 

  53.  *              SECTION: Init functions

    54. 

  54.  *  911:     function initCharset($charset)

    55. 

  55.  *  973:     function initUnicodeData($mode=null)

    56. 

  56.  * 1198:     function initCaseFolding($charset)

    57. 

  57.  * 1260:     function initToASCII($charset)

    58. 

  58.  *

    59. 

  59.  *              SECTION: String operation functions

    60. 

  60.  * 1331:     function substr($charset,$string,$start,$len=null)

    61. 

  61.  * 1384:     function strlen($charset,$string)

    62. 

  62.  * 1414:     function crop($charset,$string,$len,$crop='')

    63. 

  63.  * 1467:     function strtrunc($charset,$string,$len)

    64. 

  64.  * 1501:     function conv_case($charset,$string,$case)

    65. 

  65.  * 1527:     function specCharsToASCII($charset,$string)

    66. 

  66.  *

    67. 

  67.  *              SECTION: Internal string operation functions

    68. 

  68.  * 1567:     function sb_char_mapping($str,$charset,$mode,$opt='')

    69. 

  69.  *

    70. 

  70.  *              SECTION: Internal UTF-8 string operation functions

    71. 

  71.  * 1622:     function utf8_substr($str,$start,$len=null)

    72. 

  72.  * 1655:     function utf8_strlen($str)

    73. 

  73.  * 1676:     function utf8_strtrunc($str,$len)

    74. 

  74.  * 1698:     function utf8_strpos($haystack,$needle,$offset=0)

    75. 

  75.  * 1723:     function utf8_strrpos($haystack,$needle)

    76. 

  76.  * 1745:     function utf8_char2byte_pos($str,$pos)

    77. 

  77.  * 1786:     function utf8_byte2char_pos($str,$pos)

    78. 

  78.  * 1809:     function utf8_char_mapping($str,$mode,$opt='')

    79. 

  79.  *

    80. 

  80.  *              SECTION: Internal EUC string operation functions

    81. 

  81.  * 1885:     function euc_strtrunc($str,$len,$charset)

    82. 

  82.  * 1914:     function euc_substr($str,$start,$charset,$len=null)

    83. 

  83.  * 1939:     function euc_strlen($str,$charset)

    84. 

  84.  * 1966:     function euc_char2byte_pos($str,$pos,$charset)

    85. 

  85.  * 2007:     function euc_char_mapping($str,$charset,$mode,$opt='')

    86. 

  86.  *

    87. 

  87.  * TOTAL FUNCTIONS: 35

    88. 

  88.  * (This index is automatically created/updated by the extension "extdeveval")

    89. 

  89.  *

    90. 

  90.  */

    91. 

  91. 

    92. 

  92. 

    93. 

  93. 

    94. 

  94. 

    95. 

  95. 

    96. 

  96. 

    97. 

  97. 

    98. 

  98. 

    99. 

  99. /**

    100. 

  100.  * Notes on UTF-8

    101. 

  101.  *

    102. 

  102.  * Functions working on UTF-8 strings:

    103. 

  103.  *

    104. 

  104.  * - strchr/strstr

    105. 

  105.  * - strrchr

    106. 

  106.  * - substr_count

    107. 

  107.  * - implode/explode/join

    108. 

  108.  *

    109. 

  109.  * Functions nearly working on UTF-8 strings:

    110. 

  110.  *

    111. 

  111.  * - strlen: returns the length in BYTES, if you need the length in CHARACTERS use utf8_strlen

    112. 

  112.  * - trim/ltrim/rtrim: the second parameter 'charlist' won't work for characters not contained in 7-bit ASCII

    113. 

  113.  * - strpos/strrpos: they return the BYTE position, if you need the CHARACTER position use utf8_strpos/utf8_strrpos

    114. 

  114.  * - htmlentities: charset support for UTF-8 only since PHP 4.3.0

    115. 

  115.  *

    116. 

  116.  * Functions NOT working on UTF-8 strings:

    117. 

  117.  *

    118. 

  118.  * - str*cmp

    119. 

  119.  * - stristr

    120. 

  120.  * - stripos

    121. 

  121.  * - substr

    122. 

  122.  * - strrev

    123. 

  123.  * - ereg/eregi

    124. 

  124.  * - split/spliti

    125. 

  125.  * - preg_*

    126. 

  126.  * - ...

    127. 

  127.  *

    128. 

  128.  */

    129. 

  129. /**

    130. 

  130.  * Class for conversion between charsets

    131. 

  131.  *

    132. 

  132.  * @author	Kasper Skaarhoj <kasperYYYY@typo3.com>

    133. 

  133.  * @author	Martin Kutschker <martin.t.kutschker@blackbox.net>

    134. 

  134.  * @package TYPO3

    135. 

  135.  * @subpackage t3lib

    136. 

  136.  */

    137. 

  137. class t3lib_cs {

    138. 

  138. 	var $noCharByteVal=63;		// ASCII Value for chars with no equivalent.

    139. 

  139. 

    140. 

  140. 		// This is the array where parsed conversion tables are stored (cached)

    141. 

  141. 	var $parsedCharsets=array();

    142. 

  142. 

    143. 

  143. 		// An array where case folding data will be stored (cached)

    144. 

  144. 	var $caseFolding=array();

    145. 

  145. 

    146. 

  146. 		// An array where charset-to-ASCII mappings are stored (cached)

    147. 

  147. 	var $toASCII=array();

    148. 

  148. 

    149. 

  149. 		// This tells the converter which charsets has two bytes per char:

    150. 

  150. 	var $twoByteSets=array(

    151. 

  151. 		'ucs-2'=>1,	// 2-byte Unicode

    152. 

  152. 	);

    153. 

  153. 

    154. 

  154. 		// This tells the converter which charsets has four bytes per char:

    155. 

  155. 	var $fourByteSets=array(

    156. 

  156. 		'ucs-4'=>1,	// 4-byte Unicode

    157. 

  157. 		'utf-32'=>1,	// 4-byte Unicode (limited to the 21-bits of UTF-16)

    158. 

  158. 	);

    159. 

  159. 

    160. 

  160. 		// This tells the converter which charsets use a scheme like the Extended Unix Code:

    161. 

  161. 	var $eucBasedSets=array(

    162. 

  162. 		'gb2312'=>1,		// Chinese, simplified.

    163. 

  163. 		'big5'=>1,		// Chinese, traditional.

    164. 

  164. 		'euc-kr'=>1,		// Korean

    165. 

  165. 		'shift_jis'=>1,		// Japanese - WARNING: Shift-JIS includes half-width katakana single-bytes characters above 0x80!

    166. 

  166. 	);

    167. 

  167. 

    168. 

  168. 		// see	http://developer.apple.com/documentation/macos8/TextIntlSvcs/TextEncodingConversionManager/TEC1.5/TEC.b0.html

    169. 

  169. 		// http://czyborra.com/charsets/iso8859.html

    170. 

  170. 	var $synonyms=array(

    171. 

  171. 		'us' => 'ascii',

    172. 

  172. 		'us-ascii'=> 'ascii',

    173. 

  173. 		'cp819' => 'iso-8859-1',

    174. 

  174. 		'ibm819' => 'iso-8859-1',

    175. 

  175. 		'iso-ir-100' => 'iso-8859-1',

    176. 

  176. 		'iso-ir-109' => 'iso-8859-2',

    177. 

  177. 		'iso-ir-148' => 'iso-8859-9',

    178. 

  178. 		'iso-ir-199' => 'iso-8859-14',

    179. 

  179. 		'iso-ir-203' => 'iso-8859-15',

    180. 

  180. 		'csisolatin1' => 'iso-8859-1',

    181. 

  181. 		'csisolatin2' => 'iso-8859-2',

    182. 

  182. 		'csisolatin3' => 'iso-8859-3',

    183. 

  183. 		'csisolatin5' => 'iso-8859-9',

    184. 

  184. 		'csisolatin8' => 'iso-8859-14',

    185. 

  185. 		'csisolatin9' => 'iso-8859-15',

    186. 

  186. 		'csisolatingreek' => 'iso-8859-7',

    187. 

  187. 		'iso-celtic' => 'iso-8859-14',

    188. 

  188. 		'latin1' => 'iso-8859-1',

    189. 

  189. 		'latin2' => 'iso-8859-2',

    190. 

  190. 		'latin3' => 'iso-8859-3',

    191. 

  191. 		'latin5' => 'iso-8859-9',

    192. 

  192. 		'latin6' => 'iso-8859-10',

    193. 

  193. 		'latin8' => 'iso-8859-14',

    194. 

  194. 		'latin9' => 'iso-8859-15',

    195. 

  195. 		'l1' => 'iso-8859-1',

    196. 

  196. 		'l2' => 'iso-8859-2',

    197. 

  197. 		'l3' => 'iso-8859-3',

    198. 

  198. 		'l5' => 'iso-8859-9',

    199. 

  199. 		'l6' => 'iso-8859-10',

    200. 

  200. 		'l8' => 'iso-8859-14',

    201. 

  201. 		'l9' => 'iso-8859-15',

    202. 

  202. 		'cyrillic' => 'iso-8859-5',

    203. 

  203. 		'arabic' => 'iso-8859-6',

    204. 

  204. 		'tis-620' => 'iso-8859-11',

    205. 

  205. 		'win874' => 'windows-874',

    206. 

  206. 		'win1250' => 'windows-1250',

    207. 

  207. 		'win1251' => 'windows-1251',

    208. 

  208. 		'win1252' => 'windows-1252',

    209. 

  209. 		'win1253' => 'windows-1253',

    210. 

  210. 		'win1254' => 'windows-1254',

    211. 

  211. 		'win1255' => 'windows-1255',

    212. 

  212. 		'win1256' => 'windows-1256',

    213. 

  213. 		'win1257' => 'windows-1257',

    214. 

  214. 		'win1258' => 'windows-1258',

    215. 

  215. 		'cp1250' => 'windows-1250',

    216. 

  216. 		'cp1251' => 'windows-1251',

    217. 

  217. 		'cp1252' => 'windows-1252',

    218. 

  218. 		'ms-ee' => 'windows-1250',

    219. 

  219. 		'ms-ansi' => 'windows-1252',

    220. 

  220. 		'ms-greek' => 'windows-1253',

    221. 

  221. 		'ms-turk' => 'windows-1254',

    222. 

  222. 		'winbaltrim' => 'windows-1257',

    223. 

  223. 		'koi-8ru' => 'koi-8r',

    224. 

  224. 		'koi8r' => 'koi-8r',

    225. 

  225. 		'cp878' => 'koi-8r',

    226. 

  226. 		'mac' => 'macroman',

    227. 

  227. 		'macintosh' => 'macroman',

    228. 

  228. 		'euc-cn' => 'gb2312',

    229. 

  229. 		'x-euc-cn' => 'gb2312',

    230. 

  230. 		'euccn' => 'gb2312',

    231. 

  231. 		'cp936' => 'gb2312',

    232. 

  232. 		'big-5' => 'big5',

    233. 

  233. 		'cp950' => 'big5',

    234. 

  234. 		'eucjp' => 'euc-jp',

    235. 

  235. 		'sjis' => 'shift_jis',

    236. 

  236. 		'shift-jis' => 'shift_jis',

    237. 

  237. 		'cp932' => 'shift_jis',

    238. 

  238. 		'cp949' => 'euc-kr',

    239. 

  239. 		'utf7' => 'utf-7',

    240. 

  240. 		'utf8' => 'utf-8',

    241. 

  241. 		'utf16' => 'utf-16',

    242. 

  242. 		'utf32' => 'utf-32',

    243. 

  243. 		'utf8' => 'utf-8',

    244. 

  244. 		'ucs2' => 'ucs-2',

    245. 

  245. 		'ucs4' => 'ucs-4',

    246. 

  246. 	);

    247. 

  247. 

    248. 

  248. 		// mapping of iso-639:2 language codes to script names

    249. 

  249. 	var $lang_to_script=array(

    250. 

  250. 			// iso-639:2 language codes, see:

    251. 

  251. 			//  http://www.w3.org/WAI/ER/IG/ert/iso639.htm

    252. 

  252. 			//  http://www.loc.gov/standards/iso639-2/langcodes.html

    253. 

  253. 			//  http://www.unicode.org/onlinedat/languages.html

    254. 

  254. 		'ar' => 'arabic',

    255. 

  255. 		'bg' => 'cyrillic',		// Bulgarian

    256. 

  256. 		'bs' => 'east_european',	// Bosnian

    257. 

  257. 		'cs' => 'east_european',	// Czech

    258. 

  258. 		'da' => 'west_european',	// Danish

    259. 

  259. 		'de' => 'west_european',	// German

    260. 

  260. 		'es' => 'west_european',	// Spanish

    261. 

  261. 		'et' => 'estonian',

    262. 

  262. 		'eo' => 'unicode',		// Esperanto

    263. 

  263. 		'eu' => 'west_european',	// Basque

    264. 

  264. 		'fa' => 'arabic',	// Persian

    265. 

  265. 		'fi' => 'west_european',	// Finish

    266. 

  266. 		'fo' => 'west_european',	// Faroese

    267. 

  267. 		'fr' => 'west_european',	// French

    268. 

  268. 		'gr' => 'greek',

    269. 

  269. 		'he' => 'hebrew',		// Hebrew (since 1998)

    270. 

  270. 		'hi' => 'unicode',		// Hindi

    271. 

  271. 		'hr' => 'east_european',	// Croatian

    272. 

  272. 		'hu' => 'east_european',	// Hungarian

    273. 

  273. 		'iw' => 'hebrew',		// Hebrew (til 1998)

    274. 

  274. 		'is' => 'west_european',	// Icelandic

    275. 

  275. 		'it' => 'west_european',	// Italian

    276. 

  276. 		'ja' => 'japanese',

    277. 

  277. 		'kl' => 'west_european',	// Greenlandic

    278. 

  278. 		'ko' => 'korean',

    279. 

  279. 		'lt' => 'lithuanian',

    280. 

  280. 		'lv' => 'west_european',	// Latvian/Lettish

    281. 

  281. 		'nl' => 'west_european',	// Dutch

    282. 

  282. 		'no' => 'west_european',	// Norwegian

    283. 

  283. 		'pl' => 'east_european',	// Polish

    284. 

  284. 		'pt' => 'west_european',	// Portuguese

    285. 

  285. 		'ro' => 'east_european',	// Romanian

    286. 

  286. 		'ru' => 'cyrillic',		// Russian

    287. 

  287. 		'sk' => 'east_european',	// Slovak

    288. 

  288. 		'sl' => 'east_european',	// Slovenian

    289. 

  289. 		'sr' => 'cyrillic',		// Serbian

    290. 

  290. 		'sv' => 'west_european',	// Swedish

    291. 

  291. 		'th' => 'thai',

    292. 

  292. 		'uk' => 'cyrillic',		// Ukranian

    293. 

  293. 		'vi' => 'vietnamese',

    294. 

  294. 		'zh' => 'chinese',

    295. 

  295. 			// MS language codes, see http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vclib/html/_crt_language_strings.asp

    296. 

  296. 			// http://msdn.microsoft.com/library/default.asp?url=/library/en-us/wceinternational5/html/wce50conLanguageIdentifiersandLocales.asp

    297. 

  297. 		'ara' => 'arabic',

    298. 

  298. 		'bgr' => 'cyrillic',		// Bulgarian

    299. 

  299. 		'cat' => 'west_european',	// Catalan

    300. 

  300. 		'chs' => 'simpl_chinese',

    301. 

  301. 		'cht' => 'trad_chinese',

    302. 

  302. 		'csy' => 'east_european',	// Czech

    303. 

  303. 		'dan' => 'west_european',	// Danisch

    304. 

  304. 		'deu' => 'west_european',	// German

    305. 

  305. 		'dea' => 'west_european',	// German (Austrian)

    306. 

  306. 		'des' => 'west_european',	// German (Swiss)

    307. 

  307. 		'ena' => 'west_european',	// English (Australian)

    308. 

  308. 		'enc' => 'west_european',	// English (Canadian)

    309. 

  309. 		'eng' => 'west_european',	// English

    310. 

  310. 		'enz' => 'west_european',	// English (New Zealand)

    311. 

  311. 		'enu' => 'west_european',	// English (United States)

    312. 

  312. 		'euq' => 'west_european',	// Basque

    313. 

  313. 		'fos' => 'west_european',	// Faroese

    314. 

  314. 		'far' => 'arabic',	// Persian

    315. 

  315. 		'fin' => 'west_european',	// Finish

    316. 

  316. 		'fra' => 'west_european',	// French

    317. 

  317. 		'frb' => 'west_european',	// French (Belgian)

    318. 

  318. 		'frc' => 'west_european',	// French (Canadian)

    319. 

  319. 		'frs' => 'west_european',	// French (Swiss)

    320. 

  320. 		'ell' => 'greek',

    321. 

  321. 		'heb' => 'hebrew',

    322. 

  322. 		'hin' => 'unicode',	// Hindi

    323. 

  323. 		'hun' => 'east_european',	// Hungarian

    324. 

  324. 		'isl' => 'west_euorpean',	// Icelandic

    325. 

  325. 		'ita' => 'west_european',	// Italian

    326. 

  326. 		'its' => 'west_european',	// Italian (Swiss)

    327. 

  327. 		'jpn' => 'japanese',

    328. 

  328. 		'kor' => 'korean',

    329. 

  329. 		'lth' => 'lithuanian',

    330. 

  330. 		'lvi' => 'west_european',	// Latvian/Lettish

    331. 

  331. 		'msl' => 'west_european',	// Malay

    332. 

  332. 		'nlb' => 'west_european',	// Dutch (Belgian)

    333. 

  333. 		'nld' => 'west_european',	// Dutch

    334. 

  334. 		'nor' => 'west_european',	// Norwegian (bokmal)

    335. 

  335. 		'non' => 'west_european',	// Norwegian (nynorsk)

    336. 

  336. 		'plk' => 'east_european',	// Polish

    337. 

  337. 		'ptg' => 'west_european',	// Portuguese

    338. 

  338. 		'ptb' => 'west_european',	// Portuguese (Brazil)

    339. 

  339. 		'rom' => 'east_european',	// Romanian

    340. 

  340. 		'rus' => 'cyrillic',		// Russian

    341. 

  341. 		'slv' => 'east_european',	// Slovenian

    342. 

  342. 		'sky' => 'east_european',	// Slovak

    343. 

  343. 		'srl' => 'east_european',	// Serbian (Latin)

    344. 

  344. 		'srb' => 'cyrillic',		// Serbian (Cyrillic)

    345. 

  345. 		'esp' => 'west_european',	// Spanish (trad. sort)

    346. 

  346. 		'esm' => 'west_european',	// Spanish (Mexican)

    347. 

  347. 		'esn' => 'west_european',	// Spanish (internat. sort)

    348. 

  348. 		'sve' => 'west_european',	// Swedish

    349. 

  349. 		'tha' => 'thai',

    350. 

  350. 		'trk' => 'turkish',

    351. 

  351. 		'ukr' => 'cyrillic',	// Ukrainian

    352. 

  352. 			// English language names

    353. 

  353. 		'arabic' => 'arabic',

    354. 

  354. 		'basque' => 'west_european',

    355. 

  355. 		'bosnian' => 'east_european',

    356. 

  356. 		'bulgarian' => 'east_european',

    357. 

  357. 		'catalan' => 'west_european',

    358. 

  358. 		'croatian' => 'east_european',

    359. 

  359. 		'czech' => 'east_european',

    360. 

  360. 		'danish' => 'west_european',

    361. 

  361. 		'dutch' => 'west_european',

    362. 

  362. 		'english' => 'west_european',

    363. 

  363. 		'esperanto' => 'unicode',

    364. 

  364. 		'estonian' => 'estonian',

    365. 

  365. 		'faroese' => 'west_european',

    366. 

  366. 		'farsi' => 'arabic',

    367. 

  367. 		'finnish' => 'west_european',

    368. 

  368. 		'french' => 'west_european',

    369. 

  369. 		'galician' => 'west_european',

    370. 

  370. 		'german' => 'west_european',

    371. 

  371. 		'greek' => 'greek',

    372. 

  372. 		'greenlandic' => 'west_european',

    373. 

  373. 		'hebrew' => 'hebrew',

    374. 

  374. 		'hindi' => 'unicode',

    375. 

  375. 		'hungarian' => 'east_european',

    376. 

  376. 		'icelandic' => 'west_european',

    377. 

  377. 		'italian' => 'west_european',

    378. 

  378. 		'latvian' => 'west_european',

    379. 

  379. 		'lettish' => 'west_european',

    380. 

  380. 		'lithuanian' => 'lithuanian',

    381. 

  381. 		'malay' => 'west_european',

    382. 

  382. 		'norwegian' => 'west_european',

    383. 

  383. 		'persian' => 'arabic',

    384. 

  384. 		'polish' => 'east_european',

    385. 

  385. 		'portuguese' => 'west_european',

    386. 

  386. 		'russian' => 'cyrillic',

    387. 

  387. 		'romanian' => 'east_european',

    388. 

  388. 		'serbian' => 'cyrillic',

    389. 

  389. 		'slovak' => 'east_european',

    390. 

  390. 		'slovenian' => 'east_european',

    391. 

  391. 		'spanish' => 'west_european',

    392. 

  392. 		'svedish' => 'west_european',

    393. 

  393. 		'that' => 'thai',

    394. 

  394. 		'turkish' => 'turkish',

    395. 

  395. 		'ukrainian' => 'cyrillic',

    396. 

  396. 	);

    397. 

  397. 

    398. 

  398. 		// mapping of language (family) names to charsets on Unix

    399. 

  399. 	var $script_to_charset_unix=array(

    400. 

  400. 		'west_european' => 'iso-8859-1',

    401. 

  401. 		'estonian' => 'iso-8859-1',

    402. 

  402. 		'east_european' => 'iso-8859-2',

    403. 

  403. 		'baltic' => 'iso-8859-4',

    404. 

  404. 		'cyrillic' => 'iso-8859-5',

    405. 

  405. 		'arabic' => 'iso-8859-6',

    406. 

  406. 		'greek' => 'iso-8859-7',

    407. 

  407. 		'hebrew' => 'iso-8859-8',

    408. 

  408. 		'turkish' => 'iso-8859-9',

    409. 

  409. 		'thai' => 'iso-8859-11', // = TIS-620

    410. 

  410. 		'lithuanian' => 'iso-8859-13',

    411. 

  411. 		'chinese' => 'gb2312', // = euc-cn

    412. 

  412. 		'japanese' => 'euc-jp',

    413. 

  413. 		'korean' => 'euc-kr',

    414. 

  414. 		'simpl_chinese' => 'gb2312',

    415. 

  415. 		'trad_chinese' => 'big5',

    416. 

  416. 		'vietnamese' => '',

    417. 

  417. 		'unicode' => 'utf-8',

    418. 

  418. 	);

    419. 

  419. 

    420. 

  420. 		// mapping of language (family) names to charsets on Windows

    421. 

  421. 	var $script_to_charset_windows=array(

    422. 

  422. 		'east_european' => 'windows-1250',

    423. 

  423. 		'cyrillic' => 'windows-1251',

    424. 

  424. 		'west_european' => 'windows-1252',

    425. 

  425. 		'greek' => 'windows-1253',

    426. 

  426. 		'turkish' => 'windows-1254',

    427. 

  427. 		'hebrew' => 'windows-1255',

    428. 

  428. 		'arabic' => 'windows-1256',

    429. 

  429. 		'baltic' => 'windows-1257',

    430. 

  430. 		'estonian' => 'windows-1257',

    431. 

  431. 		'lithuanian' => 'windows-1257',

    432. 

  432. 		'vietnamese' => 'windows-1258',

    433. 

  433. 		'thai' => 'cp874',

    434. 

  434. 		'korean' => 'cp949',

    435. 

  435. 		'chinese' => 'gb2312',

    436. 

  436. 		'japanese' => 'shift_jis',

    437. 

  437. 		'simpl_chinese' => 'gb2312',

    438. 

  438. 		'trad_chinese' => 'big5',

    439. 

  439. 	);

    440. 

  440. 

    441. 

  441. 		// mapping of locale names to charsets

    442. 

  442. 	var $locale_to_charset=array(

    443. 

  443. 		'japanese.euc' => 'euc-jp',

    444. 

  444. 		'ja_jp.ujis' => 'euc-jp',

    445. 

  445. 		'korean.euc' => 'euc-kr',

    446. 

  446. 		'sr@Latn' => 'iso-8859-2',

    447. 

  447. 		'zh_cn' => 'gb2312',

    448. 

  448. 		'zh_hk' => 'big5',

    449. 

  449. 		'zh_tw' => 'big5',

    450. 

  450. 	);

    451. 

  451. 

    452. 

  452. 		// TYPO3 specific: Array with the system charsets used for each system language in TYPO3:

    453. 

  453. 		// Empty values means "iso-8859-1"

    454. 

  454. 	var $charSetArray = array(

    455. 

  455. 		'dk' => '',

    456. 

  456. 		'de' => '',

    457. 

  457. 		'no' => '',

    458. 

  458. 		'it' => '',

    459. 

  459. 		'fr' => '',

    460. 

  460. 		'es' => '',

    461. 

  461. 		'nl' => '',

    462. 

  462. 		'cz' => 'windows-1250',

    463. 

  463. 		'pl' => 'iso-8859-2',

    464. 

  464. 		'si' => 'windows-1250',

    465. 

  465. 		'fi' => '',

    466. 

  466. 		'tr' => 'iso-8859-9',

    467. 

  467. 		'se' => '',

    468. 

  468. 		'pt' => '',

    469. 

  469. 		'ru' => 'windows-1251',

    470. 

  470. 		'ro' => 'iso-8859-2',

    471. 

  471. 		'ch' => 'gb2312',

    472. 

  472. 		'sk' => 'windows-1250',

    473. 

  473. 		'lt' => 'windows-1257',

    474. 

  474. 		'is' => 'utf-8',

    475. 

  475. 		'hr' => 'windows-1250',

    476. 

  476. 		'hu' => 'iso-8859-2',

    477. 

  477. 		'gl' => '',

    478. 

  478. 		'th' => 'iso-8859-11',

    479. 

  479. 		'gr' => 'iso-8859-7',

    480. 

  480. 		'hk' => 'big5',

    481. 

  481. 		'eu' => '',

    482. 

  482. 		'bg' => 'windows-1251',

    483. 

  483. 		'br' => '',

    484. 

  484. 		'et' => 'iso-8859-4',

    485. 

  485. 		'ar' => 'iso-8859-6',

    486. 

  486. 		'he' => 'utf-8',

    487. 

  487. 		'ua' => 'windows-1251',

    488. 

  488. 		'jp' => 'shift_jis',

    489. 

  489. 		'lv' => 'utf-8',

    490. 

  490. 		'vn' => 'utf-8',

    491. 

  491. 		'ca' => 'iso-8859-15',

    492. 

  492. 		'ba' => 'iso-8859-2',

    493. 

  493. 		'kr' => 'euc-kr',

    494. 

  494. 		'eo' => 'utf-8',

    495. 

  495. 		'my' => '',

    496. 

  496. 		'hi' => 'utf-8',

    497. 

  497. 		'fo' => 'utf-8',

    498. 

  498. 		'fa' => 'utf-8',

    499. 

  499. 		'sr' => 'utf-8'

    500. 

  500. 	);

    501. 

  501. 

    502. 

  502. 		// TYPO3 specific: Array with the iso names used for each system language in TYPO3:

    503. 

  503. 		// Missing keys means: same as Typo3

    504. 

  504. 	var $isoArray = array(

    505. 

  505. 		'ba' => 'bs',

    506. 

  506. 		'br' => 'pt_BR',

    507. 

  507. 		'ch' => 'zh_CN',

    508. 

  508. 		'cz' => 'cs',

    509. 

  509. 		'dk' => 'da',

    510. 

  510. 		'si' => 'sl',

    511. 

  511. 		'se' => 'sv',

    512. 

  512. 		'gl' => 'kl',

    513. 

  513. 		'gr' => 'el',

    514. 

  514. 		'hk' => 'zh_HK',

    515. 

  515. 		'kr' => 'ko',

    516. 

  516. 		'ua' => 'uk',

    517. 

  517. 		'jp' => 'ja',

    518. 

  518. 		'vn' => 'vi',

    519. 

  519. 	);

    520. 

  520. 

    521. 

  521. 	/**

    522. 

  522. 	 * Normalize - changes input character set to lowercase letters.

    523. 

  523. 	 *

    524. 

  524. 	 * @param	string		Input charset

    525. 

  525. 	 * @return	string		Normalized charset

    526. 

  526. 	 * @author	Martin Kutschker <martin.t.kutschker@blackbox.net>

    527. 

  527. 	 */

    528. 

  528. 	function parse_charset($charset)	{

    529. 

  529. 		$charset = strtolower($charset);

    530. 

  530. 		if (isset($this->synonyms[$charset]))	$charset = $this->synonyms[$charset];

    531. 

  531. 

    532. 

  532. 		return $charset;

    533. 

  533. 	}

    534. 

  534. 

    535. 

  535. 	/**

    536. 

  536. 	 * Get the charset of a locale.

    537. 

  537. 	 *

    538. 

  538. 	 * ln            language

    539. 

  539. 	 * ln_CN         language / country

    540. 

  540. 	 * ln_CN.cs      language / country / charset

    541. 

  541. 	 * ln_CN.cs@mod  language / country / charset / modifier

    542. 

  542. 	 *

    543. 

  543. 	 * @param	string		Locale string

    544. 

  544. 	 * @return	string		Charset resolved for locale string

    545. 

  545. 	 * @author	Martin Kutschker <martin.t.kutschker@blackbox.net>

    546. 

  546. 	 */

    547. 

  547. 	function get_locale_charset($locale)	{

    548. 

  548. 		$locale = strtolower($locale);

    549. 

  549. 

    550. 

  550. 			// exact locale specific charset?

    551. 

  551. 		if (isset($this->locale_to_charset[$locale]))	return $this->locale_to_charset[$locale];

    552. 

  552. 

    553. 

  553. 			// get modifier

    554. 

  554. 		list($locale,$modifier) = explode('@',$locale);

    555. 

  555. 

    556. 

  556. 			// locale contains charset: use it

    557. 

  557. 		list($locale,$charset) = explode('.',$locale);

    558. 

  558. 		if ($charset)	return $this->parse_charset($charset);

    559. 

  559. 

    560. 

  560. 			// modifier is 'euro' (after charset check, because of xx.utf-8@euro)

    561. 

  561. 		if ($modifier == 'euro')	return 'iso-8859-15';

    562. 

  562. 

    563. 

  563. 			// get language

    564. 

  564. 		list($language,$country) = explode('_',$locale);

    565. 

  565. 		if (isset($this->lang_to_script[$language]))	$script = $this->lang_to_script[$language];

    566. 

  566. 

    567. 

  567. 		if (TYPO3_OS == 'WIN')	{

    568. 

  568. 			$cs = $this->script_to_charset_windows[$script] ? $this->script_to_charset_windows[$script] : 'window-1252';

    569. 

  569. 		} else {

    570. 

  570. 			$cs = $this->script_to_charset_unix[$script] ? $this->script_to_charset_unix[$script] : 'iso-8859-1';

    571. 

  571. 		}

    572. 

  572. 

    573. 

  573. 		return $cs;

    574. 

  574. 	}

    575. 

  575. 

    576. 

  576. 

    577. 

  577. 

    578. 

  578. 

    579. 

  579. 

    580. 

  580. 

    581. 

  581. 

    582. 

  582. 

    583. 

  583. 

    584. 

  584. 	/********************************************

    585. 

  585. 	 *

    586. 

  586. 	 * Charset Conversion functions

    587. 

  587. 	 *

    588. 

  588. 	 ********************************************/

    589. 

  589. 

    590. 

  590. 	/**

    591. 

  591. 	 * Convert from one charset to another charset.

    592. 

  592. 	 *

    593. 

  593. 	 * @param	string		Input string

    594. 

  594. 	 * @param	string		From charset (the current charset of the string)

    595. 

  595. 	 * @param	string		To charset (the output charset wanted)

    596. 

  596. 	 * @param	boolean		If set, then characters that are not available in the destination character set will be encoded as numeric entities

    597. 

  597. 	 * @return	string		Converted string

    598. 

  598. 	 * @see convArray()

    599. 

  599. 	 */

    600. 

  600. 	function conv($str,$fromCS,$toCS,$useEntityForNoChar=0)	{

    601. 

  601. 		if ($fromCS==$toCS)	return $str;

    602. 

  602. 

    603. 

  603. 			// PHP-libs don't support fallback to SGML entities, but UTF-8 handles everything

    604. 

  604. 		if ($toCS=='utf-8' || !$useEntityForNoChar)	{

    605. 

  605. 			switch($GLOBALS['TYPO3_CONF_VARS']['SYS']['t3lib_cs_convMethod'])	{

    606. 

  606. 			case 'mbstring':

    607. 

  607. 				$conv_str = mb_convert_encoding($str,$toCS,$fromCS);

    608. 

  608. 				if (false !== $conv_str)	return $conv_str; // returns false for unsupported charsets

    609. 

  609. 				break;

    610. 

  610. 

    611. 

  611. 			case 'iconv':

    612. 

  612. 				$conv_str = iconv($fromCS,$toCS.'//IGNORE',$str);

    613. 

  613. 				if (false !== $conv_str)	return $conv_str;

    614. 

  614. 				break;

    615. 

  615. 

    616. 

  616. 			case 'recode':

    617. 

  617. 				$conv_str = recode_string($fromCS.'..'.$toCS,$str);

    618. 

  618. 				if (false !== $conv_str)	return $conv_str;

    619. 

  619. 				break;

    620. 

  620. 			}

    621. 

  621. 			// fallback to TYPO3 conversion

    622. 

  622. 		}

    623. 

  623. 

    624. 

  624. 		if ($fromCS!='utf-8')	$str=$this->utf8_encode($str,$fromCS);

    625. 

  625. 		if ($toCS!='utf-8')	$str=$this->utf8_decode($str,$toCS,$useEntityForNoChar);

    626. 

  626. 		return $str;

    627. 

  627. 	}

    628. 

  628. 

    629. 

  629. 	/**

    630. 

  630. 	 * Convert all elements in ARRAY from one charset to another charset.

    631. 

  631. 	 * NOTICE: Array is passed by reference!

    632. 

  632. 	 *

    633. 

  633. 	 * @param	string		Input array, possibly multidimensional

    634. 

  634. 	 * @param	string		From charset (the current charset of the string)

    635. 

  635. 	 * @param	string		To charset (the output charset wanted)

    636. 

  636. 	 * @param	boolean		If set, then characters that are not available in the destination character set will be encoded as numeric entities

    637. 

  637. 	 * @return	void

    638. 

  638. 	 * @see conv()

    639. 

  639. 	 */

    640. 

  640. 	function convArray(&$array,$fromCS,$toCS,$useEntityForNoChar=0)	{

    641. 

  641. 		foreach($array as $key => $value)	{

    642. 

  642. 			if (is_array($array[$key]))	{

    643. 

  643. 				$this->convArray($array[$key],$fromCS,$toCS,$useEntityForNoChar);

    644. 

  644. 			} else {

    645. 

  645. 				$array[$key] = $this->conv($array[$key],$fromCS,$toCS,$useEntityForNoChar);

    646. 

  646. 			}

    647. 

  647. 		}

    648. 

  648. 	}

    649. 

  649. 

    650. 

  650. 	/**

    651. 

  651. 	 * Converts $str from $charset to UTF-8

    652. 

  652. 	 *

    653. 

  653. 	 * @param	string		String in local charset to convert to UTF-8

    654. 

  654. 	 * @param	string		Charset, lowercase. Must be found in csconvtbl/ folder.

    655. 

  655. 	 * @return	string		Output string, converted to UTF-8

    656. 

  656. 	 */

    657. 

  657. 	function utf8_encode($str,$charset)	{

    658. 

  658. 

    659. 

  659. 		if ($charset === 'utf-8')	return $str;

    660. 

  660. 

    661. 

  661. 			// Charset is case-insensitive.

    662. 

  662. 		if ($this->initCharset($charset))	{	// Parse conv. table if not already...

    663. 

  663. 			$strLen = strlen($str);

    664. 

  664. 			$outStr='';

    665. 

  665. 

    666. 

  666. 			for ($a=0;$a<$strLen;$a++)	{	// Traverse each char in string.

    667. 

  667. 				$chr=substr($str,$a,1);

    668. 

  668. 				$ord=ord($chr);

    669. 

  669. 				if (isset($this->twoByteSets[$charset]))	{	// If the charset has two bytes per char

    670. 

  670. 					$ord2 = ord($str{$a+1});

    671. 

  671. 					$ord = $ord<<8 | $ord2; // assume big endian

    672. 

  672. 

    673. 

  673. 					if (isset($this->parsedCharsets[$charset]['local'][$ord]))	{	// If the local char-number was found in parsed conv. table then we use that, otherwise 127 (no char?)

    674. 

  674. 						$outStr.=$this->parsedCharsets[$charset]['local'][$ord];

    675. 

  675. 					} else $outStr.=chr($this->noCharByteVal);	// No char exists

    676. 

  676. 					$a++;

    677. 

  677. 				} elseif ($ord>127)	{	// If char has value over 127 it's a multibyte char in UTF-8

    678. 

  678. 					if (isset($this->eucBasedSets[$charset]))	{	// EUC uses two-bytes above 127; we get both and advance pointer and make $ord a 16bit int.

    679. 

  679. 						if ($charset != 'shift_jis' || ($ord < 0xA0 || $ord > 0xDF))	{	// Shift-JIS: chars between 160 and 223 are single byte

    680. 

  680. 							$a++;

    681. 

  681. 							$ord2=ord(substr($str,$a,1));

    682. 

  682. 							$ord = $ord*256+$ord2;

    683. 

  683. 						}

    684. 

  684. 					}

    685. 

  685. 

    686. 

  686. 					if (isset($this->parsedCharsets[$charset]['local'][$ord]))	{	// If the local char-number was found in parsed conv. table then we use that, otherwise 127 (no char?)

    687. 

  687. 						$outStr.= $this->parsedCharsets[$charset]['local'][$ord];

    688. 

  688. 					} else $outStr.= chr($this->noCharByteVal);	// No char exists

    689. 

  689. 				} else $outStr.= $chr;	// ... otherwise it's just ASCII 0-127 and one byte. Transparent

    690. 

  690. 			}

    691. 

  691. 			return $outStr;

    692. 

  692. 		}

    693. 

  693. 	}

    694. 

  694. 

    695. 

  695. 	/**

    696. 

  696. 	 * Converts $str from UTF-8 to $charset

    697. 

  697. 	 *

    698. 

  698. 	 * @param	string		String in UTF-8 to convert to local charset

    699. 

  699. 	 * @param	string		Charset, lowercase. Must be found in csconvtbl/ folder.

    700. 

  700. 	 * @param	boolean		If set, then characters that are not available in the destination character set will be encoded as numeric entities

    701. 

  701. 	 * @return	string		Output string, converted to local charset

    702. 

  702. 	 */

    703. 

  703. 	function utf8_decode($str,$charset,$useEntityForNoChar=0)	{

    704. 

  704. 

    705. 

  705. 			// Charset is case-insensitive.

    706. 

  706. 		if ($this->initCharset($charset))	{	// Parse conv. table if not already...

    707. 

  707. 			$strLen = strlen($str);

    708. 

  708. 			$outStr='';

    709. 

  709. 			$buf='';

    710. 

  710. 			for ($a=0,$i=0;$a<$strLen;$a++,$i++)	{	// Traverse each char in UTF-8 string.

    711. 

  711. 				$chr=substr($str,$a,1);

    712. 

  712. 				$ord=ord($chr);

    713. 

  713. 				if ($ord>127)	{	// This means multibyte! (first byte!)

    714. 

  714. 					if ($ord & 64)	{	// Since the first byte must have the 7th bit set we check that. Otherwise we might be in the middle of a byte sequence.

    715. 

  715. 

    716. 

  716. 						$buf=$chr;	// Add first byte

    717. 

  717. 						for ($b=0;$b<8;$b++)	{	// for each byte in multibyte string...

    718. 

  718. 							$ord = $ord << 1;	// Shift it left and ...

    719. 

  719. 							if ($ord & 128)	{	// ... and with 8th bit - if that is set, then there are still bytes in sequence.

    720. 

  720. 								$a++;	// Increase pointer...

    721. 

  721. 								$buf.=substr($str,$a,1);	// ... and add the next char.

    722. 

  722. 							} else break;

    723. 

  723. 						}

    724. 

  724. 

    725. 

  725. 						if (isset($this->parsedCharsets[$charset]['utf8'][$buf]))	{	// If the UTF-8 char-sequence is found then...

    726. 

  726. 							$mByte = $this->parsedCharsets[$charset]['utf8'][$buf];	// The local number

    727. 

  727. 							if ($mByte>255)	{	// If the local number is greater than 255 we will need to split the byte (16bit word assumed) in two chars.

    728. 

  728. 								$outStr.= chr(($mByte >> 8) & 255).chr($mByte & 255);

    729. 

  729. 							} else $outStr.= chr($mByte);

    730. 

  730. 						} elseif ($useEntityForNoChar) {	// Create num entity:

    731. 

  731. 							$outStr.='&#'.$this->utf8CharToUnumber($buf,1).';';

    732. 

  732. 						} else $outStr.=chr($this->noCharByteVal);	// No char exists

    733. 

  733. 					} else $outStr.=chr($this->noCharByteVal);	// No char exists (MIDDLE of MB sequence!)

    734. 

  734. 				} else $outStr.=$chr;	// ... otherwise it's just ASCII 0-127 and one byte. Transparent

    735. 

  735. 			}

    736. 

  736. 			return $outStr;

    737. 

  737. 		}

    738. 

  738. 	}

    739. 

  739. 

    740. 

  740. 	/**

    741. 

  741. 	 * Converts all chars > 127 to numeric entities.

    742. 

  742. 	 *

    743. 

  743. 	 * @param	string		Input string

    744. 

  744. 	 * @return	string		Output string

    745. 

  745. 	 */

    746. 

  746. 	function utf8_to_entities($str)	{

    747. 

  747. 		$strLen = strlen($str);

    748. 

  748. 		$outStr='';

    749. 

  749. 		$buf='';

    750. 

  750. 		for ($a=0;$a<$strLen;$a++)	{	// Traverse each char in UTF-8 string.

    751. 

  751. 			$chr=substr($str,$a,1);

    752. 

  752. 			$ord=ord($chr);

    753. 

  753. 			if ($ord>127)	{	// This means multibyte! (first byte!)

    754. 

  754. 				if ($ord & 64)	{	// Since the first byte must have the 7th bit set we check that. Otherwise we might be in the middle of a byte sequence.

    755. 

  755. 					$buf=$chr;	// Add first byte

    756. 

  756. 					for ($b=0;$b<8;$b++)	{	// for each byte in multibyte string...

    757. 

  757. 						$ord = $ord << 1;	// Shift it left and ...

    758. 

  758. 						if ($ord & 128)	{	// ... and with 8th bit - if that is set, then there are still bytes in sequence.

    759. 

  759. 							$a++;	// Increase pointer...

    760. 

  760. 							$buf.=substr($str,$a,1);	// ... and add the next char.

    761. 

  761. 						} else break;

    762. 

  762. 					}

    763. 

  763. 

    764. 

  764. 					$outStr.='&#'.$this->utf8CharToUnumber($buf,1).';';

    765. 

  765. 				} else $outStr.=chr($this->noCharByteVal);	// No char exists (MIDDLE of MB sequence!)

    766. 

  766. 			} else $outStr.=$chr;	// ... otherwise it's just ASCII 0-127 and one byte. Transparent

    767. 

  767. 		}

    768. 

  768. 

    769. 

  769. 		return $outStr;

    770. 

  770. 	}

    771. 

  771. 

    772. 

  772. 	/**

    773. 

  773. 	 * Converts numeric entities (UNICODE, eg. decimal (&#1234;) or hexadecimal (&#x1b;)) to UTF-8 multibyte chars

    774. 

  774. 	 *

    775. 

  775. 	 * @param	string		Input string, UTF-8

    776. 

  776. 	 * @param	boolean		If set, then all string-HTML entities (like &amp; or &pound; will be converted as well)

    777. 

  777. 	 * @return	string		Output string

    778. 

  778. 	 */

    779. 

  779. 	function entities_to_utf8($str,$alsoStdHtmlEnt=0)	{

    780. 

  780. 		if ($alsoStdHtmlEnt)	{

    781. 

  781. 			$trans_tbl = array_flip(get_html_translation_table(HTML_ENTITIES));		// Getting them in iso-8859-1 - but thats ok since this is observed below.

    782. 

  782. 		}

    783. 

  783. 

    784. 

  784. 		$token = md5(microtime());

    785. 

  785. 		$parts = explode($token,ereg_replace('(&([#[:alnum:]]*);)',$token.'\2'.$token,$str));

    786. 

  786. 		foreach($parts as $k => $v)	{

    787. 

  787. 			if ($k%2)	{

    788. 

  788. 				if (substr($v,0,1)=='#')	{	// Dec or hex entities:

    789. 

  789. 					if (substr($v,1,1)=='x')	{

    790. 

  790. 						$parts[$k] = $this->UnumberToChar(hexdec(substr($v,2)));

    791. 

  791. 					} else {

    792. 

  792. 						$parts[$k] = $this->UnumberToChar(substr($v,1));

    793. 

  793. 					}

    794. 

  794. 				} elseif ($alsoStdHtmlEnt && $trans_tbl['&'.$v.';']) {	// Other entities:

    795. 

  795. 					$parts[$k] = $this->utf8_encode($trans_tbl['&'.$v.';'],'iso-8859-1');

    796. 

  796. 				} else {	// No conversion:

    797. 

  797. 					$parts[$k] ='&'.$v.';';

    798. 

  798. 				}

    799. 

  799. 			}

    800. 

  800. 		}

    801. 

  801. 

    802. 

  802. 		return implode('',$parts);

    803. 

  803. 	}

    804. 

  804. 

    805. 

  805. 	/**

    806. 

  806. 	 * Converts all chars in the input UTF-8 string into integer numbers returned in an array

    807. 

  807. 	 *

    808. 

  808. 	 * @param	string		Input string, UTF-8

    809. 

  809. 	 * @param	boolean		If set, then all HTML entities (like &amp; or &pound; or &#123; or &#x3f5d;) will be detected as characters.

    810. 

  810. 	 * @param	boolean		If set, then instead of integer numbers the real UTF-8 char is returned.

    811. 

  811. 	 * @return	array		Output array with the char numbers

    812. 

  812. 	 */

    813. 

  813. 	function utf8_to_numberarray($str,$convEntities=0,$retChar=0)	{

    814. 

  814. 			// If entities must be registered as well...:

    815. 

  815. 		if ($convEntities)	{

    816. 

  816. 			$str = $this->entities_to_utf8($str,1);

    817. 

  817. 		}

    818. 

  818. 			// Do conversion:

    819. 

  819. 		$strLen = strlen($str);

    820. 

  820. 		$outArr=array();

    821. 

  821. 		$buf='';

    822. 

  822. 		for ($a=0;$a<$strLen;$a++)	{	// Traverse each char in UTF-8 string.

    823. 

  823. 			$chr=substr($str,$a,1);

    824. 

  824. 			$ord=ord($chr);

    825. 

  825. 			if ($ord>127)	{	// This means multibyte! (first byte!)

    826. 

  826. 				if ($ord & 64)	{	// Since the first byte must have the 7th bit set we check that. Otherwise we might be in the middle of a byte sequence.

    827. 

  827. 					$buf=$chr;	// Add first byte

    828. 

  828. 					for ($b=0;$b<8;$b++)	{	// for each byte in multibyte string...

    829. 

  829. 						$ord = $ord << 1;	// Shift it left and ...

    830. 

  830. 						if ($ord & 128)	{	// ... and with 8th bit - if that is set, then there are still bytes in sequence.

    831. 

  831. 							$a++;	// Increase pointer...

    832. 

  832. 							$buf.=substr($str,$a,1);	// ... and add the next char.

    833. 

  833. 						} else break;

    834. 

  834. 					}

    835. 

  835. 

    836. 

  836. 					$outArr[]=$retChar?$buf:$this->utf8CharToUnumber($buf);

    837. 

  837. 				} else $outArr[]=$retChar?chr($this->noCharByteVal):$this->noCharByteVal;	// No char exists (MIDDLE of MB sequence!)

    838. 

  838. 			} else $outArr[]=$retChar?chr($ord):$ord;	// ... otherwise it's just ASCII 0-127 and one byte. Transparent

    839. 

  839. 		}

    840. 

  840. 

    841. 

  841. 		return $outArr;

    842. 

  842. 	}

    843. 

  843. 

    844. 

  844. 	/**

    845. 

  845. 	 * Converts a UNICODE number to a UTF-8 multibyte character

    846. 

  846. 	 * Algorithm based on script found at From: http://czyborra.com/utf/

    847. 

  847. 	 * Unit-tested by Kasper

    848. 

  848. 	 *

    849. 

  849. 	 * The binary representation of the character's integer value is thus simply spread across the bytes and the number of high bits set in the lead byte announces the number of bytes in the multibyte sequence:

    850. 

  850. 	 *

    851. 

  851. 	 *  bytes | bits | representation

    852. 

  852. 	 *      1 |    7 | 0vvvvvvv

    853. 

  853. 	 *      2 |   11 | 110vvvvv 10vvvvvv

    854. 

  854. 	 *      3 |   16 | 1110vvvv 10vvvvvv 10vvvvvv

    855. 

  855. 	 *      4 |   21 | 11110vvv 10vvvvvv 10vvvvvv 10vvvvvv

    856. 

  856. 	 *      5 |   26 | 111110vv 10vvvvvv 10vvvvvv 10vvvvvv 10vvvvvv

    857. 

  857. 	 *      6 |   31 | 1111110v 10vvvvvv 10vvvvvv 10vvvvvv 10vvvvvv 10vvvvvv

    858. 

  858. 	 *

    859. 

  859. 	 * @param	integer		UNICODE integer

    860. 

  860. 	 * @return	string		UTF-8 multibyte character string

    861. 

  861. 	 * @see utf8CharToUnumber()

    862. 

  862. 	 */

    863. 

  863. 	function UnumberToChar($cbyte)	{

    864. 

  864. 		$str='';

    865. 

  865. 

    866. 

  866. 		if ($cbyte < 0x80) {

    867. 

  867. 			$str.=chr($cbyte);

    868. 

  868. 		} else if ($cbyte < 0x800) {

    869. 

  869. 			$str.=chr(0xC0 | ($cbyte >> 6));

    870. 

  870. 			$str.=chr(0x80 | ($cbyte & 0x3F));

    871. 

  871. 		} else if ($cbyte < 0x10000) {

    872. 

  872. 			$str.=chr(0xE0 | ($cbyte >> 12));

    873. 

  873. 			$str.=chr(0x80 | (($cbyte >> 6) & 0x3F));

    874. 

  874. 			$str.=chr(0x80 | ($cbyte & 0x3F));

    875. 

  875. 		} else if ($cbyte < 0x200000) {

    876. 

  876. 			$str.=chr(0xF0 | ($cbyte >> 18));

    877. 

  877. 			$str.=chr(0x80 | (($cbyte >> 12) & 0x3F));

    878. 

  878. 			$str.=chr(0x80 | (($cbyte >> 6) & 0x3F));

    879. 

  879. 			$str.=chr(0x80 | ($cbyte & 0x3F));

    880. 

  880. 		} else if ($cbyte < 0x4000000) {

    881. 

  881. 			$str.=chr(0xF8 | ($cbyte >> 24));

    882. 

  882. 			$str.=chr(0x80 | (($cbyte >> 18) & 0x3F));

    883. 

  883. 			$str.=chr(0x80 | (($cbyte >> 12) & 0x3F));

    884. 

  884. 			$str.=chr(0x80 | (($cbyte >> 6) & 0x3F));

    885. 

  885. 			$str.=chr(0x80 | ($cbyte & 0x3F));

    886. 

  886. 		} else if ($cbyte < 0x80000000) {

    887. 

  887. 			$str.=chr(0xFC | ($cbyte >> 30));

    888. 

  888. 			$str.=chr(0x80 | (($cbyte >> 24) & 0x3F));

    889. 

  889. 			$str.=chr(0x80 | (($cbyte >> 18) & 0x3F));

    890. 

  890. 			$str.=chr(0x80 | (($cbyte >> 12) & 0x3F));

    891. 

  891. 			$str.=chr(0x80 | (($cbyte >> 6) & 0x3F));

    892. 

  892. 			$str.=chr(0x80 | ($cbyte & 0x3F));

    893. 

  893. 		} else { // Cannot express a 32-bit character in UTF-8

    894. 

  894. 			$str .= chr($this->noCharByteVal);

    895. 

  895. 		}

    896. 

  896. 		return $str;

    897. 

  897. 	}

    898. 

  898. 

    899. 

  899. 	/**

    900. 

  900. 	 * Converts a UTF-8 Multibyte character to a UNICODE number

    901. 

  901. 	 * Unit-tested by Kasper

    902. 

  902. 	 *

    903. 

  903. 	 * @param	string		UTF-8 multibyte character string

    904. 

  904. 	 * @param	boolean		If set, then a hex. number is returned.

    905. 

  905. 	 * @return	integer		UNICODE integer

    906. 

  906. 	 * @see UnumberToChar()

    907. 

  907. 	 */

    908. 

  908. 	function utf8CharToUnumber($str,$hex=0)	{

    909. 

  909. 		$ord=ord(substr($str,0,1));	// First char

    910. 

  910. 

    911. 

  911. 		if (($ord & 192) == 192)	{	// This verifyes that it IS a multi byte string

    912. 

  912. 			$binBuf='';

    913. 

  913. 			for ($b=0;$b<8;$b++)	{	// for each byte in multibyte string...

    914. 

  914. 				$ord = $ord << 1;	// Shift it left and ...

    915. 

  915. 				if ($ord & 128)	{	// ... and with 8th bit - if that is set, then there are still bytes in sequence.

    916. 

  916. 					$binBuf.=substr('00000000'.decbin(ord(substr($str,$b+1,1))),-6);

    917. 

  917. 				} else break;

    918. 

  918. 			}

    919. 

  919. 			$binBuf=substr('00000000'.decbin(ord(substr($str,0,1))),-(6-$b)).$binBuf;

    920. 

  920. 

    921. 

  921. 			$int = bindec($binBuf);

    922. 

  922. 		} else $int = $ord;

    923. 

  923. 

    924. 

  924. 		return $hex ? 'x'.dechex($int) : $int;

    925. 

  925. 	}

    926. 

  926. 

    927. 

  927. 

    928. 

  928. 

    929. 

  929. 

    930. 

  930. 

    931. 

  931. 

    932. 

  932. 

    933. 

  933. 

    934. 

  934. 

    935. 

  935. 	/********************************************

    936. 

  936. 	 *

    937. 

  937. 	 * Init functions

    938. 

  938. 	 *

    939. 

  939. 	 ********************************************/

    940. 

  940. 

    941. 

  941. 	/**

    942. 

  942. 	 * This will initialize a charset for use if it's defined in the PATH_t3lib.'csconvtbl/' folder

    943. 

  943. 	 * This function is automatically called by the conversion functions

    944. 

  944. 	 *

    945. 

  945. 	 * PLEASE SEE: http://www.unicode.org/Public/MAPPINGS/

    946. 

  946. 	 *

    947. 

  947. 	 * @param	string		The charset to be initialized. Use lowercase charset always (the charset must match exactly with a filename in csconvtbl/ folder ([charset].tbl)

    948. 

  948. 	 * @return	integer		Returns '1' if already loaded. Returns FALSE if charset conversion table was not found. Returns '2' if the charset conversion table was found and parsed.

    949. 

  949. 	 * @access private

    950. 

  950. 	 */

    951. 

  951. 	function initCharset($charset)	{

    952. 

  952. 			// Only process if the charset is not yet loaded:

    953. 

  953. 		if (!is_array($this->parsedCharsets[$charset]))	{

    954. 

  954. 

    955. 

  955. 				// Conversion table filename:

    956. 

  956. 			$charsetConvTableFile = PATH_t3lib.'csconvtbl/'.$charset.'.tbl';

    957. 

  957. 

    958. 

  958. 				// If the conversion table is found:

    959. 

  959. 			if ($charset && t3lib_div::validPathStr($charsetConvTableFile) && @is_file($charsetConvTableFile))	{

    960. 

  960. 					// Cache file for charsets:

    961. 

  961. 					// Caching brought parsing time for gb2312 down from 2400 ms to 150 ms. For other charsets we are talking 11 ms down to zero.

    962. 

  962. 				$cacheFile = t3lib_div::getFileAbsFileName('typo3temp/cs/charset_'.$charset.'.tbl');

    963. 

  963. 				if ($cacheFile && @is_file($cacheFile))	{

    964. 

  964. 					$this->parsedCharsets[$charset]=unserialize(t3lib_div::getUrl($cacheFile));

    965. 

  965. 				} else {

    966. 

  966. 						// Parse conversion table into lines:

    967. 

  967. 					$lines=t3lib_div::trimExplode(chr(10),t3lib_div::getUrl($charsetConvTableFile),1);

    968. 

  968. 						// Initialize the internal variable holding the conv. table:

    969. 

  969. 					$this->parsedCharsets[$charset]=array('local'=>array(),'utf8'=>array());

    970. 

  970. 						// traverse the lines:

    971. 

  971. 					$detectedType='';

    972. 

  972. 					foreach($lines as $value)	{

    973. 

  973. 						if (trim($value) && substr($value,0,1)!='#')	{	// Comment line or blanks are ignored.

    974. 

  974. 

    975. 

  975. 								// Detect type if not done yet: (Done on first real line)

    976. 

  976. 								// The "whitespaced" type is on the syntax 	"0x0A	0x000A	#LINE FEED" 	while 	"ms-token" is like 		"B9 = U+00B9 : SUPERSCRIPT ONE"

    977. 

  977. 							if (!$detectedType)		$detectedType = ereg('[[:space:]]*0x([[:alnum:]]*)[[:space:]]+0x([[:alnum:]]*)[[:space:]]+',$value) ? 'whitespaced' : 'ms-token';

    978. 

  978. 

    979. 

  979. 							if ($detectedType=='ms-token')	{

    980. 

  980. 								list($hexbyte,$utf8) = split('=|:',$value,3);

    981. 

  981. 							} elseif ($detectedType=='whitespaced')	{

    982. 

  982. 								$regA=array();

    983. 

  983. 								ereg('[[:space:]]*0x([[:alnum:]]*)[[:space:]]+0x([[:alnum:]]*)[[:space:]]+',$value,$regA);

    984. 

  984. 								$hexbyte = $regA[1];

    985. 

  985. 								$utf8 = 'U+'.$regA[2];

    986. 

  986. 							}

    987. 

  987. 							$decval = hexdec(trim($hexbyte));

    988. 

  988. 							if ($decval>127)	{

    989. 

  989. 								$utf8decval = hexdec(substr(trim($utf8),2));

    990. 

  990. 								$this->parsedCharsets[$charset]['local'][$decval]=$this->UnumberToChar($utf8decval);

    991. 

  991. 								$this->parsedCharsets[$charset]['utf8'][$this->parsedCharsets[$charset]['local'][$decval]]=$decval;

    992. 

  992. 							}

    993. 

  993. 						}

    994. 

  994. 					}

    995. 

  995. 					if ($cacheFile)	{

    996. 

  996. 						t3lib_div::writeFileToTypo3tempDir($cacheFile,serialize($this->parsedCharsets[$charset]));

    997. 

  997. 					}

    998. 

  998. 				}

    999. 

  999. 				return 2;

    1000. 

  1000. 			} else return false;

    1001. 

  1001. 		} else return 1;

    1002. 

  1002. 	}

    1003. 

  1003. 

    1004. 

  1004. 	/**

    1005. 

  1005. 	 * This function initializes all UTF-8 character data tables.

    1006. 

  1006. 	 *

    1007. 

  1007. 	 * PLEASE SEE: http://www.unicode.org/Public/UNIDATA/

    1008. 

  1008. 	 *

    1009. 

  1009. 	 * @param	string		Mode ("case", "ascii", ...)

    1010. 

  1010. 	 * @return	integer		Returns FALSE on error, a TRUE value on success: 1 table already loaded, 2, cached version, 3 table parsed (and cached).

    1011. 

  1011. 	 * @access private

    1012. 

  1012. 	 */

    1013. 

  1013. 	function initUnicodeData($mode=null)	{

    1014. 

  1014. 			// cache files

    1015. 

  1015. 		$cacheFileCase = t3lib_div::getFileAbsFileName('typo3temp/cs/cscase_utf-8.tbl');

    1016. 

  1016. 		$cacheFileASCII = t3lib_div::getFileAbsFileName('typo3temp/cs/csascii_utf-8.tbl');

    1017. 

  1017. 

    1018. 

  1018. 			// Only process if the tables are not yet loaded

    1019. 

  1019. 		switch($mode)	{

    1020. 

  1020. 			case 'case':

    1021. 

  1021. 				if (is_array($this->caseFolding['utf-8']))	return 1;

    1022. 

  1022. 

    1023. 

  1023. 					// Use cached version if possible

    1024. 

  1024. 				if ($cacheFileCase && @is_file($cacheFileCase))	{

    1025. 

  1025. 					$this->caseFolding['utf-8'] = unserialize(t3lib_div::getUrl($cacheFileCase));

    1026. 

  1026. 					return 2;

    1027. 

  1027. 				}

    1028. 

  1028. 				break;

    1029. 

  1029. 

    1030. 

  1030. 			case 'ascii':

    1031. 

  1031. 				if (is_array($this->toASCII['utf-8']))	return 1;

    1032. 

  1032. 

    1033. 

  1033. 					// Use cached version if possible

    1034. 

  1034. 				if ($cacheFileASCII && @is_file($cacheFileASCII))	{

    1035. 

  1035. 					$this->toASCII['utf-8'] = unserialize(t3lib_div::getUrl($cacheFileASCII));

    1036. 

  1036. 					return 2;

    1037. 

  1037. 				}

    1038. 

  1038. 				break;

    1039. 

  1039. 		}

    1040. 

  1040. 

    1041. 

  1041. 			// process main Unicode data file

    1042. 

  1042. 		$unicodeDataFile = PATH_t3lib.'unidata/UnicodeData.txt';

    1043. 

  1043. 		if (!(t3lib_div::validPathStr($unicodeDataFile) && @is_file($unicodeDataFile)))	return false;

    1044. 

  1044. 

    1045. 

  1045. 		$fh = fopen($unicodeDataFile,'rb');

    1046. 

  1046. 		if (!$fh)	return false;

    1047. 

  1047. 

    1048. 

  1048. 			// key = utf8 char (single codepoint), value = utf8 string (codepoint sequence)

    1049. 

  1049. 			// note: we use the UTF-8 characters here and not the Unicode numbers to avoid conversion roundtrip in utf8_strtolower/-upper)

    1050. 

  1050. 		$this->caseFolding['utf-8'] = array();

    1051. 

  1051. 		$utf8CaseFolding =& $this->caseFolding['utf-8']; // a shorthand

    1052. 

  1052. 		$utf8CaseFolding['toUpper'] = array();

    1053. 

  1053. 		$utf8CaseFolding['toLower'] = array();

    1054. 

  1054. 		$utf8CaseFolding['toTitle'] = array();

    1055. 

  1055. 

    1056. 

  1056. 		$decomposition = array();	// array of temp. decompositions

    1057. 

  1057. 		$mark = array();		// array of chars that are marks (eg. composing accents)

    1058. 

  1058. 		$number = array();		// array of chars that are numbers (eg. digits)

    1059. 

  1059. 		$omit = array();		// array of chars to be omitted (eg. Russian hard sign)

    1060. 

  1060. 

    1061. 

  1061. 		while (!feof($fh))	{

    1062. 

  1062. 			$line = fgets($fh,4096);

    1063. 

  1063. 				// has a lot of info

    1064. 

  1064. 			list($char,$name,$cat,,,$decomp,,,$num,,,,$upper,$lower,$title,) = split(';', rtrim($line));

    1065. 

  1065. 

    1066. 

  1066. 			$ord = hexdec($char);

    1067. 

  1067. 			if ($ord > 0xFFFF)	break;	// only process the BMP

    1068. 

  1068. 

    1069. 

  1069. 			$utf8_char = $this->UnumberToChar($ord);

    1070. 

  1070. 

    1071. 

  1071. 			if ($upper)	$utf8CaseFolding['toUpper'][$utf8_char] = $this->UnumberToChar(hexdec($upper));

    1072. 

  1072. 			if ($lower)	$utf8CaseFolding['toLower'][$utf8_char] = $this->UnumberToChar(hexdec($lower));

    1073. 

  1073. 				// store "title" only when different from "upper" (only a few)

    1074. 

  1074. 			if ($title && $title != $upper)	$utf8CaseFolding['toTitle'][$utf8_char] = $this->UnumberToChar(hexdec($title));

    1075. 

  1075. 

    1076. 

  1076. 			switch ($cat{0})	{

    1077. 

  1077. 				case 'M':	// mark (accent, umlaut, ...)

    1078. 

  1078. 					$mark["U+$char"] = 1;

    1079. 

  1079. 					break;

    1080. 

  1080. 

    1081. 

  1081. 				case 'N':	// numeric value

    1082. 

  1082. 					if ($ord > 0x80 && $num != '')	$number["U+$char"] = $num;

    1083. 

  1083. 			}

    1084. 

  1084. 

    1085. 

  1085. 				// accented Latin letters without "official" decomposition

    1086. 

  1086. 			$match = array();

    1087. 

  1087. 			if (ereg('^LATIN (SMALL|CAPITAL) LETTER ([A-Z]) WITH',$name,$match) && !$decomp)	{

    1088. 

  1088. 				$c = ord($match[2]);

    1089. 

  1089. 				if ($match[1] == 'SMALL')	$c += 32;

    1090. 

  1090. 

    1091. 

  1091. 				$decomposition["U+$char"] = array(dechex($c));

    1092. 

  1092. 				continue;

    1093. 

  1093. 			}

    1094. 

  1094. 

    1095. 

  1095. 			$match = array();

    1096. 

  1096. 			if (ereg('(<.*>)? *(.+)',$decomp,$match))	{

    1097. 

  1097. 				switch($match[1])	{

    1098. 

  1098. 					case '<circle>':	// add parenthesis as circle replacement, eg (1)

    1099. 

  1099. 						$match[2] = '0028 '.$match[2].' 0029';

    1100. 

  1100. 						break;

    1101. 

  1101. 

    1102. 

  1102. 					case '<square>':	// add square brackets as square replacement, eg [1]

    1103. 

  1103. 						$match[2] = '005B '.$match[2].' 005D';

    1104. 

  1104. 						break;

    1105. 

  1105. 

    1106. 

  1106. 					case '<compat>':	// ignore multi char decompositions that start with a space

    1107. 

  1107. 						if (ereg('^0020 ',$match[2]))	continue 2;

    1108. 

  1108. 						break;

    1109. 

  1109. 

    1110. 

  1110. 						// ignore Arabic and vertical layout presentation decomposition

    1111. 

  1111. 					case '<initial>':

    1112. 

  1112. 					case '<medial>':

    1113. 

  1113. 					case '<final>':

    1114. 

  1114. 					case '<isolated>':

    1115. 

  1115. 					case '<vertical>':

    1116. 

  1116. 						continue 2;

    1117. 

  1117. 				}

    1118. 

  1118. 				$decomposition["U+$char"] = split(' ',$match[2]);

    1119. 

  1119. 			}

    1120. 

  1120. 		}

    1121. 

  1121. 		fclose($fh);

    1122. 

  1122. 

    1123. 

  1123. 			// process additional Unicode data for casing (allow folded characters to expand into a sequence)

    1124. 

  1124. 		$specialCasingFile = PATH_t3lib.'unidata/SpecialCasing.txt';

    1125. 

  1125. 		if (t3lib_div::validPathStr($specialCasingFile) && @is_file($specialCasingFile))	{

    1126. 

  1126. 			$fh = fopen($specialCasingFile,'rb');

    1127. 

  1127. 			if ($fh)	{

    1128. 

  1128. 				while (!feof($fh))	{

    1129. 

  1129. 					$line = fgets($fh,4096);

    1130. 

  1130. 					if ($line{0} != '#' && trim($line) != '')	{

    1131. 

  1131. 

    1132. 

  1132. 						list($char,$lower,$title,$upper,$cond) = t3lib_div::trimExplode(';', $line);

    1133. 

  1133. 						if ($cond == '' || $cond{0} == '#')	{

    1134. 

  1134. 							$utf8_char = $this->UnumberToChar(hexdec($char));

    1135. 

  1135. 							if ($char != $lower)	{

    1136. 

  1136. 								$arr = split(' ',$lower);

    1137. 

  1137. 								for ($i=0; isset($arr[$i]); $i++)	$arr[$i] = $this->UnumberToChar(hexdec($arr[$i]));

    1138. 

  1138. 								$utf8CaseFolding['toLower'][$utf8_char] = implode('',$arr);

    1139. 

  1139. 							}

    1140. 

  1140. 							if ($char != $title && $title != $upper)	{

    1141. 

  1141. 								$arr = split(' ',$title);

    1142. 

  1142. 								for ($i=0; isset($arr[$i]); $i++)	$arr[$i] = $this->UnumberToChar(hexdec($arr[$i]));

    1143. 

  1143. 								$utf8CaseFolding['toTitle'][$utf8_char] = implode('',$arr);

    1144. 

  1144. 							}

    1145. 

  1145. 							if ($char != $upper)	{

    1146. 

  1146. 									$arr = split(' ',$upper);

    1147. 

  1147. 								for ($i=0; isset($arr[$i]); $i++)	$arr[$i] = $this->UnumberToChar(hexdec($arr[$i]));

    1148. 

  1148. 								$utf8CaseFolding['toUpper'][$utf8_char] = implode('',$arr);

    1149. 

  1149. 							}

    1150. 

  1150. 						}

    1151. 

  1151. 					}

    1152. 

  1152. 				}

    1153. 

  1153. 				fclose($fh);

    1154. 

  1154. 			}

    1155. 

  1155. 		}

    1156. 

  1156. 

    1157. 

  1157. 			// process custom decompositions

    1158. 

  1158. 		$customTranslitFile = PATH_t3lib.'unidata/Translit.txt';

    1159. 

  1159. 		if (t3lib_div::validPathStr($customTranslitFile) && @is_file($customTranslitFile))	{

    1160. 

  1160. 			$fh = fopen($customTranslitFile,'rb');

    1161. 

  1161. 			if ($fh)	{

    1162. 

  1162. 				while (!feof($fh))	{

    1163. 

  1163. 					$line = fgets($fh,4096);

    1164. 

  1164. 					if ($line{0} != '#' && trim($line) != '')	{

    1165. 

  1165. 						list($char,$translit) = t3lib_div::trimExplode(';', $line);

    1166. 

  1166. 						if (!$translit)	$omit["U+$char"] = 1;

    1167. 

  1167. 						$decomposition["U+$char"] = split(' ', $translit);

    1168. 

  1168. 

    1169. 

  1169. 					}

    1170. 

  1170. 				}

    1171. 

  1171. 				fclose($fh);

    1172. 

  1172. 			}

    1173. 

  1173. 		}

    1174. 

  1174. 

    1175. 

  1175. 			// decompose and remove marks; inspired by unac (Loic Dachary <loic@senga.org>)

    1176. 

  1176. 		foreach($decomposition as $from => $to)	{

    1177. 

  1177. 			$code_decomp = array();

    1178. 

  1178. 

    1179. 

  1179. 			while ($code_value = array_shift($to))	{

    1180. 

  1180. 				if (isset($decomposition["U+$code_value"]))	{	// do recursive decomposition

    1181. 

  1181. 					foreach(array_reverse($decomposition["U+$code_value"]) as $cv)	{

    1182. 

  1182. 						array_unshift($to, $cv);

    1183. 

  1183. 					}

    1184. 

  1184. 				} elseif (!isset($mark["U+$code_value"])) {	// remove mark

    1185. 

  1185. 					array_push($code_decomp, $code_value);

    1186. 

  1186. 				}

    1187. 

  1187. 			}

    1188. 

  1188. 			if (count($code_decomp) || isset($omit[$from]))	{

    1189. 

  1189. 				$decomposition[$from] = $code_decomp;

    1190. 

  1190. 			} else {

    1191. 

  1191. 				unset($decomposition[$from]);

    1192. 

  1192. 			}

    1193. 

  1193. 		}

    1194. 

  1194. 

    1195. 

  1195. 			// create ascii only mapping

    1196. 

  1196. 		$this->toASCII['utf-8'] = array();

    1197. 

  1197. 		$ascii =& $this->toASCII['utf-8'];

    1198. 

  1198. 

    1199. 

  1199. 		foreach($decomposition as $from => $to)	{

    1200. 

  1200. 			$code_decomp = array();

    1201. 

  1201. 			while ($code_value = array_shift($to))	{

    1202. 

  1202. 				$ord = hexdec($code_value);

    1203. 

  1203. 				if ($ord > 127)

    1204. 

  1204. 					continue 2;	// skip decompositions containing non-ASCII chars

    1205. 

  1205. 				else

    1206. 

  1206. 					array_push($code_decomp,chr($ord));

    1207. 

  1207. 			}

    1208. 

  1208. 			$ascii[$this->UnumberToChar(hexdec($from))] = join('',$code_decomp);

    1209. 

  1209. 		}

    1210. 

  1210. 

    1211. 

  1211. 			// add numeric decompositions

    1212. 

  1212. 		foreach($number as $from => $to)	{

    1213. 

  1213. 			$utf8_char = $this->UnumberToChar(hexdec($from));

    1214. 

  1214. 			if (!isset($ascii[$utf8_char]))	{

    1215. 

  1215. 				$ascii[$utf8_char] = $to;

    1216. 

  1216. 			}

    1217. 

  1217. 		}

    1218. 

  1218. 

    1219. 

  1219. 		if ($cacheFileCase)	{

    1220. 

  1220. 				t3lib_div::writeFileToTypo3tempDir($cacheFileCase,serialize($utf8CaseFolding));

    1221. 

  1221. 		}

    1222. 

  1222. 

    1223. 

  1223. 		if ($cacheFileASCII)	{

    1224. 

  1224. 				t3lib_div::writeFileToTypo3tempDir($cacheFileASCII,serialize($ascii));

    1225. 

  1225. 		}

    1226. 

  1226. 

    1227. 

  1227. 		return 3;

    1228. 

  1228. 	}

    1229. 

  1229. 

    1230. 

  1230. 	/**

    1231. 

  1231. 	 * This function initializes the folding table for a charset other than UTF-8.

    1232. 

  1232. 	 * This function is automatically called by the case folding functions.

    1233. 

  1233. 	 *

    1234. 

  1234. 	 * @param	string		Charset for which to initialize case folding.

    1235. 

  1235. 	 * @return	integer		Returns FALSE on error, a TRUE value on success: 1 table already loaded, 2, cached version, 3 table parsed (and cached).

    1236. 

  1236. 	 * @access private

    1237. 

  1237. 	 */

    1238. 

  1238. 	function initCaseFolding($charset)	{

    1239. 

  1239. 			// Only process if the case table is not yet loaded:

    1240. 

  1240. 		if (is_array($this->caseFolding[$charset]))	return 1;

    1241. 

  1241. 

    1242. 

  1242. 			// Use cached version if possible

    1243. 

  1243. 		$cacheFile = t3lib_div::getFileAbsFileName('typo3temp/cs/cscase_'.$charset.'.tbl');

    1244. 

  1244. 		if ($cacheFile && @is_file($cacheFile))	{

    1245. 

  1245. 			$this->caseFolding[$charset] = unserialize(t3lib_div::getUrl($cacheFile));

    1246. 

  1246. 			return 2;

    1247. 

  1247. 		}

    1248. 

  1248. 

    1249. 

  1249. 			// init UTF-8 conversion for this charset

    1250. 

  1250. 		if (!$this->initCharset($charset))	{

    1251. 

  1251. 			return false;

    1252. 

  1252. 		}

    1253. 

  1253. 

    1254. 

  1254. 			// UTF-8 case folding is used as the base conversion table

    1255. 

  1255. 		if (!$this->initUnicodeData('case'))	{

    1256. 

  1256. 			return false;

    1257. 

  1257. 		}

    1258. 

  1258. 

    1259. 

  1259. 		$nochar = chr($this->noCharByteVal);

    1260. 

  1260. 		foreach ($this->parsedCharsets[$charset]['local'] as $ci => $utf8)	{

    1261. 

  1261. 				// reconvert to charset (don't use chr() of numeric value, might be muli-byte)

    1262. 

  1262. 			$c = $this->utf8_decode($utf8, $charset);

    1263. 

  1263. 

    1264. 

  1264. 				// $cc = $this->conv($this->caseFolding['utf-8']['toUpper'][$utf8], 'utf-8', $charset);

    1265. 

  1265. 			$cc = $this->utf8_decode($this->caseFolding['utf-8']['toUpper'][$utf8], $charset);

    1266. 

  1266. 			if ($cc != '' && $cc != $nochar)	$this->caseFolding[$charset]['toUpper'][$c] = $cc;

    1267. 

  1267. 

    1268. 

  1268. 				// $cc = $this->conv($this->caseFolding['utf-8']['toLower'][$utf8], 'utf-8', $charset);

    1269. 

  1269. 			$cc = $this->utf8_decode($this->caseFolding['utf-8']['toLower'][$utf8], $charset);

    1270. 

  1270. 			if ($cc != '' && $cc != $nochar)	$this->caseFolding[$charset]['toLower'][$c] = $cc;

    1271. 

  1271. 

    1272. 

  1272. 				// $cc = $this->conv($this->caseFolding['utf-8']['toTitle'][$utf8], 'utf-8', $charset);

    1273. 

  1273. 			$cc = $this->utf8_decode($this->caseFolding['utf-8']['toTitle'][$utf8], $charset);

    1274. 

  1274. 			if ($cc != '' && $cc != $nochar)	$this->caseFolding[$charset]['toTitle'][$c] = $cc;

    1275. 

  1275. 		}

    1276. 

  1276. 

    1277. 

  1277. 			// add the ASCII case table

    1278. 

  1278. 		for ($i=ord('a'); $i<=ord('z'); $i++)	{

    1279. 

  1279. 			$this->caseFolding[$charset]['toUpper'][chr($i)] = chr($i-32);

    1280. 

  1280. 		}

    1281. 

  1281. 		for ($i=ord('A'); $i<=ord('Z'); $i++)	{

    1282. 

  1282. 			$this->caseFolding[$charset]['toLower'][chr($i)] = chr($i+32);

    1283. 

  1283. 		}

    1284. 

  1284. 

    1285. 

  1285. 		if ($cacheFile)	{

    1286. 

  1286. 				t3lib_div::writeFileToTypo3tempDir($cacheFile,serialize($this->caseFolding[$charset]));

    1287. 

  1287. 		}

    1288. 

  1288. 

    1289. 

  1289. 		return 3;

    1290. 

  1290. 	}

    1291. 

  1291. 

    1292. 

  1292. 	/**

    1293. 

  1293. 	 * This function initializes the to-ASCII conversion table for a charset other than UTF-8.

    1294. 

  1294. 	 * This function is automatically called by the ASCII transliteration functions.

    1295. 

  1295. 	 *

    1296. 

  1296. 	 * @param	string		Charset for which to initialize conversion.

    1297. 

  1297. 	 * @return	integer		Returns FALSE on error, a TRUE value on success: 1 table already loaded, 2, cached version, 3 table parsed (and cached).

    1298. 

  1298. 	 * @access private

    1299. 

  1299. 	 */

    1300. 

  1300. 	function initToASCII($charset)	{

    1301. 

  1301. 			// Only process if the case table is not yet loaded:

    1302. 

  1302. 		if (is_array($this->toASCII[$charset]))	return 1;

    1303. 

  1303. 

    1304. 

  1304. 			// Use cached version if possible

    1305. 

  1305. 		$cacheFile = t3lib_div::getFileAbsFileName('typo3temp/cs/csascii_'.$charset.'.tbl');

    1306. 

  1306. 		if ($cacheFile && @is_file($cacheFile))	{

    1307. 

  1307. 			$this->toASCII[$charset] = unserialize(t3lib_div::getUrl($cacheFile));

    1308. 

  1308. 			return 2;

    1309. 

  1309. 		}

    1310. 

  1310. 

    1311. 

  1311. 			// init UTF-8 conversion for this charset

    1312. 

  1312. 		if (!$this->initCharset($charset))	{

    1313. 

  1313. 			return false;

    1314. 

  1314. 		}

    1315. 

  1315. 

    1316. 

  1316. 			// UTF-8/ASCII transliteration is used as the base conversion table

    1317. 

  1317. 		if (!$this->initUnicodeData('ascii'))	{

    1318. 

  1318. 			return false;

    1319. 

  1319. 		}

    1320. 

  1320. 

    1321. 

  1321. 		$nochar = chr($this->noCharByteVal);

    1322. 

  1322. 		foreach ($this->parsedCharsets[$charset]['local'] as $ci => $utf8)	{

    1323. 

  1323. 				// reconvert to charset (don't use chr() of numeric value, might be muli-byte)

    1324. 

  1324. 			$c = $this->utf8_decode($utf8, $charset);

    1325. 

  1325. 

    1326. 

  1326. 			if (isset($this->toASCII['utf-8'][$utf8]))	{

    1327. 

  1327. 				$this->toASCII[$charset][$c] = $this->toASCII['utf-8'][$utf8];

    1328. 

  1328. 			}

    1329. 

  1329. 		}

    1330. 

  1330. 

    1331. 

  1331. 		if ($cacheFile)	{

    1332. 

  1332. 				t3lib_div::writeFileToTypo3tempDir($cacheFile,serialize($this->toASCII[$charset]));

    1333. 

  1333. 		}

    1334. 

  1334. 

    1335. 

  1335. 		return 3;

    1336. 

  1336. 	}

    1337. 

  1337. 

    1338. 

  1338. 

    1339. 

  1339. 

    1340. 

  1340. 

    1341. 

  1341. 

    1342. 

  1342. 

    1343. 

  1343. 

    1344. 

  1344. 

    1345. 

  1345. 

    1346. 

  1346. 

    1347. 

  1347. 

    1348. 

  1348. 

    1349. 

  1349. 

    1350. 

  1350. 

    1351. 

  1351. 

    1352. 

  1352. 

    1353. 

  1353. 	/********************************************

    1354. 

  1354. 	 *

    1355. 

  1355. 	 * String operation functions

    1356. 

  1356. 	 *

    1357. 

  1357. 	 ********************************************/

    1358. 

  1358. 

    1359. 

  1359. 	/**

    1360. 

  1360. 	 * Returns a part of a string.

    1361. 

  1361. 	 * Unit-tested by Kasper (single byte charsets only)

    1362. 

  1362. 	 *

    1363. 

  1363. 	 * @param	string		The character set

    1364. 

  1364. 	 * @param	string		Character string

    1365. 

  1365. 	 * @param	integer		Start position (character position)

    1366. 

  1366. 	 * @param	integer		Length (in characters)

    1367. 

  1367. 	 * @return	string		The substring

    1368. 

  1368. 	 * @see substr(), mb_substr()

    1369. 

  1369. 	 * @author	Martin Kutschker <martin.t.kutschker@blackbox.net>

    1370. 

  1370. 	 */

    1371. 

  1371. 	function substr($charset,$string,$start,$len=null)	{

    1372. 

  1372. 		if ($len===0)	return '';

    1373. 

  1373. 

    1374. 

  1374. 		if ($GLOBALS['TYPO3_CONF_VARS']['SYS']['t3lib_cs_utils'] == 'mbstring')	{

    1375. 

  1375. 				// cannot omit $len, when specifying charset

    1376. 

  1376. 			if ($len==null)	{

    1377. 

  1377. 				$enc = mb_internal_encoding();	// save internal encoding

    1378. 

  1378. 				mb_internal_encoding($charset);

    1379. 

  1379. 				$str = mb_substr($string,$start);

    1380. 

  1380. 				mb_internal_encoding($enc);	// restore internal encoding

    1381. 

  1381. 

    1382. 

  1382. 				return $str;

    1383. 

  1383. 			}

    1384. 

  1384. 			else {

    1385. 

  1385. 				return mb_substr($string,$start,$len,$charset);

    1386. 

  1386. 			}

    1387. 

  1387. 		} elseif ($GLOBALS['TYPO3_CONF_VARS']['SYS']['t3lib_cs_utils'] == 'iconv')	{

    1388. 

  1388. 				// cannot omit $len, when specifying charset

    1389. 

  1389. 			if ($len==null)	{

    1390. 

  1390. 				$enc = iconv_get_encoding('internal_encoding');	// save internal encoding

    1391. 

  1391. 				iconv_set_encoding('internal_encoding',$charset);

    1392. 

  1392. 				$str = iconv_substr($string,$start);

    1393. 

  1393. 				iconv_set_encoding('internal_encoding',$enc);	// restore internal encoding

    1394. 

  1394. 

    1395. 

  1395. 				return $str;

    1396. 

  1396. 			}

    1397. 

  1397. 			else {

    1398. 

  1398. 				return iconv_substr($string,$start,$len,$charset);

    1399. 

  1399. 			}

    1400. 

  1400. 		} elseif ($charset == 'utf-8')	{

    1401. 

  1401. 			return $this->utf8_substr($string,$start,$len);

    1402. 

  1402. 		} elseif ($this->eucBasedSets[$charset])	{

    1403. 

  1403. 			return $this->euc_substr($string,$start,$charset,$len);

    1404. 

  1404. 		} elseif ($this->twoByteSets[$charset])	{

    1405. 

  1405. 			return substr($string,$start*2,$len*2);

    1406. 

  1406. 		} elseif ($this->fourByteSets[$charset])	{

    1407. 

  1407. 			return substr($string,$start*4,$len*4);

    1408. 

  1408. 		}

    1409. 

  1409. 

    1410. 

  1410. 		// treat everything else as single-byte encoding

    1411. 

  1411. 		return $len === NULL ? substr($string,$start) : substr($string,$start,…
    1412.

Large files files are truncated, but you can click here to view the full file