PageRenderTime 32ms CodeModel.GetById 15ms RepoModel.GetById 0ms app.codeStats 1ms

/lib/typo3/class.t3lib_cs.php

https://bitbucket.org/synergylearning/campusconnect
PHP | 2367 lines | 1573 code | 218 blank | 576 comment | 376 complexity | 87eb15c41b0d2fb4a78985187ca298ea MD5 | raw file
Possible License(s): MPL-2.0-no-copyleft-exception, LGPL-3.0, GPL-3.0, LGPL-2.1, Apache-2.0, BSD-3-Clause, AGPL-3.0 
    

  1. <?php
    2. 

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

  3.  *  Copyright notice
    4. 

  4.  *
    5. 

  5.  *  (c) 2003-2011 Kasper Skårhøj (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.  * @author	Kasper Skårhøj <kasperYYYY@typo3.com>
    28. 

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

  29.  */
    30. 

  30. 

  31. 

  32. /**
    33. 

  33.  * Notes on UTF-8
    34. 

  34.  *
    35. 

  35.  * Functions working on UTF-8 strings:
    36. 

  36.  *
    37. 

  37.  * - strchr/strstr
    38. 

  38.  * - strrchr
    39. 

  39.  * - substr_count
    40. 

  40.  * - implode/explode/join
    41. 

  41.  *
    42. 

  42.  * Functions nearly working on UTF-8 strings:
    43. 

  43.  *
    44. 

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

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

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

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

  48.  * - preg_*: Support compiled into PHP by default nowadays, but could be unavailable, need to use modifier
    49. 

  49.  *
    50. 

  50.  * Functions NOT working on UTF-8 strings:
    51. 

  51.  *
    52. 

  52.  * - str*cmp
    53. 

  53.  * - stristr
    54. 

  54.  * - stripos
    55. 

  55.  * - substr
    56. 

  56.  * - strrev
    57. 

  57.  * - split/spliti
    58. 

  58.  * - ...
    59. 

  59.  *
    60. 

  60.  */
    61. 

  61. /**
    62. 

  62.  * Class for conversion between charsets
    63. 

  63.  *
    64. 

  64.  * @author	Kasper Skårhøj <kasperYYYY@typo3.com>
    65. 

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

  66.  * @package TYPO3
    67. 

  67.  * @subpackage t3lib
    68. 

  68.  */
    69. 

  69. class t3lib_cs {
    70. 

  70. 

  71. 	/**
    72. 

  72. 	 * @var t3lib_l10n_Locales
    73. 

  73. 	 */
    74. 

  74. 	protected $locales;
    75. 

  75. 

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

  77. 

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

  79. 	var $parsedCharsets = array();
    80. 

  80. 

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

  82. 	var $caseFolding = array();
    83. 

  83. 

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

  85. 	var $toASCII = array();
    86. 

  86. 

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

  88. 	var $twoByteSets = array(
    89. 

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

  90. 	);
    91. 

  91. 

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

  93. 	var $fourByteSets = array(
    94. 

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

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

  96. 	);
    97. 

  97. 

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

  99. 	var $eucBasedSets = array(
    100. 

  100. 		'gb2312' => 1, // Chinese, simplified.
    101. 

  101. 		'big5' => 1, // Chinese, traditional.
    102. 

  102. 		'euc-kr' => 1, // Korean
    103. 

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

  104. 	);
    105. 

  105. 

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

  107. 		// http://czyborra.com/charsets/iso8859.html
    108. 

  108. 	var $synonyms = array(
    109. 

  109. 		'us' => 'ascii',
    110. 

  110. 		'us-ascii' => 'ascii',
    111. 

  111. 		'cp819' => 'iso-8859-1',
    112. 

  112. 		'ibm819' => 'iso-8859-1',
    113. 

  113. 		'iso-ir-100' => 'iso-8859-1',
    114. 

  114. 		'iso-ir-101' => 'iso-8859-2',
    115. 

  115. 		'iso-ir-109' => 'iso-8859-3',
    116. 

  116. 		'iso-ir-110' => 'iso-8859-4',
    117. 

  117. 		'iso-ir-144' => 'iso-8859-5',
    118. 

  118. 		'iso-ir-127' => 'iso-8859-6',
    119. 

  119. 		'iso-ir-126' => 'iso-8859-7',
    120. 

  120. 		'iso-ir-138' => 'iso-8859-8',
    121. 

  121. 		'iso-ir-148' => 'iso-8859-9',
    122. 

  122. 		'iso-ir-157' => 'iso-8859-10',
    123. 

  123. 		'iso-ir-179' => 'iso-8859-13',
    124. 

  124. 		'iso-ir-199' => 'iso-8859-14',
    125. 

  125. 		'iso-ir-203' => 'iso-8859-15',
    126. 

  126. 		'csisolatin1' => 'iso-8859-1',
    127. 

  127. 		'csisolatin2' => 'iso-8859-2',
    128. 

  128. 		'csisolatin3' => 'iso-8859-3',
    129. 

  129. 		'csisolatin5' => 'iso-8859-9',
    130. 

  130. 		'csisolatin8' => 'iso-8859-14',
    131. 

  131. 		'csisolatin9' => 'iso-8859-15',
    132. 

  132. 		'csisolatingreek' => 'iso-8859-7',
    133. 

  133. 		'iso-celtic' => 'iso-8859-14',
    134. 

  134. 		'latin1' => 'iso-8859-1',
    135. 

  135. 		'latin2' => 'iso-8859-2',
    136. 

  136. 		'latin3' => 'iso-8859-3',
    137. 

  137. 		'latin5' => 'iso-8859-9',
    138. 

  138. 		'latin6' => 'iso-8859-10',
    139. 

  139. 		'latin8' => 'iso-8859-14',
    140. 

  140. 		'latin9' => 'iso-8859-15',
    141. 

  141. 		'l1' => 'iso-8859-1',
    142. 

  142. 		'l2' => 'iso-8859-2',
    143. 

  143. 		'l3' => 'iso-8859-3',
    144. 

  144. 		'l5' => 'iso-8859-9',
    145. 

  145. 		'l6' => 'iso-8859-10',
    146. 

  146. 		'l8' => 'iso-8859-14',
    147. 

  147. 		'l9' => 'iso-8859-15',
    148. 

  148. 		'cyrillic' => 'iso-8859-5',
    149. 

  149. 		'arabic' => 'iso-8859-6',
    150. 

  150. 		'tis-620' => 'iso-8859-11',
    151. 

  151. 		'win874' => 'windows-874',
    152. 

  152. 		'win1250' => 'windows-1250',
    153. 

  153. 		'win1251' => 'windows-1251',
    154. 

  154. 		'win1252' => 'windows-1252',
    155. 

  155. 		'win1253' => 'windows-1253',
    156. 

  156. 		'win1254' => 'windows-1254',
    157. 

  157. 		'win1255' => 'windows-1255',
    158. 

  158. 		'win1256' => 'windows-1256',
    159. 

  159. 		'win1257' => 'windows-1257',
    160. 

  160. 		'win1258' => 'windows-1258',
    161. 

  161. 		'cp1250' => 'windows-1250',
    162. 

  162. 		'cp1251' => 'windows-1251',
    163. 

  163. 		'cp1252' => 'windows-1252',
    164. 

  164. 		'ms-ee' => 'windows-1250',
    165. 

  165. 		'ms-ansi' => 'windows-1252',
    166. 

  166. 		'ms-greek' => 'windows-1253',
    167. 

  167. 		'ms-turk' => 'windows-1254',
    168. 

  168. 		'winbaltrim' => 'windows-1257',
    169. 

  169. 		'koi-8ru' => 'koi-8r',
    170. 

  170. 		'koi8r' => 'koi-8r',
    171. 

  171. 		'cp878' => 'koi-8r',
    172. 

  172. 		'mac' => 'macroman',
    173. 

  173. 		'macintosh' => 'macroman',
    174. 

  174. 		'euc-cn' => 'gb2312',
    175. 

  175. 		'x-euc-cn' => 'gb2312',
    176. 

  176. 		'euccn' => 'gb2312',
    177. 

  177. 		'cp936' => 'gb2312',
    178. 

  178. 		'big-5' => 'big5',
    179. 

  179. 		'cp950' => 'big5',
    180. 

  180. 		'eucjp' => 'euc-jp',
    181. 

  181. 		'sjis' => 'shift_jis',
    182. 

  182. 		'shift-jis' => 'shift_jis',
    183. 

  183. 		'cp932' => 'shift_jis',
    184. 

  184. 		'cp949' => 'euc-kr',
    185. 

  185. 		'utf7' => 'utf-7',
    186. 

  186. 		'utf8' => 'utf-8',
    187. 

  187. 		'utf16' => 'utf-16',
    188. 

  188. 		'utf32' => 'utf-32',
    189. 

  189. 		'utf8' => 'utf-8',
    190. 

  190. 		'ucs2' => 'ucs-2',
    191. 

  191. 		'ucs4' => 'ucs-4',
    192. 

  192. 	);
    193. 

  193. 

  194. 		// mapping of iso-639-1 language codes to script names
    195. 

  195. 	var $lang_to_script = array(
    196. 

  196. 			// iso-639-1 language codes, see http://www.loc.gov/standards/iso639-2/php/code_list.php
    197. 

  197. 		'af' => 'west_european', //Afrikaans
    198. 

  198. 		'ar' => 'arabic',
    199. 

  199. 		'bg' => 'cyrillic', // Bulgarian
    200. 

  200. 		'bs' => 'east_european', // Bosnian
    201. 

  201. 		'cs' => 'east_european', // Czech
    202. 

  202. 		'da' => 'west_european', // Danish
    203. 

  203. 		'de' => 'west_european', // German
    204. 

  204. 		'es' => 'west_european', // Spanish
    205. 

  205. 		'et' => 'estonian',
    206. 

  206. 		'eo' => 'unicode', // Esperanto
    207. 

  207. 		'eu' => 'west_european', // Basque
    208. 

  208. 		'fa' => 'arabic', // Persian
    209. 

  209. 		'fi' => 'west_european', // Finish
    210. 

  210. 		'fo' => 'west_european', // Faroese
    211. 

  211. 		'fr' => 'west_european', // French
    212. 

  212. 		'ga' => 'west_european', // Irish
    213. 

  213. 		'gl' => 'west_european', // Galician
    214. 

  214. 		'gr' => 'greek',
    215. 

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

  216. 		'hi' => 'unicode', // Hindi
    217. 

  217. 		'hr' => 'east_european', // Croatian
    218. 

  218. 		'hu' => 'east_european', // Hungarian
    219. 

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

  220. 		'is' => 'west_european', // Icelandic
    221. 

  221. 		'it' => 'west_european', // Italian
    222. 

  222. 		'ja' => 'japanese',
    223. 

  223. 		'ka' => 'unicode', // Georgian
    224. 

  224. 		'kl' => 'west_european', // Greenlandic
    225. 

  225. 		'km' => 'unicode', // Khmer
    226. 

  226. 		'ko' => 'korean',
    227. 

  227. 		'lt' => 'lithuanian',
    228. 

  228. 		'lv' => 'west_european', // Latvian/Lettish
    229. 

  229. 		'nl' => 'west_european', // Dutch
    230. 

  230. 		'no' => 'west_european', // Norwegian
    231. 

  231. 		'nb' => 'west_european', // Norwegian Bokmal
    232. 

  232. 		'nn' => 'west_european', // Norwegian Nynorsk
    233. 

  233. 		'pl' => 'east_european', // Polish
    234. 

  234. 		'pt' => 'west_european', // Portuguese
    235. 

  235. 		'ro' => 'east_european', // Romanian
    236. 

  236. 		'ru' => 'cyrillic', // Russian
    237. 

  237. 		'sk' => 'east_european', // Slovak
    238. 

  238. 		'sl' => 'east_european', // Slovenian
    239. 

  239. 		'sr' => 'cyrillic', // Serbian
    240. 

  240. 		'sv' => 'west_european', // Swedish
    241. 

  241. 		'sq' => 'albanian', // Albanian
    242. 

  242. 		'th' => 'thai',
    243. 

  243. 		'uk' => 'cyrillic', // Ukranian
    244. 

  244. 		'vi' => 'vietnamese',
    245. 

  245. 		'zh' => 'chinese',
    246. 

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

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

  248. 		'afk'=> 'west_european', // Afrikaans
    249. 

  249. 		'ara' => 'arabic',
    250. 

  250. 		'bgr' => 'cyrillic', // Bulgarian
    251. 

  251. 		'cat' => 'west_european', // Catalan
    252. 

  252. 		'chs' => 'simpl_chinese',
    253. 

  253. 		'cht' => 'trad_chinese',
    254. 

  254. 		'csy' => 'east_european', // Czech
    255. 

  255. 		'dan' => 'west_european', // Danisch
    256. 

  256. 		'deu' => 'west_european', // German
    257. 

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

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

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

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

  261. 		'eng' => 'west_european', // English
    262. 

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

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

  264. 		'euq' => 'west_european', // Basque
    265. 

  265. 		'fos' => 'west_european', // Faroese
    266. 

  266. 		'far' => 'arabic', // Persian
    267. 

  267. 		'fin' => 'west_european', // Finish
    268. 

  268. 		'fra' => 'west_european', // French
    269. 

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

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

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

  272. 		'geo' => 'unicode', // Georgian
    273. 

  273. 		'glg' => 'west_european', // Galician
    274. 

  274. 		'ell' => 'greek',
    275. 

  275. 		'heb' => 'hebrew',
    276. 

  276. 		'hin' => 'unicode', // Hindi
    277. 

  277. 		'hun' => 'east_european', // Hungarian
    278. 

  278. 		'isl' => 'west_euorpean', // Icelandic
    279. 

  279. 		'ita' => 'west_european', // Italian
    280. 

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

  281. 		'jpn' => 'japanese',
    282. 

  282. 		'khm' => 'unicode', // Khmer
    283. 

  283. 		'kor' => 'korean',
    284. 

  284. 		'lth' => 'lithuanian',
    285. 

  285. 		'lvi' => 'west_european', // Latvian/Lettish
    286. 

  286. 		'msl' => 'west_european', // Malay
    287. 

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

  288. 		'nld' => 'west_european', // Dutch
    289. 

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

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

  291. 		'plk' => 'east_european', // Polish
    292. 

  292. 		'ptg' => 'west_european', // Portuguese
    293. 

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

  294. 		'rom' => 'east_european', // Romanian
    295. 

  295. 		'rus' => 'cyrillic', // Russian
    296. 

  296. 		'slv' => 'east_european', // Slovenian
    297. 

  297. 		'sky' => 'east_european', // Slovak
    298. 

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

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

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

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

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

  303. 		'sve' => 'west_european', // Swedish
    304. 

  304. 		'sqi' => 'albanian', // Albanian
    305. 

  305. 		'tha' => 'thai',
    306. 

  306. 		'trk' => 'turkish',
    307. 

  307. 		'ukr' => 'cyrillic', // Ukrainian
    308. 

  308. 			// English language names
    309. 

  309. 		'afrikaans' => 'west_european',
    310. 

  310. 		'albanian' => 'albanian',
    311. 

  311. 		'arabic' => 'arabic',
    312. 

  312. 		'basque' => 'west_european',
    313. 

  313. 		'bosnian' => 'east_european',
    314. 

  314. 		'bulgarian' => 'east_european',
    315. 

  315. 		'catalan' => 'west_european',
    316. 

  316. 		'croatian' => 'east_european',
    317. 

  317. 		'czech' => 'east_european',
    318. 

  318. 		'danish' => 'west_european',
    319. 

  319. 		'dutch' => 'west_european',
    320. 

  320. 		'english' => 'west_european',
    321. 

  321. 		'esperanto' => 'unicode',
    322. 

  322. 		'estonian' => 'estonian',
    323. 

  323. 		'faroese' => 'west_european',
    324. 

  324. 		'farsi' => 'arabic',
    325. 

  325. 		'finnish' => 'west_european',
    326. 

  326. 		'french' => 'west_european',
    327. 

  327. 		'galician' => 'west_european',
    328. 

  328. 		'georgian' => 'unicode',
    329. 

  329. 		'german' => 'west_european',
    330. 

  330. 		'greek' => 'greek',
    331. 

  331. 		'greenlandic' => 'west_european',
    332. 

  332. 		'hebrew' => 'hebrew',
    333. 

  333. 		'hindi' => 'unicode',
    334. 

  334. 		'hungarian' => 'east_european',
    335. 

  335. 		'icelandic' => 'west_european',
    336. 

  336. 		'italian' => 'west_european',
    337. 

  337. 		'khmer' => 'unicode',
    338. 

  338. 		'latvian' => 'west_european',
    339. 

  339. 		'lettish' => 'west_european',
    340. 

  340. 		'lithuanian' => 'lithuanian',
    341. 

  341. 		'malay' => 'west_european',
    342. 

  342. 		'norwegian' => 'west_european',
    343. 

  343. 		'persian' => 'arabic',
    344. 

  344. 		'polish' => 'east_european',
    345. 

  345. 		'portuguese' => 'west_european',
    346. 

  346. 		'russian' => 'cyrillic',
    347. 

  347. 		'romanian' => 'east_european',
    348. 

  348. 		'serbian' => 'cyrillic',
    349. 

  349. 		'slovak' => 'east_european',
    350. 

  350. 		'slovenian' => 'east_european',
    351. 

  351. 		'spanish' => 'west_european',
    352. 

  352. 		'svedish' => 'west_european',
    353. 

  353. 		'that' => 'thai',
    354. 

  354. 		'turkish' => 'turkish',
    355. 

  355. 		'ukrainian' => 'cyrillic',
    356. 

  356. 	);
    357. 

  357. 

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

  359. 	var $script_to_charset_unix = array(
    360. 

  360. 		'west_european' => 'iso-8859-1',
    361. 

  361. 		'estonian' => 'iso-8859-1',
    362. 

  362. 		'east_european' => 'iso-8859-2',
    363. 

  363. 		'baltic' => 'iso-8859-4',
    364. 

  364. 		'cyrillic' => 'iso-8859-5',
    365. 

  365. 		'arabic' => 'iso-8859-6',
    366. 

  366. 		'greek' => 'iso-8859-7',
    367. 

  367. 		'hebrew' => 'iso-8859-8',
    368. 

  368. 		'turkish' => 'iso-8859-9',
    369. 

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

  370. 		'lithuanian' => 'iso-8859-13',
    371. 

  371. 		'chinese' => 'gb2312', // = euc-cn
    372. 

  372. 		'japanese' => 'euc-jp',
    373. 

  373. 		'korean' => 'euc-kr',
    374. 

  374. 		'simpl_chinese' => 'gb2312',
    375. 

  375. 		'trad_chinese' => 'big5',
    376. 

  376. 		'vietnamese' => '',
    377. 

  377. 		'unicode' => 'utf-8',
    378. 

  378. 		'albanian' => 'utf-8'
    379. 

  379. 	);
    380. 

  380. 

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

  382. 	var $script_to_charset_windows = array(
    383. 

  383. 		'east_european' => 'windows-1250',
    384. 

  384. 		'cyrillic' => 'windows-1251',
    385. 

  385. 		'west_european' => 'windows-1252',
    386. 

  386. 		'greek' => 'windows-1253',
    387. 

  387. 		'turkish' => 'windows-1254',
    388. 

  388. 		'hebrew' => 'windows-1255',
    389. 

  389. 		'arabic' => 'windows-1256',
    390. 

  390. 		'baltic' => 'windows-1257',
    391. 

  391. 		'estonian' => 'windows-1257',
    392. 

  392. 		'lithuanian' => 'windows-1257',
    393. 

  393. 		'vietnamese' => 'windows-1258',
    394. 

  394. 		'thai' => 'cp874',
    395. 

  395. 		'korean' => 'cp949',
    396. 

  396. 		'chinese' => 'gb2312',
    397. 

  397. 		'japanese' => 'shift_jis',
    398. 

  398. 		'simpl_chinese' => 'gb2312',
    399. 

  399. 		'trad_chinese' => 'big5',
    400. 

  400. 		'albanian' => 'windows-1250',
    401. 

  401. 		'unicode' => 'utf-8'
    402. 

  402. 	);
    403. 

  403. 

  404. 		// mapping of locale names to charsets
    405. 

  405. 	var $locale_to_charset = array(
    406. 

  406. 		'japanese.euc' => 'euc-jp',
    407. 

  407. 		'ja_jp.ujis' => 'euc-jp',
    408. 

  408. 		'korean.euc' => 'euc-kr',
    409. 

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

  410. 		'zh_cn' => 'gb2312',
    411. 

  411. 		'zh_hk' => 'big5',
    412. 

  412. 		'zh_tw' => 'big5',
    413. 

  413. 	);
    414. 

  414. 

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

  416. 		// Empty values means "iso-8859-1"
    417. 

  417. 	var $charSetArray = array(
    418. 

  418. 		'af' => '',
    419. 

  419. 		'ar' => 'iso-8859-6',
    420. 

  420. 		'ba' => 'iso-8859-2',
    421. 

  421. 		'bg' => 'windows-1251',
    422. 

  422. 		'br' => '',
    423. 

  423. 		'ca' => 'iso-8859-15',
    424. 

  424. 		'ch' => 'gb2312',
    425. 

  425. 		'cs' => 'windows-1250',
    426. 

  426. 		'cz' => 'windows-1250',
    427. 

  427. 		'da' => '',
    428. 

  428. 		'de' => '',
    429. 

  429. 		'dk' => '',
    430. 

  430. 		'el' => 'iso-8859-7',
    431. 

  431. 		'eo' => 'utf-8',
    432. 

  432. 		'es' => '',
    433. 

  433. 		'et' => 'iso-8859-4',
    434. 

  434. 		'eu' => '',
    435. 

  435. 		'fa' => 'utf-8',
    436. 

  436. 		'fi' => '',
    437. 

  437. 		'fo' => 'utf-8',
    438. 

  438. 		'fr' => '',
    439. 

  439. 		'fr_CA' => '',
    440. 

  440. 		'ga' => '',
    441. 

  441. 		'ge' => 'utf-8',
    442. 

  442. 		'gl' => '',
    443. 

  443. 		'gr' => 'iso-8859-7',
    444. 

  444. 		'he' => 'utf-8',
    445. 

  445. 		'hi' => 'utf-8',
    446. 

  446. 		'hk' => 'big5',
    447. 

  447. 		'hr' => 'windows-1250',
    448. 

  448. 		'hu' => 'iso-8859-2',
    449. 

  449. 		'is' => 'utf-8',
    450. 

  450. 		'it' => '',
    451. 

  451. 		'ja' => 'shift_jis',
    452. 

  452. 		'jp' => 'shift_jis',
    453. 

  453. 		'ka' => 'utf-8',
    454. 

  454. 		'kl' => 'utf-8',
    455. 

  455. 		'km' => 'utf-8',
    456. 

  456. 		'ko' => 'euc-kr',
    457. 

  457. 		'kr' => 'euc-kr',
    458. 

  458. 		'lt' => 'windows-1257',
    459. 

  459. 		'lv' => 'utf-8',
    460. 

  460. 		'ms' => '',
    461. 

  461. 		'my' => '',
    462. 

  462. 		'nl' => '',
    463. 

  463. 		'no' => '',
    464. 

  464. 		'pl' => 'iso-8859-2',
    465. 

  465. 		'pt' => '',
    466. 

  466. 		'pt_BR' => '',
    467. 

  467. 		'qc' => '',
    468. 

  468. 		'ro' => 'iso-8859-2',
    469. 

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

  470. 		'se' => '',
    471. 

  471. 		'si' => 'windows-1250',
    472. 

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

  473. 		'sl' => 'windows-1250',
    474. 

  474. 		'sq' => 'utf-8',
    475. 

  475. 		'sr' => 'utf-8',
    476. 

  476. 		'sv' => '',
    477. 

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

  478. 		'tr' => 'iso-8859-9',
    479. 

  479. 		'ua' => 'windows-1251',
    480. 

  480. 		'uk' => 'windows-1251',
    481. 

  481. 		'vi' => 'utf-8',
    482. 

  482. 		'vn' => 'utf-8',
    483. 

  483. 		'zh' => 'big5',
    484. 

  484. 	);
    485. 

  485. 

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

  487. 		// Missing keys means: same as TYPO3
    488. 

  488. 		// @deprecated since TYPO3 4.6, will be removed in TYPO3 6.0 - use t3lib_l10n_Locales::getIsoMapping()
    489. 

  489. 	var $isoArray = array(
    490. 

  490. 		'ba' => 'bs',
    491. 

  491. 		'br' => 'pt_BR',
    492. 

  492. 		'ch' => 'zh_CN',
    493. 

  493. 		'cz' => 'cs',
    494. 

  494. 		'dk' => 'da',
    495. 

  495. 		'si' => 'sl',
    496. 

  496. 		'se' => 'sv',
    497. 

  497. 		'gl' => 'kl',
    498. 

  498. 		'gr' => 'el',
    499. 

  499. 		'hk' => 'zh_HK',
    500. 

  500. 		'kr' => 'ko',
    501. 

  501. 		'ua' => 'uk',
    502. 

  502. 		'jp' => 'ja',
    503. 

  503. 		'qc' => 'fr_CA',
    504. 

  504. 		'vn' => 'vi',
    505. 

  505. 		'ge' => 'ka',
    506. 

  506. 		'ga' => 'gl',
    507. 

  507. 	);
    508. 

  508. 

  509. 	/**
    510. 

  510. 	 * Default constructor.
    511. 

  511. 	 */
    512. 

  512. 	public function __construct() {
    513. 

  513. 		$this->locales = t3lib_div::makeInstance('t3lib_l10n_Locales');
    514. 

  514. 	}
    515. 

  515. 

  516. 	/**
    517. 

  517. 	 * Normalize - changes input character set to lowercase letters.
    518. 

  518. 	 *
    519. 

  519. 	 * @param	string		Input charset
    520. 

  520. 	 * @return	string		Normalized charset
    521. 

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

  522. 	 */
    523. 

  523. 	function parse_charset($charset) {
    524. 

  524. 		$charset = trim(strtolower($charset));
    525. 

  525. 		if (isset($this->synonyms[$charset])) {
    526. 

  526. 			$charset = $this->synonyms[$charset];
    527. 

  527. 		}
    528. 

  528. 

  529. 		return $charset;
    530. 

  530. 	}
    531. 

  531. 

  532. 	/**
    533. 

  533. 	 * Get the charset of a locale.
    534. 

  534. 	 *
    535. 

  535. 	 * ln			language
    536. 

  536. 	 * ln_CN		 language / country
    537. 

  537. 	 * ln_CN.cs	  language / country / charset
    538. 

  538. 	 * ln_CN.cs@mod  language / country / charset / modifier
    539. 

  539. 	 *
    540. 

  540. 	 * @param	string		Locale string
    541. 

  541. 	 * @return	string		Charset resolved for locale string
    542. 

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

  543. 	 */
    544. 

  544. 	function get_locale_charset($locale) {
    545. 

  545. 		$locale = strtolower($locale);
    546. 

  546. 

  547. 			// exact locale specific charset?
    548. 

  548. 		if (isset($this->locale_to_charset[$locale])) {
    549. 

  549. 			return $this->locale_to_charset[$locale];
    550. 

  550. 		}
    551. 

  551. 

  552. 			// get modifier
    553. 

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

  554. 

  555. 			// locale contains charset: use it
    556. 

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

  557. 		if ($charset) {
    558. 

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

  559. 		}
    560. 

  560. 

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

  562. 		if ($modifier == 'euro') {
    563. 

  563. 			return 'iso-8859-15';
    564. 

  564. 		}
    565. 

  565. 

  566. 			// get language
    567. 

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

  568. 		if (isset($this->lang_to_script[$language])) {
    569. 

  569. 			$script = $this->lang_to_script[$language];
    570. 

  570. 		}
    571. 

  571. 

  572. 		if (TYPO3_OS == 'WIN') {
    573. 

  573. 			$cs = $this->script_to_charset_windows[$script] ? $this->script_to_charset_windows[$script] : 'windows-1252';
    574. 

  574. 		} else {
    575. 

  575. 			$cs = $this->script_to_charset_unix[$script] ? $this->script_to_charset_unix[$script] : 'utf-8';
    576. 

  576. 		}
    577. 

  577. 

  578. 		return $cs;
    579. 

  579. 	}
    580. 

  580. 

  581. 

  582. 	/********************************************
    583. 

  583. 	 *
    584. 

  584. 	 * Charset Conversion functions
    585. 

  585. 	 *
    586. 

  586. 	 ********************************************/
    587. 

  587. 

  588. 	/**
    589. 

  589. 	 * Convert from one charset to another charset.
    590. 

  590. 	 *
    591. 

  591. 	 * @param	string		Input string
    592. 

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

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

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

  595. 	 * @return	string		Converted string
    596. 

  596. 	 * @see convArray()
    597. 

  597. 	 */
    598. 

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

  599. 		if ($fromCS == $toCS) {
    600. 

  600. 			return $str;
    601. 

  601. 		}
    602. 

  602. 

  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) {
    609. 

  609. 						return $conv_str;
    610. 

  610. 					} // returns FALSE for unsupported charsets
    611. 

  611. 					break;
    612. 

  612. 

  613. 				case 'iconv':
    614. 

  614. 					$conv_str = iconv($fromCS, $toCS . '//TRANSLIT', $str);
    615. 

  615. 					if (FALSE !== $conv_str) {
    616. 

  616. 						return $conv_str;
    617. 

  617. 					}
    618. 

  618. 					break;
    619. 

  619. 

  620. 				case 'recode':
    621. 

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

  622. 					if (FALSE !== $conv_str) {
    623. 

  623. 						return $conv_str;
    624. 

  624. 					}
    625. 

  625. 					break;
    626. 

  626. 			}
    627. 

  627. 			// fallback to TYPO3 conversion
    628. 

  628. 		}
    629. 

  629. 

  630. 		if ($fromCS != 'utf-8') {
    631. 

  631. 			$str = $this->utf8_encode($str, $fromCS);
    632. 

  632. 		}
    633. 

  633. 		if ($toCS != 'utf-8') {
    634. 

  634. 			$str = $this->utf8_decode($str, $toCS, $useEntityForNoChar);
    635. 

  635. 		}
    636. 

  636. 		return $str;
    637. 

  637. 	}
    638. 

  638. 

  639. 	/**
    640. 

  640. 	 * Convert all elements in ARRAY with type string from one charset to another charset.
    641. 

  641. 	 * NOTICE: Array is passed by reference!
    642. 

  642. 	 *
    643. 

  643. 	 * @param	string		Input array, possibly multidimensional
    644. 

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

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

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

  647. 	 * @return	void
    648. 

  648. 	 * @see conv()
    649. 

  649. 	 */
    650. 

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

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

  652. 			if (is_array($array[$key])) {
    653. 

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

  654. 			} elseif (is_string($array[$key])) {
    655. 

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

  656. 			}
    657. 

  657. 		}
    658. 

  658. 	}
    659. 

  659. 

  660. 	/**
    661. 

  661. 	 * Converts $str from $charset to UTF-8
    662. 

  662. 	 *
    663. 

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

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

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

  666. 	 */
    667. 

  667. 	function utf8_encode($str, $charset) {
    668. 

  668. 

  669. 		if ($charset === 'utf-8') {
    670. 

  670. 			return $str;
    671. 

  671. 		}
    672. 

  672. 

  673. 			// Charset is case-insensitive.
    674. 

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

  675. 			$strLen = strlen($str);
    676. 

  676. 			$outStr = '';
    677. 

  677. 

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

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

  680. 				$ord = ord($chr);
    681. 

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

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

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

  684. 

  685. 					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?)
    686. 

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

  687. 					} else {
    688. 

  688. 						$outStr .= chr($this->noCharByteVal);
    689. 

  689. 					} // No char exists
    690. 

  690. 					$a++;
    691. 

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

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

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

  694. 							$a++;
    695. 

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

  696. 							$ord = $ord * 256 + $ord2;
    697. 

  697. 						}
    698. 

  698. 					}
    699. 

  699. 

  700. 					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?)
    701. 

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

  702. 					} else {
    703. 

  703. 						$outStr .= chr($this->noCharByteVal);
    704. 

  704. 					} // No char exists
    705. 

  705. 				} else {
    706. 

  706. 					$outStr .= $chr;
    707. 

  707. 				} // ... otherwise it's just ASCII 0-127 and one byte. Transparent
    708. 

  708. 			}
    709. 

  709. 			return $outStr;
    710. 

  710. 		}
    711. 

  711. 	}
    712. 

  712. 

  713. 	/**
    714. 

  714. 	 * Converts $str from UTF-8 to $charset
    715. 

  715. 	 *
    716. 

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

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

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

  719. 	 * @return	string		Output string, converted to local charset
    720. 

  720. 	 */
    721. 

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

  722. 

  723. 		if ($charset === 'utf-8') {
    724. 

  724. 			return $str;
    725. 

  725. 		}
    726. 

  726. 

  727. 			// Charset is case-insensitive.
    728. 

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

  729. 			$strLen = strlen($str);
    730. 

  730. 			$outStr = '';
    731. 

  731. 			$buf = '';
    732. 

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

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

  734. 				$ord = ord($chr);
    735. 

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

  736. 					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.
    737. 

  737. 

  738. 						$buf = $chr; // Add first byte
    739. 

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

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

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

  742. 								$a++; // Increase pointer...
    743. 

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

  744. 							} else {
    745. 

  745. 								break;
    746. 

  746. 							}
    747. 

  747. 						}
    748. 

  748. 

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

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

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

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

  753. 							} else {
    754. 

  754. 								$outStr .= chr($mByte);
    755. 

  755. 							}
    756. 

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

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

  758. 						} else {
    759. 

  759. 							$outStr .= chr($this->noCharByteVal);
    760. 

  760. 						} // No char exists
    761. 

  761. 					} else {
    762. 

  762. 						$outStr .= chr($this->noCharByteVal);
    763. 

  763. 					} // No char exists (MIDDLE of MB sequence!)
    764. 

  764. 				} else {
    765. 

  765. 					$outStr .= $chr;
    766. 

  766. 				} // ... otherwise it's just ASCII 0-127 and one byte. Transparent
    767. 

  767. 			}
    768. 

  768. 			return $outStr;
    769. 

  769. 		}
    770. 

  770. 	}
    771. 

  771. 

  772. 	/**
    773. 

  773. 	 * Converts all chars > 127 to numeric entities.
    774. 

  774. 	 *
    775. 

  775. 	 * @param	string		Input string
    776. 

  776. 	 * @return	string		Output string
    777. 

  777. 	 */
    778. 

  778. 	function utf8_to_entities($str) {
    779. 

  779. 		$strLen = strlen($str);
    780. 

  780. 		$outStr = '';
    781. 

  781. 		$buf = '';
    782. 

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

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

  784. 			$ord = ord($chr);
    785. 

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

  786. 				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.
    787. 

  787. 					$buf = $chr; // Add first byte
    788. 

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

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

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

  791. 							$a++; // Increase pointer...
    792. 

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

  793. 						} else {
    794. 

  794. 							break;
    795. 

  795. 						}
    796. 

  796. 					}
    797. 

  797. 

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

  799. 				} else {
    800. 

  800. 					$outStr .= chr($this->noCharByteVal);
    801. 

  801. 				} // No char exists (MIDDLE of MB sequence!)
    802. 

  802. 			} else {
    803. 

  803. 				$outStr .= $chr;
    804. 

  804. 			} // ... otherwise it's just ASCII 0-127 and one byte. Transparent
    805. 

  805. 		}
    806. 

  806. 

  807. 		return $outStr;
    808. 

  808. 	}
    809. 

  809. 

  810. 	/**
    811. 

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

  812. 	 *
    813. 

  813. 	 * @param	string		Input string, UTF-8
    814. 

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

  815. 	 * @return	string		Output string
    816. 

  816. 	 */
    817. 

  817. 	function entities_to_utf8($str, $alsoStdHtmlEnt = FALSE) {
    818. 

  818. 		// Workaround for #39287: 3rd parameter for get_html_translation_table() was only added in PHP 5.3.4 and later
    819. 

  819. 		// see http://php.net/manual/en/function.get-html-translation-table.php
    820. 

  820. 		$applyPhpCompatibilityFix = version_compare(phpversion(), '5.3.4', '<');
    821. 

  821. 

  822. 		if ($alsoStdHtmlEnt) {
    823. 

  823. 			if ($applyPhpCompatibilityFix === TRUE) {
    824. 

  824. 				$trans_tbl = array_flip(get_html_translation_table(HTML_ENTITIES, ENT_COMPAT));
    825. 

  825. 			} else {
    826. 

  826. 				$trans_tbl = array_flip(get_html_translation_table(HTML_ENTITIES, ENT_COMPAT, 'UTF-8'));
    827. 

  827. 			}
    828. 

  828. 		}
    829. 

  829. 

  830. 		$token = md5(microtime());
    831. 

  831. 		$parts = explode($token, preg_replace('/(&([#[:alnum:]]*);)/', $token . '${2}' . $token, $str));
    832. 

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

  833. 				// only take every second element
    834. 

  834. 			if ($k % 2 === 0) {
    835. 

  835. 				continue;
    836. 

  836. 			}
    837. 

  837. 

  838. 			$position = 0;
    839. 

  839. 			if (substr($v, $position, 1) == '#') { // Dec or hex entities:
    840. 

  840. 				$position++;
    841. 

  841. 				if (substr($v, $position, 1) == 'x') {
    842. 

  842. 					$v = hexdec(substr($v, ++$position));
    843. 

  843. 				} else {
    844. 

  844. 					$v = substr($v, $position);
    845. 

  845. 				}
    846. 

  846. 				$parts[$k] = $this->UnumberToChar($v);
    847. 

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

  848. 				$v = $trans_tbl['&' . $v . ';'];
    849. 

  849. 				if ($applyPhpCompatibilityFix === TRUE) {
    850. 

  850. 					$v = $this->utf8_encode($v, 'iso-8859-1');
    851. 

  851. 				}
    852. 

  852. 				$parts[$k] = $v;
    853. 

  853. 			} else { // No conversion:
    854. 

  854. 				$parts[$k] = '&' . $v . ';';
    855. 

  855. 			}
    856. 

  856. 		}
    857. 

  857. 

  858. 		return implode('', $parts);
    859. 

  859. 	}
    860. 

  860. 

  861. 	/**
    862. 

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

  863. 	 *
    864. 

  864. 	 * @param	string		Input string, UTF-8
    865. 

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

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

  867. 	 * @return	array		Output array with the char numbers
    868. 

  868. 	 */
    869. 

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

  870. 			// If entities must be registered as well...:
    871. 

  871. 		if ($convEntities) {
    872. 

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

  873. 		}
    874. 

  874. 			// Do conversion:
    875. 

  875. 		$strLen = strlen($str);
    876. 

  876. 		$outArr = array();
    877. 

  877. 		$buf = '';
    878. 

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

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

  880. 			$ord = ord($chr);
    881. 

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

  882. 				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.
    883. 

  883. 					$buf = $chr; // Add first byte
    884. 

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

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

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

  887. 							$a++; // Increase pointer...
    888. 

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

  889. 						} else {
    890. 

  890. 							break;
    891. 

  891. 						}
    892. 

  892. 					}
    893. 

  893. 

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

  895. 				} else {
    896. 

  896. 					$outArr[] = $retChar ? chr($this->noCharByteVal) : $this->noCharByteVal;
    897. 

  897. 				} // No char exists (MIDDLE of MB sequence!)
    898. 

  898. 			} else {
    899. 

  899. 				$outArr[] = $retChar ? chr($ord) : $ord;
    900. 

  900. 			} // ... otherwise it's just ASCII 0-127 and one byte. Transparent
    901. 

  901. 		}
    902. 

  902. 

  903. 		return $outArr;
    904. 

  904. 	}
    905. 

  905. 

  906. 	/**
    907. 

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

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

  909. 	 * Unit-tested by Kasper
    910. 

  910. 	 *
    911. 

  911. 	 * 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:
    912. 

  912. 	 *
    913. 

  913. 	 *  bytes | bits | representation
    914. 

  914. 	 *	  1 |	7 | 0vvvvvvv
    915. 

  915. 	 *	  2 |   11 | 110vvvvv 10vvvvvv
    916. 

  916. 	 *	  3 |   16 | 1110vvvv 10vvvvvv 10vvvvvv
    917. 

  917. 	 *	  4 |   21 | 11110vvv 10vvvvvv 10vvvvvv 10vvvvvv
    918. 

  918. 	 *	  5 |   26 | 111110vv 10vvvvvv 10vvvvvv 10vvvvvv 10vvvvvv
    919. 

  919. 	 *	  6 |   31 | 1111110v 10vvvvvv 10vvvvvv 10vvvvvv 10vvvvvv 10vvvvvv
    920. 

  920. 	 *
    921. 

  921. 	 * @param	integer		UNICODE integer
    922. 

  922. 	 * @return	string		UTF-8 multibyte character string
    923. 

  923. 	 * @see utf8CharToUnumber()
    924. 

  924. 	 */
    925. 

  925. 	function UnumberToChar($cbyte) {
    926. 

  926. 		$str = '';
    927. 

  927. 

  928. 		if ($cbyte < 0x80) {
    929. 

  929. 			$str .= chr($cbyte);
    930. 

  930. 		} else {
    931. 

  931. 			if ($cbyte < 0x800) {
    932. 

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

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

  934. 			} else {
    935. 

  935. 				if ($cbyte < 0x10000) {
    936. 

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

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

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

  939. 				} else {
    940. 

  940. 					if ($cbyte < 0x200000) {
    941. 

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

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

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

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

  945. 					} else {
    946. 

  946. 						if ($cbyte < 0x4000000) {
    947. 

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

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

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

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

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

  952. 						} else {
    953. 

  953. 							if ($cbyte < 0x80000000) {
    954. 

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

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

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

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

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

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

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

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

  962. 							}
    963. 

  963. 						}
    964. 

  964. 					}
    965. 

  965. 				}
    966. 

  966. 			}
    967. 

  967. 		}
    968. 

  968. 		return $str;
    969. 

  969. 	}
    970. 

  970. 

  971. 	/**
    972. 

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

  973. 	 * Unit-tested by Kasper
    974. 

  974. 	 *
    975. 

  975. 	 * @param	string		UTF-8 multibyte character string
    976. 

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

  977. 	 * @return	integer		UNICODE integer
    978. 

  978. 	 * @see UnumberToChar()
    979. 

  979. 	 */
    980. 

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

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

  982. 

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

  984. 			$binBuf = '';
    985. 

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

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

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

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

  989. 				} else {
    990. 

  990. 					break;
    991. 

  991. 				}
    992. 

  992. 			}
    993. 

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

  994. 

  995. 			$int = bindec($binBuf);
    996. 

  996. 		} else {
    997. 

  997. 			$int = $ord;
    998. 

  998. 		}
    999. 

  999. 

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

  1001. 	}
    1002. 

  1002. 

  1003. 

  1004. 	/********************************************
    1005. 

  1005. 	 *
    1006. 

  1006. 	 * Init functions
    1007. 

  1007. 	 *
    1008. 

  1008. 	 ********************************************/
    1009. 

  1009. 

  1010. 	/**
    1011. 

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

  1012. 	 * This function is automatically called by the conversion functions
    1013. 

  1013. 	 *
    1014. 

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

  1015. 	 *
    1016. 

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

  1017. 	 * @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.
    1018. 

  1018. 	 * @access private
    1019. 

  1019. 	 */
    1020. 

  1020. 	function initCharset($charset) {
    1021. 

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

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

  1023. 

  1024. 				// Conversion table filename:
    1025. 

  1025. 			$charsetConvTableFile = PATH_t3lib . 'csconvtbl/' . $charset . '.tbl';
    1026. 

  1026. 

  1027. 				// If the conversion table is found:
    1028. 

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

  1029. 					// Cache file for charsets:
    1030. 

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

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

  1032. 				if ($cacheFile && @is_file($cacheFile)) {
    1033. 

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

  1034. 				} else {
    1035. 

  1035. 						// Parse conversion table into lines:
    1036. 

  1036. 					$lines = t3lib_div::trimExplode(LF, t3lib_div::getUrl($charsetConvTableFile), 1);
    1037. 

  1037. 						// Initialize the internal variable holding the conv. table:
    1038. 

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

  1039. 						// traverse the lines:
    1040. 

  1040. 					$detectedType = '';
    1041. 

  1041. 					foreach ($lines as $value) {
    1042. 

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

  1043. 

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

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

  1046. 							if (!$detectedType) {
    1047. 

  1047. 								$detectedType = preg_match('/[[:space:]]*0x([[:alnum:]]*)[[:space:]]+0x([[:alnum:]]*)[[:space:]]+/', $value) ? 'whitespaced' : 'ms-token';
    1048. 

  1048. 							}
    1049. 

  1049. 

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

  1051. 								list($hexbyte, $utf8) = preg_split('/[=:]/', $value, 3);
    1052. 

  1052. 							} elseif ($detectedType == 'whitespaced') {
    1053. 

  1053. 								$regA = array();
    1054. 

  1054. 								preg_match('/[[:space:]]*0x([[:alnum:]]*)[[:space:]]+0x([[:alnum:]]*)[[:space:]]+/', $value, $regA);
    1055. 

  1055. 								$hexbyte = $regA[1];
    1056. 

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

  1057. 							}
    1058. 

  1058. 							$decval = hexdec(trim($hexbyte));
    1059. 

  1059. 							if ($decval > 127) {
    1060. 

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

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

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

  1063. 							}
    1064. 

  1064. 						}
    1065. 

  1065. 					}
    1066. 

  1066. 					if ($cacheFile) {
    1067. 

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

  1068. 					}
    1069. 

  1069. 				}
    1070. 

  1070. 				return 2;
    1071. 

  1071. 			} else {
    1072. 

  1072. 				return FALSE;
    1073. 

  1073. 			}
    1074. 

  1074. 		} else {
    1075. 

  1075. 			return 1;
    1076. 

  1076. 		}
    1077. 

  1077. 	}
    1078. 

  1078. 

  1079. 	/**
    1080. 

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

  1081. 	 *
    1082. 

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

  1083. 	 *
    1084. 

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

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

  1086. 	 * @access private
    1087. 

  1087. 	 */
    1088. 

  1088. 	function initUnicodeData($mode = NULL) {
    1089. 

  1089. 			// cache files
    1090. 

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

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

  1092. 

  1093. 			// Only process if the tables are not yet loaded
    1094. 

  1094. 		switch ($mode) {
    1095. 

  1095. 			case 'case':
    1096. 

  1096. 				if (is_array($this->caseFolding['utf-8'])) {
    1097. 

  1097. 					return 1;
    1098. 

  1098. 				}
    1099. 

  1099. 

  1100. 					// Use cached version if possible
    1101. 

  1101. 				if ($cacheFileCase && @is_file($cacheFileCase)) {
    1102. 

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

  1103. 					return 2;
    1104. 

  1104. 				}
    1105. 

  1105. 				break;
    1106. 

  1106. 

  1107. 			case 'ascii':
    1108. 

  1108. 				if (is_array($this->toASCII['utf-8'])) {
    1109. 

  1109. 					return 1;
    1110. 

  1110. 				}
    1111. 

  1111. 

  1112. 					// Use cached version if possible
    1113. 

  1113. 				if ($cacheFileASCII && @is_file($cacheFileASCII)) {
    1114. 

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

  1115. 					return 2;
    1116. 

  1116. 				}
    1117. 

  1117. 				break;
    1118. 

  1118. 		}
    1119. 

  1119. 

  1120. 			// process main Unicode data file
    1121. 

  1121. 		$unicodeDataFile = PATH_t3lib . 'unidata/UnicodeData.txt';
    1122. 

  1122. 		if (!(t3lib_div::validPathStr($unicodeDataFile) && @is_file($unicodeDataFile))) {
    1123. 

  1123. 			return FALSE;
    1124. 

  1124. 		}
    1125. 

  1125. 

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

  1127. 		if (!$fh) {
    1128. 

  1128. 			return FALSE;
    1129. 

  1129. 		}
    1130. 

  1130. 

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

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

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

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

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

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

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

  1138. 

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

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

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

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

  1143. 

  1144. 		while (!feof($fh)) {
    1145. 

  1145. 			$line = fgets($fh, 4096);
    1146. 

  1146. 				// has a lot of info
    1147. 

  1147. 			list($char, $name, $cat, , , $decomp, , , $num, , , , $upper, $lower, $title,) = explode(';', rtrim($line));
    1148. 

  1148. 

  1149. 			$ord = hexdec($char);
    1150. 

  1150. 			if ($ord > 0xFFFF) {
    1151. 

  1151. 				break;
    1152. 

  1152. 			} // only process the BMP
    1153. 

  1153. 

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

  1155. 

  1156. 			if ($upper) {
    1157. 

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

  1158. 			}
    1159. 

  1159. 			if ($lower) {
    1160. 

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

  1161. 			}
    1162. 

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

  1163. 			if ($title && $title != $upper) {
    1164. 

  1164. 				$utf8CaseFolding['toTitle'][$utf8_char] = $this->UnumberToChar(hexdec($title));
    1165. 

  1165. 			}
    1166. 

  1166. 

  1167. 			switch ($cat{0}) {
    1168. 

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

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

  1170. 					break;
    1171. 

  1171. 

  1172. 				case 'N': // numeric value
    1173. 

  1173. 					if ($ord > 0x80 && $num != '') {
    1174. 

  1174. 						$number["U+$char"] = $num;
    1175. 

  1175. 					}
    1176. 

  1176. 			}
    1177. 

  1177. 

  1178. 				// accented Latin letters without "official" decomposition
    1179. 

  1179. 			$match = array();
    1180. 

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

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

  1182. 				if ($match[1] == 'SMALL') {
    1183. 

  1183. 					$c += 32;
    1184. 

  1184. 				}
    1185. 

  1185. 

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

  1187. 				continue;
    1188. 

  1188. 			}
    1189. 

  1189. 

  1190. 			$match = array();
    1191. 

  1191. 			if (preg_match('/(<.*>)? *(.+)/', $decomp, $match)) {
    1192. 

  1192. 				switch ($match[1]) {
    1193. 

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

  1194. 						$match[2] = '0028 ' . $match[2] . ' 0029';
    1195. 

  1195. 						break;
    1196. 

  1196. 

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

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

  1199. 						break;
    1200. 

  1200. 

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

  1202. 						if (preg_match('/^0020 /', $match[2])) {
    1203. 

  1203. 							continue 2;
    1204. 

  1204. 						}
    1205. 

  1205. 						break;
    1206. 

  1206. 

  1207. 						// ignore Arabic and vertical layout presentation decomposition
    1208. 

  1208. 					case '<initial>':
    1209. 

  1209. 					case '<medial>':
    1210. 

  1210. 					case '<final>':
    1211. 

  1211. 					case '<isolated>':
    1212. 

  1212. 					case '<vertical>':
    1213. 

  1213. 						continue 2;
    1214. 

  1214. 				}
    1215. 

  1215. 				$decomposition["U+$char"] = explode(' ', $match[2]);
    1216. 

  1216. 			}
    1217. 

  1217. 		}
    1218. 

  1218. 		fclose($fh);
    1219. 

  1219. 

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

  1221. 		$specialCasingFile = PATH_t3lib . 'unidata/SpecialCasing.txt';
    1222. 

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

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

  1224. 			if ($fh) {
    1225. 

  1225. 				while (!feof($fh)) {
    1226. 

  1226. 					$line = fgets($fh, 4096);
    1227. 

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

  1228. 

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

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

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

  1232. 							if ($char != $lower) {
    1233. 

  1233. 								$arr = explode(' ', $lower);
    1234. 

  1234. 								for ($i = 0; isset($arr[$i]); $i++) {
    1235. 

  1235. 									$arr[$i] = $this->UnumberToChar(hexdec($arr[$i]));
    1236. 

  1236. 								}
    1237. 

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

  1238. 							}
    1239. 

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

  1240. 								$arr = explode(' ', $title);
    1241. 

  1241. 								for ($i = 0; isset($arr[$i]); $i++) {
    1242. 

  1242. 									$arr[$i] = $this->UnumberToChar(hexdec($arr[$i]));
    1243. 

  1243. 								}
    1244. 

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

  1245. 							}
    1246. 

  1246. 							if ($char != $upper) {
    1247. 

  1247. 								$arr = explode(' ', $upper);
    1248. 

  1248. 								for ($i = 0; isset($arr[$i]); $i++) {
    1249. 

  1249. 									$arr[$i] = $this->UnumberToChar(hexdec($arr[$i]));
    1250. 

  1250. 								}
    1251. 

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

  1252. 							}
    1253. 

  1253. 						}
    1254. 

  1254. 					}
    1255. 

  1255. 				}
    1256. 

  1256. 				fclose($fh);
    1257. 

  1257. 			}
    1258. 

  1258. 		}
    1259. 

  1259. 

  1260. 			// process custom decompositions
    1261. 

  1261. 		$customTranslitFile = PATH_t3lib . 'unidata/Translit.txt';
    1262. 

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

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

  1264. 			if ($fh) {
    1265. 

  1265. 				while (!feof($fh)) {
    1266. 

  1266. 					$line = fgets($fh, 4096);
    1267. 

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

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

  1269. 						if (!$translit) {
    1270. 

  1270. 							$omit["U+$char"] = 1;
    1271. 

  1271. 						}
    1272. 

  1272. 						$decomposition["U+$char"] = explode(' ', $translit);
    1273. 

  1273. 

  1274. 					}
    1275. 

  1275. 				}
    1276. 

  1276. 				fclose($fh);
    1277. 

  1277. 			}
    1278. 

  1278. 		}
    1279. 

  1279. 

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

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

  1282. 			$code_decomp = array();
    1283. 

  1283. 

  1284. 			while ($code_value = array_shift($to)) {
    1285. 

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

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

  1287. 						array_unshift($to, $cv);
    1288. 

  1288. 					}
    1289. 

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

  1290. 					array_push($code_decomp, $code_value);
    1291. 

  1291. 				}
    1292. 

  1292. 			}
    1293. 

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

  1294. 				$decomposition[$from] = $code_decomp;
    1295. 

  1295. 			} else {
    1296. 

  1296. 				unset($decomposition[$from]);
    1297. 

  1297. 			}
    1298. 

  1298. 		}
    1299. 

  1299. 

  1300. 			// create ascii only mapping
    1301. 

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

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

  1303. 

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

  1305. 			$code_decomp = array();
    1306. 

  1306. 			while ($code_value = array_shift($to)) {
    1307. 

  1307. 				$ord = hexdec($code_value);
    1308. 

  1308. 				if ($ord > 127) {
    1309. 

  1309. 					continue 2;
    1310. 

  1310. 				} // skip decompositions containing non-ASCII chars
    1311. 

  1311. 				else
    1312. 

  1312. 				{
    1313. 

  1313. 					array_push($code_decomp, chr($ord));
    1314. 

  1314. 				}
    1315. 

  1315. 			}
    1316. 

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

  1317. 		}
    1318. 

  1318. 

  1319. 			// add numeric decompositions
    1320. 

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

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

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

  1323. 				$ascii[$utf8_char] = $to;
    1324. 

  1324. 			}
    1325. 

  1325. 		}
    1326. 

  1326. 

  1327. 		if ($cacheFileCase) {
    1328. 

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

  1329. 		}
    1330. 

  1330. 

  1331. 		if ($cacheFileASCII) {
    1332. 

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

  1333. 		}
    1334. 

  1334. 

  1335. 		return 3;
    1336. 

  1336. 	}
    1337. 

  1337. 

  1338. 	/**
    1339. 

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

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

  1341. 	 *
    1342. 

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

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

  1344. 	 * @access private
    1345. 

  1345. 	 */
    1346. 

  1346. 	function initCaseFolding($charset) {
    1347. 

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

  1348. 		if (is_array($this->caseFolding[$charset])) {
    1349. 

  1349. 			return 1;
    1350. 

  1350. 		}
    1351. 

  1351. 

  1352. 			// Use cached version if possible
    1353. 

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

  1354. 		if ($cacheFile && @is_file($cacheFile)) {
    1355. 

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

  1356. 			return 2;
    1357. 

  1357. 		}
    1358. 

  1358. 

  1359. 			// init UTF-8 conversion for this charset
    1360. 

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

  1361. 			return FALSE;
    1362. 

  1362. 		}
    1363. 

  1363. 

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

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

  1366. 			return FALSE;
    1367. 

  1367. 		}
    1368. 

  1368. 

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

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

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

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

  1373. 

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

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

  1376. 			if ($cc != '' && $cc != $nochar) {
    1377. 

  1377. 				$this->caseFolding[$charset]['toUpper'][$c] = $cc;
    1378. 

  1378. 			}
    1379. 

  1379. 

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

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

  1382. 			if ($cc != '' && $cc != $nochar) {
    1383. 

  1383. 				$this->caseFolding[$charset]['toLower'][$c] = $cc;
    1384. 

  1384. 			}
    1385. 

  1385. 

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

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

  1388. 			if ($cc != '' && $cc != $nochar) {
    1389. 

  1389. 				$this->caseFolding[$charset]['toTitle'][$c] = $cc;
    1390. 

  1390. 			}
    1391. 

  1391. 		}
    1392. 

  1392. 

  1393. 			// add the ASCII case table
    1394. 

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

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

  1396. 		}
    1397. 

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

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

  1399. 		}
    1400. 

  1400. 

  1401. 		if ($cacheFile) {
    1402. 

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

  1403. 		}
    1404. 

  1404. 

  1405. 		return 3;
    1406. 

  1406. 	}
    1407. 

  1407. 

  1408. 	/**
    1409. 

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

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

  1411. 	 *
    1412. 

  1412. 	 * @param	string		Charset for which to initialize conversion.
    1413. 

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

  1414. 	 * @access private
    1415. 

  1415. 	 */
    1416. 

  1416. 	function initToASCII($charset) {
    1417. 

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

  1418. 		if (is_array($this->toASCII[$charset])) {
    1419. 

  1419. 			return 1;
    1420. 

  1420. 		}
    1421. 

  1421. 

  1422. 			// Use cached version if possible
    1423. 

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

  1424. 		if ($cacheFile && @is_file($cacheFile)) {
    1425. 

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

  1426. 			return 2;
    1427. 

  1427. 		}
    1428. 

  1428. 

  1429. 			// init UTF-8 conversion for this charset
    1430. 

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

  1431. 			return FALSE;
    1432. 

  1432. 		}
    1433. 

  1433. 

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

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

  1436. 			return FALSE;
    1437. 

  1437. 		}
    1438. 

  1438. 

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

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

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

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

  1443. 

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

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

  1446. 			}
    1447. 

  1447. 		}
    1448. 

  1448. 

  1449. 		if ($cacheFile) {
    1450. 

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

  1451. 		}
    1452. 

  1452. 

  1453. 		return 3;
    1454. 

  1454. 	}
    1455. 

  1455. 

  1456. 

  1457. 	/********************************************
    1458. 

  1458. 	 *
    1459. 

  1459. 	 * String operation functions
    1460. 

  1460. 	 *
    1461. 

  1461. 	 ********************************************/
    1462. 

  1462. 

  1463. 	/**
    1464. 

  1464. 	 * Returns a part of a string.
    1465. 

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

  1466. 	 *
    1467. 

  1467. 	 * @param	string		The character set
    1468. 

  1468. 	 * @param	string		Character string
    1469. 

  1469. 	 * @param	integer		Start position (character position)
    1470. 

  1470. 	 * @param	integer		Length (in characters)
    1471. 

  1471. 	 * @return	string		The substring
    1472. 

  1472. 	 * @see substr(), mb_substr()
    1473. 

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

  1474. 	 */
    1475. 

  1475. 	function substr($charset, $string, $start, $len = NULL) {
    1476. 

  1476. 		if ($len === 0 || $string === '') {
    1477. 

  1477. 			return '';
    1478. 

  1478. 		}
    1479. 

  1479. 

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

  1481. 				// cannot omit $len, when specifying charset
    1482. 

  1482. 			if ($len == NULL) {
    1483. 

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

  1484. 				mb_internal_encoding($charset);
    1485. 

  1485. 				$str = mb_substr($string, $start);
    1486. 

  1486. 				mb_internal_encoding($enc); // restore internal encoding
    1487. 

  1487. 

  1488. 				return $str;
    1489. 

  1489. 			}
    1490. 

  1490. 			else {
    1491. 

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

  1492. 			}
    1493. 

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

  1494. 				// cannot omit $len, when specifying charset
    1495. 

  1495. 			if ($len == NULL) {
    1496. 

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

  1497. 				iconv_set_encoding('internal_encoding', $charset);
    1498. 

  1498. 				$str = iconv_substr($string, $start);
    1499. 

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

  1500. 

  1501. 				return $str;
    1502. 

  1502. 			}
    1503. 

  1503. 			else {
    1504. 

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

  1505. 			}
    1506. 

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

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

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

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

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

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

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

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

  1514. 		}
    1515. 

  1515. 

  1516. 			// treat everything else as single-byte encoding
    1517. 

  1517. 		return $len === NULL ? substr($string, $start) : substr($string, $start, $len);
    1518. 

  1518. 	}
    1519. 

  1519. 

  1520. 	/**
    1521. 

  1521. 	 * Counts the number of characters.
    1522. 

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

  1523. 	 *
    1524. 

  1524. 	 * @param	string		The character set
    1525. 

  1525. 	 * @param	string		Character string
    1526. 

  1526. 	 * @return	integer		The number of characters
    1527. 

  1527. 	 * @see strlen()
    1528. 

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

  1529. 	 */
    1530. 

  1530. 	function strlen($charset, $string) {
    1531. 

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

  1532. 			return mb_strlen($string, $charset);
    1533. 

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

  1534. 			return iconv_strlen($string, $charset);
    1535. 

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

  1536. 			return $this->utf8_strlen($string);
    1537. 

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

  1538. 			return $this->euc_strlen($string, $charset);
    1539. 

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

  1540. 			return strlen($string) / 2;
    1541. 

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

  1542. 			return strlen($string) / 4;
    1543. 

  1543. 		}
    1544. 

  1544. 			// treat everything else as single-byte encoding
    1545. 

  1545. 		return strlen($string);
    1546. 

  1546. 	}
    1547. 

  1547. 

  1548. 	/**
    1549. 

  1549. 	 * Method to crop strings using the mb_substr function.
    1550. 

  1550. 	 *
    1551. 

  1551. 	 * @param  string		The character set
    1552. 

  1552. 	 * @param  string		String to be cropped
    1553. 

  1553. 	 * @param  integer		Crop length (in characters)
    1554. 

  1554. 	 * @param  string		Crop signifier
    1555. 

  1555. 	 * @return string		The shortened string
    1556. 

  1556. 	 * @see mb_strlen(), mb_substr()
    1557. 

  1557. 	 */
    1558. 

  1558. 	protected function cropMbstring($charset, $string, $len, $crop = '') {
    1559. 

  1559. 		if (intval($len) === 0 || mb_strlen($string, $charset) <= abs($len)) {
    1560. 

  1560. 			return $string;
    1561. 

  1561. 		}
    1562. 

  1562. 

  1563. 		if ($len > 0) {
    1564. 

  1564. 			$string = mb_substr($string, 0, $len, $charset) . $crop;
    1565. 

  1565. 		} else {
    1566. 

  1566. 			$string = $crop . mb_substr($string, $len, mb_strlen($string, $charset), $charset);
    1567. 

  1567. 		}
    1568. 

  1568. 

  1569. 		return $string;
    1570. 

  1570. 	}
    1571. 

  1571. 

  1572. 	/**
    1573. 

  1573. 	 * Truncates a string and pre-/appends a string.
    1574. 

  1574. 	 * Unit tested by Kasper
    1575. 

  1575. 	 *
    1576. 

  1576. 	 * @param	string		The character set
    1577. 

  1577. 	 * @param	string		Character string
    1578. 

  1578. 	 * @param	integer		Length (in characters)
    1579. 

  1579. 	 * @param	string		Crop signifier
    1580. 

  1580. 	 * @return	string		The shortened string
    1581. 

  1581. 	 * @see substr(), mb_strimwidth()
    1582. 

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

  1583. 	 */
    1584. 

  1584. 	function crop($charset, $string, $len, $crop = '') {
    1585. 

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

  1586. 			return $this->cropMbstring($charset, $string, $len, $crop);
    1587. 

  1587. 		}
    1588. 

  1588. 

  1589. 		if (intval($len) == 0) {
    1590. 

  1590. 			return $string;
    1591. 

  1591. 		}
    1592. 

  1592. 

  1593. 		if ($charset == 'utf-8') {
    1594. 

  1594. 			$i = $this->utf8_char2byte_pos($string, $len);
    1595. 

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

  1596. 			$i = $this->euc_char2byte_pos($string, $len, $charset);
    1597. 

  1597. 		} else {
    1598. 

  1598. 			if ($len > 0) {
    1599. 

  1599. 				$i = $len;
    1600. 

  1600. 			} else {
    1601. 

  1601. 				$i = strlen($string) + $len;
    1602. 

  1602. 				if ($i <= 0) {
    1603. 

  1603. 					$i = FALSE;
    1604. 

  1604. 				}
    1605. 

  1605. 			}
    1606. 

  1606. 		}
    1607. 

  1607. 

  1608. 		if ($i === FALSE) { // $len outside actual string length
    1609. 

  1609. 			return $string;
    1610. 

  1610. 		} else {
    1611. 

  1611. 			if ($len > 0) {
    1612. 

  1612. 				if (strlen($string{$i})) {
    1613. 

  1613. 					return substr($string, 0, $i) . $crop;
    1614. 

  1614. 

  1615. 				}
    1616. 

  1616. 			} else {
    1617. 

  1617. 				if (strlen($string{$i - 1})) {
    1618. 

  1618. 					return $crop . substr($string, $i);
    1619. 

  1619. 				}
    1620. 

  1620. 			}
    1621. 

  1621. 

  1622. 			/*
    1623. 

  1623. 			   if (abs($len)<$this->strlen($charset,$string))	{	// Has to use ->strlen() - otherwise multibyte strings ending with a multibyte char will return TRUE here (which is not a catastrophe, but...)
    1624. 

  1624. 				   if ($len > 0)	{
    1625. 

  1625. 					   return substr($string,0,$i).$crop;
    1626. 

  1626. 				   } else {
    1627. 

  1627. 					   return $crop.substr($string,$i);
    1628. 

  1628. 				   }
    1629. 

  1629. 			   }
    1630. 

  1630.    */
    1631. 

  1631. 		}
    1632. 

  1632. 		return $string;
    1633. 

  1633. 	}
    1634. 

  1634. 

  1635. 	/**
    1636. 

  1636. 	 * Cuts a string short at a given byte length.
    1637. 

  1637. 	 *
    1638. 

  1638. 	 * @param	string		The character set
    1639. 

  1639. 	 * @param	string		Character string
    1640. 

  1640. 	 * @param	integer		The byte length
    1641. 

  1641. 	 * @return	string		The shortened string
    1642. 

  1642. 	 * @see mb_strcut()
    1643. 

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

  1644. 	 */
    1645. 

  1645. 	function strtrunc($charset, $string, $len) {
    1646. 

  1646. 		if ($len <= 0) {
    1647. 

  1647. 			return '';
    1648. 

  1648. 		}
    1649. 

  1649. 

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

  1651. 			return mb_strcut($string, 0, $len, $charset);
    1652. 

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

  1653. 			return $this->utf8_strtrunc($string, $len);
    1654. 

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

  1655. 			return $this->euc_strtrunc($string, $len, $charset);
    1656. 

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

  1657. 			if ($len % 2) {
    1658. 

  1658. 				$len--;
    1659. 

  1659. 			} // don't cut at odd positions
    1660. 

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

  1661. 			$x = $len % 4;
    1662. 

  1662. 			$len -= $x; // realign to position dividable by four
    1663. 

  1663. 		}
    1664. 

  1664. 			// treat everything else as single-byte encoding
    1665. 

  1665. 		return substr($string, 0, $len);
    1666. 

  1666. 	}
    1667. 

  1667. 

  1668. 	/**
    1669. 

  1669. 	 * Translates all characters of a string into their respective case values.
    1670. 

  1670. 	 * Unlike strtolower() and strtoupper() this method is locale independent.
    1671. 

  1671. 	 * Note that the string length may change!
    1672. 

  1672. 	 * eg. lower case German "ß" (sharp S) becomes upper case "SS"
    1673. 

  1673. 	 * Unit-tested by Kasper
    1674. 

  1674. 	 * Real case folding is language dependent, this method ignores this fact.
    1675. 

  1675. 	 *
    1676. 

  1676. 	 * @param	string		Character set of string
    1677. 

  1677. 	 * @param	string		Input string to convert case for
    1678. 

  1678. 	 * @param	string		Case keyword: "toLower" means lowercase conversion, anything else is uppercase (use "toUpper" )
    1679. 

  1679. 	 * @return	string		The converted string
    1680. 

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

  1681. 	 * @see strtolower(), strtoupper()
    1682. 

  1682. 	 */
    1683. 

  1683. 	function conv_case($charset, $string, $case) {
    1684. 

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

  1685. 			if ($case == 'toLower') {
    1686. 

  1686. 				$string = mb_strtolower($string, $charset);
    1687. 

  1687. 			} else {
    1688. 

  1688. 				$string = mb_strtoupper($string, $charset);
    1689. 

  1689. 			}
    1690. 

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

  1691. 			$string = $this->utf8_char_mapping($string, 'case', $case);
    1692. 

  1692. 		} elseif (isset($this->eucBasedSets[$charset])) {
    1693. 

  1693. 			$string = $this->euc_char_mapping($string, $charset, 'case', $case);
    1694. 

  1694. 		} else {
    1695. 

  1695. 				// treat everything else as single-byte encoding
    1696. 

  1696. 			$string = $this->sb_char_mapping($string, $charset, 'case', $case);
    1697. 

  1697. 		}
    1698. 

  1698. 

  1699. 		return $string;
    1700. 

  1700. 	}
    1701. 

  1701. 

  1702. 	/**
    1703. 

  1703. 	 * Equivalent of lcfirst/ucfirst but using character set.
    1704. 

  1704. 	 *
    1705. 

  1705. 	 * @param string $charset
    1706. 

  1706. 	 * @param string $string
    1707. 

  1707. 	 * @param string $case
    1708. 

  1708. 	 * @return string
    1709. 

  1709. 	 * @see t3lib_cs::conv_case()
    1710. 

  1710. 	 */
    1711. 

  1711. 	public function convCaseFirst($charset, $string, $case) {
    1712. 

  1712. 		$firstChar = $this->substr($charset, $string, 0, 1);
    1713. 

  1713. 		$firstChar = $this->conv_case($charset, $firstChar, $case);
    1714. 

  1714. 		$remainder = $this->substr($charset, $string, 1);
    1715. 

  1715. 		return $firstChar . $remainder;
    1716. 

  1716. 	}
    1717. 

  1717. 

  1718. 	/**
    1719. 

  1719. 	 * Converts special chars (like æøåÆØÅ, umlauts etc) to ascii equivalents (usually double-bytes, like æ => ae etc.)
    1720. 

  1720. 	 *
    1721. 

  1721. 	 * @param string $charset Character set of string
    1722. 

  1722. 	 * @param string $string Input string to convert
    1723. 

  1723. 	 * @return string The converted string
    1724. 

  1724. 	 */
    1725. 

  1725. 	function specCharsToASCII($charset, $string) {
    1726. 

  1726. 		if ($charset == 'utf-8') {
    1727. 

  1727. 			$string = $this->utf8_char_mapping($string, 'ascii');
    1728. 

  1728. 		} elseif (isset($this->eucBasedSets[$charset])) {
    1729. 

  1729. 			$string = $this->euc_char_mapping($string, $charset, 'ascii');
    1730. 

  1730. 		} else {
    1731. 

  1731. 				// treat everything else as single-byte encoding
    1732. 

  1732. 			$string = $this->sb_char_mapping($string, $charset, 'ascii');
    1733. 

  1733. 		}
    1734. 

  1734. 

  1735. 		return $string;
    1736. 

  1736. 	}
    1737. 

  1737. 

  1738. 

  1739. 	/**
    1740. 

  1740. 	 * converts the language codes that we get from the client (usually HTTP_ACCEPT_LANGUAGE)
    1741. 

  1741. 	 * into a TYPO3-readable language code
    1742. 

  1742. 	 * @param	$languageCodesList	list of language codes. something like 'de,en-us;q=0.9,de-de;q=0.7,es-cl;q=0.6,en;q=0.4,es;q=0.3,zh;q=0.1'
    1743. 

  1743. 	 *			 see http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.4
    1744. 

  1744. 	 * @return	string	a preferred language that TYPO3 supports, or "default" if none found
    1745. 

  1745. 	 * @author	Benjamin Mack (benni.typo3.org)
    1746. 

  1746. 	 */
    1747. 

  1747. 	public function getPreferredClientLanguage($languageCodesList) {
    1748. 

  1748. 		$allLanguageCodes = array();
    1749. 

  1749. 		$selectedLanguage = 'default';
    1750. 

  1750. 

  1751. 			// get all languages where TYPO3 code is the same as the ISO code
    1752. 

  1752. 		foreach ($this->charSetArray as $typo3Lang => $charSet) {
    1753. 

  1753. 			$allLanguageCodes[$typo3Lang] = $typo3Lang;
    1754. 

  1754. 		}
    1755. 

  1755. 

  1756. 			// get all languages where TYPO3 code differs from ISO code
    1757. 

  1757. 			// or needs the country part
    1758. 

  1758. 			// the iso codes will here overwrite the default typo3 language in the key
    1759. 

  1759. 		foreach ($this->locales->getIsoMapping() as $typo3Lang => $isoLang) {
    1760. 

  1760. 			$isoLang = join('-', explode('_', $isoLang));
    1761. 

  1761. 			$allLanguageCodes[$typo3Lang] = $isoLang;
    1762. 

  1762. 		}
    1763. 

  1763. 

  1764. 			// move the iso codes to the (because we're comparing the keys with "isset" later on)
    1765. 

  1765. 		$allLanguageCodes = array_flip($allLanguageCodes);
    1766. 

  1766. 

  1767. 

  1768. 		$preferredLanguages = t3lib_div::trimExplode(',', $languageCodesList);
    1769. 

  1769. 			// order the preferred languages after they key
    1770. 

  1770. 		$sortedPreferredLanguages = array();
    1771. 

  1771. 		foreach ($preferredLanguages as $preferredLanguage) {
    1772. 

  1772. 			$quality = 1.0;
    1773. 

  1773. 			if (strpos($preferredLanguage, ';q=') !== FALSE) {
    1774. 

  1774. 				list($preferredLanguage, $quality) = explode(';q=', $preferredLanguage);
    1775. 

  1775. 			}
    1776. 

  1776. 			$sortedPreferredLanguages[$preferredLanguage] = $quality;
    1777. 

  1777. 		}
    1778. 

  1778. 

  1779. 			// loop through the languages, with the highest priority first
    1780. 

  1780. 		arsort($sortedPreferredLanguages, SORT_NUMERIC);
    1781. 

  1781. 		foreach ($sortedPreferredLanguages as $preferredLanguage => $quality) {
    1782. 

  1782. 			if (isset($allLanguageCodes[$preferredLanguage])) {
    1783. 

  1783. 				$selectedLanguage = $allLanguageCodes[$preferredLanguage];
    1784. 

  1784. 				break;
    1785. 

  1785. 			}
    1786. 

  1786. 

  1787. 				// strip the country code from the end
    1788. 

  1788. 			list($preferredLanguage, $preferredCountry) = explode('-', $preferredLanguage);
    1789. 

  1789. 			if (isset($allLanguageCodes[$preferredLanguage])) {
    1790. 

  1790. 				$selectedLanguage = $allLanguageCodes[$preferredLanguage];
    1791. 

  1791. 				break;
    1792. 

  1792. 			}
    1793. 

  1793. 		}
    1794. 

  1794. 		if (!$selectedLanguage || $selectedLanguage == 'en') {
    1795. 

  1795. 			$selectedLanguage = 'default';
    1796. 

  1796. 		}
    1797. 

  1797. 		return $selectedLanguage;
    1798. 

  1798. 	}
    1799. 

  1799. 

  1800. 

  1801. 	/********************************************
    1802. 

  1802. 	 *
    1803. 

  1803. 	 * Internal string operation functions
    1804. 

  1804. 	 *
    1805. 

  1805. 	 ********************************************/
    1806. 

  1806. 

  1807. 	/**
    1808. 

  1808. 	 * Maps all characters of a string in a single byte charset.
    1809. 

  1809. 	 *
    1810. 

  1810. 	 * @param	string		the string
    1811. 

  1811. 	 * @param	string		the charset
    1812. 

  1812. 	 * @param	string		mode: 'case' (case folding) or 'ascii' (ASCII transliteration)
    1813. 

  1813. 	 * @param	string		'case': conversion 'toLower' or 'toUpper'
    1814. 

  1814. 	 * @return	string		the converted string
    1815. 

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

  1816. 	 */
    1817. 

  1817. 	function sb_char_mapping($str, $charset, $mode, $opt = '') {
    1818. 

  1818. 		switch ($mode) {
    1819. 

  1819. 			case 'case':
    1820. 

  1820. 				if (!$this->initCaseFolding($charset)) {
    1821. 

  1821. 					return $str;
    1822. 

  1822. 				} // do nothing
    1823. 

  1823. 				$map =& $this->caseFolding[$charset][$opt];
    1824. 

  1824. 				break;
    1825. 

  1825. 

  1826. 			case 'ascii':
    1827. 

  1827. 				if (!$this->initToASCII($charset)) {
    1828. 

  1828. 					return $str;
    1829. 

  1829. 				} // do nothing
    1830. 

  1830. 				$map =& $this->toASCII[$charset];
    1831. 

  1831. 				break;
    1832. 

  1832. 

  1833. 			default:
    1834. 

  1834. 				return $str;
    1835. 

  1835. 		}
    1836. 

  1836. 

  1837. 		$out = '';
    1838. 

  1838. 		for ($i = 0; strlen($str{$i}); $i++) {
    1839. 

  1839. 			$c = $str{$i};
    1840. 

  1840. 			if (isset($map[$c])) {
    1841. 

  1841. 				$out .= $map[$c];
    1842. 

  1842. 			} else {
    1843. 

  1843. 				$out .= $c;
    1844. 

  1844. 			}
    1845. 

  1845. 		}
    1846. 

  1846. 

  1847. 		return $out;
    1848. 

  1848. 	}
    1849. 

  1849. 

  1850. 

  1851. 	/********************************************
    1852. 

  1852. 	 *
    1853. 

  1853. 	 * Internal UTF-8 string operation functions
    1854. 

  1854. 	 *
    1855. 

  1855. 	 ********************************************/
    1856. 

  1856. 

  1857. 	/**
    1858. 

  1858. 	 * Returns a part of a UTF-8 string.
    1859. 

  1859. 	 * Unit-tested by Kasper and works 100% like substr() / mb_substr() for full range of $start/$len
    1860. 

  1860. 	 *
    1861. 

  1861. 	 * @param	string		UTF-8 string
    1862. 

  1862. 	 * @param	integer		Start position (character position)
    1863. 

  1863. 	 * @param	integer		Length (in characters)
    1864. 

  1864. 	 * @return	string		The substring
    1865. 

  1865. 	 * @see substr()
    1866. 

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

  1867. 	 */
    1868. 

  1868. 	function utf8_substr($str, $start, $len = NULL) {
    1869. 

  1869. 		if (!strcmp($len, '0')) {
    1870. 

  1870. 			return '';
    1871. 

  1871. 		}
    1872. 

  1872. 

  1873. 		$byte_start = $this->utf8_char2byte_pos($str, $start);
    1874. 

  1874. 		if ($byte_start === FALSE) {
    1875. 

  1875. 			if ($start > 0) {
    1876. 

  1876. 				return FALSE; // $start outside string length
    1877. 

  1877. 			} else {
    1878. 

  1878. 				$start = 0;
    1879. 

  1879. 			}
    1880. 

  1880. 		}
    1881. 

  1881. 

  1882. 		$str = substr($str, $byte_start);
    1883. 

  1883. 

  1884. 		if ($len != NULL) {
    1885. 

  1885. 			$byte_end = $this->utf8_char2byte_pos($str, $len);
    1886. 

  1886. 			if ($byte_end === FALSE) // $len outside actual string length
    1887. 

  1887. 			{
    1888. 

  1888. 				return $len < 0 ? '' : $str;
    1889. 

  1889. 			} // When length is less than zero and exceeds, then we return blank string.
    1890. 

  1890. 			else
    1891. 

  1891. 			{
    1892. 

  1892. 				return substr($str, 0, $byte_end);
    1893. 

  1893. 			}
    1894. 

  1894. 		}
    1895. 

  1895. 		else	{
    1896. 

  1896. 			return $str;
    1897. 

  1897. 		}
    1898. 

  1898. 	}
    1899. 

  1899. 

  1900. 	/**
    1901. 

  1901. 	 * Counts the number of characters of a string in UTF-8.
    1902. 

  1902. 	 * Unit-tested by Kasper and works 100% like strlen() / mb_strlen()
    1903. 

  1903. 	 *
    1904. 

  1904. 	 * @param	string		UTF-8 multibyte character string
    1905. 

  1905. 	 * @return	integer		The number of characters
    1906. 

  1906. 	 * @see strlen()
    1907. 

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

  1908. 	 */
    1909. 

  1909. 	function utf8_strlen($str) {
    1910. 

  1910. 		$n = 0;
    1911. 

  1911. 		for ($i = 0; strlen($str{$i}); $i++) {
    1912. 

  1912. 			$c = ord($str{$i});
    1913. 

  1913. 			if (!($c & 0x80)) // single-byte (0xxxxxx)
    1914. 

  1914. 			{
    1915. 

  1915. 				$n++;
    1916. 

  1916. 			}
    1917. 

  1917. 			elseif (($c & 0xC0) == 0xC0) // multi-byte starting byte (11xxxxxx)
    1918. 

  1918. 			{
    1919. 

  1919. 				$n++;
    1920. 

  1920. 			}
    1921. 

  1921. 		}
    1922. 

  1922. 		return $n;
    1923. 

  1923. 	}
    1924. 

  1924. 

  1925. 	/**
    1926. 

  1926. 	 * Truncates a string in UTF-8 short at a given byte length.
    1927. 

  1927. 	 *
    1928. 

  1928. 	 * @param	string		UTF-8 multibyte character string
    1929. 

  1929. 	 * @param	integer		the byte length
    1930. 

  1930. 	 * @return	string		the shortened string
    1931. 

  1931. 	 * @see mb_strcut()
    1932. 

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

  1933. 	 */
    1934. 

  1934. 	function utf8_strtrunc($str, $len) {
    1935. 

  1935. 		$i = $len - 1;
    1936. 

  1936. 		if (ord($str{$i}) & 0x80) { // part of a multibyte sequence
    1937. 

  1937. 			for (; $i > 0 && !(ord($str{$i}) & 0x40); $i--) {
    1938. 

  1938. 				// find the first byte
    1939. 

  1939. 				;
    1940. 

  1940. 			}
    1941. 

  1941. 			if ($i <= 0) {
    1942. 

  1942. 				return '';
    1943. 

  1943. 			} // sanity check
    1944. 

  1944. 			for ($bc = 0, $mbs = ord($str{$i}); $mbs & 0x80; $mbs = $mbs << 1) {
    1945. 

  1945. 				// calculate number of bytes
    1946. 

  1946. 				$bc++;
    1947. 

  1947. 			}
    1948. 

  1948. 			if ($bc + $i > $len) {
    1949. 

  1949. 				return substr($str, 0, $i);
    1950. 

  1950. 			}
    1951. 

  1951. 			// fallthru: multibyte char fits into length
    1952. 

  1952. 		}
    1953. 

  1953. 		return substr($str, 0, $len);
    1954. 

  1954. 	}
    1955. 

  1955. 

  1956. 	/**
    1957. 

  1957. 	 * Find position of first occurrence of a string, both arguments are in UTF-8.
    1958. 

  1958. 	 *
    1959. 

  1959. 	 * @param	string		UTF-8 string to search in
    1960. 

  1960. 	 * @param	string		UTF-8 string to search for
    1961. 

  1961. 	 * @param	integer		Positition to start the search
    1962. 

  1962. 	 * @return	integer		The character position
    1963. 

  1963. 	 * @see strpos()
    1964. 

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

  1965. 	 */
    1966. 

  1966. 	function utf8_strpos($haystack, $needle, $offset = 0) {
    1967. 

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

  1968. 			return mb_strpos($haystack, $needle, $offset, 'utf-8');
    1969. 

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

  1970. 			return iconv_strpos($haystack, $needle, $offset, 'utf-8');
    1971. 

  1971. 		}
    1972. 

  1972. 

  1973. 		$byte_offset = $this->utf8_char2byte_pos($haystack, $offset);
    1974. 

  1974. 		if ($byte_offset === FALSE) {
    1975. 

  1975. 			return FALSE;
    1976. 

  1976. 		} // offset beyond string length
    1977. 

  1977. 

  1978. 		$byte_pos = strpos($haystack, $needle, $byte_offset);
    1979. 

  1979. 		if ($byte_pos === FALSE) {
    1980. 

  1980. 			return FALSE;
    1981. 

  1981. 		} // needle not found
    1982. 

  1982. 

  1983. 		return $this->utf8_byte2char_pos($haystack, $byte_pos);
    1984. 

  1984. 	}
    1985. 

  1985. 

  1986. 	/**
    1987. 

  1987. 	 * Find position of last occurrence of a char in a string, both arguments are in UTF-8.
    1988. 

  1988. 	 *
    1989. 

  1989. 	 * @param	string		UTF-8 string to search in
    1990. 

  1990. 	 * @param	string		UTF-8 character to search for (single character)
    1991. 

  1991. 	 * @return	integer		The character position
    1992. 

  1992. 	 * @see strrpos()
    1993. 

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

  1994. 	 */
    1995. 

  1995. 	function utf8_strrpos($haystack, $needle) {
    1996. 

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

  1997. 			return mb_strrpos($haystack, $needle, 'utf-8');
    1998. 

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

  1999. 			return iconv_strrpos($haystack, $needle, 'utf-8');
    2000. 

  2000. 		}
    2001. 

  2001. 

  2002. 		$byte_pos = strrpos($haystack, $needle);
    2003. 

  2003. 		if ($byte_pos === FALSE) {
    2004. 

  2004. 			return FALSE;
    2005. 

  2005. 		} // needle not found
    2006. 

  2006. 

  2007. 		return $this->utf8_byte2char_pos($haystack, $byte_pos);
    2008. 

  2008. 	}
    2009. 

  2009. 

  2010. 	/**
    2011. 

  2011. 	 * Translates a character position into an 'absolute' byte position.
    2012. 

  2012. 	 * Unit tested by Kasper.
    2013. 

  2013. 	 *
    2014. 

  2014. 	 * @param	string		UTF-8 string
    2015. 

  2015. 	 * @param	integer		Character position (negative values start from the end)
    2016. 

  2016. 	 * @return	integer		Byte position
    2017. 

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

  2018. 	 */
    2019. 

  2019. 	function utf8_char2byte_pos($str, $pos) {
    2020. 

  2020. 		$n = 0; // number of characters found
    2021. 

  2021. 		$p = abs($pos); // number of characters wanted
    2022. 

  2022. 

  2023. 		if ($pos >= 0) {
    2024. 

  2024. 			$i = 0;
    2025. 

  2025. 			$d = 1;
    2026. 

  2026. 		} else {
    2027. 

  2027. 			$i = strlen($str) - 1;
    2028. 

  2028. 			$d = -1;
    2029. 

  2029. 		}
    2030. 

  2030. 

  2031. 		for (; strlen($str{$i}) && $n < $p; $i += $d) {
    2032. 

  2032. 			$c = (int) ord($str{$i});
    2033. 

  2033. 			if (!($c & 0x80)) // single-byte (0xxxxxx)
    2034. 

  2034. 			{
    2035. 

  2035. 				$n++;
    2036. 

  2036. 			}
    2037. 

  2037. 			elseif (($c & 0xC0) == 0xC0) // multi-byte starting byte (11xxxxxx)
    2038. 

  2038. 			{
    2039. 

  2039. 				$n++;
    2040. 

  2040. 			}
    2041. 

  2041. 		}
    2042. 

  2042. 		if (!strlen($str{$i})) {
    2043. 

  2043. 			return FALSE;
    2044. 

  2044. 		} // offset beyond string length
    2045. 

  2045. 

  2046. 		if ($pos >= 0) {
    2047. 

  2047. 				// skip trailing multi-byte data bytes
    2048. 

  2048. 			while ((ord($str{$i}) & 0x80) && !(ord($str{$i}) & 0x40)) {
    2049. 

  2049. 				$i++;
    2050. 

  2050. 			}
    2051. 

  2051. 		} else {
    2052. 

  2052. 				// correct offset
    2053. 

  2053. 			$i++;
    2054. 

  2054. 		}
    2055. 

  2055. 

  2056. 		return $i;
    2057. 

  2057. 	}
    2058. 

  2058. 

  2059. 	/**
    2060. 

  2060. 	 * Translates an 'absolute' byte position into a character position.
    2061. 

  2061. 	 * Unit tested by Kasper.
    2062. 

  2062. 	 *
    2063. 

  2063. 	 * @param	string		UTF-8 string
    2064. 

  2064. 	 * @param	integer		byte position
    2065. 

  2065. 	 * @return	integer		character position
    2066. 

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

  2067. 	 */
    2068. 

  2068. 	function utf8_byte2char_pos($str, $pos) {
    2069. 

  2069. 		$n = 0; // number of characters
    2070. 

  2070. 		for ($i = $pos; $i > 0; $i--) {
    2071. 

  2071. 			$c = (int) ord($str{$i});
    2072. 

  2072. 			if (!($c & 0x80)) // single-byte (0xxxxxx)
    2073. 

  2073. 			{
    2074. 

  2074. 				$n++;
    2075. 

  2075. 			}
    2076. 

  2076. 			elseif (($c & 0xC0) == 0xC0) // multi-byte starting byte (11xxxxxx)
    2077. 

  2077. 			{
    2078. 

  2078. 				$n++;
    2079. 

  2079. 			}
    2080. 

  2080. 		}
    2081. 

  2081. 		if (!strlen($str{$i})) {
    2082. 

  2082. 			return FALSE;
    2083. 

  2083. 		} // offset beyond string length
    2084. 

  2084. 

  2085. 		return $n;
    2086. 

  2086. 	}
    2087. 

  2087. 

  2088. 	/**
    2089. 

  2089. 	 * Maps all characters of an UTF-8 string.
    2090. 

  2090. 	 *
    2091. 

  2091. 	 * @param	string		UTF-8 string
    2092. 

  2092. 	 * @param	string		mode: 'case' (case folding) or 'ascii' (ASCII transliteration)
    2093. 

  2093. 	 * @param	string		'case': conversion 'toLower' or 'toUpper'
    2094. 

  2094. 	 * @return	string		the converted string
    2095. 

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

  2096. 	 */
    2097. 

  2097. 	function utf8_char_mapping($str, $mode, $opt = '') {
    2098. 

  2098. 		if (!$this->initUnicodeData($mode)) {
    2099. 

  2099. 			return $str;
    2100. 

  2100. 		} // do nothing
    2101. 

  2101. 

  2102. 		$out = '';
    2103. 

  2103. 		switch ($mode) {
    2104. 

  2104. 			case 'case':
    2105. 

  2105. 				$map =& $this->caseFolding['utf-8'][$opt];
    2106. 

  2106. 				break;
    2107. 

  2107. 

  2108. 			case 'ascii':
    2109. 

  2109. 				$map =& $this->toASCII['utf-8'];
    2110. 

  2110. 				break;
    2111. 

  2111. 

  2112. 			default:
    2113. 

  2113. 				return $str;
    2114. 

  2114. 		}
    2115. 

  2115. 

  2116. 		for ($i = 0; strlen($str{$i}); $i++) {
    2117. 

  2117. 			$c = ord($str{$i});
    2118. 

  2118. 			if (!($c & 0x80)) // single-byte (0xxxxxx)
    2119. 

  2119. 			{
    2120. 

  2120. 				$mbc = $str{$i};
    2121. 

  2121. 			}
    2122. 

  2122. 			elseif (($c & 0xC0) == 0xC0) { // multi-byte starting byte (11xxxxxx)
    2123. 

  2123. 				for ($bc = 0; $c & 0x80; $c = $c << 1) {
    2124. 

  2124. 					$bc++;
    2125. 

  2125. 				} // calculate number of bytes
    2126. 

  2126. 				$mbc = substr($str, $i, $bc);
    2127. 

  2127. 				$i += $bc - 1;
    2128. 

  2128. 			}
    2129. 

  2129. 

  2130. 			if (isset($map[$mbc])) {
    2131. 

  2131. 				$out .= $map[$mbc];
    2132. 

  2132. 			} else {
    2133. 

  2133. 				$out .= $mbc;
    2134. 

  2134. 			}
    2135. 

  2135. 		}
    2136. 

  2136. 

  2137. 		return $out;
    2138. 

  2138. 	}
    2139. 

  2139. 

  2140. 

  2141. 	/********************************************
    2142. 

  2142. 	 *
    2143. 

  2143. 	 * Internal EUC string operation functions
    2144. 

  2144. 	 *
    2145. 

  2145. 	 * Extended Unix Code:
    2146. 

  2146. 	 *  ASCII compatible 7bit single bytes chars
    2147. 

  2147. 	 *  8bit two byte chars
    2148. 

  2148. 	 *
    2149. 

  2149. 	 * Shift-JIS is treated as a special case.
    2150. 

  2150. 	 *
    2151. 

  2151. 	 ********************************************/
    2152. 

  2152. 

  2153. 	/**
    2154. 

  2154. 	 * Cuts a string in the EUC charset family short at a given byte length.
    2155. 

  2155. 	 *
    2156. 

  2156. 	 * @param	string		EUC multibyte character string
    2157. 

  2157. 	 * @param	integer		the byte length
    2158. 

  2158. 	 * @param	string		the charset
    2159. 

  2159. 	 * @return	string		the shortened string
    2160. 

  2160. 	 * @see mb_strcut()
    2161. 

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

  2162. 	 */
    2163. 

  2163. 	function euc_strtrunc($str, $len, $charset) {
    2164. 

  2164. 		$sjis = ($charset == 'shift_jis');
    2165. 

  2165. 		for ($i = 0; strlen($str{$i}) && $i < $len; $i++) {
    2166. 

  2166. 			$c = ord($str{$i});
    2167. 

  2167. 			if ($sjis) {
    2168. 

  2168. 				if (($c >= 0x80 && $c < 0xA0) || ($c >= 0xE0)) {
    2169. 

  2169. 					$i++;
    2170. 

  2170. 				} // advance a double-byte char
    2171. 

  2171. 			}
    2172. 

  2172. 			else {
    2173. 

  2173. 				if ($c >= 0x80) {
    2174. 

  2174. 					$i++;
    2175. 

  2175. 				} // advance a double-byte char
    2176. 

  2176. 			}
    2177. 

  2177. 		}
    2178. 

  2178. 		if (!strlen($str{$i})) {
    2179. 

  2179. 			return $str;
    2180. 

  2180. 		} // string shorter than supplied length
    2181. 

  2181. 

  2182. 		if ($i > $len) {
    2183. 

  2183. 			return substr($str, 0, $len - 1); // we ended on a first byte
    2184. 

  2184. 		} else {
    2185. 

  2185. 			return substr($str, 0, $len);
    2186. 

  2186. 		}
    2187. 

  2187. 	}
    2188. 

  2188. 

  2189. 	/**
    2190. 

  2190. 	 * Returns a part of a string in the EUC charset family.
    2191. 

  2191. 	 *
    2192. 

  2192. 	 * @param	string		EUC multibyte character string
    2193. 

  2193. 	 * @param	integer		start position (character position)
    2194. 

  2194. 	 * @param	string		the charset
    2195. 

  2195. 	 * @param	integer		length (in characters)
    2196. 

  2196. 	 * @return	string		the substring
    2197. 

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

  2198. 	 */
    2199. 

  2199. 	function euc_substr($str, $start, $charset, $len = NULL) {
    2200. 

  2200. 		$byte_start = $this->euc_char2byte_pos($str, $start, $charset);
    2201. 

  2201. 		if ($byte_start === FALSE) {
    2202. 

  2202. 			return FALSE;
    2203. 

  2203. 		} // $start outside string length
    2204. 

  2204. 

  2205. 		$str = substr($str, $byte_start);
    2206. 

  2206. 

  2207. 		if ($len != NULL) {
    2208. 

  2208. 			$byte_end = $this->euc_char2byte_pos($str, $len, $charset);
    2209. 

  2209. 			if ($byte_end === FALSE) // $len outside actual string length
    2210. 

  2210. 			{
    2211. 

  2211. 				return $str;
    2212. 

  2212. 			}
    2213. 

  2213. 			else
    2214. 

  2214. 			{
    2215. 

  2215. 				return substr($str, 0, $byte_end);
    2216. 

  2216. 			}
    2217. 

  2217. 		}
    2218. 

  2218. 		else	{
    2219. 

  2219. 			return $str;
    2220. 

  2220. 		}
    2221. 

  2221. 	}
    2222. 

  2222. 

  2223. 	/**
    2224. 

  2224. 	 * Counts the number of characters of a string in the EUC charset family.
    2225. 

  2225. 	 *
    2226. 

  2226. 	 * @param	string		EUC multibyte character string
    2227. 

  2227. 	 * @param	string		the charset
    2228. 

  2228. 	 * @return	integer		the number of characters
    2229. 

  2229. 	 * @see strlen()
    2230. 

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

  2231. 	 */
    2232. 

  2232. 	function euc_strlen($str, $charset) {
    2233. 

  2233. 		$sjis = ($charset == 'shift_jis');
    2234. 

  2234. 		$n = 0;
    2235. 

  2235. 		for ($i = 0; strlen($str{$i}); $i++) {
    2236. 

  2236. 			$c = ord($str{$i});
    2237. 

  2237. 			if ($sjis) {
    2238. 

  2238. 				if (($c >= 0x80 && $c < 0xA0) || ($c >= 0xE0)) {
    2239. 

  2239. 					$i++;
    2240. 

  2240. 				} // advance a double-byte char
    2241. 

  2241. 			}
    2242. 

  2242. 			else {
    2243. 

  2243. 				if ($c >= 0x80) {
    2244. 

  2244. 					$i++;
    2245. 

  2245. 				} // advance a double-byte char
    2246. 

  2246. 			}
    2247. 

  2247. 

  2248. 			$n++;
    2249. 

  2249. 		}
    2250. 

  2250. 

  2251. 		return $n;
    2252. 

  2252. 	}
    2253. 

  2253. 

  2254. 	/**
    2255. 

  2255. 	 * Translates a character position into an 'absolute' byte position.
    2256. 

  2256. 	 *
    2257. 

  2257. 	 * @param	string		EUC multibyte character string
    2258. 

  2258. 	 * @param	integer		character position (negative values start from the end)
    2259. 

  2259. 	 * @param	string		the charset
    2260. 

  2260. 	 * @return	integer		byte position
    2261. 

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

  2262. 	 */
    2263. 

  2263. 	function euc_char2byte_pos($str, $pos, $charset) {
    2264. 

  2264. 		$sjis = ($charset == 'shift_jis');
    2265. 

  2265. 		$n = 0; // number of characters seen
    2266. 

  2266. 		$p = abs($pos); // number of characters wanted
    2267. 

  2267. 

  2268. 		if ($pos >= 0) {
    2269. 

  2269. 			$i = 0;
    2270. 

  2270. 			$d = 1;
    2271. 

  2271. 		} else {
    2272. 

  2272. 			$i = strlen($str) - 1;
    2273. 

  2273. 			$d = -1;
    2274. 

  2274. 		}
    2275. 

  2275. 

  2276. 		for (; strlen($str{$i}) && $n < $p; $i += $d) {
    2277. 

  2277. 			$c = ord($str{$i});
    2278. 

  2278. 			if ($sjis) {
    2279. 

  2279. 				if (($c >= 0x80 && $c < 0xA0) || ($c >= 0xE0)) {
    2280. 

  2280. 					$i += $d;
    2281. 

  2281. 				} // advance a double-byte char
    2282. 

  2282. 			}
    2283. 

  2283. 			else {
    2284. 

  2284. 				if ($c >= 0x80) {
    2285. 

  2285. 					$i += $d;
    2286. 

  2286. 				} // advance a double-byte char
    2287. 

  2287. 			}
    2288. 

  2288. 

  2289. 			$n++;
    2290. 

  2290. 		}
    2291. 

  2291. 		if (!strlen($str{$i})) {
    2292. 

  2292. 			return FALSE;
    2293. 

  2293. 		} // offset beyond string length
    2294. 

  2294. 

  2295. 		if ($pos < 0) {
    2296. 

  2296. 			$i++;
    2297. 

  2297. 		} // correct offset
    2298. 

  2298. 

  2299. 		return $i;
    2300. 

  2300. 	}
    2301. 

  2301. 

  2302. 	/**
    2303. 

  2303. 	 * Maps all characters of a string in the EUC charset family.
    2304. 

  2304. 	 *
    2305. 

  2305. 	 * @param	string		EUC multibyte character string
    2306. 

  2306. 	 * @param	string		the charset
    2307. 

  2307. 	 * @param	string		mode: 'case' (case folding) or 'ascii' (ASCII transliteration)
    2308. 

  2308. 	 * @param	string		'case': conversion 'toLower' or 'toUpper'
    2309. 

  2309. 	 * @return	string		the converted string
    2310. 

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

  2311. 	 */
    2312. 

  2312. 	function euc_char_mapping($str, $charset, $mode, $opt = '') {
    2313. 

  2313. 		switch ($mode) {
    2314. 

  2314. 			case 'case':
    2315. 

  2315. 				if (!$this->initCaseFolding($charset)) {
    2316. 

  2316. 					return $str;
    2317. 

  2317. 				} // do nothing
    2318. 

  2318. 				$map =& $this->caseFolding[$charset][$opt];
    2319. 

  2319. 				break;
    2320. 

  2320. 

  2321. 			case 'ascii':
    2322. 

  2322. 				if (!$this->initToASCII($charset)) {
    2323. 

  2323. 					return $str;
    2324. 

  2324. 				} // do nothing
    2325. 

  2325. 				$map =& $this->toASCII[$charset];
    2326. 

  2326. 				break;
    2327. 

  2327. 

  2328. 			default:
    2329. 

  2329. 				return $str;
    2330. 

  2330. 		}
    2331. 

  2331. 

  2332. 		$sjis = ($charset == 'shift_jis');
    2333. 

  2333. 		$out = '';
    2334. 

  2334. 		for ($i = 0; strlen($str{$i}); $i++) {
    2335. 

  2335. 			$mbc = $str{$i};
    2336. 

  2336. 			$c = ord($mbc);
    2337. 

  2337. 

  2338. 			if ($sjis) {
    2339. 

  2339. 				if (($c >= 0x80 && $c < 0xA0) || ($c >= 0xE0)) { // a double-byte char
    2340. 

  2340. 					$mbc = substr($str, $i, 2);
    2341. 

  2341. 					$i++;
    2342. 

  2342. 				}
    2343. 

  2343. 			}
    2344. 

  2344. 			else {
    2345. 

  2345. 				if ($c >= 0x80) { // a double-byte char
    2346. 

  2346. 					$mbc = substr($str, $i, 2);
    2347. 

  2347. 					$i++;
    2348. 

  2348. 				}
    2349. 

  2349. 			}
    2350. 

  2350. 

  2351. 			if (isset($map[$mbc])) {
    2352. 

  2352. 				$out .= $map[$mbc];
    2353. 

  2353. 			} else {
    2354. 

  2354. 				$out .= $mbc;
    2355. 

  2355. 			}
    2356. 

  2356. 		}
    2357. 

  2357. 

  2358. 		return $out;
    2359. 

  2359. 	}
    2360. 

  2360. 

  2361. }
    2362. 

  2362. 

  2363. if (defined('TYPO3_MODE') && isset($GLOBALS['TYPO3_CONF_VARS'][TYPO3_MODE]['XCLASS']['t3lib/class.t3lib_cs.php'])) {
    2364. 

  2364. 	include_once($GLOBALS['TYPO3_CONF_VARS'][TYPO3_MODE]['XCLASS']['t3lib/class.t3lib_cs.php']);
    2365. 

  2365. }
    2366. 

  2366. 

  2367. ?>
    2368. 

  2368.